Syntax-Directed Translation

1
Syntax-Directed Translation

2
Syntax-Directed Translation

3
 Syntax-Directed Translation
In a syntax-directed definition, each production A→α is associated
with a set of semantic rules of the form:
b=f(c1,c2,…,cn)
where f is a function and b can be one of the followings:

 b is a synthesized attribute of A and c1,c2,…,cn are attributes of

the grammar symbols in the production ( A→α ).
OR
 b is an inherited attribute one of the grammar symbols in α (on
the right side of the production), and c1,c2,…,cn are attributes of the
grammar symbols in the production ( A→α ).

4
 Syntax-Directed Translation

1. We associate information with the programming language constructs by

attaching attributes to grammar symbols.

2. Values of these attributes are evaluated by the semantic rules associated

with the production rules.

3. Evaluation of these semantic rules:

– may generate intermediate codes
– may put information into the symbol table
– may perform type checking
– may issue error messages
– may perform some other activities
– in fact, they may perform almost any activities.

4. An attribute may hold almost any thing.

– a string, a number, a memory location, a complex record.

5
Example : Syntax-Directed Translation

6
 Annotated Parse Tree
1. A parse tree showing the values of attributes at each node is called
an annotated parse tree.
2. Values of Attributes in nodes of annotated parse-tree are either,
– initialized to constant values or by the lexical analyzer.
– determined by the semantic-rules.

3. The process of computing the attributes values at the nodes is

called annotating (or decorating) of the parse tree.

4. Of course, the order of these computations depends on the

dependency graph induced by the semantic rules.

7
Syntax-Directed Definitions and Translation Schemes
1. When we associate semantic rules with productions, we use two
notations:
– Syntax-Directed Definitions (abstract)
– Translation Schemes (detail)

A. Syntax-Directed Definitions:
– give high-level specifications for translations
– hide many implementation details such as order of evaluation of semantic actions.
– We associate a production rule with a set of semantic actions, and we do not say when
they will be evaluated.

B. Translation Schemes:
– indicate the order of evaluation of semantic actions associated with a production rule.
– In other words, translation schemes give a little bit information about implementation
details.
8
 Syntax-Directed Definitions and Translation
Schemes
• Conceptually with both the syntax directed translation and
translation scheme we
– Parse the input token stream
– Build the parse tree
– Traverse the tree to evaluate the semantic rules at the parse tree nodes.

Input string parse tree dependency graph evaluation

order for
semantic rules

Conceptual view of syntax directed translation

9
 Syntax-Directed Definition -- Example

Production Semantic Rules

L→En print(E.val)
E → E1 + T E.val = E1.val + T.val
E→T E.val = T.val
T → T1 * F T.val = T1.val * F.val
T→F T.val = F.val
F→(E) F.val = E.val
F → digit F.val = digit.lexval
1. Symbols E, T, and F are associated with a synthesized attribute val.
2. The token digit has a synthesized attribute lexval (it is assumed that it is
evaluated by the lexical analyzer).
3. Terminals are assumed to have synthesized attributes only. Values for attributes
of terminals are usually supplied by the lexical analyzer.
4. The start symbol does not have any inherited attribute unless otherwise stated.
10
Order of Evaluation

11
 Dependency Graph
• Directed Graph
• Shows interdependencies between attributes.
• If an attribute b at a node depends on an attribute c, then the semantic rule for b
at that node must be evaluated after the semantic rule that defines c.
• Construction:
– Put each semantic rule into the form b=f(c1,…,ck) by introducing dummy
synthesized attribute b for every semantic rule that consists of a procedure
call.
– E.g.,
• LEn print(E.val)
• Becomes: dummy = print(E.val)

– The graph has a node for each attribute and an edge to the node for b from the
node for c if attribute b depends on attribute c.

12
 Dependency Graph Construction
for each node n in the parse tree do
for each attribute a of the grammar symbol at n do
construct a node in the dependency graph for a

