We have not described how to parse a string according
to a context-free grammar to get a parse tree.
Instead, we will assume we already have a parse tree for
a MiniJava Statement, and sketch the process of generating
an equivalent TC-201 assembly language program.
This sketch is intended to give some insight into the
code-generation phase of a compiler.
We consider the MiniJava Statement:
{
sum = 0;
n = 1;
while (n < 10)
{sum = sum + n;
n = n + 1;}
System.out.println(sum);
}
This is a correct MiniJava Statement, which has a parse
tree as follows (with abbreviations St, Exp, ID, and IL
for Statement, Expression, IDENTIFIER, and INTEGER_LITERAL.)
Note that since Identifier can only be replaced by IDENTIFIER,
they have been identified below.
St
---------------------------------------------
/ | \ \ \ \
{ | \ \ \ }
St St St St
------ ------ ------------- ------------------------
/ | \ \ / | \ \ | \ \ \ \ | \ \ \ \
ID = Exp ; ID = Exp ; while ( Exp ) \ System.out.println ( Exp ) ;
| --- | --- --- \ ---
sum | n | / | \ \ |
IL IL Exp < Exp \ ID
| | --- --- \ |
0 1 | | \ sum
ID IL \
| | St
n 10 ---------------------
/ / \ \
{ / \ }
St St
------ -------
/ | \ \ / | \ \
ID = Exp ; ID = Exp ;
| --- | ---
sum / | \ n / | \
/ + \ / + \
Exp Exp Exp Exp
--- --- --- ---
| | | |
ID ID ID IL
| | | |
sum n n 1
Note that we have interpreted productions of the form
Statement ::= "{" (Statement)* "}"
as allowing a parse tree in which a node labeled by the
nonterminal symbol Statement may have a leftmost child
labeled by {, a rightmost child labeled by }, and zero
or more children (in between) labeled by Statement.
We also assume that the lexical items ID and IL are annotated
by the actual identifier or integer literal they correspond to.
(For another example of a MiniJava Statement parse tree, see
Another MiniJava parse tree.)
Now the goal is to sketch the process of generating code
for the TC-201 computer
for this parse tree to suggest how it could be automated.
We need to reserve one memory location in the TC-201 for
each identifier and integer literal in the program,
so we can first gather them up and construct data
statements for them:
sum: data 0
n: data 0
c0: data 0
c1: data 1
c10: data 10
We've assigned simple symbolic names to the integer
literals 0, 1, 10.
According to our usual convention, these data statements
will be placed after the instructions for the program.
Then we may proceed recursively, processing the parse
tree from the root (top node) down.
At the root we have a Statement that consists of {,
four Statements, and }.
Clearly the { and }, though necessary for the syntax
of the program, do not further contribute to the meaning
of the program.
A Statement that consists of a sequence of Statements can
be compiled by (recursively) generating code for each of
constituent Statements, and then placing that code in
sequence in the memory, because the meaning of a sequence
of Statements in MiniJava is: execute the first Statement,
then execute the second Statement, then execute the third
Statement, and so on, for each of the Statements in the sequence.
The first of the four Statements is an assignment, which
is parsed as
ID = Exp ;
(Recall that we've replaced Identifier by IDENTIFIER, abbreviated
by ID.)
The instructions for an assignment are (recursively) generate
code to calculate the value of the Expression on the right hand
side and get that value into the accumulator, and follow
that by a store instruction into the memory location for
the Identifier, in this case, sum.
Schematically, we have
(code to get value of Expression in accumulator)
store sum
In this case, the Expression is just an INTEGER_LITERAL, so
the instructions to get its value into the accumulator consist
of just a load instruction from the memory location that holds
the integer literal, in this case, c0.
Thus, the code for the first of the four Statements is:
load c0
store sum
This correctly represents the intended meaning of the
MiniJava Statement "sum = 0;".
The generation of instructions for the next MiniJava
Statements, "n = 1;" is similar, and results in the
instructions:
load c1
store n
The third Statement of the four is more complex, it is
a while Statement that is parsed as
"while" "(" Expression ")" Statement
The Expression gives the condition for the while body to
be executed, and the Statement is the while body.
The instructions generated form a loop that tests
the while condition -- if it is false, execution
jumps to the next Statement in sequence, and if it
is true, the instructions for the while body are executed,
and at the end there is a jump back to the instructions
to test the while condition again.
Schematically, we have:
loop: (instructions to put value of Expression in accumulator)
skippos
jump next
(instructions for the Statement (while body))
jump loop
next: ...
Here we have assumed that the while body will be executed
as long as the value of the Expression is positive.
If we make the convention that positive numbers represent
true and non-positive numbers represent false, then
an Expression with a positive value will cause the while
body to be executed again, and an Expression with a zero
or negative value will cause the while Statement to terminate.
The Expressions we have in this program are just IDENTIFIERS,
INTEGER_LITERALS, sum Expressions, of the form
Exp + Exp
and less than Expressions, of the form
Exp < Exp
Sum expressions can be evaluated by recursively evaluating
the first Expression and saving its value in a temporary
location, recursively evaluating the second Expression,
and using an add instruction to add the value in the
temporary location to it.
Schematically, we have
(instructions to put value of first Expression in accumulator)
store temp1
(instructions to put value of second Expression in accumulator)
add temp1
