4. syntax-directed translation · when translation is deﬁned in terms ofsemantic actions, the...

Introduction SDT: Syntax-Directed Translation SDD: Syntax-Directed Definition HACS

4. Syntax-Directed Translation

Eva Rose Kristoffer Rose

NYU Courant InstituteCompiler Construction (CSCI-GA.2130-001)

http://cs.nyu.edu/courses/fall14/CSCI-GA.2130-001/lecture-4.pdf

September 25, 2014

Eva Rose, Kristoffer Rose Compiler Construction (CSCI-GA.2130-001) 4. Syntax-Directed Translation September 25, 2014 1 / 62

http://cs.nyu.edu/courses/fall14/CSCI-GA.2130-001/lecture-4.pdf


1 Introduction

2 SDT: Syntax-Directed Translation

3 SDD: Syntax-Directed Definition

4 HACSReviewS-attributed SDDsRecursive Translation Schemes



1 Introduction






Contextsource program

Lexical Analysis--

Syntax AnalysisTokens

--

Semantic AnalysisTree

--

Intermediate Representation GeneratorTree

--

SymbolTable

OptimizerIR--

Code GeneratorIR--

Machine-Dependent Code OptimizerIR--

target machine code��



The Trees

TREE INTERIOR NODES GRAMMAR

parse tree nonterminals concrete syntaxabstract syntax tree programming constructs abstract syntax

Example (abstract syntax)+

−

9 5

2 E→ E + E | E− E | digit



Back to the introductory example...



From Abstract Syntax Tree (AST)

position = initial + rate * 60

parsed into abstract syntax tree:

=

〈id,1〉 +

〈id,2〉 ∗〈id,3〉〈num,60〉

id lexeme1 position2 initial3 rate



. . . to Annotated AST. . .

= t = float

〈id,1〉

t = float

+ t = float

〈id,2〉

t = float

∗ t = float

〈id,3〉

t = float

〈num,60〉

t = int

id lexeme t1 position float2 initial float3 rate float



. . . to “Fixed” AST

= t = float

〈id,1〉

t = float

+ t = float

〈id,2〉

t = float

∗ t = float

〈id,3〉

t = float

int-to-float t = float

〈num,60〉 t = int

id lexeme t1 position float2 initial float3 rate float



1 Introduction






Syntax-Directed Translation

We have built a parse (or AST) tree, now what? How will thistree and production rules help the translation?

Intuitively, we need to associate something with eachproduction and each tree node:

I something that evaluates the meaning at each node,I something that emits the meaning as program fragments.



Syntax-Directed Definition (SDD)

Attributes Each grammar symbol (terminal or nonterminal)has an attribute (“meaning”) associated.

Semantic Rules Each production has semantic rules associatedfor computing the attributes.



Example: SDD for Infix to Postfix Notation

Consider the grammar:

expr→ expr + term| expr− term| term

term→ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

expr has an attribute expr.t, term has an attribute term.t.



Example: SDD Infix to Postfix Notation

PRODUCTION SEMANTIC RULE

expr→ expr1 + term2 expr.t = expr1.t || term2.t || ′+′expr→ expr1 − term2 expr.t = expr1.t || term2.t || ′−′expr→ term1 expr.t = term1.tterm→ 0 term.t =′ 0′

term→ 1 term.t =′ 1′

. . . . . .term→ 9 term.t =′ 9′

−||− means concatenation, −1, −2 disambiguates



Attribute Values in Parse Trees

expr.t = 9 5−2+

expr.t = 9 5−

expr.t = 9

term.t = 9

9

− term.t = 5

5

+ term.t = 2

2



Translation Schemes

I Equivalent mechanism.I Attaching program fragments to productions.I The program fragments are called semantic

actions/side-effects.I They “emit” the program fragments during “tree traversal”.

Example (rest→ +term {print(′+′)} rest1)

rest

+ term {print(′+′)} rest1



Semantic Action Table: Infix to Postfix Notation

PRODUCTIONS WITH SIDE-EFFECTS/ACTIONS

