1. Compiler Construction Compiler Construction Semantic Analysis I

2. 2

3. CFG -> DFA Item: E ::= E +. E - indicates the rule E ::= E + E,and that we have parsed E, seen a +, and we are ready to parse another E State has many items – S ::= id. := E – S ::= id. : S If the grammar has no reduce-reduce and no shift-reduce conflicts, it is LR(0) 3

4. Closures E ::= E +. T – E ::= E +. T – T ::=. T * F – T ::=. T / F – T ::=. F – F ::=. num – F ::=. id 4 CFG: E ::= E + T T ::= T * F T ::= T / F T ::= F F ::= num F ::= id

5. Example S ::= R $ R ::= R b R ::= a 5

6. Example2 S ::= E $ E ::= E + T | T T ::= id | ( E ) 6 sactiongoto id()+$SET 0s5s6 19 1 s3s2 2aaaaa 3s5s6 4 4r2 5r4 6s5s6 79 7 s8s3 8r5 9r3

7. A grammar that is not LR(0) S ::= E $ E ::= E + T | T T ::= T * F | F F ::= id | ( E ) State I1 has a shift-reduce conflict! 7 I0: S ::=. E $ E ::=. E + T E ::=. T T ::=. T * F T ::=. F F ::=. id F ::=. ( E ) I1: E ::= T. T ::= T. * F

8. Another grammar that is not LR(0) S ::= X X ::= Y | id Y ::= id State I1 has a reduce-reduce conflict! 8 I0: S ::=. X $ X ::=. Y X ::=. id Y ::=. id I1: X ::= id. Y ::= id.

9. Can we fix it? S ::= E $ E ::= E + T | T T ::= T * F | F F ::= id | ( E ) We can see that * can’t follow E. Use the look-ahead token to resolve conflict. This is SLR(1) which is more powerful than LR(0) 9

10. LR(1) vs LALR(1) In LR(1),item A ::= a, s1 != A ::= a, s2 if s1 != s2. This results to a large number of states LALR(1) : – New item: A := a, s3, where s3 is the union of s1 and s2 Since we make the expected lookahead sets larger, there is a danger that some conflicts will have worse chances to be resolved. 10

11. LR variants LR(0) – what we’ve seen so far SLR(1) – Removes infeasible reduce actions via FOLLOW set reasoning LR(1) – LR(0) with one lookahead token in items LALR(1) – LR(1) with merging of states with same LR(0) component 11

12. Grammar Hierarchy 12 Non-ambiguous CFG LR(1) LALR(1) SLR(1) LL(1) LR(0)

13. 13

14. Semantic analysis: motivation Syntax analysis is not enough 14 int a; a = “hello”; int a; b = 1; Assigning wrong type Assigning undeclared variable int a; int a; a = 1; Variable re declaration

15. Goals of semantic analysis Check “correct” use of programming constructs Context sensitive – Beyond context-free grammars – Deeper analysis than lexical and syntax analysis Semantic rules for checking correctness – Scope rules – Type-checking rules – Other specific rules Guarantee partial correctness – Runtime checks pointer dereferencing array access … 15

16. Semantic rules: examples A variable must be declared before being used A variable should not be declared multiple times A variable should be initialized before being used Non-void method should contain return statement along all execution paths break / continue statements allowed only in loops this keyword cannot be used in static method main method should have specific signature 16

17. Example of semantic rules Type rules are an important class of semantic rules – In an assignment, RHS and LHS must have the same type – The type of a conditional test expression must be Boolean 17

18. Scope Scope of identifier – portion of program where identifier can be referred to Scope – Statement block – Method body – Class body – Module / package / file – Whole program (multiple modules) 18

