View
220
Download
1
Embed Size (px)
Citation preview
Outline• What is Semantic Analysis
• Why is it needed?
• Syntax directed translations/attribute grammar (Chapter 3)
Semantic Analysis
• The “meaning of the program”
• Requirements related to the “context” in which a construct occurs
• Context sensitive requirements - cannot be specified using a context free grammar
• Requires complicated and unnatural context free grammars
• Guides subsequent phases
Basic Compiler Phases
Source program (string)
Fin. Assembly
lexical analysis
syntax analysis
semantic analysis
Tokens
Abstract syntax tree
Front-End
Back-End
Example Semantic Condition
• In C – break statements can only occur inside switch or
loop statements
Partial Grammar for C
Stm Exp;
Stm if (Exp) Stm
Stm if (Exp) Stm else Stm
Stm while (Exp) do Stm
Stm break;
Stm {StList }
StList StList Stm
StList
Refined Grammar for C
StmExp;
Stm if (Exp) Stm
Stm if (Exp) Stm else Stm
Stm while (Exp) do LStm
Stm {StList }
StList StList Stm
StList
LStm break;
LStm Exp;
LStm if (Exp) LStm
LStm if (Exp) LStm else LStm
LStm while (Exp) do LStm
LStm {LStList }
LStList LStList LStm
LStList
A Possible Abstract Syntax for Ctypedef struct A_St_ *A_St;struct A_St { enum {A_if, A_while, A_break, A_block, ...} kind; A_pos pos; union { struct { A_Exp e; A_St st1; A_St st2; } if_st; struct { A_Exp e; A_St st; } while_st; struct { A_St st1; A_St st2; } block_st; ... } u ; }
A_St A_IfStm(A_Exp, A_St, A_St);A_St A_WhileStm(A_Exp A_St);A_St A_BreakStm(void);A_St A_BlockStm(A_St, A_St);
stm : IF ‘(‘ exp ‘)’ stm { $$ = A_IfStm($3, $5, NULL) ; } | IF ‘(‘ exp ‘)’ stm ELSE stm { $$ = A_IfStm($3, $5, $7) ; }
| WHILE ‘(‘ exp ‘)’ stm { $$ = A_WhileStm($3, $5); } | ‘{‘ stmList ‘}’ { $$ = $2; }
| BREAK `;' { $$ = A_BreakStm(); } ;stmList : stmList st { $$ = A_BlockStm($1, $2) ;} | /* empty */ {$$ = NULL ;}
Partial Bison Specification
void check_break(A_St st){switch (st->kind) {case A_if: check_break(st-> u.if_st.st1); check_break(st->u.if_st.st2); break; case A_while: break ;case A_break: error(“Break must be enclosed within a loop”, st->pos); break; case A_block: check_break(st->u.block_st.st1) check_break(st->u.block_st.st2); break; }}
A Semantic Check(on the abstract syntax tree)
%{static int loop_count = 0 ;%}%%stm : exp ‘;’
| IF ‘(‘ exp ‘)’ stm | IF ‘(‘ exp ‘)’ stm ELSE stm
| WHILE ‘(‘ exp ‘)’ m stm { loop_count--;} | ‘{‘ stmList ‘}’
| BREAK ‘;’ { if (!loop_count) error(“Break must be enclosed within a loop”, line_count);
} ;stmList : stmList st
| /* empty */ ;
m : /* empty */ { loop_count++ ;} ;
Syntax Directed Solution
Problems with Syntax Directed Translations
• Grammar specification may be tedious (e.g., to achieve LALR(1))
• May need to rewrite the grammar to incorporate different semantics
• Modularity is impossible to achieve
• Some programming languages allow forwarddeclarations (Algol, ML and Java)
Example Semantic Condition: Scope Rules
• Variables must be defined within scope• Dynamic vs. Static Scope rules• Cannot be coded using a context free grammar
Dynamic vs. Static Scope Rules
procedure p; var x: integer procedure q ; begin { q } … x
… end { q }; procedure r ; var x: integer begin { r } q ; end; { r }begin { p } q ; r ; end { p }
Partial Grammar for Pascal
Stm id Assign Exp
Exp IntConst
Exp RealConst
Exp Exp + Exp
Exp Exp -Exp
Exp ( Exp )
Refined Grammar for Pascal
Stm RealId Assign RealExp
IntExp IntConstRealExp RealConst
IntExp IntExp + IntExp
IntExp IntExp -IntExp
IntExp ( IntExp )
StmRealId Assign IntExp
StmIntExpAssign IntExp
IntExp IntId
RealExp RealExp -RealExp
RealExp ( RealExp )
RealIntExp RealId
RealExp RealExp + RealExp
RealExp RealExp + IntExp
RealExp IntExp + RealExp
RealExp RealExp -RealExp
RealExp RealExp -IntExp
RealExp IntExp -RealExp
%%...stm : id Assign exp {compat_ass(lookup($1), $4) ; }
;exp : exp PLUS exp { compat_op(PLUS, $1, $3); $$ = op_type(PLUS, $1, $3); }
| exp MINUS exp { compat_op(MINUS, $1, $3); $$ = op_type(MINUS, $1, $3); }
| ID { $$ = lookup($1); }| INCONST { $$= ty_int ; }| REALCONST { $$ = ty_real ;}| ‘(‘ exp ‘)’ { $$ = $2 ; }
;
Syntax Directed Solution
Attribute Grammars [Knuth 68]
• Generalize syntax directed translations• Every grammar symbol can have several attributes• Every production is associated with evaluation
rules– Context rules
• The order of evaluation is automatically determined– declarative
• Multiple visits of the abstract syntax tree
stm id Assign exp {compat_ass(id.type, exp.type) }
exp exp PLUS exp { compat_op(PLUS, exp[1].type,exp[2].type) exp[0].type = op_type(PLUS, exp[1].type, exp[2].type) }exp exp MINUS exp { compat_op(MINUS, exp[1].type, exp[2].type) exp[0].type = op_type(MINUS, exp[1].type, exp[2].type) }exp ID { exp.type = lookup(id.repr) }exp INCONST { exp.type= ty_int ; }exp REALCONST { exp.type = ty_real ;}exp ‘(‘ exp ‘)’ { exp[0].type = exp[1].type ; }
Attribute Grammar for Types
Z L
{ Z.v = L.v }
Z L.L
{ Z.v = L[1].v + L[2].v }
L L B
{ L[0].v = L[1].v + B.v } L B { L.v = B.v }
}
B 0
{B.v = 0 }
B 1
{B.v = ? }
Z L
{ Z.v = L.v }
Z L.L
{ Z.v = L[1].v + L[2].v }
L L B
{ L[0].v = L[1].v + B.v } L B { L.v = B.v }
B 0
{B.v = 0 }
B 1
{B.v = 2B.s }
Z L
{ Z.v = L.v }
Z L.L
{ Z.v = L[1].v + L[2].v }
L L B
{ L[0].v = L[1].v + B.v
B.s = L[0].s
L[1].s = L[0].s + 1}
}
L B
{ L.v = B.v
B.s = L.s
}B 0
{B.v = 0 }
B 1
{B.v = 2B.s }
Z L
{ Z.v = L.v
L.s = 0 }
Z L.L
{ Z.v = L[1].v + L[2].v
L[1].s = 0
L[2].s=? }
L L B
{ L[0].v = L[1].v + B.v
B.s = L[0].s
L[1].s = L[0].s + 1}
}
L B
{ L.v = B.v
B.s = L.s
}B 0
{B.v = 0 }
B 1
{B.v = 2B.s }
Z L
{ Z.v = L.v
L.s = 0 }
Z L.L
{ Z.v = L[1].v + L[2].v
L[1].s = 0
L[2].s=-L[2].l }
L L B
{ L[0].v = L[1].v + B.v
B.s = L[0].s
L[1].s = L[0].s + 1
L[0].l = L[1].l + 1}
}
L B
{ L.v = B.v
B.s = L.s
L.l = 1
}
B 0
{B.v = 0 }
B 1
{B.v = 2B.s }
Z
L . L
B
1
L B
L B
B
1
0
1
L.l=1
L.l=1
L.l=2
L.l=3L.s=0 L.s=-3
B.s=0
L.s=-1
B.s=-1
B.s=-2
B.s=-3
B.v=1
L.v=1
B.v=0.5
L.v=0.5 B.v=0
L.v=0.5
B.v=0.125
L.v=0.625
Z.v=1.625
L.s=-2
Summary
• Several ways to enforce semantic correctness conditions– syntax
• Regular expressions
• Context free grammars
– syntax directed
– traversals on the abstract syntax tree
– later compiler phases?
– Runtime?
• There are tools that automatically generate semantic analyzer from specification(Based on attribute grammars)