1. Ben-Gurion University
Winter Compiler Principles Exercises on scanning & top-down parsing
Roman Manevich
Ben-Gurion University

2. Scanning question 1
Write a regular expression for positive integers where every three consecutive digits, starting from the right, are separated by a _
Examples: _ _784_153
Negative examples: 1_ _5422

3. Scanning question 1
Write a regular expression for positive integers where every three consecutive digits, starting from the right, are separated by a _
Examples: _ _784_153
Negative examples: 1_ _5422
Answer: D = 0 | 1 | 2 … | 9 Small = D | DD | DDD Three = DDD R = Small (_Three)*

4. Parsing question 1
Consider the grammar below S  ( L ) | a L  L , S | S
show a parse tree for each of the following
(a, a)
(a, (a, a))

5. Answer S ( L ) S L L L S S S a , ( a , a )

6. Parsing question 2 Consider the grammar G L  L , a | a
What is the language generated by G?
Eliminate the left-recursion in G
Write a non-left-recursive version without ε productions
Construct an LL(1) parser and run it on a, a, a

7. Parsing question 2 Consider the grammar G L  L , a | a Answer
What is the language generated by G?
Eliminate the left-recursion in G
Write a non-left-recursive version with ε productions
Is the resulting grammar LL(1)?
Answer
The language given by the regular expression (a ,)* a
L  a M M  , a M | ε
L  a | a M M  , a M | , a
The grammar contains FIRST-FIRST conflicts for both L and M and therefore it is not LL(1)

8. Parsing question 3 Consider the grammar G1 below X  P P P  a P  b
Q: Is it ambiguous?

9. Parsing question 3 Consider the grammar G1 below X  P P P  a P  b
Q: Is it ambiguous?
A: since the only non-terminal with alternatives is P and the first of its two alternatives ({a} and {b}) the grammar is LL(1). All LL(1) grammars are unambiguous

10. Parsing question 4
Consider the following grammar E  a ( S ) w t E  a ( S ) w b S  S ; c | c
Construct an LL(1) parser, applying any transformations necessary if the grammar is not in LL(1)
Hint: move the ) down to help transformations
Apply the parser to the input a (c; c) w b
Note: the following solution is over-complicated since there is an implicit constraint – no epsilon productions are allowed. Otherwise the solution is pretty simple.

11. Answer
The grammar E  a ( S ) w t E  a ( S ) w b S  S ; c | c will have a FIRST-FIRST conflict for E, since the first two rules start with ‘a ( S ) w’.
We therefore apply left-factoring and obtain E  a ( S ) E’ E’  w b | w t S  S ; c | c

12. Answer (with bugs)
The grammar E  a ( S ) E’ E’  w b | w t S  S ; c | c Is left-recursive on S so we eliminate the left-recursion and obtain the grammar
E  a ( S ) E’ E’  w b | w t S  c | c ; S

13. Answer
Let’s compute FIRST sets for E  a ( S ) E’ E’  w b | w t S  c | c ; S
FIRST(S  c) = FIRST(c ; S) = {c} FIRST(w b)=FIRST(w t) = {w} so there are FIRST-FIRST conflict. We apply left-factoring to both E’ and S and obtain E  a ( S ) E’ E’  w E’’ E’’  b | t S  c S’ S’  ε | ; S
Now if we apply substitution for S’ we will just get back to a left-recursive grammar. Time to use the hint

14. Answer
Starting from E  a ( S ) E’ E’  w E’’ E’’  b | t S  c | c ; S Let’s move ) from E to S
E  a ( S E’ E’  w E’’ E’’  b | t S  c ) | c ; S
Now let’s apply left-factoring to S and obtain: E  a ( S E’ E’  w E’’ E’’  b | t S  c S’ S’  ) | ; S

15. Answer
Let’s compute FIRST sets for (1) E  a (S E’ (2) E’  w E’’ (3) E’’  b (4) E’’  t (5) S  c S’ (6) S’  ) (7) S’  ; S
FIRST(E) = {a} FIRST(E’) = {w} FIRST(E’’) = {b, t} FIRST(S) = {c} FIRST(S’) = {), ;}
There are no conflicts so the grammar is in LL(1)

16. Parsing table ; ) c t b w ( a 1 E 2 E’ 4 3
E’’ 5 S 7 6 S’

17. Running on a ( c; c ) w b Input suffix Stack content Move
predict(E, a) = E  a ( S E’
a ( S E’ $
match(a, a)
( c; c ) w b $
( S E’ $
match( ‘(‘, ‘(‘)
c; c ) w b $
S E’ $
predict(S, c) = S  c S’
c S’ E’ $
match(c, c)
; c ) w b $
S’ E’ $
predict(S’, ;) = S’  ; S
; S E’ $
match( ‘(;, ‘;‘)
c ) w b $
) w b $
predict(S’, ‘)’) = S’  )
) E’ $
match( ‘)‘, ‘)‘)
w b $
E’ $
predict(E’, w) = E’  w E’’
w E’’ $
match(w, w)
b $
E’’ $
predict(E’’, b) = E’’  b
match(b, b) $

18. Running on a ( c; c ) w b
Input suffix
Stack content
Move
a ( c; c ) w b$ E$
predict(E, a) = E  a ( S E’
a ( S E’ $
match(a, a)
( c; c ) w b $
( S E’ $
match( ‘(‘, ‘(‘)
c; c ) w b $
S E’ $
predict(S, c) = S  c S’
c S’ E’ $
match(c, c)
; c ) w b $
S’ E’ $
predict(S’, ;) = S’  ; S
; S E’ $
match( ‘(;, ‘;‘)
c ) w b $
) w b $
predict(S’, ‘)’) = S’  )
) E’ $
match( ‘)‘, ‘)‘)
w b $
E’ $
predict(E’, w) = E’  w E’’
w E’’ $
match(w, w)
b $
E’’ $
predict(E’’, b) = E’’  b
match(b, b) $
Since the input has been read and the stack is empty – the parsing was successful and the input is accepted