for each node n in the parse tree do

for each semantic rule b = f(c1,…,cn)
associated with the production used at n do
for i= 1 to n do
construct an edge from
the node for ci to the node for b

13
 Dependency Graph Construction
• Example
• Production Semantic Rule
E→E1 + E2 E.val = E1.val + E2.val

E . val

E1. val + E2 . Val

• E.val is synthesized from E1.val and E2.val
• The dotted lines represent the parse tree that is not part of the
dependency graph.

14
 Dependency Graph
D → T L L.in = T.type
T → int T.type = integer
T → real T.type = real
L → L1 id L1.in = L.in,
addtype(id.entry,L.in)

L → id addtype(id.entry,L.in)

15
 Attribute Grammar
• So, a semantic rule b=f(c1,c2,…,cn) indicates that the attribute b
depends on attributes c1,c2,…,cn.

• In a syntax-directed definition, a semantic rule may evaluate a

value of an attribute or it may have some side effects such as
printing values.

• An attribute grammar is a syntax-directed definition in which the

functions in the semantic rules cannot have side effects (they
can only evaluate values of attributes).

16
S-Attributed Definition

17
 Draw the Tree Example 3*5+4n
L

E val=19
Print(19)
E val=15

T val=15
T val=4
T val=3
F val=4
F val=3 F val=5
n
digit
* + lexval =4
digit digit
lexval =3 lexval =5
 Dependency Graph of Previous Example
Input: 3*5+4 L

E.val=19 n

E.val=15 + T.val=4

T.val=15 F.val=4

T.val=3 * F.val=5 digit.lexval=4

F.val=3 digit.lexval=5
digit.lexval=3
19
 Inherited attributes
• An inherited value at a node in a parse tree is defined in terms of
attributes at the parent and/or siblings of the node.

• Convenient way for expressing the dependency of a programming

language construct on the context in which it appears.

• We can use inherited attributes to keep track of whether an

identifier appears on the left or right side of an assignment to
decide whether the address or value of the assignment is needed.

• Example: The inherited attribute distributes type information to the

various identifiers in a declaration.
20
 Syntax-Directed Definition – Inherited Attributes

Production Semantic Rules

D→TL L.in = T.type
T → int T.type = integer
T → real T.type = real
L → L1 id L1.in = L.in, addtype(id.entry,L.in)
L → id addtype(id.entry,L.in)

1. Symbol T is associated with a synthesized attribute type.

2. Symbol L is associated with an inherited attribute in.

21
 L-Attributed Definitions
• When translation takes place during parsing, order of evaluation is
linked to the order in which the nodes of a parse tree are created by
parsing method.
• A natural order can be obtained by applying the procedure dfvisit to the
root of a parse tree.
• We call this evaluation order depth first order.
• L-attributed definition is a class of syntax directed definition whose
attributes can always be evaluated in depth first order( L stands for left
since attribute information flows from left to right).
 L-Attributed Definitions

A syntax-directed definition is L-attributed if each inherited

attribute of Xj, where 1≤j≤n, on the right side of A → X1X2...Xn
depends only on

1. The attributes of the symbols X1,...,Xj-1 to the left of Xj in the

production

2. The inherited attribute of A

Every S-attributed definition is L-attributed, since the restrictions

apply only to the inherited attributes (not to synthesized
attributes).
 Evaluating Semantic Rules
• Parse Tree methods
– At compile time evaluation order obtained from the topological sort of
dependency graph.
– Fails if dependency graph has a cycle
• Rule Based Methods
– Semantic rules analyzed by hand or specialized tools at compiler
construction time
– Order of evaluation of attributes associated with a production is pre-
determined at compiler construction time
• Oblivious Methods
– Evaluation order is chosen without considering the semantic rules.
– Restricts the class of syntax directed definitions that can be implemented.
– If translation takes place during parsing order of evaluation is forced by
parsing method.

24
 Syntax Trees

