ANNOUNCEMENTS:

• No class next Tuesday (3/3/98)
• Prof. Fischer's office hours will be 11-12 next Monday (3/2/98)
• Read sections 5.1-5.3 in the textbook
• The midterm exam will be approximately 1-2 weeks later than the tentative date

Abstract Syntax Trees (AST) and Java Cup

stmt -> ident = exp ;
stmt ::= ident asg exp semi
stmt ::= ident:i asg exp:e semi
	  {: RESULT = new asgNode(i, e, i.linenum, i.colnum);
	   :}

		-----------
      stmt = 	| asgNode |
		-----------
		 /	\
        	/	 \
     	      ident	 exp

Example 2

original production: in cup form with actions:

stmts -> stmt stmts stmts ::= stmt:s1 stmts:s2 {: RESULT = new stmtsNode(s1, s2, s1.linenum, s1.colnum); :}

AST Tree produced:

		-------------
       stmts =  | stmtsNode |
		-------------
	 	 /	\
		/	 \
	      stmt	stmts

The parser generator combines the AST trees produced by each production to form the complete tree for the given grammar. Later, type checking and code generation can be done on a node by node basis. Combining the above two examples gives the following AST tree:

		-------------
       		| stmtsNode |
		-------------
	 	 /	\
		/	 \
	  -----------	... (not defined in this example)	
	  | asgNode |
	  -----------
	    /	\
	   /	 \
	 ident	 exp

For project 3, we will build an unparser utility which will walk through the complete AST tree and print out the original tokens in the same way they were entered. This not only facilitates grading, but is a good way to check for errors in the structure of the tree for debugging. Each node will have a member function "void Unparse(int indent)" to print out the information it contains.

For example, the Unparse routine for identNode will be easy to implement. It will print out the serial number for the token, using Registration.toString(). A more complex example is for the asgNode. The code for this is as follows:

	
	void Unparse(int indent){
		genIndent(indent);
		target.Unparse(0);
		System.out.print(" = ");
		source.Unparse(0);
		System.out.println(";");
	}

GRAMMAR ANALYSIS

S -> A B | x B-> b A -> a A C -> d

As discussed last lecture, this grammar has two structural problems: C is not reachable from the start production (unreachable non-terminal) A causes an infinite loop if it is reached (non terminating non-terminal)

Marking Algorithms (such as the three below) can be used to fix these and other grammar errors. Note that in these algorithms that if a non-terminal is marked, all instances of it should be marked. For these notes, marked non-terminals will be in parentheses.

1. Mark all terminal symbols
2. while (there are more symbols that can be marked){
   if (all symbols on right side of arrow are marked){ mark left side }
   }

(S) -> A (B)
     | (x)
(B) -> (b)
(A) -> (a) A
(C) -> (d)

1. Mark start symbol
2. while (there are more symbols that can be marked){
   if (left side is marked){ mark all non-terminals on right side }
   }

(S) -> (A) (B)
     |  (x)
(B) -> (b)
(A) -> (a) (A)
 C  -> d

A -> B C
B -> lambda
C -> lambda

1. If (A->lambda) is a production, mark A.
2. while (there are more symbols that can be marked){
   if (B-> C D E ... X is a production and the entire right side is marked){ mark B }
   }

S -> A (B) (C)
A -> a
(B) -> (C)  (D)
(D) -> d | lambda
(C) -> c | lambda

Derivation
Step		Expression
0		S -> A B C
1		S => a B C
2		  => a C D C
3		  => a D C
4		  => a C
5		  => a

Some notation and examples:

=>	one derivation step		(ex.  	see above)		
=>+	one or more derivation steps	(ex.	S=>+ a)
=>*	zero or more derivation steps	(ex	S=>* S)

PARSING

• Top Down (simpler method)
• Bottom Up (more powerful method)

E -> E + T
   | T
T-> T  * ID
   |  ID

start here->	  E
       	       /  |   \
      	      E   +    T
      	      |	       |
      	      T	       ID
              |
      	      ID	

Bottom Up Parse

Search for ID in all productions Try expanding each non-terminal until you get the correct expression

E / | \ E | | | | | T | T | | | start here -> ID + ID

Top Down parsing is simpler but slower because you have to search each production for each non-terminal in the expression. Later, we will learn more precise techniques for finding these parse trees. In general, top-down parsing uses approximately i^3 steps to parse an expression where i is the number of tokens.

		Number of Tries 
Expression	to Get Correct Parse		i
---------------------------------------------------
(a]			7			2	
((a]]			17			4
(((a]]]			37			6