Chapter 3 Context-Free Grammars and Parsing Ambiguous Grammar

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

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

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. Samuel2005@126.com

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

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. Samuel2005@126.com

6. Example exp → exp op exp | (exp) | number op →+ | - | * * - 42 34 3 - 34 * 3 42 √ × exp → exp addop exp | term addop →+ | - term → term mulop term | factor mulop →* factor →(exp) | number Samuel2005@126.com

7. (34 – 3) – 42 = –11 34 – (3 – 42) = 73 Ambiguous 34 – 3 – 42 √ × (34 – 3) – 42 Samuel2005@126.com

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. Samuel2005@126.com

9. Example 34 - 3 - 42has a unique parse tree Samuel2005@126.com

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

11. Dangling else Problem statement → if-stmt | other if-stmt → if (exp)statement | if(exp) statementelsestatement exp → 0 | 1 • if (0) if (1) other else other has two parse trees with two meaning if (0) if (1) other else otherand if (0) if (1) other else other √ × Samuel2005@126.com

12. if (0) if (1) other else other Samuel2005@126.com

13. if (0) if (1) other else other Samuel2005@126.com

14. Dangling else Problem statement → if-stmt | other if-stmt → if (exp)statement | if(exp) statementelsestatement exp → 0 | 1 • if (0) if (1) other else other has two parse trees with two meaning if (0) if (1) other else otherand if (0) if (1) other else other • Modify the grammar. • Disambiguating rule: the most closely nested rule. Samuel2005@126.com

15. if (0) if (1) other else other Dangling else Problem statement → matched-stmt | unmatched-stmt matched-stmt →if (exp) matched-stmt else matched-stmt | other unmatched-stmt → if (exp)statement | if(exp) matched-stmtelseunmatched-stmt exp → 0 | 1 Samuel2005@126.com

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

17. Extended BNF Notation (EBNF) • { }repetitions A → β {α} and A → {α} β Samuel2005@126.com

18. Left and Right Recursion • Left recursive grammar: • A → A α | β • Equivalent to β α* • A → β {α} • Right recursive grammar: • A → αA | β • Equivalent toα* β • A → {α} β Samuel2005@126.com

19. Extended BNF Notation (EBNF) • { }repetitions A → β {α} and A → {α} β • [ ] optional constructs statement → if-stmt | other if-stmt → if (exp)statement | if(exp) statementelsestatement exp → 0 | 1 statement → if-stmt | other if-stmt → if (exp)statement[elsestatement] exp → 0 | 1 Samuel2005@126.com

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. Samuel2005@126.com

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: Samuel2005@126.com

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: Samuel2005@126.com

23. Syntax Diagrams(cont) • An optional construct such as • A → [ B ] • Is drawn as: Samuel2005@126.com

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 Samuel2005@126.com

25. Example statement → if-stmt | other if-stmt → if (exp)statement | if(exp) statementelsestatement exp → 0 | 1 statement → if-stmt | other if-stmt → if (exp)statement[elsestatement] exp → 0 | 1 Samuel2005@126.com

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 Samuel2005@126.com

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 Samuel2005@126.com

28. Syntax Tree for Factorial Program Samuel2005@126.com

29. Homework 1.2 1.3 1.7 2.1 2.2 2.4 2.5 2.8 2.12 2.17 2.24 3.3 3.5 3.6 3.24 Samuel2005@126.com

30. Homework 3.5Write 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. Samuel2005@126.com

31. Homework 3.6Consider 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 Samuel2005@126.com

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