Upload
gerald-pierce
View
235
Download
0
Embed Size (px)
Citation preview
1
Module 29
• Parse/Derivation Trees– Leftmost derivations, rightmost derivations
• Ambiguous Grammars– Examples
• Arithmetic expressions
• If-then-else Statements
– Inherently ambiguous CFL’s
2
Context-Free Grammars
Parse Trees
Leftmost/rightmost derivations
Ambiguous grammars
3
Parse Tree
• Parse/derivation trees are structured derivations– The structure graphically illustrates semantic
information about the string
• Formalization of concept we encountered in regular languages unit– Note, what we saw before were not exactly parse
trees as we define them now, but they were close
4
Parse Tree Example
• Parse tree for string ( )(( )) and grammar BALG– BALG = (V, , S, P)
• V = {S}, = {(, )}, S = S
• P = S --> SS | (S) | – One derivation of ( )(( ))
• S ==> SS ==> (S)S ==> ( )S ==> ( )(S) ==> ( )((S)) ==> ( )(( ))
– Parse tree
S
S S
SS( ( ))
S( )
5
Comments about Example *
• Syntax: – draw a unique arrow from each
variable to each character that is a direct child of that variable
• A line instead of an arrow is ok
– The derived string can be read in a left to right traversal of the leaves
• Semantics– The tree graphically illustrates the
nesting structure of the string of parentheses
S
S S
SS( ( ))
S( )
6
Leftmost/Rightmost Derivations *
• There is more than one derivation of the string ( )(( )).– S ==> SS ==> (S)S ==>( )S ==> ( )(S)
==> ( )((S)) ==> ( )(( ))– S ==> SS ==> (S)S ==> (S)(S) ==> ( )(S)
==> ( )((S)) ==> ( )(( ))– S ==> SS ==> S(S) ==> S((S)) ==> S(( ))
==> (S)(( )) ==>( )(( ))
• Leftmost derivation– Leftmost variable is always expanded– Which one of the above is leftmost?
• Rightmost derivation– Rightmost variable is always expanded– Which one of the above is rightmost?
S
S S
SS( ( ))
S( )
7
Comments
• Fix a string and a grammar– Any derivation corresponds to a
unique parse tree
– Any parse tree can correspond to many different derivations
• Example– The one parse tree corresponds to all
three derivations
• Unique mappings– For any parse tree, there is a unique
leftmost/rightmost derivation that it corresponds to
S
S S
SS( ( ))
S( )
– S ==> SS ==> (S)S ==>( )S ==> ( )(S)
==> ( )((S)) ==> ( )(( ))
– S ==> SS ==> (S)S ==> (S)(S) ==> ( )(S)
==> ( )((S)) ==> ( )(( ))
– S ==> SS ==> S(S) ==> S((S)) ==> S(( ))
==> (S)(( )) ==>( )(( ))
8
Example *
• S ==> SS ==> SSS ==> (S)SS ==> ( )SS ==> ( )S ==> ( )– The above is a leftmost derivation of the string ( ) from the
grammar BALG
– Draw the corresponding parse tree
– Draw the corresponding rightmost derivation
• S ==> (S) ==> (SS) ==> (S(S)) ==> (S( )) ==> (( ))– The above is a rightmost derivation of the string (( )) from the
grammar BALG
– Draw the corresponding parse tree
– Draw the corresponding leftmost derivation
9
Ambiguous Grammars
Examples:
Arithmetic Expressions
If-then-else statements
Inherently ambiguous grammars
10
Ambiguous Grammars
• A grammar G is ambiguous if there exists a string x in L(G) with two or more distinct parse trees– (2 or more distinct leftmost/rightmost derivations)
• Example– Grammar AG is ambiguous
• String aaa in L(AG) has 2 rightmost derivations– S ==> SS ==> SSS ==> SSa ==> Saa ==> aaa
– S ==> SS ==> Sa ==> SSa ==> Saa ==> aaa
11
2 Simple Examples *
• Grammar BALG is ambiguous– String ( ) in L(BALG) has >1 leftmost
derivation• S ==> (S) ==> ( )• S ==> (S) ==> (SS) ==>(S) ==>( )• Give another leftmost derivation of ( ) from BALG
• Grammar ABG is NOT ambiguous– Consider any string x in {aibi | i > 0}
• There is a unique parse tree for x
12
Legal Arithmetic Expressions
• Develop a grammar MATHG = (V, , S, P) for the language of legal arithmetic expressions– = {0, 1, +, *, -, /, (, )}
– Strings in the language include• 0
• 10
• 10*11111+100
• 10*(11111+100)
– Strings not in the language include• 10+
• 11++101
• )(
13
Grammar MATHG1
• V = {E, N}• = {0, 1, +, *, -, /, (, )}• S = E• P:
– E --> N | E+E | E*E | E/E | E-E | (E)
– N --> N0 | N1 | 0 | 1
14
MATHG1 is ambiguous
• Come up with two distinct leftmost derivations of the string 11+0*11– E ==> E+E ==> N+E ==> N1+E ==> 11+E ==>
11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==> 11+0*11
– E ==> E*E ==> E+E*E ==> N+E*E ==> N1+E*E ==> 11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==>11+0*11
• Draw the corresponding parse trees
E --> N | E+E | E*E | E/E | E-E | (E)N --> N0 | N1 | 0 | 1
15
Corresponding Parse Trees
• E ==> E+E ==> N+E ==> N1+E ==> 11+E ==> 11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==> 11+0*11
• E ==> E*E ==> E+E*E ==> N+E*E ==> N1+E*E ==> 11+E*E ==> 11+N*E ==> 11+0*E ==> 11+0*N ==> 11+0*N1 ==>11+0*11
E
E E+
E E*N
N
1
1 N
0
N
N 1
1
E
N
N
1
1
* EE
N
0
+ EE
N
N 1
1
16
Parse Tree Meanings *
E
E E+
E E*N
N
1
1 N
0
N
N 1
1
E
N
N
1
1
* EE
N
0
+ EE
N
N 1
1
Note how the parse trees captures the semantic meaning of string 11+0*11.More specifically, what number does the first parse tree represent?
What number does the second parse tree represent?
17
Implications
• Two interpretations of string 11+0*11– 11+(0*11) = 11– (11+0)*11 = 1001
• What if a line in a program is– MSU_Tuition = 11+0*11;– What is MSU_Tuition?
• Depends on how the expression 11+0*11 is parsed.• This is not good.• Ambiguity in grammars is undesirable, particularly if the grammar is
used to develop a compiler for a programming language like C++.
• In this case, there is an unambiguous grammar for the language of arithmetic expressions
18
If-Then-Else Statements
• A grammar ITEG = (V, , S, P) for the language of legal If-Then-Else statements– V = (S, BOOL)
– = {adv<80, adv>50, grade=3.5, grade=3.0, if, then, else}
– S = S
– P: • S --> if BOOL then S else S | if BOOL then S |grade=3.5 |
grade=3.0
• BOOL --> adv<80 | adv>50
19
ITEG is ambiguous
• Come up with two distinct leftmost derivations of the string – if adv<80 then if adv>50 then grade=3.5 else grade=3.0– S ==>if BOOL then S else S ==> if adv<80 then S else S ==> if adv<80
then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0
– S ==>if BOOL then S ==> if adv<80 then S ==> if adv<80 then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0
• Draw the corresponding parse trees
S --> if BOOL then S |grade=3.5 | grade=3.0 | if BOOL then S else S BOOL --> adv<80 | adv>50
20
Corresponding Parse Trees• S ==>if BOOL then S else S ==> if adv<80 then
S else S ==> if adv<80 then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0
• S ==>if BOOL then S ==> if adv<80 then S ==> if adv<80 then if BOOL then S else S ==> if adv<80 then if adv>50 then S else S ==> if adv<80 then if adv>50 then grade=3.5 else S ==> if adv<80 then if adv>50 then grade=3.5 else grade=3.0
S S
if B then S else S
adv<80 if B then S grade=3.0
adv>50 grade=3.5
if B then S
adv<80 else Sif B then S
adv>50 grade=3.5 grade=3.0
21
Parse Tree Meanings *
S
if B then S else S
if B then Sadv<80
adv>50 grade=3.5
grade=3.0
S
if B then S
else Sif B then Sadv<80
adv>50 grade=3.5 grade=3.0
If you receive a 90 on advanced points, what is your grade?By parse tree 1
By parse tree 2
22
Implications
• Two interpretations of string – if adv<80 then if adv>50 then grade=3.5 else grade=3.0
– Issue is which if-then does the last ELSE attach to?
– This phenomenon is known as the “dangling else”
– Answer: Typically, else binds to NEAREST if-then
• In this case, there is an unambiguous grammar for handling if-then’s as well as if-then-else’s
23
Inherently ambiguous CFL’s
• A CFL L is inherently ambiguous iff for all CFG’s G such that L(G) = L, G is ambiguous
• Examples so far– None of the CFL’s we’ve seen so far are inherently ambiguous
– While the CFG’s we’ve seen ambiguous, there do exist unambiguous CFG’s for those CFL’s.
• Later result– There exist inherently ambiguous CFL’s
– Example: {aibjck | i=j or j=k or i=j=k}• Note i=j=k is unnecessary, but I added it here for clarity
24
Summary
• Parse trees illustrate “semantic” information about strings
• Ambiguous grammars are undesirable– This means there are multiple parse trees for some string
– These strings can be interpreted in multiple ways
• There are some heuristics people use for taking an ambiguous grammar and making it unambiguous, but this is not the focus of this course
• There are some inherently ambiguous grammars– Thus, the above heuristics do not always work