2301373semantic analysis1 checking what parsers cannot

2301373 Semantic Analysis 1

Semantic Analysis

Checking what parsers cannot


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


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


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.


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


Example of Attribute Grammar Construct:

num digit

Attribute: val

Grammar num -> num digit num -> digit digit -> 0|1|…|9

Grammar rule Semantic rule

num1 -> num2 digit num1.val= num2.val*10+ digit.val

num -> digit num.val = digit.val

digit -> 0 digit.val = 0











Parse Tree with Attributes

numval = 45*10+5

numval = 4*10+5

digitval = 5

numval = 4

digitval = 5

digitval = 4

5

4

5















Attribute Grammar for Data Type Declaration

Grammar Ruledec -> type varListtype -> int type -> floatvarList1 -> id , varList2

varList -> id

Semantic RulevarList.dtype = type.dtypetype.dtype = inttype.dtype = realid.dtype = varList1.dtypevarList2.dtype= varList1.dtypeid.dtype = varList.dtype

type

dec

varList

floatid varList

,

id

dtype= real dtype=real

dtype=real

dtype=real

dtype=real


Another Example of Attribute Grammar

Grammar Rule

Bnum -> num baseC

baseC ->o

baseC -> d

num1 -> num2 digit

num -> digit

digit -> 0|1|…|7

digit -> 8 | 9

val=19

base=8val=3

base=8val=19 base=8

base=8val=2

base=8val=2

Bnum

num

numo

baseC

digit

digit

Semantic Rule

num.base=baseC.base Bnum.val=num.val

baseC.base=8

baseC.base=10

num2.base=num1.base digit.base=num1.base

num1.val= if digit.val=error then error else

num2.val*num1.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


Evaluation Order From semantic ruleX.a=f(X1.a1, X2.a2,…, Xn.an)

Value of a in node X depends on the values of a1 in X1, a2 in X2,…, and an in Xn.

The order of evaluation can be shown in a dependency graph, which is a directed acyclic graph (DAG).

X.a

X2.a2X1.a1 Xn.an…

X.a

X2.a2X1.a1 Xn.an…

X.a

X2.a2X1.a1 Xn.an…

X.a

X2.a2X1.a1 Xn.an…


Dependency Graph: Example 1

numval = 45*10+5

numval = 4*10+5

digitval = 5

numval = 4

digitval = 5

digitval = 4

5

4

5















Dependency Graph: Example 2Grammar Ruledec -> type varListtype -> int type -> floatvarList1 -> id , varList2

varList -> id

Semantic RulevarList.dtype = type.dtypetype.dtype = inttype.dtype = realid.dtype = varList1.dtypevarList2.dtype= varList1.dtypeid.dtype = varList.dtype

type

dec

varList

floatid varList

,

id

dtype= real dtype=real

dtype=real

dtype=real

dtype=real


Dependency Graph:Example 3Grammar Rule Semantic Rule

Bnum -> num baseC num.base=baseC.base Bnum.val=num.val

baseC ->o baseC.base=8

baseC -> d baseC.base=10

num1 -> num2 digit num2.base=num1.base digit.base=num1.base

num1.val= if digit.val=error then error else

num2.val*num1.base + digit.val

num -> digit num.val=digit.val digit.base=num.base

digit -> 0|1|…|7 digit.val = numval(D), where D is 0, 1,…,7

digit -> 8 | 9 digit.val = if digit.base=8 then error else numval(D), where D is 8,9Bnum

num

num o

baseC

digit

digit


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


Synthesized Attributes An attribute a is a

synthesized attribute if for a grammar rule A ->X1

X2 … Xn , an attribute equation with a on the

LHS is of the form A.a =

f(X1.a1, X2.a2, … Xn.an), 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.



num -> digit num.val = digit.valdigit -> 0|1|…|9 digit.val = val(D)

num

num digit

num digit

digit

5

4

5


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

num digit

num digit

digit

5

4

5 4

4 5

45

5

5

455


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 aj at Xi in each grammar rule X -> X1 X2 … Xn depends on the value of attributes of symbols X, X1, X2,…, Xi-1.

Grammar Rule Semantic Ruledec -> type varList varList.dtype = type.dtypetype -> int type.dtype = inttype -> float type.dtype = realvarList1 -> id , varList2 id.dtype = varList1.dtype

varList -> id id.dtype = varList.dtype

type

dec

varList

float id varList,

id


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 id varList,

id

float

float float

float

float


Another Example of Inherited AttributesProc 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 Rule Semantic Rule

Bnum -> num baseC num.base=baseC.base; Bnum.val=num.val

baseC ->o baseC.base=8

baseC -> d baseC.base=10

num1 -> num2 digit num2.case=num1.base; digit.base=num1.base;

num1.val= if digit.val=error then error else num2.val*num1.base + digit.val

num -> digit num.val=digit.val; digit.base=num.base

digit -> 0|1|…|7 digit.val = numval(D)

digit -> 8 | 9 digit.val = if digit.base=8 then error else numval(D)

Bnum

num

num o

baseC

digit

digit

base=8base=8

base=8

val=5base=8

val=5 base=8val=4

val=44val=44


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;

}


Attribute Computation During Parsing

2301373semantic analysis1 checking what parsers cannot

Documents

semantic analysischecking

semantic concept

return type

semantic analysisparse

semanticsan attribute

syntactic rule

attributes of variables

attributes of construct