1. 9. Creating and Evaluating a
Compiler Structures
, Semester 2,
9. Creating and Evaluating a
Parse Tree
Objective
extend the expressions language compiler to generate a parse tree for the input program, and then evaluate it

2. Overview
1. The Expressions Grammar 2. exprParse2.c 3. Parse Tree Data Structures 4. Revised Parse Functions 5. Tree Building 6. Tree Printing 7. Tree Evaluation

3. In this lecture Front End Back End Source Program Lexical Analyzer
Syntax Analyzer
In this lecture
Semantic Analyzer
Int. Code Generator
concentrating
on parse tree
generation and
evaluation
Intermediate Code
Code Optimizer
Back
End
As I said earlier, there will be 5 homeworks, each of which will contribute to 5% of your final grade. You will have at least 2 weeks to complete each of the homeworks.
Talking about algorithms really helps you learn about them, so I encourage you all to work in small groups. If you don’t have anyone to work with please either me or stop by my office and I will be sure to match you up with others. PLEASE make sure you all work on each problem; you will only be hurting yourself if you leach off of your partners. Problems are HARD! I will take into account the size of your group when grading your homework.
Later in the course I will even have a contest for best algorithm and give prizes out for those who are most clever in their construct.
I will allow you one late homework. You *must* write on the top that you are taking your late.
Homework 1 comes out next class.
Target Code Generator
Target Lang. Prog.

4. 1. The Expressions Grammar
Its LL(1) grammar:
Stats => ( [ Stat ] \n )*
Stat => let ID = Expr | Expr
Expr => Term ( (+ | - ) Term )*
Term => Fact ( (* | / ) Fact ) *
Fact => '(' Expr ')' | Int | Id

5. An Expressions Program (test3.txt)
5 + 6 let x = ( (x*y)/2) // comments // y let x = 5 let y = x /0 // comments

6. exprParse2.c
A recursive descent parser using the expressions language.
This version of the parser differs from exprParse1.c by having the parse functions (e.g. statements(), statement()) create a parse tree as they execute.
continued

7. There's a new printTree() function which prints the final tree, and evalTree() which evaluates it.
Usage:
$ gcc -Wall -o exprParse2 exprParse2.c $ ./exprParse2 < test1.txt

8. Output for test1.txt \n \n = printed tree; same as y = + x 2 3 x
let x = 2
let y = 3 + x
> exprParse2 < test1.txt \n NULL = x 2 y + 3 \n \n =
printed
tree;
same as y
NULL = + x 2 3 x
continued

9. evaluation of the parse tree x being declared x = 2 == 2
y being declared
y = 5
== 5
>
evaluation of the
parse tree

10. 3. Parse Tree Data Structures
typedef struct TreeNode { Token operTok; union { char *id; int value; struct {struct TreeNode *left, *right;} branches; } u; } Tree;
A tree is made from TreeNodes.

11. Graphically one of ID, INT, NEWLINE, ASSIGNOP, PLUSOP, MINUSOP,
MULTOP, DIVOP
TreeNode
operTok id
variable name (for ID) OR
a union, u
value
integer (for INT) OR
children pointers of
this node (used by
NEWLINE, ASSIGNOP, PLUSOP, MINUSOP,
MULTOP, DIVOP)
branches
left
right

12. Macros for Using TreeNode Fields
#define TreeOper(t) ((t)->operTok) #define TreeID(t) ((t)->u.id) #define TreeValue(t) ((t)->u.value) #define TreeLeft(t) ((t)->u.branches.left) #define TreeRight(t) ((t)->u.branches.right)

13. 4. Revised Parse Functions
The parse functions have the same 'shape' as the ones in exprParse0.c, but now call tree building functions, and return a Tree result.
Functions:
main(), statements(), statement(), expression(), term(), factor()

14. main() Before and After
int main(void) // parse, then print and evaluate the resulting tree { Tree *t; nextToken(); t = statements(); match(SCANEOF); printTree(t, 0); printf("\n\n"); evalTree(t); return 0; }
int main(void) { nextToken(); statements(); match(SCANEOF); return 0; }

15. statements() Before and After
with no semantic actions
void statements(void) // statements ::= { [ statement] '\n' } { dprint("Parsing statements\n"); while (currToken != SCANEOF) { if (currToken != NEWLINE) statement(); match(NEWLINE); } } // end of statements()