Syntax-Tree
– an intermediate representation of the compiler’s input.
– A condensed form of the parse tree.
– Syntax tree shows the syntactic structure of the program while
omitting irrelevant details.
– Operators and keywords are associated with the interior nodes.
– Chains of simple productions are collapsed.
Syntax directed translation can be based on syntax tree as well as
parse tree.

25
 Syntax Tree-Examples
Expression: if B then S1 else S2
+ if - then - else

5 * B S1 S2
Statement:
3 4 • Node’s label indicates what kind
• Leaves: identifiers or constants of a statement it is
• Internal nodes: labelled with • Children of a node correspond to
operations the components of the statement
• Children: of a node are its
operands
26
 Constructing Syntax Tree for Expressions
• Each node can be implemented as a record with several fields.
• Operator node: one field identifies the operator (called label of
the node) and remaining fields contain pointers to operands.
• The nodes may also contain fields to hold the values (pointers to
values) of attributes attached to the nodes.

• Functions used to create nodes of syntax tree for expressions

with binary operator are given below.
– mknode(op,left,right)
– mkleaf(id,entry)
– mkleaf(num,val)

Each function returns a pointer to a newly created node.

27
 Constructing Syntax Tree for Expressions-

Example: a-4+c
+
1. p1:=mkleaf(id,entrya);
2. p2:=mkleaf(num,4);
- id
3. p3:=mknode(-,p1,p2)
4. p4:=mkleaf(id,entryc);
to entry for c
5. p5:= mknode(+,p3,p4); num 4
id

• The tree is constructed to entry for a

bottom up.

28
 A syntax Directed Definition for Constructing
Syntax Tree
1. It uses underlying productions of the grammar to schedule the calls
of the functions mkleaf and mknode to construct the syntax tree
2. Employment of the synthesized attribute nptr (pointer) for E and T
to keep track of the pointers returned by the function calls.
PRODUCTIONSEMANTIC RULE
E  E1 + T E.nptr = mknode(“+”,E1.nptr ,T.nptr)
E  E1 - T E.nptr = mknode(“-”,E1.nptr ,T.nptr)
ET E.nptr = T.nptr
T  (E) T.nptr = E.nptr
T  id T.nptr = mkleaf(id, id.lexval)
T  num T.nptr = mkleaf(num, num.val)

29
 Annotated parse tree depicting construction of
syntax tree for the expression a-4+c
E.nptr

E.nptr + T.nptr

E.nptr - T.nptr id
+
T.nptr num
- id
id
Entry for c
id nu
m
Entry for a 30
 A Translation Scheme Example
• A simple translation scheme that converts infix expressions
to the
corresponding postfix expressions.
E→TR
R → + T { print(“+”) } R1
R→ε
T → id { print(id.name) }
a+b+c ab+c+

infix expression postfix expression

 Translation of Assignment Statements
• In the syntax directed translation, assignment statement is mainly
dealt with expressions. The expression can be of type real, integer,
array and records.
• Consider the grammar

S → id := E
E → E1 + E2
E → E1 * E2
E → (E1)
E → id
 Translation of Assignment Statements
Production rule Semantic actions
• The p returns the entry
S → id :=E {p = look_up(id.name);
If p ≠ nil then
for id.name in the
Emit (p = E.place) symbol table.
Else
Error; • The Emit function is
} used for appending the
E → E1 + E2 {E.place = newtemp(); three address code to
Emit (E.place = E1.place '+'
E2.place) the output file.
} Otherwise it will report
E → E1 * E2 {E.place = newtemp(); an error.
Emit (E.place = E1.place '*'
E2.place) • The newtemp() is a
}
function used to
E → (E1) {E.place = E1.place}
generate new temporary
E → id {p = look_up(id.name);
If p ≠ nil then variables.
Emit (E.place = p)
Else
• E.place holds the value
Error; of E.
}
 Translation of Assignment Statements
