slike bài giảng môn chương trình dịch chương 5 syntax-directed translation

Compilation PhasesSource code Scanner Parser Semantic analyzer Intermediate code generation Intermediate code Optimized code back end... One-pass CompilerBKIT code Scanner √ Parser... Mu

Syntax-Directed Translation

Dr Nguyen Hua PhungFalcuty of CSE – HCMUT

2007

Compilation Phases

Source code Scanner

Parser

Semantic analyzer

Intermediate code generation

Intermediate code

Optimized code back end

• A pass consists of reading an input file

and writing an output file

• A pass may include many phases

• One-pass or multi-pass compilation

– internal form

– information dependence

One-pass Compiler

BKIT code

Scanner √ Parser

Multi-pass Compiler

BKIT code

Scanner √ Parser

Semantic Analyzer

• enforce semantic requirements:

– is an identifier a scalar, array, struct or a method ?

– is an identifier declared before used?

Syntax-directed Definition

• Each grammar symbol associates with it a set of attributes

• Each grammar production associates with

it a set of semantics rules which evaluate

the symbols in the production

4 F.val = 8

T.val = 8 E.val = 8

4 F.val = 5

4 F.val = 5

T→ F {T.val = F.val}

E→ T {E.val = T.val}

Example 2

E → E1 + T E.node = new BinExp(E1.node,+, T.node)

E → T E.node = T.node

T → T1 * F T.node = new BinExp(T1.node,*, F.node)

T → F T.node = F.node

F → ( E ) F.node = E.node

F → digit F.node = new LitExp(digit.lexeme)

F → id F.node = new VarExp(id.lexeme)

BinExp LitExp(8)

Synthesized Attribute

• An attribute of a grammar symbol in LHS is synthesized

if its value is computed from the values of the attributes

of the grammar symbols in RHS

• A syntax-directed definition that consists of only

synthesized attributes is called a S-attributed definition

4 F.val = 8

T.val = 8 E.val = 8

Inherited Attribute

• An attribute of a grammar symbol in RHS is inherited if its value is computed from the values of the attributes of the grammar symbols in LHS and/or RHS

E’

T +

T’ F

E → T E’ E’.in = T.val; E.val = E’.val

E’ → + T E’1 E’1.in = E’.in add T.val; E.val = E’1.val

T → F T’ T’.in = F.val; T.val = T’.val

T’ → * F T’1 T’1.in = T’.in mul F.val; T’.val = T’1.val

F → digit F.val = IntVal(digit.lexeme)

E.val = E’.val = 17 E

T

E’

T +

E ’.in =E’.in add T.val = 17

L-attributed Definitions

– the attributes of X1,X2,…Xj-1

– the inherited attributes of A

E → T E’ E’.in = T.val ; E.val = E’.val

E’ → + T E’1 E’1.in = E’.in add T.va l; E.val = E’1.val

T → F T’ T’.in = F.val ; T.val = T’.val

T’ → * F T’1 T’1.in = T’.in mul F.val ; T’.val = T’1.val

E → T {E’.in = T.val} E’ {E.val = E’.val}

E’ → + T {E’1.in = E’.in add T.val} E’1 {E’.val = E’1.val}

E’ → ∈ {E’.val = E’.in}

T → F {T’.in = F.val} T’ {T.val = T’.val}

T’ → * F {T’1.in = T’.in mul F.val} T’1 {T’.val = T’1.val}

T’ → ∈ {T’.val = T’.in}

F → ( E ) {F.val = E.val}

F → digit {F.val = IntVal (digit.lexeme)}

Top-down Translation

• Read Algorithm 5.2 page 306

Imperative Approach

• Create a function for each nonterminal

• Semantics actions are inserted into

corresponding places in the function

L → E $ { print (E.val)}

E → T {E’.in = T.val} E’ {E.val = E’.val}

E’ → + T {E’1.in = E’.in add T.val} E’1 {E’.val = E’1.val}

E’ → ∈ {E’.val = E’.in}

T → F {T’.in = F.val} T’ {T.val = T’.val}

T’ → * F {T’1.in = T’.in mul F.val} T’1 {T’.val = T’1.val}

T’ → ∈ {T’.val = T’.in}

F → ( E ) {F.val = E.val}

