1. Joey Paquet, 2000, 20021 Lecture 8 Syntax-Directed Translation

2. Joey Paquet, 2000, 20022 Syntax-Directed Translation Translation process driven by the syntactic structure of the program, as given by the parser Semantic actions are integrated in the parsing process In this view, compilation is divided in two parts: –analysis (syntactic, semantic) –synthesis (code generation and optimization) The semantic analysis becomes the link between analysis and synthesis

3. Joey Paquet, 2000, 20023 Syntax-Directed Translation Semantic actions (implemented as semantic routines) finish the analysis phase by performing semantic checking in productions that need such checks Semantic actions provide a meaning for the productions They are the starting point for code generation (synthesis) Thus, the semantic routines are the heart of the compiler

4. Joey Paquet, 2000, 20024 Syntax-Directed Translation Semantic routines can be formalized using attribute grammars They augment ordinary context-free grammars with attributes that represent semantic properties such as type, value or correctness used in semantic analysis (checking) and code generation (translation) It is useful to keep checking and translation facilities distinct in the semantic routines’ implementation Semantic checking is machine-independent and code generation is not, so separating them gives more flexibility to the compiler

5. Joey Paquet, 2000, 20025 Attribute Migration Attributes gathered from a child in the abstract syntax tree are called synthetized attributes Attributes gathered from a sibling in the abstract syntax tree are called inherited attributes

6. Joey Paquet, 2000, 20026 Example: Attribute Migration E 1  id = E 2 E = : [E 2 : v:  ] [(id:  )  defVar] [id.val  v] [E 1.val:   v] E 1  E 2  E 3 E * : [E 2 : v 2 :  ] [E 3 : v 3 :  ] [E 1.val:   v 2  v 3 ] E 1  E 2 + E 3 E + : [E 2 : v 2 :  ] [E 3 : v 3 :  ] [E 1.val:   v 2 + v 3 ] E  idE id : [(id:  )  defVar] [(E.val:  )  id.val] E  constE const : [const : v :  ] [(E.val:  )  v] Y=3*X+Z E (v 3*vx+vz :  ) E (v (3*vx)+vz :  )id (v Y :  ) = E (v 3*vx :  ) id (v Z :  ) + E(v Z :  ) const (3:  )id (v X :  ) * E(v X :  )E (3:  )

7. Joey Paquet, 2000, 20027 Example 2: Attribute Migration Problems arise when rules are factorized: E  TE’ E’  +TE’ |  T  FT’ T’   FT’ |  F  id | const E T1T1 T2T2 T’ 2 * F1F1 id (v a :  ) T’ 1  F2F2 id (v b :  ) E’ 2  T’ 3  F3F3 id (v c :  ) E’ 1 + a+b*c

8. Joey Paquet, 2000, 20028 Example 2: Attribute Migration E T1T1 T2T2 T’ 2 * F1F1 id (v a :  ) T’ 1  F2F2 id (v b :  ) E’ 2  T’ 3  F3F3 id (v c :  ) E’ 1 + a+b*c E  TE’ E’  +TE’ |  T  FT’ T’   FT’ |  F  id | const Solution: migrate attributes sideways:

9. Joey Paquet, 2000, 20029 Attr. Migration: Implementation Parse(){ type Es; lookahead = NextToken() if (E(Es);Match('$')) return(true); else return(false); }

10. Joey Paquet, 2000, 200210 Attr. Migration: Implementation E(type &Es){ type Ts,E's if (lookahead is in [0,1,(]) if (T(Ts);E'(Ts,E's);) // E' inherits from T write(E->TE') Es = E's // Synthetised attribute sent up return(true) else return(false) else return(false) }

11. Joey Paquet, 2000, 200211 Attr. Migration: Implementation E'(type &Ti, type &E's){ type Ts,E'2s if (lookahead is in [+]) if (Match('+');T(Ts);E'(Ts,E'2s))// E' inherits from T write(E'->TE') E's = semcheckop(Ti,E'2s) // Semantic check & synthetized // attribute sent up return(true) else return(false) else if (lookahead is in [$,)] write(E'->epsilon) E's = Ti // Synth. attr. is inhertied // from T (sibling, not child) // and sent up return(true) else return(false) }

12. Joey Paquet, 2000, 200212 Attr. Migration: Implementation T(type &Ts){ type Fs, T's if (lookahead is in [0,1,(]) if (F(Fs);T'(Fs,T's);) // T' inherits from F write(T->FT') Ts = T's // Synthetized attribute sent up return(true) else return(false) else return(false) }

13. Joey Paquet, 2000, 200213 Attr. Migration: Implementation T'(type Fi, type &T's){ type Fs, T'2s if (lookahead is in [*]) if (Match('*');F(Fs);T'(Fs,T'2s)) // T' inherits from F write(T'->*FT') T's = semcheckop(Fi,T'2s) // Sem. check + synth. // attribute sent up return(true) else return(false) else if (lookahead is in [+,$,)] write(T'->epsilon) T's = Fi // Synthetized attr. is // inhertied from F (sibling, // not child) & sent up the tree return(true) else return(false) }

14. Joey Paquet, 2000, 200214 Attr. Migration: Implementation F(type &Fs){ type Es if (lookahead is in [0]) if (Match('id')) write(F->id) Fs = gettype(id.name,table) // Gets the attribute ``type'' // from the symbol table and // sends it up the tree as Fs return(true) else return(false) else if (lookahead is in [(]) if (Match('(');E(Es);Match(')')) write(F->(E)) Fs = Es// Synthetized attribute sent // up the tree return(true) else return(false) }

15. Joey Paquet, 2000, 200215 Attr. Migration: Implementation type semcheckop(type ti,type ts){ if (ti == ts) return(ti) else return(typerror) } type gettype(name, table){ if (name is in table) return (type) else return(typerror) }