expr→ expr1 + term2 {print(‘+′)}expr→ expr1 − term2 {print(‘−′)}expr→ termterm→ 0 {print(‘0′)}term→ 1 {print(‘1′)}term→ 2 {print(‘2′)}term→ 3 {print(‘3′)}term→ 4 {print(‘4′)}term→ 5 {print(‘5′)}term→ 6 {print(‘6′)}term→ 7 {print(‘7′)}term→ 8 {print(‘8′)}term→ 9 {print(‘9′)}



Tree Traversal in Translation Schemes: Depth-First

◦

◦

◦ ◦

◦

__



Semantic Actions/Side-Effects in Parse Tree

expr

expr

expr

term

9{print(′9′)}

− term

5{print(′5′)}

{print(′−′)}+ term

2{print(′2′)}

{print(′+′)}

Input: 9− 5 + 2. Output (print): 9 5−2+. Single depth-firsttraversal.



Summaryexpr.t = 95− 2+

expr.t = 95−

expr.t = 9

term.t = 9

9

− term.t = 5

5

+ term.t = 2

2 attributes/semantic rules (HACS)

expr

expr

expr

term

9

{print(′9′)}

− term

5

{print(′5′)}

{print(′−′)}+ term

2

{print(′2′)}

{print(′+′)}

semantic actions/side-effects (yacc)



Tree Traversal and Translation Schemes

When translation is defined in terms of semantic actions, thetree traversal order, that is the order in which the nodes arevisited, becomes essential.



Exercise

Construct an SDD that generates an attribute t in prefixnotation for each expression expr, for arithmetic expressions.(You only need to consider: ‘+’,’−’, and ’∗’ expressions). Prefixnotation is where the operator comes before its operands; e.g.,− x y is the prefix notation for x − y.



Solution: SDD for Infix Notation into Prefix Notation


expr→ expr1 + term2 expr.t = ′ +′ || expr1.t || term2.texpr→ expr1 − term2 expr.t = ′ −′ || expr1.t || term2.texpr→ expr1 ∗ term2 expr.t = ′ ∗′ || expr1.t || term2.texpr→ term expr.t = term.tterm→ 0 term.t =′ 0′

term→ 1 term.t =′ 1′

. . . . . .term→ 9 term.t =′ 9′



1 Introduction






Syntax-Directed Definition (SDD)

Recall the key definition:

Grammar Given a context-free grammar.Attributes Each grammar symbol (terminal or nonterminal)

has a set of attributes associated.Semantic Rules Each production has a set of semantic rules

associated for computing the attributes.

If X is a symbol, a is an attribute, then X.a denotes the value ofa at node X.



Synthesized and Inherited Attributes

Synthesized attributes at node N are defined only in terms ofthe attribute values of the children of N, and N itself.

Inherited attributes at node N is defined only in terms ofattribute values at N’s parent, N itself, and N’ssiblings.



Example: SDD for Desk Calculator


1. L→ E $ L.val = E.val2. E→ E1 + T E.val = E1.val + T.val3. E→ T E.val = T.val4. T → T1 ∗ F T.val = T1.val× F.val5. T → F T.val = F.val6. F → (E) F.val = E.val7. F → digit F.val = digit.lexval

‘val’ and ‘lexval’ are synthesized attributes.



Characteristics of Desk Calculator

I S-attributed (only synthesized attributes)

I attribute grammar (without side-effects)

Order of attribute evaluation: any bottom-up traversal.



Tree Traversal: Depth-First

◦

◦

◦ ◦

◦

__

Post-order (default). Pre-order. Binary trees: also in-order.Eva Rose, Kristoffer Rose Compiler Construction (CSCI-GA.2130-001) 4. Syntax-Directed Translation September 25, 2014 29 / 62


Exercise: Desk Calculator

Give annotated parse trees for the following expressions:

I (3 + 4) ∗ (5 + 6) $I 1 ∗ 2 ∗ 3 ∗ (4 + 5) $

(Parse trees showing attributes and their values)



Exercise: Mingling with Inherited Attributes. . .

PRODUCTION SEMANTIC RULES

1. T → F T′ T′.inh = F.val; T.val = T′.syn2. T′ → ∗ F T′1 T′1.inh = T′.inh× F.val; T′.syn = T′1.syn3. T′ → ε T′.syn = T′.inh4. F → digit F.val = digit.lexval