F → digit {F.val = IntVal (digit.lexeme)}

Example (cont’d)

Select(E → TE’) = {(,digit}

• E → T { E’.in = T.val} E’ {E.val = E’.val}

Example (cont’d)

E’ → + T {E’1.in = E’.in add T.val} E’1 {E’.val = E’1.val}

E’ → ∈ {E’.val = E’.in}

int parseE’( int E’in ) {

int Tval, E1’in, E1’val, E’val;

switch (lookahead) {

case ‘+’ : match(‘+’);

Tval = parseT();

E1’in = E’in + Tval;

E1’val = parseE’( E1’in );

E’val = E1’val;

return E’val;

case ‘)’: case EOF: E’val = E’in; return E’val;

default: error(“waiting for +, ) and EOF”);

}

}

Implicit Parser Tree

• No real parser tree generated

• A nonterminal node is actually a call to the corresponding function

• A terminal node is actually a call to the

Object-oriented Approach

• A class is created for each nonterminal

• A method parse is created for each class

• For each terminal in a right hand side of a production, a call to match

• For each nonterminal in a right hand side

of a production, the corresponding object

is created and its method parse is called

class E { void parse() {

switch (lookahead) { case ‘(‘: case ‘digit’:

}

Example (cont’d)

Object E

Explicit Parser Tree

• The OO approach really creates a parser tree

• Each instance of a class represents an

instance of a nonterminal in the parser

tree

• Attributes can be attached to nodes easily

• Semantics actions can be evaluated when parsing or later

L → E $ { print (E.val)}

E → T {E’.in = T.val} E’ {E.val = E’.val}

E’ → + T {E’1.in = E’.in add T.val} E’1 {E’.val = E’1.val}

E’ → ∈ {E’.val = E’.in}

T → F {T’.in = F.val} T’ {T.val = T’.val}

T’ → * F {T’1.in = T’.in mul F.val} T’1 {T’.val = T’1.val}

T’ → ∈ {T’.val = T’.in}

F → ( E ) {F.val = E.val}

F → digit {F.val = IntVal (digit.lexeme)}

Example (cont’d)

• Attributes:

class L { }

class E { int val; }

class E’ { int in,val; }

class T { int val; }

class T’ {int in, val; }

class F {int val; }

E’.in, T’.in

E.val, E’.val, T.val, T’.val, F.val

Example (cont’d)

E’ → + T {E’1.in = E’.in add T.val} E’1 {E’.val = E’1.val}

E’ → ∈ {E’.val = E’.in}

class E’ {

int in, val;

void parse() {

switch (lookahead) { case ‘+’ : match(‘+’);

( T t = new T()).parse();

E’ e1’ = new E’();

e1’.in = this.in + t.val;

Abstract Syntax Tree (AST)

• Phrases

• AST

• How to make an AST?

An binary-expression-phrase has 2 subphrases: 2 expressions.

An if-phrase has 3 subphrases: 1 expression and 2 statements

A while-phrase has 2 subphrases: 1 expression and 1 statement

8 + 5 * 4

E T

E’

T +

• More natural than a parser tree:

– Some extra nonterminals used to solve

ambiguity become unnecessary

– Delimiters are removed

– Keywords become implicit

• Be able to traverse in any order

• Used widely in type checker, code

optimization, code generation

F → num {F.node = new LitExp(num.Lexeme)}

F → id {F.node = new VarExp(id.Lexeme)}

F → ( E ) {F.node = E.node}

BinExp VarExp(a)

F.node=new LitExp(num)

Hand-on Exercise

• Write the translation scheme to generate

an AST for the following grammar:

Directed Acyclic Graph (DAG)

• Like a syntax tree

• a node may have more than one parent

a + a * (b – c) + (b – c) * d

b a

Bottom-up Evaluation for S-attributed Definitions

• The values of the synthesized attributes

associated with the grammar symbols are kept on the stack

• When a reduction is made, the

synthesized attributes of the LHS are

computed from the attributes of the RHS

on the stack

Removing Embedding Actions

Bottom-up Evaluation for L-attributed Definitions

Stack Val

D → T {L.in = T.type } L

T → int {T.type = int}

T → float {T.type = float}

Example (con’t)

D → T L