1. Compiler Construction
Chapter 4
Compiler Construction
Dr K. V. N. Sunitha

2. Compiler Construction
Parsing
Determining whether a string is derivable a grammar or not.
Two approaches based on the order in which a parse tree is constructed are given below:
Top-down parsing
∙ Starts construction at root of parse tree and proceeds to children.
∙ Uses LMD
Bottom-up parsing
∙ Starts at leaves and proceeds to root
∙ Uses reverse or rightmost derivation
Compiler Construction
Dr K. V. N. Sunitha

3. Compiler Construction
Top Down Parsing
Example: of top-down parsing using a subset of the types of Pascal (the token dotdot stands for "..", and  "^" means a pointer)
      type     --> simple                   |    id                   |    array [ simple ] of type       simple -->  integer                   |      char                   |      num   dotdot   num      The top down construction of a parse tree for the string             array [ num dotdot num ] of integer
Compiler Construction
Dr K. V. N. Sunitha

4. Array [Num Dotdot Num] of Integer
Grammar
type     --> simple                   |    id  | array [ simple ] of type
simple -->  integer               |      char | num dotdot   num
Compiler Construction
Dr K. V. N. Sunitha

5. Compiler Construction
Bottom up parsing:
S ->aABe
A - > Abc | b
B -> d , w= abbcde
abbcde
aAbcde
aAde
aABe S
Compiler Construction
Dr K. V. N. Sunitha

6. Compiler Construction
Types of Parsers
Top down parsers
Recursive descent (predictive /non-predictive) parsers
Non-recursive descent predictive parser, i.e. LL(1)
Bottom up parsers
LR parsers
LR(0) – Least powerful than SLR
Simple LR, i.e. SLR(1) – Simple and least powerful.
Look ahead LR, i.e. LALR(1) – power and cost is
intermediate between the two
Canonical LR, i.e. CLR(1)/LR(1) – Most powerful and costly
Compiler Construction
Dr K. V. N. Sunitha

7. Compiler Construction
To design predictive parsers, grammar has to be free of left recursion and should be left factored.
Recursive descent predictive parser for parsing i+i
using E→ E+ T | T, T→ i After eliminating left recursion ‘G’ is,
E → TE’ , E’ → +TE’ |ε , T → i $
Compiler Construction
Dr K. V. N. Sunitha

8. Compiler Construction{
if (L==‘+’)
Match(‘+’);
T();
E’(); }
else return;
Match(chat t) {
if (t==L)
L=getchar();
else
Printf(“err\n”); }
char L;
L=getchar();
main() {
E();
E() {
T();
E’(); }
T() {
Match(i); }
if (L==“$”)
printf(“successful”); }
Compiler Construction
Dr K. V. N. Sunitha

9. Non-recursive Predictive Parsers
Avoid recursion for efficiency reasons
Used widely
INPUT BUFFER a + b $ X Y Z $
STACK
LL(1) Parser
Output
Parsing Table
Compiler Construction
Dr K. V. N. Sunitha

10. Compiler Construction
Parsing Algorithm
Let X be the grammar symbol on top of stack, ‘a’ is current input
symbol
Stack contents and remaining input called parser configuration
(initially push $ then start symbol S on to stack and read
complete input string in input buffer)
If X=a=$ halt and announce successful completion
If X=a ≠ $ pop X off stack advance input ptr to next symbol
If X is a nonterminal, the parser consults parsing table entry M[X,a]. This parsing table entry will be either a production of the grammar or blank entry. If, for example,
X->UVW replace X with WVU (U on top)
Output the production used above
Compiler Construction
Dr K. V. N. Sunitha

11. Example: input string: id + id *id
E → TE’
E’ → +TE’ | ε
T → F T’
T’ → *FT’ | ε
F → id |(E)
Example: input string: id + id *id
Parsing table: id + * ( ) $ E
E→TE’ E’
E’→+TE’
E’→ε T
T→FT’ T’
T’→ε
T’→*FT’ F
F→id
F→(E)
Compiler Construction
Dr K. V. N. Sunitha

