1. Context-Free Grammars and Parsing
Chapter 3
Context-Free Grammars and Parsing
Ambiguous Grammar
Gang S. Liu
College of Computer Science & Technology
Harbin Engineering University
Compiler

2. Ambiguous Grammar
exp → exp op exp | (exp) | number
op → + | - | *
The string 34 – 3 * 42 has two different parse trees and syntax trees. * - *
A grammar that generates a string with two distinct parse trees is called an ambiguous grammar.
Compiler

3. Two Ways to Deal with Ambiguity
Disambiguating rule
State a rule that specifies in each ambiguous case which of the trees is correct.
It corrects the ambiguity without changing and complicating the grammar.
Syntactic structure of the language is not given by the grammar alone.
Change grammar into a form that forces the construction of a correct parse tree.
In both cases we must decide which of the trees are correct.
Compiler

4. Ambiguous Grammar
exp → exp op exp | (exp) | number
op → + | - | *
The string 34 – 3 * 42 has two different parse trees and syntax trees. * - *
A grammar that generates a string with two distinct parse trees is called an ambiguous grammar.
Compiler

5. Precedence Some operations have precedence over other operations.
Multiplication has precedence over addition.
To handle the precedence of operations in the grammar, we group the operators into groups of equal precedence.
We must write a different rule for each precedence.
Compiler

6. Example √ × exp → exp op exp | (exp) | number op → + | - | * - * × √
exp → exp addop exp | term
addop → + | -
term → term mulop term | factor
mulop → *
factor → (exp) | number
Compiler

7. Ambiguous √ × 34 – 3 – 42 (34 – 3) – 42 (34 – 3) – 42 = –11
34 – (3 – 42) = 73
(34 – 3) – 42
Compiler

8. Associativity Some operation (like subtraction) are left associative.
A series of subtraction operations is performed from left to right.
exp → exp addop exp | term
Recursion on both sides of the operator allows either side to match repetitions of the operator in a derivation.
exp → exp addop term | term
The right recursion is replaced with the base case, forcing the repetitive matches on the left side
Left recursion makes addition and subtraction left associative.
Compiler

9. Example 34 - 3 - 42 has a unique parse tree Compiler

10. Example exp → exp addop term | term addop → + | -
term → term mulop factor | factor
mulop → *
factor → (exp) | number
34- 3* 42 has a unique parse tree
exp
exp addop term
term term mulop factor
factor factor * number
number number
Compiler

11. Dangling else Problem √ × statement → if-stmt | other
if-stmt → if (exp) statement
| if (exp) statement else statement
exp → 0 | 1
if (0) if (1) other else other has two parse trees with two meaning
if (0) if (1) other else other and
if (0) if (1) other else other √ ×
Compiler

12. if (0) if (1) other else other
Compiler

13. if (0) if (1) other else other
Compiler

14. Dangling else Problem statement → if-stmt | other
if-stmt → if (exp) statement
| if (exp) statement else statement
exp → 0 | 1
if (0) if (1) other else other has two parse trees with two meaning
if (0) if (1) other else other and
if (0) if (1) other else other
Modify the grammar.
Disambiguating rule: the most closely nested rule.
Compiler

15. if (0) if (1) other else other
Dangling else Problem
if (0) if (1) other else other
statement → matched-stmt | unmatched-stmt
matched-stmt → if (exp) matched-stmt else
matched-stmt | other
unmatched-stmt → if (exp) statement
| if (exp) matched-stmt else unmatched-stmt
exp → 0 | 1
Compiler

16. Inessential Ambiguity
Sometimes a grammar may be ambiguous and yet always produce unique abstract syntax trees.
Example:
( a + b ) + c = a + ( b + c )
Compiler

17. Extended BNF Notation (EBNF)
{ } repetitions
A → β {α} and A → {α} β
Compiler

18. Left and Right Recursion
Left recursive grammar:
A → A α | β
Equivalent to β α *
A → β {α}
Right recursive grammar:
A → α A | β
Equivalent to α * β
A → {α} β
Compiler

19. Extended BNF Notation (EBNF)
{ } repetitions
A → β {α} and A → {α} β
[ ] optional constructs
statement → if-stmt | other
if-stmt → if (exp) statement
| if (exp) statement else statement
exp → 0 | 1
statement → if-stmt | other
if-stmt → if (exp) statement [ else statement ]
exp → 0 | 1
Compiler

20. Syntax Diagrams
Graphical representations for visually representing EBNF rules are called syntax diagrams.
They consist of boxes representing terminals and nonterminals, arrowed lines representing sequencing and choices, and nonterminal labels for each diagram representing the grammar rule defining that nonterminal.
A round or oval box is used to indicate terminals in a diagram, while a square or rectangular box is used to indicate nonterminals.
Compiler

21. Syntax Diagrams(cont)
As an example, consider the grammar rule
factor → ( exp ) | number
This is written as a syntax diagram in the following way:
Compiler

22. Syntax Diagrams(cont)
Syntax diagrams are written from the EBNF rather than the BNF, so we need diagrams representing repetition and optional constructs. Given a repetition such as
A → { B }
The corresponding syntax diagram is usually drawn as follow:
Compiler

23. Syntax Diagrams(cont)
An optional construct such as
A → [ B ]
Is drawn as:
Compiler

24. Example exp → exp addop term | term addop → + | –
term → term mulop factor | factor
mulop → *
factor → (exp) | number
exp → term { addop term }
addop → + | –
term → factor { mulop factor }
mulop → *
factor → (exp) | number
Compiler

25. Example statement → if-stmt | other if-stmt → if (exp) statement
| if (exp) statement else statement
exp → 0 | 1
statement → if-stmt | other
if-stmt → if (exp) statement [ else statement ]
exp → 0 | 1
Compiler

26. Context-free Grammar for TINY
program → stmt-sequence
stmt-sequence → stmt-sequence ; statement | statement
statement → if-stmt | repeat-stmt | assign-stmt| read-stmt | write-stmt
if-stmt → if exp then stmt-sequence end |
if exp then stmt-sequence else stmt-sequence end
repeat-stmt → repeat stmt-sequence until exp
assign-stmt → identifier := exp
read-stmt → read identifier
write-stmt → write exp
exp → simple-exp comp-op simple-exp | simple-exp
comp-op → < | =
simple-exp → simple-exp addop term | term
addop → + | -
term → term mulop factor | factor
mulop → * | /
factor → (exp) | number | identifier
Compiler

27. Factorial Program { Sample program in TINY language -
computes factorial }
read x; { input an integer }
if 0 < x then { don't compute if x <= 0 }
fact := 1;
repeat
fact := fact * x;
x := x - 1
until x = 0;
write fact { output factorial of x }
end
Compiler

28. Syntax Tree for Factorial Program
Compiler

29. Homework
Compiler

30. Homework
3.5 Write a grammar for Boolean expressions that includes the constants true and false, the operators and, or, and not, and parentheses. Be sure to give or a lower precedence than and and and a lower precedence than not and to allow repeated not’s, as in the Boolean expression not not true. Also be sure your grammar is not ambiguous.
Compiler

31. Homework
3.6 Consider the following grammar representing simplified LISP-like expressions:
a. Write a leftmost and a rightmost derivation for the string ( a 23 (m x y) ) .
b. Draw a parse tree for the string of part(a).
lexp → atom | list
atom → number | identifier
list → (lexp-seq)
lexp-seq → lexp-seq lexp | lexp
Compiler

32. Homework 3.24 For the TINY program read x; x := x + 1;
a. Draw the TINY parse tree.
b. Draw the TINY syntax tree.
read x;
x := x + 1;
write x
Compiler