Hello it's a me again @drifter1! I was in vacation for one week, but am now back at home to post yet another article! Today we continue with my Compiler Series, a series where we implement a complete compiler for a simple C-like language by using the C-tools Flex and Bison. In this article we will generate code for Simple Statements (Break, Continue, Increment, Decrement).
Requirements:
Actually you need to read and understand all the topics that I covered in the series as a whole, as these articles will give you access to knowledge about:
What Compiler Design is (mainly the steps)
For which exact Language the Compiler is build for (Tokens and Grammar)
How to use Flex and Bison
How to implement a lexer and parser for the language using those tools
What the Symbol Table is and how we implement it
How we combine Flex and Bison together
How we can pass information from the Lexer to the Parser
How we define operator priorities, precedencies and associativity
What Semantic Analysis is (Attributes, SDT etc.)
How we do the so called "Scope Resolution"
How we declare types and check the type inter-compatibility for different cases that include function parameters and assignments
How we check function calls later on using a "Revisit queue", as function declarations mostly happen after functions get used (in our Language)
Intermediate Code Representations, including AST's
How we implement an AST (structure and management)
Action Rules for AST nodes and more
The target system's architecture and its assembly language (MIPS)
Register Allocation & Assignment and how we implement it
How we generate Assembly code for various cases
Difficulty:
Talking about the series in general this series can be rated:
Intermediate to Advanced
Today's topic(s) can be rated:
Easy
So, without further ado, let's now finally start with the actual Tutorial...
Actual Tutorial Content
Increment & Decrement Statements
An increment or decrement statement is basically the same as the arithmetic expression one. The only difference between those two is that the result of the statement "version" is not directly used inside of an expression that contains other variables. This all means that the increment/decrement statement is basically not included in our adjacency Graph, as there is no adjacency relationship between the variable that gets incremented/decremented and another variable.
Thinking about integer incrementation/decrementation we have:
For Floating-point Incrementations and Decrementations we will have to store the immediate '1.0' inside of $f28 and apply ADD.D and SUB.D correspondingly.
By the end of this article, we will see what gets generated for the file: "full_example.c".
Break & Continue Statements
In the context of Loops (for loop in the diagram), we can visualize the break and continue statements as following:
As you can see the break statement immediately stops the loop (while or for) from executing, "jumping us out" of the loops body. On the other hand, the continue statement skips the current iteration's code, making sure to increment the loop counter and also checking the loop condition.
Implementing the break-statement is quite simple as we will just have to jump to a label right that will be generated right after the Loops-Code. For now we will only include a temporary label.
Implementing the continue-statement is more tricky. In for-loops we can easily include a Label right before the incrementation/decrementation of the loop counter (i++/i--) and jump there. In while-loops things are more difficult. In a quite older article of the series, we wrote some code that finds out which variable is the loop counter, but still how exactly all this gets implemented will be covered in the corresponding article of While Loop Generation.
So, what is the code for a break or continue statement? Well, it's simply:
J Label
In other words, the code for generating any of those two simple statements is:
The two functions that we wrote in this article have to be included inside of the main function's traversal. This basically means, that we write the following Code for the cases "SIMPLE_NODE" and "INCR_NODE":
...
/* simple case */
case SIMPLE_NODE:
generate_simple(fp, "Temp_Label");
break;
/* increment statement */
case INCR_NODE:
temp_incr = (AST_Node_Incr*) node;
generate_incr_decr(fp, temp_incr);
break;
...
Compiler Output for full_example.c
Running our compiler we get the following output file:
And this is actually it for today's post! In the next article we will generate the machine code for Assignments.
Next up on this series, in general, are:
Machine Code generation (MIPS Assembly)
Various Optimizations in the Compiler's Code
Which are all topics for which we will need more than one article to complete them. Also, note that we might also get into AST Code Optimizations later on, or that we could even extend the Language by adding complex datatypes (structs and unions), more rules etc.
So, see ya next time!
GitHub Account:
https://github.com/drifter1
Keep on drifting! ;)
Writing a simple Compiler on my own - Generating Code for Simple St... | Ecency
How I gamed EOS Defi projects and still got rektcmichel ·
@drifter1! I was in vacation for one week, but am now back at home to post yet another article! Today we continue with my Compiler Series, a series where we implement a complete compiler for a simple C-like language by using the C-tools Flex and Bison. In this article we will generate code for Simple Statements (Break, Continue, Increment, Decrement).
