Syntax Directed Translation

Syntax Directed Translation (ASU Ch 5)
• 2 notations for associating semantic rules with productions
– syntax-directed translations (grammar + semantic rules)
– translation schemes (semantic rule evaluation order is given)
• conceptual process
– input string
– parse tree
– dependency graph: dependencies between attributes are
shown e.g. type, string, value, memory location
– semantic rules: compute values of attributes associated with
symbols appearing in a production
• may generate code / save info in symbol table / issue error messages
1
14/10/2014 DFR - CC - SDT

Syntax Directed Definitions (ASU Ch 5.1)
• grammar + semantic rules
• semantic rules
– compute values of attributes associated with symbols in P
– set up dependencies between attributes => evaluation order
• synthesised attribute
– value at parse tree node determined from attribute values at
the children of the node (can be evaluated in bottom up traversal)
• inherited attribute
– value at parse tree node determined from attribute values at
the parent and/or the left siblings of that node
• annotated parse tree shows the values of attributes at each node
2
14/10/2014 DFR - CC - SDT

Syntax Directed Definitions (ASU Ch 5.1)
• Each grammar P: A => α has an associated set of semantic
rules of the form b := f(c 1 , c 2 , c 3 , …, c k )
– either
• b is a synthesised attribute of A and c 1 , c 2 , c 3 , …, c k are
attributes of the grammar symbols of P
• b is an inherited attribute of one of the grammar symbols
on the RHS of P and c 1 , c 2 , c 3 , …, c k are attributes of the
grammar symbols of P
– b depends on the attributes c 1 , c 2 , c 3 , …, c k
– attribute grammar: a syntax-directed definition in which the
functions in semantic rules cannot have side effects
– functions in semantic rules are often written as expressions
3
14/10/2014 DFR - CC - SDT

Synthesised Attribute: example (ASU Fig 5.2)
S-attributed definition
production
semantic rules
L => E n print(E.val)
E => E 1 + T E.val := E 1 .val + T.val
E => T E.val := T.val
T => T 1 * F T.val := T 1 .val * F.val
T => F T.val := F.val
F => ( E ) F.val := E.val
F => digit F.val := digit.lexval
n = new line, X.val = integer value synthesised attribute, digit.lexval is a
synthesised attribute supplied by the lexical analyser
4
14/10/2014 DFR - CC - SDT

Synthesised Attribute: example (ASU Ch 5.1, Fig 5.3)
• In a syntax-directed
definition, Ts are assumed to
have synthesised values only
• the start symbol is assumed
NOT to have any inherited
attributes
• S-attributed definition: one
that uses exclusively
synthesised attributes
– can always be annotated
by evaluating the
semantic rules at each
node bottom up
• annotated parse tree: 3*5+4 n
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
Similarly for type checking – type attr
5
14/10/2014 DFR - CC - SDT

Inherited Attribute: example (ASU Ch 5.1, Figs 5.4. 5.5)
production semantic rules
D => T L L.in := T.type
T => integer T.type := integer
T => real T.type := real
L => L 1 , id L 1 .in := L.in
addT(id.entry, L.in)
L => id addT(id.entry, L.in)
• Parse tree for real id 1 , id 2 , id 3
D
T.type = real
L.in = real
real L.in = real , id 3
L.in = real , id 2
id 1
6
14/10/2014 DFR - CC - SDT

Dependency Graphs (ASU Ch 5.1)
• A directed graph showing interdependencies among inherited
and synthesised attributes
– if attribute b at a node depends on attribute c => semantic rule for b
must be evaluated after the semantic rule for c
• to construct a dependency graph for a parse tree
– put each semantic rule into the form b := f(c 1 , c 2 , c 3 , …, c k )
– the graph has a node for each attribute / an edge from c to b if b
depends on c
– algorithm:
for each node n in the parse tree do for each attribute a (of n) construct a
node in the dependency graph for a
for each node n in the parse tree do for each semantic rule
b := f(c 1 , c 2 , c 3 , …, c k ) do for i := 1 to k construct an edge from c i to b
7
14/10/2014 DFR - CC - SDT

Dependency Graphs (ASU Ch 5.1 Fig 5.7)
8
• Evaluation order is given by a
topological sort - any TS
gives a valid order of
evaluation for the semantic
rules
• i.e. the dependent attributes
c 1 , c 2 , c 3 , …, c k are known at
the node before f is evaluated
• rule sequence (see figure)
a4 := real
a5 := a4
add_type(id3.entry, a5)
a7 := a5
add_type(id2.entry, a7)
a9 := a7
add_type(id1.entry, a9)
Example directed graph
real id 1 , id 2 , id 3
D
4
T.type = real
L.in = real
real L.in = real , id 3
9
L.in = real , id 2
10
id 1
14/10/2014 DFR - CC - SDT
7
1
5
8
6
2
3

