1. 2301373Semantic Analysis1 Checking what parsers cannot

2. 2301373Semantic Analysis2 Outline  Overview  Attribute grammar Attribute Semantic rule  Computing attributes Evaluation order Synthesized and Inherited attribute Computation of attributes during parsing  Type checking Type declaration Type inference  Symbol table

3. 2301373Semantic Analysis3 Overview  Semantics Static semantics  Data type (in some languages e.g. C, FORTRAN)  Names Run-time semantics  Data value  Data type (in other languages e.g. Perl)  Semantic analyzer Determine if the semantic of the program is correct according to the definition of the language Concern only static semantics

4. 2301373Semantic Analysis4 Overview (cont’d)  How to describe semantics Associated to syntax  Syntax-directed semantics An attribute represents a semantic concept. A semantic rule (or attribute equation) is associated to a syntactic rule. A semantic rule describes the relationship between attributes of symbols in a syntactic rule.

5. 2301373Semantic Analysis5 Attribute Grammar  Language construct Variables, function declarations, statements  Attribute Property of language construct  Name, address, type, value, and scope are attributes of variables.  Return type, parameter types, return address, and scope are attributes of functions.  Syntax tree is an attributes of code sections.  Attribute equation (semantic rule) Associated with grammar production Specify the relationship between attributes of construct in a syntactic rule.  Attribute grammar Set of attribute equations

6. 2301373Semantic Analysis6 Example of Attribute Grammar  Construct: num digit  Attribute: val  Grammar num -> num digit num -> digit digit -> 0|1|…|9 Grammar ruleSemantic rule num 1 -> num 2 digit num 1.val= num 2.val*10+ digit.val num -> digitnum.val = digit.val digit -> 0digit.val = 0 digit -> 1digit.val = 1 digit -> 2digit.val = 2 digit -> 3digit.val = 3 digit -> 4digit.val = 4 digit -> 5digit.val = 5 digit -> 6digit.val = 6 digit -> 7digit.val = 7 digit -> 8digit.val = 8 digit -> 9digit.val = 9

7. 2301373Semantic Analysis7 Parse Tree with Attributes num val = 45*10+5 num val = 4*10+5 digit val = 5 num val = 4 digit val = 5 digit val = 4 5 4 5 Grammar ruleSemantic rule num 1 -> num 2 digit num 1.val= num 2.val*10+ digit.val num -> digitnum.val = digit.val digit -> 0digit.val = 0 digit -> 1digit.val = 1 digit -> 2digit.val = 2 digit -> 3digit.val = 3 digit -> 4digit.val = 4 digit -> 5digit.val = 5 digit -> 6digit.val = 6 digit -> 7digit.val = 7 digit -> 8digit.val = 8 digit -> 9digit.val = 9

8. 2301373Semantic Analysis8 Attribute Grammar for Data Type Declaration Grammar Rule dec -> type varList type -> int type -> float varList 1 -> id, varList 2 varList -> id Semantic Rule varList.dtype = type.dtype type.dtype = int type.dtype = real id.dtype = varList 1.dtype varList 2.dtype= varList 1.dtype id.dtype = varList.dtype type dec varList float idvarList, id dtype= real

9. 2301373Semantic Analysis9 Another Example of Attribute Grammar Grammar Rule Bnum -> num baseC baseC ->o baseC -> d num 1 -> num 2 digit num -> digit digit -> 0|1|…|7 digit -> 8 | 9 val=19 base=8 val=3 base=8 val=19 base=8 val=2 base=8 val=2 Bnum num o baseC digit Semantic Rule num.base=baseC.base Bnum.val=num.val baseC.base=8 baseC.base=10 num 2.base=num 1.base digit.base=num 1.base num 1.val= if digit.val=error then error else num 2.val*num 1.base + digit.val num.val=digit.val digit.base=num.base digit.val = numval(D), where D is 0, 1,…,7 digit.val = if digit.base=8 then error else numval(D), where D is 8,9

10. 2301373Semantic Analysis10 Evaluation Order  From semantic rule X.a=f(X 1.a 1, X 2.a 2,…, X n.a n ) Value of a in node X depends on the values of a 1 in X 1, a 2 in X 2,…, and a n in X n. The order of evaluation can be shown in a dependency graph, which is a directed acyclic graph (DAG). X.a X 2.a 2 X 1.a 1 X n.a n … X.a X 2.a 2 X 1.a 1 X n.a n … X.a X 2.a 2 X 1.a 1 X n.a n … X.a X 2.a 2 X 1.a 1 X n.a n …

11. 2301373Semantic Analysis11 Dependency Graph: Example 1 num val = 45*10+5 num val = 4*10+5 digit val = 5 num val = 4 digit val = 5 digit val = 4 5 4 5 Grammar ruleSemantic rule num 1 -> num 2 digit num 1.val= num 2.val*10+ digit.val num -> digitnum.val = digit.val digit -> 0digit.val = 0 digit -> 1digit.val = 1 digit -> 2digit.val = 2 digit -> 3digit.val = 3 digit -> 4digit.val = 4 digit -> 5digit.val = 5 digit -> 6digit.val = 6 digit -> 7digit.val = 7 digit -> 8digit.val = 8 digit -> 9digit.val = 9