16. Tree. statements(void) { Tree. t,. left,
Tree *statements(void) { Tree *t, *left, *statTree; left = NULL; dprint("Parsing statements\n"); while (currToken != SCANEOF) { if (currToken != NEWLINE) statTree = statement(); else statTree = NULL; match(NEWLINE); if (statTree != NULL) { t = makeTreeNode(NEWLINE, left, statTree); left = t; } return left; } // end of statements()

17. Tree Structure for statements
A statements sequence:
s1 \n1 s2 \n2 s3 \n3
becomes:
\n3
\n2 s3
\n1 s2 s1
NULL

18. statement() Before and After
with no semantic actions
void statement(void) // statement ::= ( 'let' ID '=' EXPR ) | EXPR { if (currToken == LET) { match(LET); match(ID); match(ASSIGNOP); expression(); } else } // end of statement()

19. Tree. statement(void) { Tree. t,. idTree,
Tree *statement(void) { Tree *t, *idTree, *exprTree; dprint("Parsing statement\n"); if (currToken == LET) { match(LET); idTree = matchId(); // build tree node, not symbol table entry match(ASSIGNOP); exprTree = expression(); t = makeTreeNode(ASSIGNOP, idTree, exprTree); } else // expression t = expression(); return t; } // end of statement()

20. Tree Structures for statement= or
expr
tree ID
node
expr
tree

21. expression() Before and After
with no semantic actions
void expression(void) // expression ::= term ( ('+'|'-') term )* { term(); while((currToken == PLUSOP) || (currToken == MINUSOP)) { match(currToken); } } // end of expression()

22. Tree. expression(void) { Tree. t,. left,
Tree *expression(void) { Tree *t, *left, *right; int isAddOp; dprint("Parsing expression\n"); left = term(); while((currToken == PLUSOP)||(currToken == MINUSOP)) { isAddOp = (currToken == PLUSOP) ? 1 : 0; nextToken(); right = term(); if (isAddOp == 1) // addition t = makeTreeNode(PLUSOP, left, right); else // subtraction t = makeTreeNode(MINUSOP, left, right); left = t; } return left; } // end of expression()

23. Tree Structure for expression
An expression sequence:
t t2 - t t4
becomes: +2 - t4 +1 t3 t2 t1

24. term() Before and After
with no semantic actions
void term(void) // term ::= factor ( ('*'|'/') factor )* { factor(); while((currToken == MULTOP) || (currToken == DIVOP)) { match(currToken); } } // end of term()

25. Tree. term(void) { Tree. t,. left,
Tree *term(void) { Tree *t, *left, *right; int isMultOp; dprint("Parsing term\n"); left = factor(); while((currToken == MULTOP) || (currToken == DIVOP)) { isMultOp = (currToken == MULTOP) ? 1 : 0; nextToken(); right = factor(); if (isMultOp == 1) // multiplication t = makeTreeNode(MULTOP, left, right); else // division t = makeTreeNode(DIVOP, left, right); left = t; } return left; } // end of term()

26. Tree Structure for term
An term sequence:
f1 *1 f2 / f3 *2 f4
becomes: *2 / f4 *1 f3 f2 f1

27. factor() Before and After
with no semantic actions
void factor(void) // factor ::= '(' expression ')' | INT | ID { if(currToken == LPAREN) { match(LPAREN); expression(); match(RPAREN); } else if(currToken == INT) match(INT); else if (currToken == ID) match(ID); else syntax_error(currToken); } // end of factor()

28. Tree. factor(void) { Tree
Tree *factor(void) { Tree *t = NULL; dprint("Parsing factor\n"); if(currToken == LPAREN) { match(LPAREN); t = expression(); match(RPAREN); } else if(currToken == INT) { t = makeIntLeaf(currTokValue); match(INT); else if (currToken == ID) t = matchId(); // do not access symbol table else syntax_error(currToken); return t; } // end of factor()

29. Match an ID (Extended)
Tree *matchId(void) { Tree *t; if (currToken == ID) t = makeIDLeaf(tokString); match(ID); return t; } // end of matchID()

30. Tree Structure for factor
There are three possible nodes:
tree
node
INT
node ID
node or or

31. 5. Tree Building
TreeNode
The nodes in a parse tree are connected by the parse functions.
A tree node can have three different shapes:
operTok id OR
a union
value OR
branches
left
right

32. Making a Tree Node
Tree *treeMalloc(void) // a tree node with no fields specified { Tree *t; t = (Tree *) malloc( sizeof(Tree) ); if(t == NULL) { /* out of memory? */ perror("Tree Node not made; out of memory"); exit(1); } return t; } // end of treeMalloc()

33. Making an ID Node operTok ID "id str" id no symbol table entry
Tree *makeIDLeaf(char *id) { Tree *t; t = treeMalloc(); TreeOper(t) = ID; TreeID(t) = (char *) malloc(strlen(id)+1); strcpy(TreeID(t), id); return t; } // end of makeIDLeaf() id
"id str"
no symbol table entry
created yet

34. Making an INT Node operTok INT integer value
Tree *makeIntLeaf(int value) { Tree *t; t = treeMalloc(); TreeOper(t) = INT; TreeValue(t) = value; return t; } // end of makeIntLeaf()
value
integer

35. Making a Node with Children
Tree *makeTreeNode(Token op, Tree *left, Tree *right) /* Build an internal tree node, which contains an operator and points to two subtrees.*/ { Tree *t; t = treeMalloc(); TreeOper(t) = op; TreeLeft(t) = left; TreeRight(t) = right; return t; } // end of makeTreeNode()
operTok op
branches
left
right

36. 6. Tree Printing
The printTree() function recurses over the tree, and does three different things depending on the three possible 'shapes' for a tree node.
It includes an indent counter, which is used to print spaces (indents) in front of the node information.

37. void printTree(Tree *t, int indent) // print a tree, indenting by indent spaces { printIndent(indent); if (t == NULL) { printf("NULL\n"); return; } :
continued

38. Token tok = TreeOper(t); if (tok == INT) printf("%d\n", TreeValue(t)); else if (tok == ID) printf("%s\n", TreeID(t)); else { // operator if (tok == NEWLINE) printf("\\n\n"); // show the \n else printf("%s\n", tokSyms[tok]); printTree(TreeLeft(t), indent+2); printTree(TreeRight(t), indent+2); } } // end of printTree()

39. void printIndent(int n) { int spaces; for(spaces = 0; spaces
void printIndent(int n) { int spaces; for(spaces = 0; spaces != n; spaces++) putchar(' '); } // end of printIndent()

40. Tree Printing Examples
> exprParse2 < test2.txt \n NULL = x56 2 bing_BONG - * 27 * 5 / 67 3
let x56 = 2
let bing_BONG = (27 * 2) - x56
5 * (67 / 3)

41. Graphically \n \n * / 5 \n = 67 3 bing_ BONG - S3 NULL = x56 * x56 227 2 S1 S2

42. test3.txt
5 + 6 let x = ( (x*y)/2) // comments // y let x = 5 let y = x /0 // comments

43. > exprParse2 < test3.txt \n NULL + 5 6 = x 2 / * x y 2 = 5

44. 7. Tree Evaluation Tree evaluation works in two stages:
evalTree() searches over the tree looking for subtrees which start with an operator which is not NEWLINE
these subtrees are evaluated by eval(), using the operators in their nodes

45. Finding non-NEWLINEs \n evalTree() used here \n * / 5 \n = 67 3
bing_ BONG -
NULL =
x56 *
x56 2 27 2
eval() used here

46. Code
void evalTree(Tree *t) { if (t == NULL) return; Token tok = TreeOper(t); if (tok == NEWLINE) { evalTree( TreeLeft(t) ); evalTree( TreeRight(t) ); } else printf("== %d\n", eval(t)); } // end of evalTree()

47. be one of ID, INT, ASSIGNOP, PLUSOP, MINUSOP,
The operator can
be one of ID, INT, ASSIGNOP, PLUSOP, MINUSOP,
MULTOP, DIVOP
int eval(Tree *t) { SymbolInfo *si; if (t == NULL) return 0; Token tok = TreeOper(t); if (tok == ID) { si = getIDEntry( TreeID(t) ); // lookup ID in symbol table return si->value; } :
7 possibilities
continued

48. else if (tok == INT) return TreeValue(t); else if (tok == ASSIGNOP) { // id = expr si = evalID(TreeLeft(t)); //add ID to sym. table int result = eval(TreeRight(t)); si->value = result; printf("%s = %d\n", si->id, result); return result; } else if (tok == PLUSOP) return eval(TreeLeft(t)) + eval(TreeRight(t)); else if (tok == MINUSOP) return eval(TreeLeft(t)) - eval(TreeRight(t)); :

49. else if (tok == MULTOP) return eval(TreeLeft(t))
else if (tok == MULTOP) return eval(TreeLeft(t)) * eval(TreeRight(t)); else if (tok == DIVOP) { int right = eval(TreeRight(t)); if (right == 0) { printf("Error: Div by 0; using 1 instead\n"); return eval(TreeLeft(t)); } else return eval(TreeLeft(t)) / right; return 0; // shouldn't reach here } // end of eval()

50. this function finds or creates a symbol table entry for the id, and
SymbolInfo *evalID(Tree *t) { char *id = TreeID(t); return getIDEntry(id); // create sym. table entry for id } // end of evalID()
this function finds or creates a
symbol table entry for the id, and
return a pointer to the entry
(same as in exprParse1.c)

51. Evaluation Examples let x = 2 let y = 3 + x
$ ./exprParse2 < test1.txt : x declared x = 2 == 2 y declared y = 5 == 5

52. // test2.txt example let x56 = 2 let bing_BONG = (27 * 2) - x56
$ ./exprParse2 < test2.txt : x56 declared x56 = 2 == 2 bing_BONG declared bing_BONG = 52 == 52 == 110
// test2.txt example
let x56 = 2
let bing_BONG = (27 * 2) - x56
5 * (67 / 3)

53. 5 + 6 let x = 2 3 + ( (x*y)/2) // comments // y let x = 5 let y = x /0
$ ./exprParse2 < test3.txt : == 11 x declared x = 2 == 2 y declared == 3 x = 5 == 5 Error: Division by zero; using 1 instead y = 5