19. Scope example 19 class Foo { int value; int test() { int b = 3; return value + b; } void setValue(int c) { value = c; { int d = c; c = c + d; value = c; } class Bar extends Foo { void setValue(int c) { value = c; test(); } scope of local variable b scope of formal parameter c scope of c scope of local variable in statement block d scope of method test scope of field value

20. Scope nesting Scopes may be enclosed in other scopes void foo(){ int a; … { int a; } } 20 same name but different symbol

21. Scope tree Generally scope hierarchy forms a tree 21 class Foo { int value; int test() { int b = 3; return value + b; } void setValue(int c) { value = c; { int d = c; c = c + d; value = c; } Foo value test b setValue c block I d block I

22. Subclasses Scope of subclass enclosed in scope of its superclass – Subtype relation must be acyclic 22 Class Foo { int a; } Class Bar extends Foo { } Bar sees “a” as well

23. Scope hierarchy in IC Global scope – The names of all classes defined in the program Class scope – Instance scope: all fields and methods of the class – Static scope: all static methods – Scope of subclass nested in scope of its superclass Method scope – Formal parameters and local variables Code block scope – Variables defined in block 23

24. Scope rules in IC “When resolving an identifier at a certain point in the program, the enclosing scopes are searched for that identifier.” “local variables and method parameters can only be used after they are defined in one of the enclosing block or method scopes.” “Fields and virtual methods can be used in expressions of the form e.f or e.m() when e has class type C and the instance scope of C contains those fields and methods.” “ static methods can be used in expressions of the form C.m() if the static scope of C contains m.” … 24

25. Symbol table An environment that stores information about identifiers A data structure that captures scope information 25 SymbolKindTypeProperties valuefieldint… testmethod-> intprivate setValuemethodint -> voidpublic

26. Symbol table Each entry in symbol table contains – name of an identifier – kind (variable/method/field…) – Type (int, string, myClass…) – Additional properties, e.g., final, public One symbol table for each scope 26

27. Scope nesting in IC 27 SymbolKindTypeProperties Global SymbolKindTypeProperties Class SymbolKindTypeProperties Method SymbolKindTypeProperties Block names of all classes fields and methods formals + locals variables defined in block

28. Symbol table example 28 class Foo { int value; int test() { int b = 3; return value + b; } void setValue(int c) { value = c; { int d = c; c = c + d; value = c; } scope of value scope of b scope of c scope of d block1

29. Symbol table example 29 class Foo { int value; int test() { int b = 3; return value + b; } void setValue(int c) { value = c; { int d = c; c = c + d; value = c; } SymbolKindTypeProperties valuefieldint… testmethod-> int setValuemethodint -> void (Foo) SymbolKindTypeProperties bvarint… (test) SymbolKindTypeProperties cvarint… (setValue) SymbolKindTypeProperties dvarint… (block1)

30. Checking scope rules 30 SymbolKindTypeProperties valuefieldint… testmethod-> int setValuemethodint -> void SymbolKindTypeProperties bvarint… SymbolKindTypeProperties cvarint… SymbolKindTypeProperties dvarint… (Foo) (test)(setValue) (block1) void setValue(int c) { value = c; { int d = c; c = c + d; value = c; } lookup(value)

31. Catching semantic errors 31 SymbolKindTypeProperties valuefieldint… testmethod-> int setValuemethodint -> void SymbolKindTypeProperties bvarint… SymbolKindTypeProperties cvarint… SymbolKindTypeProperties dvarint… (Foo) (test)(setValue) (block1) void setValue(int c) { value = c; { int d = c; c = c + d; myValue = c; } lookup(myValue) Error ! undefined symbol

32. Symbol table operations insert – Insert new symbol (to current scope) lookup – Try to find a symbol in the table – May cause lookup in parent tables – Report an error when symbol not found How do we check illegal re-definitions? 32

33. Symbol table construction via AST traversal 33 class MethodDecl Stmt MethodDecl ClassDecl root name=Foo name=setValue name=test VarDecl id=b StmtBlock Stmt VarDecl id=d Symbolkind globals Symbolkind Foo Symbol test Symbol setValue Foo testmethod setValuemethod bvar c Symbol block1 dvar

34. Linking AST nodes to enclosing table 34 class MethodDecl Stmt MethodDecl ClassDecl root name=Foo name=setValue name=test VarDecl id=b StmtBlock Stmt VarDecl id=d Symbolkind globals Symbolkind Foo Symbol test Symbol setValue Foo testmethod setValuemethod bvar c Symbol block1 dvar

35. What’s in an AST node public abstract class ASTNode { /** line in source program **/ private int line; /** reference to symbol table of enclosing scope **/ private SymbolTable enclosingScope; /** accept visitor **/ public abstract void accept(Visitor v); /** accept propagating visitor **/ public abstract U accept(PropagatingVisitor v,D context); /** return line number of this AST node in program **/ public int getLine() {…} /** returns symbol table of enclosing scope **/ public SymbolTable enclosingScope() {…} } 35

36. Symbol table implementation public class SymbolTable { /** map from String to Symbol **/ private Map entries; private String id; private SymbolTable parentSymbolTable; public SymbolTable(String id) { this.id = id; entries = new HashMap (); } … } public class Symbol { private String id; private Type type; private Kind kind; … } 36

37. Symbol table implementation Using java.util.HashMap – HashMap keys should obey equals / hashcode contracts – Safe when key is symbol name ( String ) 37

38. Forward references class A { void foo() { bar(); } void bar() { … } 38 Program root ClassDecl id=A MethodDecl id=foo retType=void MethodDecl id=bar retType=void Call id=bar() class Symbolkind globals Symbolkind A A foomethod barmethod Undefined identifier bar() bar used before encountered declaration How do we handle forward references?

39. Multiple phases Building visitor – A propagating visitor – Propagates reference to the symbol table of the current scope Checking visitor – On visit to node perform check using symbol tables Resolve identifiers – Look for symbol in table hierarchy 39

40. Building phase 40 class MethodDecl ClassDecl root name=Foo name=setValue name=test VarDecl id=b StmtBlock Stmt VarDecl id=d Symbolkind globals Symbolkind Foo SymbolKind test Symbolkind setValue Foo testmethod setValuemethod bvar c Symbolkind block1 dvar unresolved symbol Stmt setValue()

41. Checking phase 41 class MethodDecl ClassDecl root name=Foo name=setValue name=test VarDecl id=b StmtBlock Stmt VarDecl id=d Symbolkind globals Symbolkind Foo SymbolKind test Symbolkind setValue Foo testmethod setValuemethod bvar c Symbolkind block1 dvar Stmt setValue()

42. Forward references – solution 2 Use forward reference marker Update symbol table when symbol defined – Remove forward-reference marker Count unresolved symbols Upon exit check that #unresolved=0 42

43. Forward reference flag example class A { void foo() { bar(); } void bar() { … } 43 Program root ClassDecl id=A MethodDecl id=foo retType=void MethodDecl id=bar retType=void Call id=bar() class Symbolkind globals SymbolkindFREF A A foomethod barmethodtrue