G22.

2130-001
Compiler Construction
Lecture 2:
Syntax-Directed Translator

Mohamed Zahran (aka Z)

[email protected]
 What Will We Do?
• Build a very simple compiler
• Only the front end
– Code generation
• Easy and limited source language
• Will touch upon everything quickly
• Chapters 3-8 give more details
 ANALYSIS PHASE
•Break your program into pieces
•Produce an internal presentation of it
Allows a translator to handle multicharacter constructs
Abstract Syntax Tree
•A data structure
•Hold information about source code constructs
•Information collected incrementally at analysis phase
•Used by synthesis phase
How Do We Define Language Syntax?

• Using a special notation

• Context-free grammar
• Set of rules

Example:

If ( expression ) statement else statement

Corresponds to a rule:

stmt -> if (expr) stmt else stmt

 Production Rules
stmt -> if (expr) stmt else stmt
body or right hand side
head or
left hand side (LHS)

may be read as:

can have the form
 Production Rules
stmt -> if (expr) stmt else stmt

Nonterminals
They need more rules to define them.
 Production Rules
stmt -> if (expr) stmt else stmt

Terminals
No more rules needed for them
 Components of Context-Free Grammar

• Set of terminal symbols

• Set of nonterminals
• set of productions
– The head is nonterminal
– The body is a sequence of teminals and/or
nonterminals
• Designation of one nonterminal as
starting symbol
 Example

What are the terminals here?

What are the nonterminals?

What does this grammar generate?

 Some Definitions
• String of terminals: sequence of zero or more
terminals
• Derivation:
– given the grammar (i.e. productions)
– begin with the start symbol
– repeatedly replacing nonterminal by the body
– We obtain the language defined by the grammar
(i.e. group of terminal strings)
• Parsing:
– Given a string of terminals
– Figure out how to derive it from the start symbol
of the grammar
 Example

How to derive: 9-5+7 from the above rules?

 Parse Tree
• Pictorially shows how the start symbol
of a grammar derives a given string

Root is labeled by the start

symbol

A -> XYX Interior nodes are nonterminals

Each leave is a terminal or ε

The process of finding a parse tree for a given string of terminals is called parsing.
 Example
Deriving 9-5+2 from
 Example

Can we derive 9-5+2 from

 Ambiguity
• A grammar is ambiguous if it has more than one parse
tree generating the same string of terminals
 Example
Is the following grammar ambiguous?
S -> +SS | -SS | a
 Example
Is the following grammar ambiguous?
S-> S(S)S | ε
 Example
Is the following grammar ambiguous?
S -> a | S + S | SS | S* | (S)
 Associativity of Operators
How will you evaluate this?
9-5-2
Will ‘5’ go with the ‘-’ on the left or the one
on the right?

If it goes with the one on the left: (9-5)-2 we say

that the operator ‘-’ is left-associative

If it goes with the one on the right: 9-(5-2) we say

that the operator ‘-’ is right-associative
 Associativity of Operators
How to express associativity in production
rules?

term-> term – digit Left-associative

digit -> 0|1|2|3|4|5|6|7|8|9 (9-5)-2

term->digit-term
digit -> 0|1|2|3|4|5|6|7|8|9 Right-associative
9-(5-2)
 Precedence of Operators
• Associativity applies to occurrence of
the same operator
• What if operators are different?
• How will you evaluate: 9-5*2
• We say ‘*’ has higher precedence than ‘-’
if it takes its operands before ‘-’
 Precedence of Operators
How to present this in productions?

The above example shows both precedence and associativity

* / have higher precedence then + -
All of them are left associative
 Example
Construct unambiguous context-free
grammar for left-associate list of
identifiers separate by commas
 Syntax-Directed Translation
• We have built a parse-tree, now what?
• How will this tree and production rules
help in translation?
• This means we have to associate
something with each production and
with each tree node
 Syntax-Directed Translation
• Attributes
– Each symbol (terminal or nonterminal) has
an attribute
– Semantic rules for calculating attributes of
a node from its children
• Translation scheme is a notation for
attaching program fragments to
productions
 expr and term each
has an attribute:
expr.t and term.t
term

|| means concatenate
Attribute values at nodes for 9-5+2
•Build the tree
•Start from leaves
•Using semantic rules till you reach root

Attributes can be evaluated during a single

bottom-up traversal of a parse tree.
 Another Way:
Translation Schemes
• Another notation
• Attaching program fragments to
productions
• These program fragments are called
semantic actions
example:
9-5+2
9-5+2

With semantic actions

With attributes
Concerning Tree Traversal

Depth first
•Preorder
•Postorder
 Back to Parsing!
• We have a set of productions
• We have a string of terminals
• We need to form the parse-tree that
will generate that string
Given this set of productions: and this string:

for( ; expr ; expr ) other

How can we generate this?

Note: Sometimes choosing the right production may involve trial and error, and backtracking
Parsing With No-Backtracking
• Top-down method
• Based on recursive procedures
• Part of a parsing category called:
Recursive-descent parsing
• The lookahead symbol unambiguously
determines the flow-of control
 Designing Predictive Parser
• By examining the lookahead symbol we
choose a production
• There must not be any conflict between
two bodies with same head otherwise we
cannot use predictive-parsing
• The procedure mimics the body of the
chosen production
– nonterminal is a procedure call
– terminal is matched and lookahead advances
 Example
expr -> expr + term | term

term
expr -> term factor
term + term
factor -> + term factor | ε
term + term + term
…
 Enough for Today
• Next time we will continue our trip for
building simple translator
• This lecture covered 2.1 -> 2.4