‘inh’ is inherited, and ‘val’, ‘syn’ are synthesized.



Dependency Graphs

Dependency graphs depicts the flow of information amongattributes.



Example: Attributes

Parse tree for 3 ∗ 5 based on SDD:

T 9 val

F 3 val

digit 1 lexval

T′5inh 8 syn

∗ F 4 val

digit 2 lexval

T′6inh 7 syn

ε

OO

''

))

OO77 ;;

ii

ii



Example: Attributes with Dependency Graph

Parse tree for 3 ∗ 5 based on SDD:

T 9 val

F 3 val

digit 1 lexval

T′5inh 8 syn

∗ F 4 val

digit 2 lexval

T′6inh 7 syn

ε

OO

''

))

OO77 ;;

ii

ii



Dependency Graphs

Central problem: Determining the efficient evaluation order forthe attribute instances in a given parse tree.



Calculating Attributes

Cycles possible!


A→ B A.s = B.i; B.i = A.s + 1

When dependency graphs have cycles, evaluation is “stuck”!



Well-behaved SDD Classes

Given an SDD, hard to tell if there exists a parse tree whosedependency graphs have cycles!

Safe way to go: use classes of SDDs that guarantee anevaluation order:

S-Attributed Definitions all attributes are synthesized.L-Attributed Definitions “left” restrictions on dependency

graph edges.



L-Attributed Definitions

Suppose an attribute rule for A→ X1 X2 . . . Xi . . . Xn producesinherited Xi.a attribute. The rule may only use:

I inherited attributes associated with the head (A),I inherited or synthesized attributes associated with the

occurences of symbols X1,X2, . . . ,Xi−1 located left of Xi.I Inherited or synthesized attributes associated with the

occurence of Xi itself, as long as not part of a dependencygraph cycle!

or, the produced attribute is synthesized.



Example: Mingling with Inherited Attributes. . .

Decide if the SDD is L-attributed and argue :






Another example

The following SDD is NOT L-attributed. Why?


A→ B C A.s = B.bB.i = F(C.c,A.s)

where B.i is inherited, and A.s, C.c are synthesized.



Another example

The following SDD is NOT L-attributed. Why?


A→ B C A.s = B.bB.i = F(C.c,A.s)



Construction of Abstract Syntax Trees

TREE INTERIOR NODES GRAMMAR

parse tree nonterminals concrete syntaxabstract syntax tree programming constructs abstract syntax

Example (abstract syntax)+

−

9 5

2 E→ E + E | E− E | digit



Construction of AST

Example 1: S-attributed SDD for simple expresssions.


1. E→ E1 + T2 E.node = new Node(′+′, E1.node, T2.node)2. E→ E1 − T2 E.node = new Node(′−′, E1.node, T2.node)3. E→ T E.node = T.node4. T → ( E ) T.node = E.node5. T → id T.node = new Leaf(id, id.entry)6. T → num T.node = new Leaf(num,num.entry)

I Show the AST for a− 4 + cEva Rose, Kristoffer Rose Compiler Construction (CSCI-GA.2130-001) 4. Syntax-Directed Translation September 25, 2014 44 / 62


Construction of AST

Example 2: L-attributed SDD for simple expresssions.


1. E→ T E′ E.node = E′.syn; E′.inh = T.node2. E′ → +T E′

1 E′1.inh = new Node(′+′, E′.node, T.node)

E′.syn = E′1.syn

3. E′ → −T E′1 E′

1.inh = new Node(′−′, E′.node, T.node)E′.syn = E′

1.syn4. E′ → ε E′.syn = E′.inh5. T → ( E ) T.node = E.node6. T → id T.node = new Leaf(id, id.entry)7. T → num T.node = new Leaf(num,num.entry)

I Show AST and dependency graph for a− 4 + c



Syntax-Directed Translation of Type Expressions


1 T → B C T.syn = C.synC.inh = B.syn

2 B→ int B.syn = integer3 B→ float B.syn = integer4 C→ [num]C1 C.syn = array(num.val, C1.syn)

C1.inh = C.inh5 C→ ε C.syn = C.inh

I Show AST and dependencies for int[2][3]



1 Introduction






HACS Review: Lexical Specification

space [ \t\n] ;