12. Compiler Construction
Construction of Parsing Table Requires Two Functions: First() and Follow();
Evaluated by following 2 rules
If α is terminal, First(X)=(X)
If X is a non-terminal
(a) & has null production (i.e.) X →ε , First(X)=(ε)
(b) & has non null production, X →X1X2X3
First(X)=First(X1X2X3) = First(X1) if X1 => ε
First(X)=First(X1)-{ε} U First(X2X3 ) if X1 => ε * *
Compiler Construction
Dr K. V. N. Sunitha

13. Compiler Construction
Expr Grammar
Expr Grammar without Left Recursion
E → E + T | T
T → T * F | F
F → id |(E)
E → TE’
E’ → +TE’ | ε
T → F T’
T’ → *FT’ | ε
F → id |(E)
First() E
{id, ( } E’
{+, ε} T T’
{*, ε} F
Compiler Construction
Dr K. V. N. Sunitha

14. Compiler Construction
More Examples
A → Bb | C d
B → a B | ε
C → c C | ε
First(A) = {a,b, c,d},
First (B) = {a, ε},First (C) = {c, ε}
S → ABCDE
A → a | ε
B → b | ε
C → c | ε
D → d | ε
E → e
First(S)= ?
Compiler Construction
Dr K. V. N. Sunitha

15. Compiler Construction
S → ACB | C bB | Ba
A → da | BC
B → g | ε
C → h | ε
First(S) = ?
First(A) = ?
First(B) = ?
First(C) = ?
Compiler Construction
Dr K. V. N. Sunitha

16. Follow(A): Set of Terminals That May Follow Immediately to Right of A
Evaluted by 3 rules
If A is start symbol, Follow (A) = {$}
If S → α A β is in G, Follow (A) = First(β) –{ε }
If S → α A or S → α A β {β => ε},
Follow (A) = Follow (S); *
Compiler Construction
Dr K. V. N. Sunitha

17. Compiler Construction
Expr Grammar without left recursion
Expr Grammar
E → TE’
E’ → +TE’ | ε
T → FT’
T’ → *FT’ | ε
F → id |(E)
E → E + T | T
T → T * F | F
F → id |(E)
First() E
{id, ( } E’
{+, ε} T T’
{*, ε} F
Follow()
{ ), $ }
{ +, ),$}
{*,+,),$}
Compiler Construction
Dr K. V. N. Sunitha

18. Compiler Construction
Examples - Follow( )
1. S → a AB b A → c | ε B → d | ε Follow (A)={ b, d} Follow (B)={ b}
Compiler Construction
Dr K. V. N. Sunitha

19. Compiler Construction
Examples - Follow( )
2. S → a B D h
B → c C
C → b C | ε
D → E F
E → g | ε
F → f | ε
Follow (B) = ? = Follow (C)
Follow( D ) = ? Follow (E) = ? Follow (F)= ?
Compiler Construction
Dr K. V. N. Sunitha

20. LL(1) Parsing Table Construction
For each production A → α , repeat the following steps.
For each terminal ‘a’ in first(α), add
A → α to M [A ,a]
If ε is in First(α), add A → α to M [A,b] for each ‘b’ in Follow (A).
Compiler Construction
Dr K. V. N. Sunitha

21. Compiler Construction
Construct LL(1) parser to parse string (a,a)
G is S → ( L ) | a, L → L , S | S.
After eliminating left recursion, S → ( L ) | a
L → S L’
L’ → , S L’ | є a , ( ) $ S
S → a
S → (L) L
L → S L’ L’
L’ → , S L’
L’ → є.
Compiler Construction
Dr K. V. N. Sunitha

22. Compiler Construction
Construct LL(1) parser
S → AaBb |AbBa, A → є, B → є
Check whether above grammar is LL(1)?
Compiler Construction
Dr K. V. N. Sunitha