CSE309N
Chapter 2
A Simple One – Pass Compiler
Chapter 2
CSE309N
The Entire Compilation Process
Grammars for Syntax Definition
Syntax-Directed Translation
Parsing - Top Down & Predictive
Pulling Together the Pieces
The Lexical Analysis Process
Symbol Table Considerations
A Brief Look at Code Generation
Concluding Remarks/Looking Ahead
Chapter 2
CSE309N
Overview
Programming Language can be defined by describing
1. The syntax of the language
1. What its program looks like
2. We use CFG or BNF (Backus Naur Form)
2. The semantics of the language
1. What its program mean
2. Difficult to describe
3. Use informal descriptions and suggestive examples
Chapter 2
CSE309N
Grammars for Syntax Definition
A Context-free Grammar (CFG) Is Utilized to
Describe the Syntactic Structure of a Language
A CFG Is Characterized By:
1. A Set of Tokens or Terminal Symbols
2. A Set of Non-terminals
3. A Set of Production Rules
Each Rule Has the Form
NT {T, NT}*
4. A Non-terminal Designated As
the Start Symbol
Chapter 2
CSE309N
Grammars for Syntax Definition
Example CFG
list list + digit
list list - digit
list digit
digit 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
(the “|” means OR)
(So we could have written
list list + digit | list - digit | digit )
Chapter 2
CSE309N
Information
A string of tokens is a sequence of zero or more tokens.
The string containing with zero tokens, written as , is called
empty string.
A grammar derives strings by beginning with the start symbol
and repeatedly replacing the non terminal by the right side of a
production for that non terminal.
The token strings that can be derived from the start symbol form
the language defined by the grammar.
Chapter 2
CSE309N
Grammars are Used to Derive Strings:
Using the CFG defined on the earlier slide, we can
derive the string: 9 - 5 + 2 as follows:
list list + digit P1 : list list + digit
list - digit + digit P2 : list list - digit
digit - digit + digit P3 : list digit
9 - digit + digit P4 : digit 9
9 - 5 + digit P4 : digit 5
9-5+2 P4 : digit 2
Chapter 2
CSE309N
Grammars are Used to Derive Strings:
This derivation could also be represented via a Parse Tree
(parents on left, children on right)
list list + digit list
list - digit + digit
digit - digit + digit
list + digit
9 - digit + digit - 2
list digit
9 - 5 + digit
9-5+2 5
digit
9
Chapter 2
CSE309N
Defining a Parse Tree
A parse tree pictorially shows how the start symbol of a
grammar derives a string in the language.
More Formally, a Parse Tree for a CFG Has the Following
Properties:
Root Is Labeled With the Start Symbol
Leaf Node Is a Token or
Interior Node Is a Non-Terminal
If A x1x2…xn, Then A Is an Interior; x1x2…xn Are
Children of A and May Be Non-Terminals or Tokens
Chapter 2
CSE309N
Other Important Concepts
Ambiguity
Two derivations (Parse Trees) for the same token string.
string string
-
+ string string
string string
+ string
string - string 2 9 string
9 5 5 2
Grammar:
string string + string | string – string | 0 | 1 | …| 9
Why is this a Problem ?
Chapter 2
CSE309N
Other Important Concepts
Associativity of Operators
Left vs. Right
list right
list + digit letter = right
2 a =
list - digit letter right
5 b
digit letter
9 c
list list + digit | right letter = right | letter
| list - digit | digit letter a | b | c | …| z
digit 0 | 1 | 2 | …| 9
Chapter 2
CSE309N
Embedding Associativity
The language of arithmetic expressions with + -
(ambiguous) grammar that does not enforce
associativity
string string + string | string – string | 0 | 1 | …| 9
non-ambiguous grammar enforcing left
associativity (parse tree will grow to the left)
string string + digit | string - digit | digit
digit 0 | 1 | 2 | …| 9
non-ambiguous grammar enforcing right
associativity (parse tree will grow to the right)
string digit + string | digit - string | digit
digit 0 | 1 | 2 | …| 9
Chapter 2
CSE309N
Other Important Concepts
Operator Precedence
What does ( )
9+5*2 Typically * / is precedence
mean? + - order
This can be expr expr + term | expr – term | term
incorporated term term * factor | term / factor | factor
into a grammar factor digit | ( expr )
via rules: digit 0 | 1 | 2 | 3 | … | 9
Precedence Achieved by:
expr & term for each precedence level
Rules for each are left recursive or associate to the left
Chapter 2
CSE309N
Syntax for Statements
stmt id := expr
| if expr then stmt
| if expr then stmt else stmt
| while expr do stmt
| begin opt_stmts end
Ambiguous Grammar?
Chapter 2
CSE309N
Syntax-Directed Translation
Associate Attributes With Grammar Rules and Translate as Parsing
occurs
The translation will follow the parse tree structure (and as a result the
structure and form of the parse tree will affect the translation).
First example: Inductive Translation.
Infix to Postfix Notation Translation for Expressions
Translation defined inductively as: Postfix(E) where E is an
Expression.
Rules
1. If E is a variable or constant then Postfix(E) = E
2. If E is E1 op E2 then Postfix(E)
= Postfix(E1 op E2) = Postfix(E1) Postfix(E2) op
3. If E is (E1) then Postfix(E) = Postfix(E1)
Chapter 2
CSE309N
Examples
Postfix( ( 9 – 5 ) + 2 )
= Postfix( ( 9 – 5 ) ) Postfix( 2 ) +
= Postfix( 9 – 5 ) Postfix( 2 ) +
= Postfix( 9 ) Postfix( 5 ) - Postfix( 2 ) +
=95–2+
Postfix(9 – ( 5 + 2 ) )
= Postfix( 9 ) Postfix( ( 5 + 2 ) ) -
= Postfix( 9 ) Postfix( 5 + 2 ) –
= Postfix( 9 ) Postfix( 5 ) Postfix( 2 ) + –
=952+–
Chapter 2
CSE309N
Syntax-Directed Definition
Each Production Has a Set of Semantic Rules
Each Grammar Symbol Has a Set of Attributes
For the Following Example, String Attribute “t” is
Associated With Each Grammar Symbol
expr expr – term | expr + term | term
term 0 | 1 | 2 | 3 | … | 9
recall: What is a Derivation for 9 + 5 - 2?
list list - digit list + digit - digit digit + digit - digit
9 + digit - digit 9 + 5 - digit 9 + 5 - 2
Chapter 2
CSE309N
Syntax-Directed Definition (2)
Each Production Rule of the CFG Has a Semantic
Rule
Production Semantic Rule
expr expr + term expr.t := expr.t || term.t || ‘+’
expr expr – term expr.t := expr.t || term.t || ’-’
expr term expr.t := term.t
term 0 term.t := ‘0’
term 1 term.t := ‘1’
…. ….
term 9 term.t := ‘9’
Note: Semantic Rules for expr define t as a
“synthesized attribute” i.e., the various copies of t
obtain their values from “children t’s”
Chapter 2
CSE309N
Semantic Rules are Embedded in Parse Tree
expr.t =95-2+
expr.t =95- term.t =2
expr.t =9 term.t =5
term.t =9
9 - 5 + 2
It starts at the root and recursively visits the children of
each node in left-to-right order
The semantic rules at a given node are evaluated once all
descendants of that node have been visited.
A parse tree showing all the attribute values at each node
is called annotated parse tree. Chapter 2
CSE309N
Translation Schemes
Embedded Semantic Actions into the right sides of
the productions.
A translation scheme is
expr expr + term {print(„+‟)}
like a syntax-directed
definition except the
expr - term {print(„-‟)}
order of evaluation of
term the semantic rules is
term 0 {print(„0‟)} explicitly shown.
term 1 {print(„1‟)}
expr
… {print(„+‟)}
+
term 9 {print(„9‟)} expr term
- {print(„-‟)} 2 {print(„2‟)}
expr term
5 {print(„5‟)}
term
9 {print(„9‟)}
Chapter 2