Methods for Evaluating Semantic Rules
(ASU Ch 5.1)
• Parse tree methods: obtain evaluation order at compile time
from the topological sort of the DG for parse tree for each input
(DG must be DAG)
• Rule-based methods: semantic rules associated with Ps
analysed at compiler construction time (either by hand or
specialised tool) - evaluation order predetermined at
compile time
• Oblivious Methods: evaluation order chosen without
considering semantic rules - forced by the parsing method
• the last two do not need to construct the DG explicitly - more efficient in
use of compile time and space
9
14/10/2014 DFR - CC - SDT

Construction of Syntax Trees (ASU Ch 5.2 Ex 5.7)
• Intermediate representation
• de-couples translation from
parsing
• condensed form of parse tree
• examples
3
*
3*5+4 if B then S 1 else S 2
+ if-then-else
5
4
B S 1 S 2
• Syntax trees for expressions
(cf translation to post-fix form)
• operations
– mknode(op left, right)
– mkleaf(id, entry)
– mkleaf(num, entry)
• e.g. a-4+c
p1 := mkleaf(id, entry-a)
p2 := mkleaf(num, 4)
p3 := mknode(‘-’, p1, p2)
p4 := mkleaf(id, entry-c)
p5 := mknode(‘+’, p3, p4)
see ASU Fig 5.8 for syntax tree
10
14/10/2014 DFR - CC - SDT

Syntax-directed Definition for Constructing Syntax Trees
(ASU Ch 5.2 Fig 5.9)
• S-attributed definition - expressions containing + -
• uses the underlying Ps of the G to schedule the semantic rules
production
E => E 1 + T
E => E 1 - T
E => T
T => ( E )
T => id
T => num
semantic rules
E.nptr := mknode(‘+’, E 1 .nptr, T.nptr)
E.nptr := mknode(‘-’, E 1 .nptr, T.nptr)
E.nptr := T.nptr
T.nptr := E.nptr
T.nptr := mkleaf(id, id.entry)
T.nptr := mkleaf(num, id.entry)
• nptr is a synthesised attribute - pointer to nodes in the syntax tree
• see ASU Fig 5.8 for the syntax tree and Fig 5.10 for the syntax / parse tree
11
14/10/2014 DFR - CC - SDT

Directed Acyclic Graphs for Expressions (
ASU Ch 5.2 Fig 5.11)
• a + a * ( b - c ) + ( b - c ) * d
• note the common sub-expressions a and (b-c)
+
+ *
*
-
d
a
b
c
• see ASU Fig 5.12 (p291) for the instructions (mknode / mkleaf) and Fig 5.13
(p292) for an array implementation of the nodes
12
14/10/2014 DFR - CC - SDT

Bottom Up Evaluation of S-attributed Definitions
(ASU Ch 5.3 Fig 5.15)
• Syntax-directed definitions with only synthesised attributes
• can be evaluated by a bottom up parser (BUP) as input is parsed
• values associated with the attributes can be kept on the stack as
extra fields
• implementation using an LR parser (e.g. YACC)
• e.g. A => XYZ and A.a := f (X.x, Y.y, Z.z)
TOS
state
X
Y
Z
value
X.x
Y.y
Z.z
13
14/10/2014 DFR - CC - SDT

