Syntax Directed Translation

1
 Syntax Directed Translation

Translate a sequence of tokens

into a sequence of actions

2
 Syntax Directed Translation
• Augment CFG rules with translation rules (at least 1 per
production)
• Define translation of LHS nonterminal as function of
Constants
the right-hand-side nonterminals' translations
the right-hand-side tokens' values (e.g. the integer value associated
with INTLITERAL token, or the String value associated with an ID
token)
• To translate an input string
Build the parse tree.
Use the translation rules to compute the translation of each
nonterminal in the tree, working bottom up.
3
 SDT Example 1
CFG Rules Input string
B -> 0 B.trans = 0 10110
| 1 B.trans = 1
| B 0 B.trans = B2.trans * 2
| B 1 B.trans = B2.trans * 2 + 1 22 B

11 B 0

Translation is 5 B 1
the value of
the binary 2 B 1
input in
decimal 1 B 0

4
SDT Example 2: Declarations Translation is a
String of ids
CFG Rules
DList → ε DList.trans = “”
| DList Decl DList.trans = Decl.trans + “ “ + DList2.trans
Decl → Type id Decl.trans = id.value
Type → int
| bool
“yy xx ” DList

Input string
int xx; “xx ” DList “yy” Decl
bool yy;
Type id
“” DList “xx” Decl

Type id bool
ε

int 5
 Exercise
Only add declarations of type int to the output String.
Augment the previous grammar:
CFG Rules
DList → ε DList.trans = “”
| DList Decl DList.trans = Decl.trans + “ “ +
DList2.trans
Decl → Type id ; Decl.trans = id.value
Type → int
| bool

Different nonterms can Rules can have conditionals

have different types

6
 SDT Example 2b: ints only Translation is a
String of int ids
only
CFG Rules
DList → ε DList.trans = “”
| Decl DList DList.trans = Decl.trans + “ “ + DList2.trans
Decl → Type id ; if (Type.trans) {Decl.trans = id.value} else {Decl.trans =
“”}
Type → int Type.trans = true
| bool Type.trans = false
Input string
“ xx ” DList
int xx;
bool yy; “xx ” DList “” Decl

false Type id
Different nonterms can “” DList “xx” Decl
have different types
ε
true Type id bool
Rules can have conditionals

int 7
 SDT Example 3: Type Checking

• Language of expressions that use the three

operators: +, &&, == using the terminal
symbols PLUS, AND , EQUALS, respectively.
• Integer literals are represented by INTLITERAL token
and the tokens TRUE and FALSE represent the
literals true and false.
• A syntax-directed translation that type checks
these expressions; i.e., for type-correct
expressions, the translation will be the type of the
expression (either int or bool), and for expressions
that involve type errors, the translation will be the
special value error 8
 SDT Example 3 Type Checking
Cont.
We'll use the following type rules:
• Both operands of the + operator must be of
type int.
• Both operands of the && operator must be of
type bool.
• Both operands of the == operator must have
the same (non-error) type.

9
SDT Example 3 Type Checking Cont.

10
 SDT Example 3 Type Checking Cont.

Annotated parse tree for (2+2)==4

11
 SDT for Parsing
In the previous examples, the SDT process
assigned different types to the translation:
– Example 1: tokenized stream to an integer value
– Example 2: tokenized stream to a (java) String
– Example 3: tokenized stream to {int, bool, error}
Next, we’ll go from tokens to an Abstract-Syntax
Tree (AST)

12
 Abstract Syntax tree (AST)
• A condensed form of the parse tree
• Operators appear at internal nodes instead of
at leaves.
• "Chains" of single productions are collapsed.
• Lists are "flattened".
• Syntactic details (e.g., parentheses, commas,
semi-colons) are omitted.
• AST is a better structure for later stages
13
 Abstract Syntax Tree Example 1
Parse Tree Expr
mult
Example: (5+2)*8
Term

int
Term * Factor
mult (8)

Factor intlit (8)

add int
(8) ( Expr )
add
int int Expr + Term
(5) (2)
Term Factor int
(2)
int Factor intlit (2)
(5)
intlit (5)
14
 Exercise
Expr -> Expr + Term
• Show the AST for: | Term
(1 + 2) * (3 + 4) * 5 + 6 Term -> Term * Factor
| Factor
Factor -> intlit
| ( Expr )

15
 AST
• For constructs other than expressions
– Lists of declarations, lists of statements, lists of
parameters, … should be flattened,
– Operators (e.g., "assign", "while", "if") go at
internal nodes, not at leaves
– Syntactic details are omitted

16
AST Example 2

17
AST Example 2 Cont.

18
AST Example 2 Cont.

19
 AST for Parsing
In previous slides we did our translation in two steps
– Structure the stream of tokens into a parse tree
– Use the parse tree to build an abstract syntax tree, throw away the
parse tree
In practice, we will combine these into 1 step

Question: Why do we even need an AST?

– More of a “logical” view of the program
– Generally easier to work with

20
 AST Implementation
How do we actually represent an AST in code?

21
 AST in Code
• Note that we’ve assumed a field-like structure in our SDT actions:
DList.trans = Decl.trans + “ “ + DList2.trans

• In our parser, we’ll

define classes for each type of nonterminal
Have a field within the class for each nonterminal attribute
• In the above rule we might represent DList as
public class DList{
public String trans;
}

• When we execute an SDT rule

– we create a new node object for the RHS of SDT rule
– Note the same rule can be executed multiple times during parsing and an
object corresponding to the RHS of SDT rule gets created in each of these
times
22
– propagate its fields with the fields of the LHS node
 AST In Code Cont.
Define a class for each AST node:
class ExpNode { } //root class

class IntNode extends ExpNode {

int value;
public IntLitNode(int val) {...}
}

class PlusNode extends ExpNode {

ExpNode left;
ExpNode right;
public PlusNode( ExpNode e1, ExpNode e2 ) { ... }
}

class TimesNode extends ExpNode {

ExpNode left;
ExpNode right;
public TimesNode( ExpNode e1, ExpNode e2 ) { ... }
23
}
 Implementing ASTs for Expressions
CFG Translation Rules
Expr -> Expr + Term Expr1.trans = new PlusNode(Expr2.trans, Term.trans)
| Term Expr.trans = Term.trans
Term -> Term * Factor Term1.trans = new TimesNode(Term2.trans, Factor.trans)
| Factor Term.trans = Factor.trans
Factor -> intlit Factor.trans = new IntNode(intlit.value)
| ( Expr ) Factor.trans = Expr.trans

Example: 1 + 2

Expr
PlusNode
ExpNode left:
Expr plus Term ExpNode right:
Term Factor

Factor intlit IntNode IntNode

2 value: 1 value: 2
intlit
1
24
 An AST for a code snippet
void foo(int x, int y){
if (x == y){
return;
}
while ( x < y){
cout << “hello”;
FuncBody x = x + 1;
}
}

if while return

== return < print =

x y x y “hello” x +

x 1 25
 Note
To implement general AST more classes are
needed:
class ifNode{…}
class whileNode{…}
class lessThanNode{…}
class returnNode{…}
class greaterThanNod{…}
…
26