Syntax-Directed Translation

1. Syntax-Directed Definitions
A syntax-directed definition is a generalization of a context-
free grammar in which:
– Each grammar symbol is associated with a set of
attributes.
– This set of attributes for a grammar symbol is partitioned
into two subsets called
• synthesized and
• inherited attributes of that grammar symbol.
– Each production rule is associated with a set of semantic
rules.
 Syntax-Directed Definition –
Example(calculator)
Production Semantic Rules
L → E return 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).
 Synthesized attributes
• The attribute values are computed from the
values of attributes at the children’s of that
node in the parse tree is called synthesized
attributes. Eg: calculator
Synthesized attributes- Example
 Inherited attributes
• The attribute values are computed from the
values of attributes of their parents and their
siblings of that node is called inherited
attributes. Eg: Declaration statements
 Inherited attributes- Example
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)

Example: real id, id, id;

Inherited attributes- Example
 Dependency Graph
• The interdependencies among the inherited and
synthesized attributes at the nodes in the parse
tree can be depicted by a directed graph is called
dependency graph.
 Evaluation Order
• A topological sort of a directed acyclic
graph is any ordering m1, m2,….mk of
the node of the graph such that edges
go from nodes earlier in the ordering to
later nodes; that is, if mi->mj is an edge
from mi to mj, then mi appears before
mj in the ordering.
• Several methods have been proposed
for evaluating semantic rules:
 Parse tree methods.
 Rule based methods.
 Oblivious methods.
2. Construction of Syntax Trees
3*5+4
Syntax Trees- Example
Syntax Trees-Syntax directed defnition
PRODUCTION SEMANTIC 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)
Directed Acyclic Graphs for Expressions
(1) p1 := mkleaf(id,a);
(2) p2 := mkleaf(id,a);
(3) p3 := mkleaf(id,b);
(4) p4 := mkleaf(id,c);
(5) p5 := mknode(' - ' ,p3,p4);
(6) p6 := mknode(' * ' ,p2,p5);
(7) p7 := mknode(' + ' ,p1,p6);
(8) p8 := mkleaf(id,b);
(9) p9 := mkleaf(id,c);
(10) p10 := mknode(' - ' ,p8,p9);
(11) p11 := mkleaf(id,d);
(12) p12 := mknode(' * ' ,p10,p11);
(13) p13 := mknode(' + ' ,p7,p12);
Directed Acyclic Graphs for
Expressions
 Bottom-Up Evaluation of S-Attributed
Definitions
• A syntax directed definition that uses
synthesized attributes exclusively is said to be
an S- attributed definition.
Table: Parser stack with attributes.
State Val

X X.x
Y Y.x
top Z Z.x
 Production Code fragment

L->E n print(val[top])
E->E + T val[ntop] :=val[top-2] + val[top]
E->T
E->T*F val[ntop] :=val[top-2] * val[top]
T->F
F->(E) val[ntop] := val[top-1]
F-> digit
 3. L-attributed definitions
• These are definitions that define rules for determining
inherited attributes in which each inherited attribute
depends only on
 The attributes of the symbols to the left of it in the
production
 The inherited attributes of the non-terminal on the left-
side of the production
• Every L-attributed definition is L-attributed, as the rules
stated above apply only to inherited attributes. L-
attributed definitions are said to be L-attributed as
information flows from left to right in the syntax tree.
4. Top down translation
5. Bottom up evaluation of
inherited attributes
Production Semantic Rules
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)

Example: real id, id, id;