Beruflich Dokumente
Kultur Dokumente
Parsing Techniques
Top-down parsers
Start at the root of the parse tree from the start symbol and grow toward leaves (similar to a derivation)
Bottom-up parsers
Start at the leaves and grow toward root We can think of the process as reducing the input string to the start symbol At each reduction step a particular substring matching the right-side of a production is replaced by the symbol on the left-side of the production Bottom-up parsers handle a large class of grammars
CH4.2
Top-down Parsing
S start symbol fringe of the parse tree A D C B
S
left-to-right scan
?
left-most derivation
?
input string upper fringe of the parse tree
lookahead
Bottom-up Parsing
lookahead S A
?
C
lookahead
CH4.3
Bottom-up Parsing
CH4.4
Bottom Up Parsing
Shift-Reduce Parsing Reduce a string to the start symbol of the grammar. At every step a particular sub-string is matched (in left-toright fashion) to the right side of some production and then it is substituted by the non-terminal in the left hand side of the production.
Reverse order
Handles
Handle of a string: Substring that matches the RHS of some production AND whose reduction to the non-terminal on the LHS is a step along the reverse of some rightmost derivation. Formally:
handle of a right sentential form is <A , location of in > , that satisfies the above property. i.e. A is a handle of at the location immediately
after the end of , if:
* A => S => rm rm
A certain sentential form may have many different handles. Right sentential forms of a non-ambiguous grammar have one unique handle
CH4.6
Example
Consider: S aABe A Abc | b Bd S aABe aAde aAbcde abbcde It follows that: S aABe is a handle of aABe in location 1. B d is a handle of aAde in location 3. A Abc is a handle of aAbcde in location 2. A b is a handle of abbcde in location 2.
CH4.7
Handle Pruning
A rightmost derivation in reverse can be obtained by handle-pruning. Apply this to the previous example. S aABe A Abc | b Bd
abbcde Find the handle = b at loc. 2 Derive id+id*id By two different Rightmost aAbcde derivations b at loc. 3 is not a handle: aAAcde ... blocked.
CH4.8
S = 0 1 2 n-1 n = w
for i n to 1 by -1 Find the handle Ai i in i Replace i with Ai to generate i-1
CH4.9
Handle Pruning, II
Left part
Viable prefix
Example
Sentential Form S Expr Expr Term Expr Term * Factor Expr Term * <id,y> Expr Factor * <id,y> Expr <num,2> * <id,y> Term <num,2> * <id,y> Factor <num,2> * <id,y>
<id,x> <num,2> * <id,y>
1 2 3 4 5 6 7 8 9
S Expr Expr Expr + Term | Expr Term | Term Term Term * Factor | Term / Factor | Factor Factor num | id
The expression grammar
CH4.11
Two problems:
locate a handle and decide which production to use (if there are more than two candidate productions).
shift input symbols into the stack until a handle is found on top of it. reduce the handle to the corresponding non-terminal. other operations:
accept when the input is consumed and only the start symbol is on the stack, also: error
CH4.12
Example
STACK
$ $ id $E
INPUT
id + id * id$ + id * id$ + id * id$
Remark
Shift Reduce by E id
E+E | E*E | ( E ) | id
CH4.13
num
none 9,1 7,1 4,1 none none 8,3 7,3 none none 9,5 5,5 3,3 1,1 none
Term Fact.
Term
*
Fact.
<id,y>
<id,x> <num,2>
1. Shift until top-of-stack is the right end of a handle 2. Pop the right end of the handle & reduce
CH4.14
Shift-reduce Parsing
Shift reduce parsers are easily built and easily understood A shift-reduce parser has just four actions Shift next word is shifted onto the stack Reduce right end of handle is at top of stack Locate left end of handle within the stack Pop handle off stack & push appropriate lhs Accept stop parsing & report success Error call an error reporting/recovery routine Accept & Error are simple Shift is just a push and a call to the scanner Reduce takes |rhs| pops & 1 push
Handle finding is key
CH4.15
Conflicts
shift/reduce or reduce/reduce Example:
Input else
More Conflicts
stmt id ( parameter-list ) stmt expr := expr parameter-list parameter-list , parameter | parameter
parameter id
expr-list expr-list , expr | expr expr id | id ( expr-list ) Consider the string A(I,J)
Corresponding token stream is id(id, id) After three shifts: Stack = id(id Input = , id)
How the symbol third from the top of stack determines the reduction to be made, even though it is not involved in the reduction. Shift-reduce parsing can utilize information far down in the stack to guide the parse
CH4.17
Operator-Precedence Parser
Operator grammar
small,
but an important class of grammars we may have an efficient operator precedence parser (a shift-reduce parser) for an operator grammar.
Ex: EAB A a Bb
Precedence Relations
In operator-precedence parsing, we define three disjoint precedence relations between certain pairs of terminals.
a <. b a = b a .> b
b has higher precedence than a b has same precedence as a b has lower precedence than a
The determination of correct precedence relations between terminals are based on the traditional notions of associativity and precedence of operators. (Unary minus causes a problem).
CH4.19
The intention of the precedence relations is to find the handle of a right-sentential form, <. with marking the left end, = appearing in the interior of the handle, and .> marking the right hand. In our input string $a1a2...an$, we insert the precedence relation between the pairs of terminals (the precedence relation holds between the terminals in that pair).
CH4.20
id + id
.>
*
.>
$
.>
+
* $
<.
<.
.>
.>
<.
.>
.>
.>
Then the input string id+id*id with the precedence relations inserted will be:
CH4.21
Scan the string from left end until the first .> is encountered. Then scan backwards (to the left) over any = until a <. is encountered. The handle contains everything to left of the first .> and to the right of the <. is encountered.
E id E id E id E E*E E E+E $ id + id * id $ $ E + id * id $ $ E + E * id $ $ E + E * .E $ $E+E$ $E$
$ <. id .> + <. id .> * <. id .> $ $ <. + <. id .> * <. id .> $ $ <. + <. * <. id .> $ $ <. + <. * .> $ $ <. + .> $ $$
CH4.22
CH4.23
input
id+id*id$ +id*id$ +id*id$ id*id$ *id$ *id$ id$ $ $ $ $
action
$ <. id id .> + shift shift id .> * shift shift id .> $ * .> $ + .> $ accept shift reduce E id reduce E id
<.
.>
.> .>
CH4.24
We use associativity and precedence relations among operators. If operator 1 has higher precedence than operator 2, 1 .> 2 and 2 <. 1 If operator 1 and operator 2 have equal precedence, they are left-associative 1 .> 2 and 2 .> 1 they are right-associative 1 <. 2 and 2 <. 1
2.
3.
For all operators , <. id, id .> , <. (, (<. , .> ), ) .> , .> $, and $ <.
Also, let (=) ( <. ( ( <. id
4.
$ <. ( $ <. id
id .> ) id .> $
) .> $ ) .> )
CH4.25
Operator-Precedence Relations
+ .> .> .> .> .> .> <. .> <. .> .> .> .> .> .> <. .> <. * <. <. .> .> .> .> <. .> <. / <. <. .> .> .> .> <. .> <. ^ <. <. <. <. <. .> <. .> <. id <. <. <. <. <. <. <. ( <. <. <. <. <. <. <. ) .> .> .> .> .> .>
=
.> .>
+ * / ^ id ( ) $
CH4.26
Operator-Precedence parsing cannot handle the unary minus when we also have the binary minus in our grammar. The best approach to solve this problem, let the lexical analyzer handle this problem.
The lexical analyzer will return two different tokens for the unary minus and the binary minus. The lexical analyzer will need a lookhead to distinguish the binary minus from the unary minus.
Then, we make <. unary-minus for any operator unary-minus .> if unary-minus has higher precedence than unary-minus <. if unary-minus has lower (or equal) precedence than
CH4.27
Precedence Functions
Compilers using operator precedence parsers do not need to store the table of precedence relations. The table can be encoded by two precedence functions f and g that map terminal symbols to integers. For symbols a and b. f(a) < g(b) whenever a <. b f(a) = g(b) whenever a = b f(a) > g(b) whenever a .> b Algorithm 4.6 Constructing precedence functions
CH4.28
1.
2. 3.
4.
CH4.29
Example
+ * 4 3 Id 4 5 $ 0 0
gid
fid
f g
2 1
f*
g*
g+
f+
f$
g$
CH4.30
Disadvantages:
It cannot handle the unary minus (the lexical analyzer should handle the unary minus). Small class of grammars. Difficult to decide which language is recognized by the grammar. simple powerful enough for expressions in programming languages
Advantages:
CH4.31
CH4.32
CH4.33
Example
id id ( ) $ e1: e3 <. e3 <. ( e3 <. e3 <. )
.>
$
.>
=.
.>
e4
.>
e2
e1
Called when : whole expression is missing insert id onto the input issue diagnostic: missing operand
e2:
Called when : expression begins with a right parenthesis delete ) from the input issue diagnostic: unbalanced right parenthesis
CH4.34
Example
id id ( ) $ e3: e3 <. e3 <. ( e3 <. e3 <. )
.>
$
.>
=.
.>
e4
.>
e2
e1
Called when : id or ) is followed by id or ( insert + onto the input issue diagnostic: missing operator
e4:
Called when : expression ends with a left parenthesis pop ( from the stack issue diagnostic: missing right parenthesis
CH4.35
The End
CH4.36