S • Consider the
assignment and
id := E expression statement as:
x:= a*b + c*d
E1 E2
+
E2 E1 E2
E1
*
*
id id
id id

c d
a b
 Translation of Assignment Statements
Production rule Semantic actions • Consider the
E → id {p = look_up(id.name); assignment and
id.name is a If p ≠ nil then
Emit (E.place = p) expression statement as:
Thus, p = a
Else
Error;
x:= a*b + c*d
Thus, }
E.Place = a
Again, {p = look_up(id.name);
E → id If p ≠ nil then
id.name is b Emit (E.place = p)
Thus, p = b Else
Error;
Thus, }
E.Place = a

E → E1 * E2 {E.place = newtemp();
E.Place = t1 Emit (E.place = E1.place '*'
t1 = a * b E2.place)
}
 Translation of Assignment Statements
Production rule Semantic actions
• Consider the
E → id {p = look_up(id.name); assignment and
id.name is c If p ≠ nil then
Emit (E.place = p) expression statement as:
Thus, p = c
Else
Error;
x:= a*b + c*d
Thus, }
E.Place = c
Again, {p = look_up(id.name);
E → id If p ≠ nil then
id.name is d Emit (E.place = p)
Thus, p = d Else
Error;
Thus, }
E.Place = d

E → E1 * E2 {E.place = newtemp();
E.Place = t2 Emit (E.place = E1.place
t2 = c * d '*' E2.place)
}
 Translation of Assignment Statements
Production rule Semantic actions
• Consider the
E → E1 + E2 {E.place = newtemp();
assignment and
Emit (E.place = E1.place '+'
E1.Place = t1 E2.place) expression statement as:
E2.Place = t2 }
E.Place = t3 x:= a*b + c*d
t3 = t1 + t2

E → id {p = look_up(id.name);
If p ≠ nil then
Thus, Emit (E.place = p)
Else
E.Place = x • Thus, final ICG based
Error;
} on SDT for assignment
S → id :=E {p = look_up(id.name); statements is:
id.name is x If p ≠ nil then
Thus, p = x Emit (p = E.place) t1 = a * b
Else
Error; t2 = c * d
Thus, }
x = t3
t3 = t1 + t2
x = t3
 Translation of Iterative Statements
• Consider the grammar

S  if E then S1
S  if E then S1 else S2
S  while E repeat S1
 Translation of Iterative Statements
Production rule Semantic actions

S  if E then S1 E.true := newlabel

E.false := S.next
S1.next := S.next
S.code := E.code | | generate(E.true ':') | | S1.code
S  if E then S1 E.true := newlabel
else S2 E.false := newlabel
S1.next := S.next
S2.next := S.next
code1 := E.code | | generate(E.true ':') | | S1.code
code2 := generate('goto' S.next) | |
code3 := generate(E.false ':') | | S2.code
S.code := code1 | | code2| | code3
 Translation of Iterative Statements
Production rule Semantic actions

S  while E S.begin := newlabel

repeat S1 E.true := newlabel
E.false := S.next
S1.next := S.begin
code1 := generate(S.begin ':') | | E.code
code2 := generate(E.true ':') | | S1.code
code3 := generate('goto' S.begin) | |
S.code := code1 | | code2 | | code3
 Translation of Iterative Statements
Production rule Semantic actions • Consider the statement
S  if E then S1 E.true := newlabel as:
E.True = L1 E.false := S.next
E.False = S.next S1.next := S.next If a then b
S.code := E.code |
S1.next = S.next
| generate(E.true ':') |
S.Code = a | S1.code
L1:
b

Thus, final ICG based on SDT for

assignment statements is:
a
L1 : b
S.Next
 Translation of Boolean Statements
• Consider the grammar

E  id relop id
E  true
E  false
Translation of Boolean Statements
Example of ICG for Boolean Statements using SDT
Alternative : Translation of Boolean Statements
Example : Alternative : Translation of Boolean
Statements
Example