LL(1) Parsing

1
LL(1) Parsing
Programming Language Concepts Lecture 7

• Prepared by
• Manuel E. Bermúdez, Ph.D.
• Associate Professor
• University of Florida

2
Example

• Build the LL(1) parse table for the following
  grammar.
• S ? begin SL end begin
• ? id E id
• SL ? SL S begin,id
• ? S begin,id
• E ? ET (, id
• ? T (, id
• T ? PT (, id
• ? P (, id
• P ? (E) (
• ? id id

- not LL(1)
3
(No Transcript)
4
Example (contd)

• Lemma Left recursion always produces a
  non-LL(1) grammar (e.g., SL, E above)
• Proof Consider
• A ? A? First (?) or Follow (A)
• ? ? First (?) Follow (A)

5
Problems with our Grammar

• SL is left recursive.
• E is left recursive.
• T ? P T both begin with the same ? P
  sequence of symbols (P).

6
Solution to Problem 3

• Change T ? P T (, id
• ? P (, id
• to T ? P X (, id
• X ? T
• ? , , )
• Follow(X)
• Follow(T) due to T ? P X
• Follow(E) due to E ? ET , E ? T
• , , ) due to E ? ET, S ? id E
  
• and P ? (E)

Disjoint!
7
Solution to Problem 3 (contd)

• In general, change
• A ? ??1
• ? ??2
• . . .
• ? ??n
• to A ? ? X
• X ? ?1
• . . .
• ? ?n

Hopefully all the ?s begin with different symbols
8
Solution to Problems 1 and 2

• We want (((( T T) T) T))
• Instead, (T) (T) (T) (T)
• Change E ? E T (, id
• ? T (, id
• To E ? T Y (, id
• Y ? T Y
• ? , )
• Follow(Y) ? Follow(E)
• , )

No longer contains , because we eliminated the
production E ? E T
9
Solution to Problems 1 and 2 (contd)

• In general,
• Change A ? A?1 A ? ? 1
• . . . . . .
• ? A?n ? ? m
• to A ? ?1 X X ? ?1 X
• . . . . . .
• ? ?m X ? ?n X
• ?

10
Solution to Problems 1 and 2 (contd)

• In our example,
• Change SL ? SL S begin, id
• ? S begin, id
• To SL ? S Z begin, id
• Z ? S Z begin, id
• ? end

11
Modified Grammar

• S ? begin SL end begin
• ? id E id
• SL ? S Z begin,id
• Z ? S Z begin,id
• ? end
• E ? T Y (,id
• Y ? T Y
• ? ,)
• T ? P X (,id
• X ? T
• ? ,,)
• P ? (E) (
• ? id id

Disjoint. Grammar is LL(1)
12
(No Transcript)
13
(No Transcript)
14
Recursive Descent Parsing

• Top-down parsing strategy, suitable for LL(1)
  grammars.
• One procedure per nonterminal.
• Contents of stack embedded in recursive call
  sequence.
• Each procedure commits to one production, based
  on the next input symbol, and the select sets.
• Good technique for hand-written parsers.

15
For our Modified, LL(1) Grammar

• proc S S ? begin SL end
• ? id E
• case Next_Token of
• T_begin Read(T_begin)
• SL
• Read (T_end)
• T_id Read(T_id)
• Read (T_)
• E
• Read (T_)
• otherwise Error
• end
• end

Read (T_X) verifies that the upcoming token is
X, and consumes it.
Next_Token is the upcoming token.
16
For our Modified, LL(1) Grammar (contd)

• proc SL SL ? SZ
• S
• Z
• end
• proc E E ? TY
• T
• Y
• end

Technically, should have insisted that Next Token
be either T_begin or T_id, but S will do that
anyway. Checking early would aid error
recovery.
// Ditto for T_( and T_id.
17
For our Modified, LL(1) Grammar (contd)

• proc ZZ ? SZ
• ?
• case Next Token of
• T_begin, T_id SZ
• T_end
• otherwise Error
• end
• end

18
For our Modified, LL(1) Grammar (contd)
Could have used a case statement

• proc Y Y ? TY
• ?
• if Next Token T_ then
• Read (T_)
• T
• Y
• end
• proc T T ? PX
• P
• X
• end

Could have checked for T_( and T_id.
19
For our Modified, LL(1) Grammar (contd)

• proc XX ? T
• ?
• if Next Token T_ then
• Read (T_)
• T
• end

20
For our Modified, LL(1) Grammar (contd)

• proc P P ?(E)
• ? id
• case Next Token of
• T_( Read (T_()
• E
• Read (T_))
• T_id Read (T_id)
• otherwise Error
• end
• end

21
LL(1) Parsing
Programming Language Concepts Lecture 7

• Prepared by
• Manuel E. Bermúdez, Ph.D.
• Associate Professor
• University of Florida