S-attributed Definitions: Parser Example
(ASU Ch 5.3 Fig 5.16 see also Fig 5.2)
production
semantic rules
L => E n print(val[TOS])
E => E 1 + T val[NTOS] := val[TOS-2] + val[TOS]
E => T
T => T 1 * F val[NTOS] := val[TOS-2] * val[TOS]
T => F
F => ( E ) val[NTOS] := val[TOS-1]
F => id
– NTOS = TOS - r + 1 ( r is # symbols reduced on RHS)
– see ASU Fig 5.17 (next slide) for example of 3 * 5 + 4
14
14/10/2014 DFR - CC - SDT

S-attributed Definitions: Parser Example
(ASU Ch 5.3 Fig 5.17 - see also Fig 5.16 (previous slide))
15
input state value production used
3 * 5 + 4 n - -
* 5 + 4 n 3 3
* 5 + 4 n F 3 F => digit
* 5 + 4 n T 3 T => F
5 + 4 n T * 3 :
+ 4 n T * 5 3 : 5
+ 4 n T * F 3 : 5 F => digit
+ 4 n T 15 T => T * F
+ 4 n E 15 E => T
4 n E + 15 :
n E + 4 15 : 4
n E + F 15 : 4 F => digit
n E + T 15 : 4 T => F
n E 19 E => E + T
E n 19 :
L 19 L => E n
14/10/2014 DFR - CC - SDT

L-attributed Definitions (ASU Ch 5.4)
• Order of evaluation of attributes is linked to the order in which
the nodes of the parse tree are created
• depth-first order
• a syntax-directed definition is L-attributed if each inherited
attribute of Xj 1

Translation Scheme (ASU Ch 5.4 Fig 5.20)
• A context free grammar in which the attributes are associated with
grammar symbols and semantic actions enclosed within { } are
inserted within the RHS of productions
• example of a translation scheme + parse tree for 9-5+2 => 95-2+
E => T R
R => addop T { print(addop.lexeme) } R 1 | ¤
(¤ = empty)
T => num { print( num.val ) }
E
T
R
T print(‘-’) R
T print(‘+’) R
9 { print(‘9’) } - 5 { print(‘5’) } + 2 { print(‘2’) } ¤
17
14/10/2014 DFR - CC - SDT

Translation Scheme (ASU Ch 5.4 Fig 5.20)
• P: T => T 1 * F and semantic rule T.val := T 1 .val * F.val yield
production + semantic action T => T 1 * F { T.val := T 1 .val * F.val }
• for both inherited and synthesised attributes
– an inherited attribute for a symbol on the RHS of P must be
computed in a (semantic) action before that symbol
– an action must not refer to a synthesised attribute on the right of the
action
– a synthesised attribute for the NT on the left can only be computed
after all attributes it references have been computed
– the action computing such attributes can be placed at the end of the
RHS of P
– see ASU p 299 for a counter example
18
14/10/2014 DFR - CC - SDT

Top-Down Translation (ASU Ch 5.5 Fig 5.24)
• implementation of L-attribute definitions during predictive
parsing using left recursion grammars and left recursion
elimination algorithms
• e.g. translation schema with left recursive grammar
E => E 1 + T { E.val := E 1 .val + T.val }
E => E 1 - T { E.val := E 1 .val - T.val }
E => T { E.val := T.val }
T => ( E ) { T.val := E.val }
T => num { T.val := num.val }
19
14/10/2014 DFR - CC - SDT

Top-Down Translation (ASU Ch 5.5 Fig 5.25)
• Grammar
• transformed translation scheme with right recursive
grammar (i.e. grammar + interleaved semantic actions)
1. E T R
2. R + T R 1
3. R - T R 1
4. R ¤
5. T ( E )
6. T num
1. E T { R.i := T.val } R { E.val := R.s }
2. R + T { R 1 .i := R.i + T.val } R 1 { R.s := R 1 .s }
3. R - T { R 1 .i := R.i - T.val } R 1 { R.s := R 1 .s }
4. R ¤ { R.s := R.i }
5. T ( E ) { T.val := E.val }
6. T num { T.val := num.val }
X.i - inherited attribute
X.s - synthesised attribute
20
14/10/2014 DFR - CC - SDT

Top-Down Translation (ASU Ch 5.5 Fig 5.26)
• Evaluation of the expression 9-5+2
T.val = 9 R.i = 9
E
E T { R.i := T.val } R { E.val := R.s }
R + T { R 1 .i := R.i + T.val } R 1 { R.s := R 1 .s }
R - T { R 1 .i := R.i - T.val } R 1 { R.s := R 1 .s }
R ¤ { R.s := R.i }
T (E) { T.val := E.val }
T num { T.val := num.val }
num.val = 9 - T.val = 5 R.i = 4
num.val = 5 + T.val = 2 R.i = 6
num.val = 2 ¤
21
14/10/2014 DFR - CC - SDT

Summary
• syntax-directed translations -
grammar + semantic rules
– synthesised attributes
– inherited attributes
– b := f(c 1 , c 2 , c 3 , …, c k )
• S-attributed definition
– only synthesised attributes
• dependency graphs
• constructing syntax trees
– syntax-directed definition
• DAGs for expressions
• bottom up evaluation of S-
attributed definitions
• L-attributed definitions
– inherited attributes depend
on A and left siblings A => α
• translation schemes
– CFG + attributes + semantic
actions in { } in RHS of P
• top down translation
– left recursive grammar
– right recursive grammar
– X.i & X.s attributes
22
14/10/2014 DFR - CC - SDT