Ambiguous Grammars

Deciding if a CFG grammar is ambiguous is undecidable.
Some languages are inherently ambiguous.
A language is ambiguous if the same string can be represented by two different parse trees.
Or if there are two different left-most or right most derivations of the string.
Or right most.

This is a problem for

 
 E   →  E + E
    |  E * E
    |  ( E )
    |  id

since E => E+E => id+E => id+E*E=> id+id*E=> id+id*id
and E => E*E => E+E*E => id+E*E=> id+id*E=> id+id*id
Which as we have seen has two different parse trees.
The problem is that we need to select a rule to apply and all rules are equal.

Furthermore, we have seen this grammar disambiguated by adding a rule.

 
E  →  E+T   
     |      T   
T  →  T*F   
     |      F   
F  → ( E)  
     |      id

In some sense, this has forced the evaluation of + to be at a different level from the evaluation of *
Or guarantees that * will be lower (thus happen earlier) in the parse tree than +
The book notes, as does the Bison book, that disambiguation rules can dispose of undesirable parse trees.
- Apparently bison implements an alternative type of parser called a GLR parser which can handle ambiguity
- "you can hand any grammar to bison, and it will crate a parser that parses something ,resolving the conflicts at parse time. But the more conflicts it has, the less likely it is that your parser will resolve the conflicts the way you want."

Show that the following is ambiguous by describing two different parse trees for aabbab


 S  →  aSbS 
      |  bSaS 
      |  ε

What causes the ambiguity in this language?

Another ambiguous grammar, which is a problem for us.


 stmt →  if expr then stmt  
        |     if expr then stmt else stmt  
        |     other

Derive two different parse trees for if E₁ then if E₂ then S₁ else S₂
The ambiguity comes from the two choices at the top level.

We want to select the derivation which corresponds to the left most (python indentation)

if E₁ then             if E₁ then
   if E₂ then              if E₂ then
      S₁                      S₁
   else                else
      S₂                  S₂

C/C++ and most other sane languages require else to be associated with the closest then.
To solve this problem we will introduce the concept of a matched statement.
That is a complete if-then-else statement
And an unmatched statement, an if-then

Then we build the rules to force the statements inside of the then clause to be matched statements.


stmt        → matched_stmt
                |   open_stmt
matched_stmt → if expr then  matched_stmt else unmatched_stmt   
                |    other   
open_stmt   → if expr then stmt 
                |   if expr then  matched_stmt else open_stmt

Do exercise 4.3.3 on page 217

If time, show that the following is ambiguous, derive a non-ambiguous grammar. (Use the string aadccb)


 S →  aS  
       |    SB  
       |    d  
 B →  Bb  
       |    c

stmt	→	if expr then stmt
	\|	if expr then stmt else stmt
	\|	other

stmt	→	matched_stmt
	\|	open_stmt
matched_stmt	→	if expr then matched_stmt else unmatched_stmt
	\|	other
open_stmt	→	if expr then stmt
	\|	if expr then matched_stmt else open_stmt