token Int | 〈Digit〉+ ;token Float | 〈Int〉 "." 〈Int〉 ;

token fragment Digit | [0−9] ;



This Week

I S-attributed SDDs.

I Recursive Translation Schemes.



S-attributed SDD

Only synthesized attributes.



Example: Type Synthesis SDD


E→ E1 + E2 E.t = Unif(E1.t, E2.t) (1)| E1 ∗ E2 E.t = Unif(E1.t, E2.t) (2)| int E.t = Int (3)| float E.t = Float (4)



Example: Type Synthesis HACS Sorts

sort Type | Int | Float;



Example: Type Synthesis HACS Unification Rules

sort Type | scheme Unif(Type,Type);Unif(Int, Int) →Int;Unif(Float, #) →Float;Unif(#, Float) →Float;



Example: Type Synthesis SDD Rule (1)

E→ E1 + E2 | E.t = Unif(E1.t, E2.t) (1)

J〈Exp#1 ↑ type(#t1)〉+〈Exp#2 ↑ type(#t2)〉K ↑ type(Unif(#t1,#t2))



Example: Type Synthesis HACS

attribute ↑type(Type);

sort Exp; ↑type;

J 〈Exp#1 ↑type(#t1)〉 + 〈Exp#2 ↑type(#t2)〉 K↑type(Unif(#t1,#t2));J 〈Exp#1 ↑type(#t1)〉 ∗ 〈Exp#2 ↑type(#t2)〉 K↑type(Unif(#t1,#t2));J 〈Int#〉 K↑type(Int);J 〈Float#〉 K↑type(Float);



Recursive Translation Scheme

// New syntax for value conversion from Int to Float:

sort Exp | Jfloat 〈Exp〉K;



Recursive Translation Scheme (II)

// New scheme for inserting all needed int−to−float conversions:

sort Exp | scheme I2F(Exp);



Recursive Translation Scheme (III)

// Cases for +:

I2F(J〈Exp#1↑type(Int)〉+〈Exp#2↑type(Int)〉K↑type(#t))→ J〈Exp I2F(#1)〉 + 〈Exp I2F(#2)〉K↑type(#t);

I2F(J〈Exp#1↑type(Float)〉+〈Exp#2↑type(Int)〉K↑type(#t))→ J〈Exp I2F(#1)〉 + (float〈Exp I2F(#2)〉)K↑type(#t);

I2F(J〈Exp#1↑type(Int)〉+〈Exp#2↑type(Float)〉K↑type(#t))→ J(float〈Exp I2F(#1)〉) + 〈Exp I2F(#2)〉K↑type(#t);

I2F(J〈Exp#1↑type(Float)〉+〈Exp#2↑type(Float)〉K↑type(#t))→ J〈Exp I2F(#1)〉 + 〈Exp I2F(#2)〉K↑type(#t);



Recursive Translation Scheme (IV)

// Cases for *:

I2F(J〈Exp#1↑type(Int)〉∗〈Exp#2↑type(Int)〉K↑type(#t))→ J〈Exp I2F(#1)〉 ∗ 〈Exp I2F(#2)〉K↑type(#t);

I2F(J〈Exp#1↑type(Float)〉∗〈Exp#2↑type(Int)〉K↑type(#t))→ J〈Exp I2F(#1)〉 ∗ (float〈Exp I2F(#2)〉)K↑type(#t);

I2F(J〈Exp#1↑type(Int)〉∗〈Exp#2↑type(Float)〉K↑type(#t))→ J(float〈Exp I2F(#1)〉) ∗ 〈Exp I2F(#2)〉K↑type(#t);

I2F(J〈Exp#1↑type(Float)〉∗〈Exp#2↑type(Float)〉K↑type(#t))→ J〈Exp I2F(#1)〉 ∗ 〈Exp I2F(#2)〉K↑type(#t);



Recursive Translation Scheme (II)

// Cases for literals:

I2F(J〈Int#1〉K↑type(#t)) →J〈Int#1〉K↑type(#t);I2F(J〈Float#1〉K↑type(#t)) →J〈Float#1〉K↑type(#t);



Questions?

[email protected] [email protected]


4. syntax-directed translation · when translation is deﬁned in terms ofsemantic actions, the...

Documents