12. 2301373Semantic Analysis12 Dependency Graph: Example 2 Grammar Rule dec -> type varList type -> int type -> float varList 1 -> id, varList 2 varList -> id Semantic Rule varList.dtype = type.dtype type.dtype = int type.dtype = real id.dtype = varList 1.dtype varList 2.dtype= varList 1.dtype id.dtype = varList.dtype type dec varList float idvarList, id dtype= real

13. 2301373Semantic Analysis13 Dependency Graph:Example 3 Grammar RuleSemantic Rule Bnum -> num baseCnum.base=baseC.base Bnum.val=num.val baseC ->obaseC.base=8 baseC -> dbaseC.base=10 num 1 -> num 2 digitnum 2.base=num 1.base digit.base=num 1.base num 1.val= if digit.val=error then error else num 2.val*num 1.base + digit.val num -> digitnum.val=digit.val digit.base=num.base digit -> 0|1|…|7digit.val = numval(D), where D is 0, 1,…,7 digit -> 8 | 9digit.val = if digit.base=8 then error else numval(D), where D is 8,9 Bnum num o baseC digit

14. 2301373Semantic Analysis14 Rule-based Attribute Evaluation  Order of attribute evaluation can be fixed at compiler construction Attribute grammar is to be analyzed in order to find the orger of evaluation  Used often in practice  Not general method  Two types of attributes Synthesized attributes Inherited attributes

15. 2301373Semantic Analysis15 Synthesized Attributes  An attribute a is a synthesized attribute if for a grammar rule A ->X 1 X 2 … X n, an attribute equation with a on the LHS is of the form A. a = f( X 1. a 1, X 2. a 2, … X n. a n ), or all dependencies point from child to parent in the parse tree  If all attributes in an attribute grammar are synthesized attributes, the grammar is called an S- attributed grammar. Grammar ruleSemantic rule num 1 -> num 2 digit num 1.val= num 2.val*10+ digit.val num -> digitnum.val = digit.val digit -> 0|1|…|9digit.val = val(D) num digit numdigit 5 4 5

16. 2301373Semantic Analysis16 Order of Evaluation for Synthesized Attributes  Use postorder (or bottom- up) evaluation Procedure PostEval (T:node) {for each child C of T {PostEval(C); } compute all synthesized attributes of T } num digit numdigit 5 4 5 4 4 5 45 5 5 455

17. 2301373Semantic Analysis17 Inherited Attributes  An attribute is an inherited attribute if it is not a synthesized attribute.  An attribute grammar is an L-attributed grammar if for each inherited attribute a j at X i in each grammar rule X -> X 1 X 2 … X n depends on the value of attributes of symbols X, X 1, X 2,…, X i-1. Grammar RuleSemantic Rule dec -> type varListvarList.dtype = type.dtype type -> int type.dtype = int type -> float type.dtype = real varList 1 -> id, varList 2 id.dtype = varList 1.dtype varList -> id id.dtype = varList.dtype type dec varList float idvarList, id

18. 2301373Semantic Analysis18 Order of Evaluation for Inherited Attributes  Use preorder and inorder evaluation together Procedure Eval (T:node) {case nodeType(T) of dec: {Eval(typeChild(T)); varList.dtype=type.dtype; Eval(varChild(T));} type: {if child(T) is int then T.dtype=int; if child(T) is float then T.dtype=real; } varList: {leftChild(T).dtype=T.dtype; if (rightmostChild(T) is not null) then {rightmostChild(T).dtype=T.dtype; Eval(rightChild(T));} } type dec varList float idvarList, id float

19. 2301373Semantic Analysis19 Another Example of Inherited Attributes Proc Eval(T:node) { case Nodetype(T) of Bnum: { Eval(rightChild(T)); (leftChild(T)).base= (rightChild(T)).base; Eval(leftChild(T)); T.val=leftChild(T).val;} baseC: { if child(T)=o then T.base=8; if child(T)=d thenT.base=10;} num: { leftChild(T).base=T.base; Eval(leftChild(T)); if (rightChild(T)!=null) then { rightChild(T).base=T.base; Eval(rightChild(T); T.val=f(T); } else T.val=leftChild(T).val; cal val} digit: { … } } Grammar RuleSemantic Rule Bnum -> num baseCnum.base=baseC.base; Bnum.val=num.val baseC ->obaseC.base=8 baseC -> dbaseC.base=10 num 1 -> num 2 digitnum 2.case=num 1.base; digit.base=num 1.base; num 1.val= if digit.val=error then error else num 2.val*num 1.base + digit.val num -> digitnum.val=digit.val; digit.base=num.base digit -> 0|1|…|7digit.val = numval(D) digit -> 8 | 9 digit.val = if digit.base=8 then error else numval(D) Bnum num o baseC digit base=8 val=5 base=8 val=5 base=8 val=4 val=44

20. 2301373Semantic Analysis20 Evaluation Order for Synthesized + Inherited Attributes Procedure CombinedEval(T:node) {for each child C of T {compute all inherited attributes of C; CombinedEval(C); } compute all synthesized attributes of T; }

21. 2301373Semantic Analysis21 Attribute Computation During Parsing