CSE309-2
Transcript of CSE309-2
-
8/8/2019 CSE309-2
1/62
Chapter 2
CSE309N
Chapter 2Chapter 2A Simple OneA Simple One Pass CompilerPass Compiler
Dewan Tanvir Ahmed
Computer Science & EngineeringBangladesh University of Engineering and Technology
-
8/8/2019 CSE309-2
2/62
Chapter 2
CSE309N
The Entire Compilation Process
Grammars for Syntax DefinitionGrammars for Syntax Definition SyntaxSyntax--Directed TranslationDirected Translation
ParsingParsing -- Top Down & PredictiveTop Down & Predictive
Pulling Together the PiecesPulling Together the Pieces The Lexical Analysis ProcessThe Lexical Analysis Process
Symbol Table ConsiderationsSymbol Table Considerations
A Brief Look at Code GenerationA Brief Look at Code Generation Concluding Remarks/Looking AheadConcluding Remarks/Looking Ahead
-
8/8/2019 CSE309-2
3/62
Chapter 2
CSE309N
OverviewOverview
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
-
8/8/2019 CSE309-2
4/62
Chapter 2
CSE309N
Grammars for Syntax DefinitionGrammars for Syntax Definition
AA ContextContext--freeGrammarfreeGrammar ((CFGCFG) Is Utilized to) Is Utilized toDescribe the Syntactic Structure of a LanguageDescribe the Syntactic Structure of a Language
A CFG Is Characterized By:A CFG Is Characterized By:
1. A Set ofTokens orTerminal Symbols
2. A Set ofNon-terminals
3. A Set ofProduction RulesEach Rule Has the Form
NTp {T, NT}*
4. A Non-terminal Designated As
the Start Symbol
-
8/8/2019 CSE309-2
5/62
Chapter 2
CSE309N Grammars for Syntax DefinitionGrammars for Syntax DefinitionExample CFGExample CFG
listp list + digit
listp list - digit
listp digit
digitp 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
(the | means OR)(So we could have written
listp list + digit | list - digit | digit )
-
8/8/2019 CSE309-2
6/62
Chapter 2
CSE309N
InformationInformation
A string of tokens is a sequence of zero or more tokens.
The string containing with zero tokens, written as , iscalled 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.
-
8/8/2019 CSE309-2
7/62
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:
listp list+ digit
p list- digit+ digit
p digit- digit+ digit
p 9 - digit+ digit
p 9 - 5 + digit
p 9 - 5 + 2
P1 : listp list + digit
P2 : listp list - digit
P3 : listp digit
P4 : digitp 9
P4 : digitp 5
P4 : digitp 2
-
8/8/2019 CSE309-2
8/62
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
digit
digit
list
digit
list
9
5
2-
+
listp list+ digit
p list- digit+ digit
p digit- digit+ digit
p 9 - digit+ digit
p 9 - 5 + digit
p 9 - 5 + 2
-
8/8/2019 CSE309-2
9/62
Chapter 2
CSE309N
A More ComplexGrammar
What is this grammar for ?
What does represent ?What kind of production rule is this ?
blockp begin opt_stmts end
opt_stmtsp stmt_list|
stmt_listp stmt_list ; stmt | stmt
-
8/8/2019 CSE309-2
10/62
Chapter 2
CSE309N
Defining a Parse Tree
A parse tree pictorially shows how the start symbol of agrammar 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 aNon-Terminal
If Ap x1x2xn, Then A Is an Interior; x1x2xn Are
Children of A and May BeNon-Terminals orTokens
-
8/8/2019 CSE309-2
11/62
Chapter 2
CSE309N Other Important ConceptsAmbiguity
string string
string string
string
+
2-
59
Why is this a Problem ?
Grammar:
stringp string + string | string string| 0 | 1 | | 9
Two derivations (Parse Trees) for the same token string.
stringstringstringstring
string
-
9 +
5 2
-
8/8/2019 CSE309-2
12/62
Chapter 2
CSE309N Other Important ConceptsAssociativity of Operators
Left vs. Right
right
letter
letter
right
letter
right
c
b
a =
=
rightp letter = right | letter
letterp a | b | c | | z
list
digit
digit
list
digit
list
9
5
2-
+
listp list + digit |
| list - digit | digit
digitp 0 | 1 | 2 | | 9
-
8/8/2019 CSE309-2
13/62
Chapter 2
CSE309N
Embedding AssociativityEmbedding Associativity
The language of arithmetic expressions with +The language of arithmetic expressions with + -- (ambiguous) grammar that does not enforce
associativitystringp string + string | string string| 0 | 1 | | 9
non-ambiguous grammar enforcing leftassociativity (parse tree will grow to the left)
stringp string + digit | string - digit | digit
digitp 0 | 1 | 2 | | 9
non-ambiguous grammar enforcing rightassociativity (parse tree will grow to the right)
stringp digit + string | digit - string | digit
digitp 0 | 1 | 2 | | 9
-
8/8/2019 CSE309-2
14/62
Chapter 2
CSE309N Other Important ConceptsOperator Precedence
What does
9 + 5 * 2
mean?
Typically
( )
* /+ -
is precedence
order
This can be
incorporated
into a grammar
via rules:
exprp expr + term | expr term | term
termp term * factor | term / factor | factor
factorp digit | ( expr )
digitp 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
-
8/8/2019 CSE309-2
15/62
Chapter 2
CSE309N
Syntax for StatementsSyntax for Statements
stmtp id := expr
| ifexprthen stmt
| ifexpr then stmtelse stmt
| while expr do stmt
| begin opt_stmts end
Ambiguous Grammar?
-
8/8/2019 CSE309-2
16/62
Chapter 2
CSE309N
Syntax-DirectedTranslation
Associate Attributes With Grammar Rules and Translate as Parsingoccurs
The translation will follow the parse tree structure (and as a result thestructure and form of the parse tree will affect the translation).
First example: Inductive Translation.
InfixInfix toto PostfixPostfixNotation Translation for ExpressionsNotation Translation for Expressions Translation defined inductively as: Postfix(E) where E is an
Expression.
1. IfE is a variable orconstant then Postfix(E) = E2. IfE is E1 op E2 then Postfix(E)
= Postfix(E1 op E2) = Postfix(E1) Postfix(E2) op
3. IfE is (E1) then Postfix(E) = Postfix(E1)
Rules
-
8/8/2019 CSE309-2
17/62
Chapter 2
CSE309N
ExamplesExamples
Postfix( ( 9 5 ) + 2 )
= Postfix( ( 9 5 ) ) Postfix( 2 ) +
= Postfix( 9 5 ) Postfix( 2 ) +
= Postfix( 9 ) Postfix( 5 ) - Postfix( 2 ) +
= 9 5 2 +
Postfix(9 ( 5 + 2 ) )
= Postfix( 9 ) Postfix( ( 5 + 2 ) ) -
= Postfix( 9 ) Postfix( 5 + 2 )
= Postfix( 9 ) Postfix( 5 ) Postfix( 2 ) +
= 9 5 2 +
-
8/8/2019 CSE309-2
18/62
Chapter 2
CSE309N
Syntax-Directed Definition
Each Production Has a Set ofSemantic Rules Each Grammar Symbol Has a Set ofAttributes
For the Following Example, String Attribute t is
Associated With Each Grammar Symbol
recall: What is a Derivation for 9 + 5 - 2?
exprp expr term | expr + term | term
termp 0 | 1 | 2 | 3 | | 9
listp list- digit p list+ digit- digit p digit+ digit- digitp 9 + digit- digit p 9 + 5 - digitp 9 + 5 - 2
-
8/8/2019 CSE309-2
19/62
Chapter 2
CSE309N
Syntax-Directed Definition (2))
Each Production Rule of the CFG Has a SemanticEach Production Rule of the CFG Has a SemanticRuleRule
NoteNote: Semantic Rules for: Semantic Rules forexprexprdefinedefine ttas aas asynthesized attribute i.e., the various copies ofsynthesized attribute i.e., the various copies ofttobtain their values from childrenobtain their values from children ttss
Production Semantic Rule
exprp expr + term expr.t := expr.t || term.t || +
exprp expr term expr.t := expr.t || term.t || -exprp term expr.t := term.ttermp 0 term.t := 0
termp 1 term.t := 1. .
termp 9 term.t := 9
-
8/8/2019 CSE309-2
20/62
Chapter 2
CSE309N
Semantic Rules are Embedded in Parse Tree
expr.t =95-
expr.t =9
expr.t =95-2+
term.t =5
term.t =2
term.t =9
2+5-9
It starts at the root and recursively visits the children ofeach node in left-to-right order
The semantic rules at a given node are evaluated once allThe semantic rules at a given node are evaluated once alldescendants of that node have been visited.descendants of that node have been visited.
A parse tree showing all the attribute values at each nodeA parse tree showing all the attribute values at each node
is called annotated parse tree.is called annotated parse tree.
-
8/8/2019 CSE309-2
21/62
Chapter 2
CSE309N Translation SchemesEmbedded Semantic Actions into the right sides of
the productions.
exprp expr + term {print(+)}
p expr - term {print(-)}
p term
termp 0 {print(0)}
termp 1 {print(1)}
termp 9 {print(9)}
term
term
termexpr
expr
expr
9
5
2-
+
{print(-)}
{print(9)}
{print(5)}
{print(2)}
{print(+)}
A translation scheme islike a syntax-directed
definition except the
order of evaluation of
the semantic rules is
explicitly shown.
-
8/8/2019 CSE309-2
22/62
Chapter 2
CSE309N
ParsingParsing
Parsing is the process of determining if astring of tokens can be generated by a grammar.
Parser must be capable of constructing the
tree.
Two types of parser
Top-down:
starts at root
proceeds towards leaves
Bottom-up:
starts at leaves
proceeds towards root
-
8/8/2019 CSE309-2
23/62
Chapter 2
CSE309N
Parsing Top-Down& Predictive
TopTop--Down ParsingDown Parsing Parse tree / derivation of aParse tree / derivation of atoken string occurs in atoken string occurs in atop down fashion.top down fashion.
For Example, Consider:For Example, Consider:
typep simple
| o id
| array [ simple ]of type
simplep integer
| char
| num dotdot num
Suppose input is :
array [ num dotdot num ]of integer
Parsing would begin with
typep ???
Start symbol
-
8/8/2019 CSE309-2
24/62
Chapter 2
CSE309N
TopTop--Down Parse (type = start symbol)Down Parse (type = start symbol)
type]simple of[array
type
type]simple of[array
type
numnum dotdot
Input : array [ num dotdot num ]of integer
Lookahead symbol
type
?
Input : array [ num dotdot num ]of integer
Lookahead symbol
-
8/8/2019 CSE309-2
25/62
Chapter 2
CSE309N
TopTop--Down Parse (type = start symbol)Down Parse (type = start symbol)
Input : array [ num dotdot num ]of integer
type]simple of[array
type
numnum dotdot simple
type]simple of[array
type
numnum dotdot simple
integer
Lookahead symbol
The selection of
production for nonterminal may involve
trail and error
-
8/8/2019 CSE309-2
26/62
Chapter 2
CSE309N Top-Down ProcessRecursive Descent or Predictive Parsing
Parser Operates by Attempting to Match Tokens in theInput Stream
Utilize both Grammar and Input Below to Motivate Codefor Algorithm
array [ num dotdot num ]of integer
typep simple
| o id
| array [ simple ]of type
simplep integer
| char
| num dotdot num
procedure match ( t: token ) ;
begin
if lookahead= t thenlookahead : = nexttoken
else error
end ;
-
8/8/2019 CSE309-2
27/62
Chapter 2
CSE309N
TopTop--Down Algorithm (Continued)Down Algorithm (Continued)
procedure type ;begin
if lookahead is in {integer, char, num } then simple
else if lookahead = o then begin match(o ) ; match( id ) endelse if lookahead= array then begin
match( array ); match([); simple; match(]); match(of); type
end
else errorend ;procedure simple ;begin
if lookahead= integer then match ( integer );
else if lookahead= char then match( char );
else if lookahead= num then begin
match(num); match(dotdot); match(num)
end
else error
end ;
-
8/8/2019 CSE309-2
28/62
Chapter 2
CSE309N
TracingTracing
Input: array [ num dotdot num ]of integer
To initialize the parser:
setglobal variable :lookahead = array
call procedure:type
Procedure callto type withlookahead = array resultsinthe actions:
match( array ); match([); simple; match(]); match(of); type
Procedure callto simple withlookahead = num resultsinthe actions:
match(num); match(dotdot); match(num)
Procedure callto type withlookahead = integer resultsinthe actions:
simple
Procedure callto simple withlookahead = integer resultsinthe actions:
match ( integer )
-
8/8/2019 CSE309-2
29/62
Chapter 2
CSE309N
LimitationsLimitations
Can we apply the previous technique to everyCan we apply the previous technique to everygrammar?grammar? NO:NO:
typep simple
| array [ simple ]of type
simplep integer
| array digit
digitp 0|1|2|3|4|5|6|7|8|9
consider the string consider the string array 6the predictive parser starts withthe predictive parser starts with typetype and lookahead=and lookahead=
array
apply productionapply production typep simple ORORtypep array digit????
-
8/8/2019 CSE309-2
30/62
Chapter 2
CSE309N
When to UseWhen to Use --ProductionsProductions
The recursive descent parser will use -productions as adefault when no other production can be used.
stmtp begin opt_stmts end
opt_stmtsp stmt_list|
While parsing opt_stmts, if the lookahead symbol is
not in FIRST(stmts_list), then the -productions is
used.
-
8/8/2019 CSE309-2
31/62
Chapter 2
CSE309N
Designing a Predictive ParserDesigning a Predictive Parser
Consider AConsider ApEpE FIRST(E)=set of leftmost tokens that appear in E or instrings generated by E.
E.g. FIRST(type)={o,array,integer,char,num}
Consider productions of the formConsider productions of the form AApEpE,, AApFpF the setsthe setsFIRST(FIRST(EE) and FIRST() and FIRST(FF) should be disjoint) should be disjoint
Then we can implement predictive parsingThen we can implement predictive parsing
Starting with Ap? we find into which FIRST() set the
lookahead symbol belongs to and we use thisproduction.
Any non-terminal results in the correspondingprocedure call
Terminals are matched.
-
8/8/2019 CSE309-2
32/62
Chapter 2
CSE309N
Problems with Top Down ParsingProblems with Top Down Parsing
Left Recursion in CFGMay Cause Parser to Loop Forever.Left Recursion in CFGMay Cause Parser to Loop Forever. Indeed:Indeed: In the production ApAEwe write the program
procedure A{
if lookahead belongs to First(AE) then
call the procedure A}
Solution: Remove Left Recursion...Solution: Remove Left Recursion... without changing the Language defined by the
Grammar.
-
8/8/2019 CSE309-2
33/62
Chapter 2
CSE309N
Dealing with Left recursionDealing with Left recursion
Solution: Algorithm to Remove Left Recursion:Solution: Algorithm to Remove Left Recursion:
exprp expr+ term | expr- term | term
termp 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
exprp term rest
restp + term rest | - term rest|
termp 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
BASIC IDEA
ApAE|FbecomesAp FR
RpER|
-
8/8/2019 CSE309-2
34/62
Chapter 2
CSE309N
What happens to semantic actions?What happens to semantic actions?
exprp expr + term {print(+)}
p expr - term {print(-)}
p term
termp 0 {print(0)}
termp 1 {print(1)}
termp 9{print(9)}
exprp term rest
restp + term {print(+)} rest
p - term {print(-)} rest
p
termp 0 {print(0)}
termp 1 {print(1)}
termp 9 {print(9)}
-
8/8/2019 CSE309-2
35/62
Chapter 2
CSE309N Comparing GrammarsComparing Grammarswith Left Recursionwith Left Recursion
Notice Location of Semantic Actions in TreeNotice Location of Semantic Actions in Tree
What is Order of Processing?What is Order of Processing?
expr
expr
expr
term
term
term
{print(2)}
{print(+)}
{print(5)}
{print(-)}
{print(9)}
5
+
2
-
9
-
8/8/2019 CSE309-2
36/62
Chapter 2
CSE309N Comparing GrammarsComparing Grammarswithout Left Recursionwithout Left Recursion
Now, Notice Location of Semantic Actions in TreeNow, Notice Location of Semantic Actions in Treefor Revised Grammarfor Revised Grammar
What is Order of Processing in this Case?What is Order of Processing in this Case?
{print(2)}
expr
term
term {print(-)}
term {print(+)}
{print(5)}
{print(9)} rest
rest
2
5
-9
+
rest
-
8/8/2019 CSE309-2
37/62
Chapter 2
CSE309N Procedure for the Non terminalsexpr, term, and rest
expr(){
term(), rest();
}
rest()
{
if ( lookahead == +) {
match(+); term(); putchar(+); rest();
}
else if ( lookahead = -) {match(-); term(); putchar(-); rest();
}
else ;
}
-
8/8/2019 CSE309-2
38/62
Chapter 2
CSE309N Procedure for the Non terminalsexpr, term, and rest (2)
term()
{
if (isdigit(lookahead)){
putchar(lookahead); match();
}
else error();
}
-
8/8/2019 CSE309-2
39/62
Chapter 2
CSE309N
Optimizing the translatorOptimizing the translator
Tail recursion
When the last statement executed in a procedure body is a
recursive call of the same procedure, the call is said to be tail
recursion.rest()
{
L: if ( lookahead == +) {
match(+); term(); putchar(+); goto L;
}
else if ( lookahead = -) {
match(-); term(); putchar(-); goto L;
}
else ;
}
-
8/8/2019 CSE309-2
40/62
Chapter 2
CSE309N
Optimizing the translatorOptimizing the translator
expr(){
term(),while(1)
if ( lookahead == +) {
match(+); term(); putchar(+);}
else if ( lookahead = -) {
match(-); term(); putchar(-);
}
else break;
}
-
8/8/2019 CSE309-2
41/62
Chapter 2
CSE309N
Lexical AnalysisLexical Analysis
A lexical analyzer reads and converts the input into a stream of tokens to
be analyzed by the parser.
A sequence of input characters that comprises a single token is called a
lexeme.
Functional Responsibilities
1. White Space and Comments Are Filtered Out
blanks, new lines, tabs are removed modifying the grammar to incorporate white space into
the syntax difficult to implement
-
8/8/2019 CSE309-2
42/62
Chapter 2
CSE309N
Functional Responsibilities (2)
Constants
The job of collecting digits into integers is generally given to a
lexical analyzer because numbers can be treated as single units
during translation.
numbe the token representing an integer.
The value of the integer will be passed along as an attribute of the
token num
Example:
31 + 28 + 59
< +, >
NB: 2nd Component of the tuples, theattributes, play no role during parsing, but
needed during translation
-
8/8/2019 CSE309-2
43/62
Chapter 2
CSE309N
Functional Responsibilities (3)
Recognizing Identifiers and Keywords
Compilers use identifiers as names of
Variables
Arrays
Functions
A grammar for a language treats an identifier as token
Example:
credit = asset + goodwill;
Lexical analyzer would convert it like
id = id + id ;
309
-
8/8/2019 CSE309-2
44/62
Chapter 2
CSE309N
Functional Responsibilities (3)
Recognizing Identifiers and Keywords (2)
Languages use fixed character strings ( if, while, extern) to identify certain
construct. We call them keywords.
A mechanism is needed fir deciding when a lexeme forms a keyword and
when it forms an identifier.
Solution
1. Keywords are reserved.
2. The character string forms an identifier
only if it is not a keyword.
CSE309N
-
8/8/2019 CSE309-2
45/62
Chapter 2
CSE309N
Interface to the Lexical AnalyzerInterface to the Lexical Analyzer
Lexical
AnalyzerParser
Pass token
and its
attributes
Input
Read
character
Push back
character1. Read characters from input
2. Groups them into lexeme
3. Passes the token together with
attribute values to the later stage
This part is implemented
with a buffer
Why pushback?
CSE309N
-
8/8/2019 CSE309-2
46/62
Chapter 2
CSE309N The Lexical Analysis ProcessA Graphical Depiction
uses getchar ( ) to
read character
pushes back c using
ungetc (c , stdin)
returns token
to caller
tokenval
Sets global variable
to attribute value
lexan ( )
lexical
analyzer
CSE309N
-
8/8/2019 CSE309-2
47/62
Chapter 2
CSE309N
Example of a Lexical AnalyzerExample of a Lexical Analyzer
function lexan: integer ; [ Returns an integer encoding of token]var lexbuf: array[ 0 .. 100 ]of char ;
c : char ;
begin
loop begin
read a character into c ;if c is a blank or a tab then
do nothing
else if c is a newline then
lineno : = lineno + 1
else if c is a digit then beginset tokenval to the value of this and following digits ;
return NUM
end
CSE309N
-
8/8/2019 CSE309-2
48/62
Chapter 2
CSE309N
Algorithm for Lexical AnalyzerAlgorithm for Lexical Analyzer
else if c is a letter then beginplace c and successive letters and digits into lexbuf;
p : = lookup ( lexbuf) ;
ifp = 0 then
p : = insert( lexbf, ID) ;
tokenval: =preturn the tokenfield of table entryp
end
else
set tokenval to NONE ; / * there is no attribute * /
return integer encoding of charactercend
end
Note: Insert / Lookup operations occur against the Symbol Table !
CSE309N
-
8/8/2019 CSE309-2
49/62
Chapter 2
CSE309N
Symbol Table ConsiderationsSymbol Table Considerations
ARRAY symtable
lexptr token attributes
div
mod
id
id
0
1
2
3
4
EOSiEOStnuocEOSdomEOSvid
ARRAY lexemes
OPERATIONS: Insert (string, token_ID)
Lookup (string)
NOTICE: Reserved words are placed into
symbol table for easy lookup
Attributes may be associated with each entry, i.e.,
Semantic Actions
Typing Info: idp integeretc.
CSE309N
-
8/8/2019 CSE309-2
50/62
Chapter 2
CSE309N
Abstract StackMachinesAbstract StackMachines
The front end of a compiler constructs an intermediate representation ofthe source program from which the back end generates the target program.
One popular form of intermediate representation is code for an abstract
stack machine.
I will show you how code will be generated for it.
The properties of the machine
1. Instruction memory
2. Data memory
3. All arithmetic operations are performed on values on a stack
CSE309N
-
8/8/2019 CSE309-2
51/62
Chapter 2
CSE309N
InstructionsInstructions
Instructions fall into three classes.1. Integer arithmetic
2. Stack manipulation
3. Control flow
push 5
rvalue 2
+
rvalue 3
*
. . .
1
2
3
4
5
6
16
7
0
11
7
...
1
2
3
4
Instructions Stack Data
pc
t
op
CSE309N
-
8/8/2019 CSE309-2
52/62
Chapter 2
CSE309N
LL--value and Rvalue and R--valuevalue
What is the difference between left and right side identifier?
L-value Vs. R-value of an identifier
I : = 5 ; L - Location
I : = I + 1 ; R Contents
The right side specifies an integer value, while left side specifies
where the value is to be stored.
Usually,
r-values are what we think as valuesl-values are locations.
CSE309N
-
8/8/2019 CSE309-2
53/62
Chapter 2
CSE309N
Stack manipulationStack manipulation
push v push v onto the stack
rvalue l push contents on data location l
lvalue l push address of data location lpop throw away value on top of the stack
:= the r-value on top is placed in the l-value below
it and both are popped
copy push a copy of the top on the stack
CSE309N
-
8/8/2019 CSE309-2
54/62
Chapter 2
CSE309N
Translation of ExpressionsTranslation of Expressions
Day = (1461*y) mod4 + (153*m +2 ) mod5 + d
lvalue day
push 1461
rvalue y
*
push 4
mod
push 153
rvalue m
*
push 2
+
push 5
mod
+
rvalue d
+
:=
0
1
2
-3
...
1
2 day
3 y
4 m
5 d
CSE309N
-
8/8/2019 CSE309-2
55/62
Chapter 2
CSE309N
Translation of Expressions (2)Translation of Expressions (2)
22 22
14611461
22
14611461
11
22
14611461
22
14611461
44
22
11
22
11
153153
CSE309N
-
8/8/2019 CSE309-2
56/62
Chapter 2
CSE309N
Translation of Expressions (3)Translation of Expressions (3)
22
11
153153
22
22
11
306306
22
11
306306
22
22
11
308308
22
11
308308
55
22
11
33
22
44
CSE309N
-
8/8/2019 CSE309-2
57/62
Chapter 2
CSE309N
Translation of Expressions (4)Translation of Expressions (4)
22
44
--33
22
11
0
1
2
-3
...
1
2 day
3 y
4 m
5 d
CSE309N
-
8/8/2019 CSE309-2
58/62
Chapter 2
CSE309N
Control FlowControl Flow
label l target of jumps to l; has no other effect
goto l next instruction is taken from statement with label l
gofalse l pop the top value; jump if it is zero
gotrue l pop the top value; jump if it is nonzero
halt stop execution
The control flow instructions for the stack
machine are
CSE309N
-
8/8/2019 CSE309-2
59/62
Chapter 2
CSE309N
Translation of statementsTranslation of statements
If
code for expr
gofalse out
code for stmt1
label out
stmt p if exprthen stmt1
{ out := newlabel;stmt.t := expr.t ||
gofalse out ||
stmt1.t ||
label out }
CSE309N
-
8/8/2019 CSE309-2
60/62
Chapter 2
CSE309N
Translation of statements (2)Translation of statements (2)
label test
code for expr
gofalse out
code for stmt1
goto test
label out
while
stmt pwhile exprdo stmt1
{ test := newlabel;
out := newlabel;
stmt.t := label test ||
expr.t ||
gofalse out ||
stmt1.t ||
goto test ||
label out }
CSE309N
-
8/8/2019 CSE309-2
61/62
Chapter 2
CSE309N
Concluding Remarks / Looking Ahead
Weve Reviewed / Highlighted Entire CompilationProcess
Introduced Context-free Grammars (CFG) andIndicated /Illustrated Relationship to CompilerTheory
Reviewed Many Different Versions of ParseTrees That Assist in Both Recognition andTranslation
Well Return to Beginning - Lexical Analysis
Well Explore Close Relationship of LexicalAnalysis to Regular Expressions, Grammars, andFinite Automatons
CSE309N
-
8/8/2019 CSE309-2
62/62
TheEnd