Chapter 5.

Syntax-Directed
Translation
 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

Fig. 5.2. Syntax-directed definition of a simple desk calculator

2
 L

n
E.val = 19

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

Fig. 5.3. Annotated parse tree for 3*5+4n.

3
 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 )

Fig. 5.4. Syntax-directed definition with inherited attribute L.in.

4
 D

T.type = real L.in = real

real L.in = real , id3

L.in = real , id2

id1

Fig. 5.5. Parse tree with inherited attribute in at each node labeled L.

5
 E val

E1 + E2
val val

Fig. 5.6. E.val is synthesized from E1.val and E2.val

6
 D

T in 5 L
4 6
type

real in 7 L 8 , id3 3 entry

in 9 L 10 , id2 2 entry

id1 1 entry

Fig. 5.7. Dependency graph for parse tree of Fig. 5.5

7
 Production Code Fragment
LEn print ( val [top] )
E  E1 + T val [ntop] := val [top – 2]+val [top]
ET
T  T1 * F val [ntop] := val [top – 2]×val [top]
TF
F(E) val [ntop] := val [top – 1]
F  digit

Fig. 5.16. Implementation of a desk calculator with an LR parser.

8
 L-Attributed Definitions
A syntax-directed definition is L-attribute if each inherited attribute of Xj,
1≤ j≤n, on the right side of A → X1X2 · · · Xn , depends only on

1. the attributes of the symbols X1 , X2 , · · · , Xj-1 to the left of Xj in the pr

oduction and
 the inherited attributes of A.

Note that every S-attributes definition is L-attributed, because the

restrictions (1) and (2) apply only to inherited attributes

9
Example 5.17. The type of an identifier can be passed by copy rules
using inherited attributes as shown in Fig. 5.32 (adapted from Fig. 5.7).
We shall first examine the moves made by a bottom-up parser on the input
real p, q, r

then we show how the value of attirbute T.type can be accessed when the
productions for L are applied. The translation scheme we wish to implement is

DT
L { L.in := T.type }
T  int { T.type := integer }
T  real { T.type := real }
L  { L1.in := L.in }
L1 , id { addtype ( id.entry , L.in ) }
L  id { addtype ( id.entry , L.in ) }

10
 D

T in L
type
in
real L , r

in
L , q

Fig.5.32. At each node for L, L.in = T.type.

If we ignore the actions in the above translation scheme, the sequence of
moves made by the parser on the input of Fig. 5.32. is as in Fig. 5.33. For
clarity, we show the corresponding grammar symbol instead of a stack
state and the actual identifier instead of the token id.
11
 Input state Production Used
real p,q,r −
p,q,r real
p,q,r T T → real
,q,r T p
,q,r T L L → id
q,r T L ,
,r T L , q
,r T L L → L , id
r T L ,
T L , r
T L L → L , id
D D → T L
Fig. 5.33.Whenever a right side for L is reduced, T is just below the right
side. 12
 Production Code Fragment

DT L ;
T  int val [ntop] := integer
T  real val [ntop] := real
L  L1 , id addtype (val [top] , val [top−3] )
L  id addtype (val [top] , val [top−1] )

Fig. 5.34. The value of T.type is used in place of L.in

13
Example 5.18. As an instance where we cannot predict the position, consider th
e
following translation scheme:
Production Semantic Rules
S → aAC C.i := A.s
S → bABC C.i := A.s
(5.6)
C→c C.s := g ( C.i )

C inherits the synthesized attribute A.s by a copy rule. Note that there may or
may not be a B between A and C in the stack. When reduction by C → c is
performed, the value of C.i is either in val [top−1]or in val [top−2], but it is
not clear which case applies.
14
 Production Semantic Rules
S → aAC C.i := A.s
S → bABMC M.i := A.s ; C.i := M.s
C→c C.s := g ( C.i )
M→є M.s := M.i
S S

b A B M C
b A B C s i s i
s
i
є

(a) original production (b) modified dependencies

Fig. 5.35. Copying an attribute value through a marker M.
15