View
245
Download
0
Category
Preview:
Citation preview
Translation
code translation convertedcode
In compilers, this is the task of creatingexecutable from source code.
How is it done?
So far, we have analysed the code, identifyingthe "words" and the syntactical form.
Together, these help us understand themeaning of the code, and so we will use thestructure we have identified to create thetarget code.
Postfix Notation
Postfix notation is a method for writingexpressions which is unambiguous, and corresponds to the processing order we usein bottom-up parsing.
a+b is written as ab+a*b is written as ab*: :
In general, we define it recursively:
postfix for E1 <op> E2 is (postfix for E1)(postfix for E2)<op>
and
postfix for (E) is (postfix for E)
Postfix exampleWe can write a+(b*c)*(b*(a+b)) as
abc*bab+**+
To read a postfix expression, start from the leftand move right. By the time we reach an operator,we take the correct number of operands we havemost recently recognised, to get a new expression.
Above, b and c are the operands of the first *,a and b are the operands of the first +, etc.
Labelling the operators, we get:
a+1(b*1c)*2(b*3(a+2b))
which translates to
abc*1bab+2*3*2+1
Translating while parsing1) S -> S + T2) S -> T3) T -> T * F4) T -> F5) F -> ( S )6) F -> a
print ("+")
print("*")
print(a)
Parsing a+a*a+a produces the followingsequence:
a+a*a+a <=6 F+a*a+a <=T+a*a+a <= S+a*a+a <=6
S+F*a+a <=S+T*a+a <=6 S+T*F+a <=3 S+T+a <=1
S+a <=6 S +F <= S+T <=1 S
The order in which the productions wereapplied is 6, 6, 6, 3, 1, 6, 1, which causes theoutput of
aaa*+a*
The Value StackAll we are able to do using the previous methodis execute an action whenever a rule is used.We can't store up actions for future use.
However, we can extend the idea, by associatingvalues with each symbol on the stack. Theactions we then carry out can use those values that have been stored.
Suppose that we are about to reduce byA -> x1 x2 .... xn
This means that the furthest right symbols onthe symbol stack are:
x1 x2 ... xn
Call the values associated with those symbols$1, $2, ..., $n
When we carry out the reduction, we removethose symbols, and replace by A.
Changing the Value StackRemove the first n symbols from the stack, andreplace by a new value for A, which we will call$$. The value we want to store for A will dependon the values we stored for the xi
That is, $$ = f($1, $2, ..., $n), for some function f.
The only other case we need to consider iswhen we place a terminal on the stack. Wheredo we get its value?
Generally, we expect the lexical analyser tofind the value for us.
This means that in your Lex script, every time you recognise an integer or a real, you must translate it into a number of the appropriate form.
Computing the value of expressions
1) S -> S + T2) S -> T3) T -> T * F4) T -> F5) F -> ( S )6) F -> 17) F -> 28) F -> 3
$$ := $1 + $3$$ := $1$$ := $1 * $3$$ := $1$$ := $2$$ := 1$$ := 2$$ := 3
Note: this is a simplification
In practice, we would have 6) F -> a, andexpect the lexical analyser to return thedifferent integer values
Parsing the expressions
Symbol
1FTSS+S+2S+FS+TS+T*S+T*3S+T*FS+TS
Values
11111•1•21•21•21•2•1•2•31•2•31•67
Stack0050302010160165016301690169701697501697 10016901
Input1+2*3#
+2*3#+2*3#+2*3#+2*3#
2*3#*3#*3#*3#3#
####
ActionS5R6R4R2S6S5R6R4S7S5R6R3R1A
Value Stack in Lex
Lex must place the values in yylval
1. digit string - compute the value, place in yylval
2. char string - copy to a string array, place the index of its start point in yylval
3. real string - convert to a floating point, store in an array of reals, place the index of its start point in yylval
4. identifier - store as for strings
Lex and yylval
%{#include "y.tab.h"#include <stdlib.h>extern int yylval;%}
%%[0-9]+ {yylval = atoi(yytext);
/* convert string to integer */ return INT_T;}
[ \t] ; /* ignore space */
: :: :: :
%%
Value Stack in Yacc
Yacc allows an action after each production.The action will be performed immediatelybefore the reduction.
Values are represented using the $$ and $inotation.
When the statement is reached by Yacc, it will translate the different $i's into theirappropriate types
Using Yacc's Value Stack
%%Finish : Expr {printf("%d",$1);} ;
Expr : Expr PLUS_T Term{$$ = $1 + $3;}
| Term;
Term : Term MUL_T Factor{$$ = $1 * $3;}
| Factor;
Factor : OB_T Expr CB_T{$$ = $2;}
| INT_T;
%%
Syntax-Directed Translation
Yacc allows us to use the value stack.
However, this method only allows us toassociate a single value with each symbol.
We may want to record more information:
data types
places in the symbol table
code fragments
We will extend the idea of the value stackby associating multiple values with symbols
AttributesWith each symbol in the grammar, associatea set of attributes.
The attributes can be of any type, and represent any information we can express.
With each production in the grammar,associate a set of semantic rules, determininghow the values of the attributes are to becomputed.
The computation can modify the values ofthe attributes, or can have side-effects,modifying some external structure - e.g. thesymbol table - or can output results to thescreen or to a file.
Formal attribute definition
p) A -> is a grammar rule.
p) has associated with a set of semanticfunctions of the form
b := f(c1, c2, ..., cn)
where b, c1, c2, ..., cn are attributes of any symbol appearing in p).
If b is an attribute of A, then b is a synthesised attribute.
If b is an attribute of one of the symbols in , then b is an inherited attribute
Syntax-directed Definition: Example
1)
2)
3)
4)
5)
6)
7)
S -> E
E1 -> E2 + T
E -> T
T1 -> T2 * F
T -> F
F -> ( E )
F -> digit
print(E.val)
E1.val := E2.val + T.val
E.val := T.val
T1.val := T2.val * F.val
T.val := F.val
F.val := E.val
F.val := digit.lexval
Synthesised Attributes
The value of a synthesised attribute eithercomes from the child nodes, or from theproperties of the symbol itself.
As soon as a symbol is recognised in bottom-upparsing, the values of its synthesisedattributes can be obtained.
Thus, if a derivation of a string uses onlysymbols with synthesised attributes, we canevaluate all the attributes as we carry outthe parse.
A syntax-directed definition which uses onlysynthesised attributes is called anS-attributed definition.
6 + 2 * 3
S
E
T
F
val = 12
E
T
F
6
val = 6
val = 6
val = 6
lexval = 6
T
F
2
val = 2
lexval = 2
3lexval = 3
val = 2 val = 3
val = 6
+
*
12
Annotated Parse Tree
Inherited AttributesAn inherited attribute has its value determinedby the attribute values of its parent orsiblings.
Inherited attributes are useful for describingthe way in which the meaning of a symboldepends upon the context in which itappears.
For example, the meaning of the identifier "num" is different in the two cases below:
real num;
int num;
Thus a "type" attribute cannot be determinedfrom the symbol alone, but must be derivedfrom the attribute of parent or sibling symbols.
Inherited Attribute Example
1)
2)
3)
4)
5)
D -> T L
T -> int
T -> real
L1 -> L2, id
L -> id
L.t := T.t
T.t := integer
T.t := real
L2.t := L1.t, addtype(id.entry, L1.t)
addtype(id.entry, L.t)
D
T L
real , idL
, idL
id
t = real t = real
t = real
t = real
entry
entry
entry
addentry(...)
addentry(...)
addentry(...)
Augmented Parse Tree
real id1 , id2 , id3
Information FlowD
T L
real , idL
, idL
id
t = real t = real
t = real
t = real
entry
entry
entry
real id1 , id2 , id3
addentry(...)
addentry(...)
addentry(...)
Dependency Graph
The augmented parse tree on the previous slide is called a dependency graph.
We use dependency graphs to determinethe order in which we must evaluate theattributes to get a completely evaluatedparse tree.
A topological sort is an ordering of theattributes of a graph which is a valid orderin which to evaluate the attributes.
Topological SortD
T L
real , idL
, idL
id
t = real t = real
t = real
t = real
entry
entry
entry
real id1 , id2 , id3
addentry(...)
addentry(...)
addentry(...)
12
3
4
5
6
7
8
9
10
Evaluation methods
parse-tree based At compile time,construct a parse tree, then a dependencygraph, then a topological sort. Evaluatethe attributes in that order.
rule based When the compiler isconstructed, analyse the rules fordependencies between attributes, andfix the order of evaluation beforecompilation begins.
oblivious Use a fixed evaluation orderwithout analysing the dependencies.This limits the class of grammars thatcan be implemented.
Syntax Trees
A syntax tree is a condensed parse tree,where the operators and keywords do notappear as leaves, but with the parent nodesthat would have been their parents in theparse tree.
S => if B then S1 else S2
Example:
has the syntax tree:
if then else
B S1 S2
6 + 2 * 3
E
E T+
T *T F
F F 3
26
+
6 *
32
Using Syntax Trees
A syntax tree allows the translation processto be separated from the parsing process.
A grammar that is best for parsing mightnot explicitly represent the hierarchicalnature of the programs it describes
The parsing method imposes an orderin which the nodes are considered, whichmight not be the best order for translation.
Constructing Syntax Trees
We can use a syntax-directed definition tocreate syntax trees in a similar way to theway we created postfix expressions.
We will represent each node as a simpledata structure.
Operator structures will have a name and a number of fields containing pointers to eachoperand.
Simple operand structures will have a typeand a value.
E.g. 2+3 will be represented by:
+
num 2 num 3
Functions We require the following three functions:
mknode(op,left,right): creates aninternal node for the operator "op", withtwo fields for pointers to the left andright operands.
mkleaf_id(id,entry): creates a leafnode for the identifier "id", and a field fora pointer to the symbol table entry for "id".
mkleaf_num(num,val): creates a leafnode, labelled "num", with a field forthe value of the number.
Each function returns a pointer to the nodejust created.
Example Definition
1)
2)
3)
4)
5)
6)
7)
E1 -> E2 + T
E -> T
T1 -> T2 * F
T -> F
F -> ( E )
F -> id F -> num
E1.ptr := mknode("+", E2.ptr,T.ptr)
E.ptr := T.ptr
T1.ptr := mknode("*",T2.ptr, F.ptr)
T.ptr := F.ptr
F.ptr := E.ptr
F.ptr := mkleaf_id(id, id.entry)
F.ptr := mkleaf_num(num,num.val)
Constructing 6+2*x
E
E T+
T *T F
F F 3
26
ptr =
ptr = ptr =
ptr =ptr = ptr =
ptr =ptr =
+
num 6
id
*
num 2
Compound Statements
CStat -> Stat ; CStat
CStat -> Stat
Stat -> s
s ; s ; s ; s
CStat
CStat
CStat
CStat
Stat
Stat
Stat
Stat
;
;
;
s
s
s
s
Parse Tree
CStat1.ptr := mknode(";", Stat.ptr,CStat2.ptr)
CStat.ptr := Stat.ptr
Stat.ptr := mkleaf_id(id, s)
;
;
;
s
s
s s
Syntax tree
CStat1.ptr := CStat2.ptr; addChild(CStat1.ptr,Stat.ptr)
CStat.ptr := mkXnode(Stat.ptr)
Stat.ptr := mkleaf_id(id, s)
s s s s
seq
id
...(s)...
Seq -> CStat Seq.ptr := CStat.ptr;
seq ...
CStat1.ptr := Stat.ptr; addSib(Stat.ptr,CStat2.ptr)
CStat.ptr := Stat.ptr
Stat.ptr := mkleaf_id(id, s)
s s s s
seq
id
...(s)...
sibling
Seq -> CStat Seq.ptr := CStat.ptr;
Sample Program
int a b c;int g[5];
int testFunc(int x) { real y;
y := (x+a)/2; print(y); return a;}
main() {
a := 1; while (a < 3) do { testFunc(a); a := a + 1; }}
Recommended