Syntax Analysis — CFG, LL(1), FIRST/FOLLOW, Recursive Descent

🎯 Learning Objectives

• Write context-free grammars for programming languages
• Compute FIRST and FOLLOW sets
• Construct LL(1) parsing tables
• Implement recursive descent parsers
• Identify and eliminate left recursion and left factoring

1. Context-Free Grammars

1.1 Intuition

1.2 Formal Definition

• V: Non-terminals (syntactic variables)
• T: Terminals (tokens)
• P: Productions (rules of the form $A \to \alpha$)
• S: Start symbol Example: Arithmetic expressions

pseudo
E  → E + T | T         // Addition
T  → T * F | F         // Multiplication
F  → ( E ) | id        // Primary

1.3 Derivations

pseudo
E ⇒ E + T ⇒ T + T ⇒ F + T ⇒ id + T
  ⇒ id + T * F ⇒ id + F * F ⇒ id + id * id

1.4 Parse Trees

2. Eliminating Ambiguity and Left Recursion

2.1 Ambiguity

java
E → E + E | E * E | ( E ) | id
// String "id + id * id" has two parse trees (implicit left vs right associativity)

2.2 Left Recursion Elimination

pseudo
A  → β A'
A' → α A' | ε

pseudo
Before: E → E + T | T
After:  E  → T E'
        E' → + T E' | ε

2.3 Left Factoring

pseudo
S → if E then S
S → if E then S else S

pseudo
S  → if E then S S'
S' → else S | ε

3. FIRST and FOLLOW Sets

3.1 FIRST(X)

pseudo
1. If X is a terminal: FIRST(X) = {X}
2. If X → ε: add ε to FIRST(X)
3. If X → Y₁ Y₂ ... Yₖ:
   Add FIRST(Y₁) - {ε}
   If Y₁ ⇒* ε, add FIRST(Y₂) - {ε}
   If Y₁...Yₖ ⇒* ε, add ε

3.2 FOLLOW(X)

sql
1. Add $ to FOLLOW(S)
2. If A → αBβ: add FIRST(β) - {ε} to FOLLOW(B)
3. If A → αB or A → αBβ where β ⇒* ε:
   add FOLLOW(A) to FOLLOW(B)

3.3 Worked Example

pseudo
E  → T E'
E' → + T E' | ε
T  → F T'
T' → * F T' | ε
F  → ( E ) | id

• E → T E': FIRST(T) = { (, id }
• Done: FIRST(E) = { (, id } FOLLOW(E) Calculation:
• $ in FOLLOW(E) (rule 1)
• F → ( E ) (rule 2): ) in FOLLOW(E)
• FOLLOW(E) = { $, ) }

4. LL(1) Parsing

4.1 LL(1) Parsing Table

pseudo
For each production A → α:
  1. For each a in FIRST(α) - {ε}:
     add A → α to M[A, a]
  2. If ε in FIRST(α):
     for each b in FOLLOW(A):
       add A → α to M[A, b]

4.2 LL(1) Parsing Algorithm

python
Run Inline
stack = ['$', S]  # Start symbol with bottom marker
input = tokens + ['$']
while stack not empty:
    X = stack.top()
    a = input[0]
    if X == a:
        pop(X); consume(a)  # Match
    elif X is terminal:
        ERROR
    elif M[X, a] exists:
        pop(X)
        push M[X, a] in reverse order
    else:
        ERROR

4.3 Worked Example

5. Common Pitfalls

Pitfall 1: Left recursion in LL(1) → infinite loop

Pitfall 2: FIRST set missing ε

Pitfall 3: Ambiguous grammar passes FIRST/FOLLOW check

6. 📝 Practice Questions

Q1: Compute FIRST and FOLLOW for: S → a S b | ε

Answer:

• FIRST(S) = {a, ε}
• FOLLOW(S) = {$, b}

Derivation: FIRST(S): rule S→aSb adds a; S→ε adds ε. FOLLOW(S): $ added by rule 1. From S→a S b: b added by rule 2. Q2: Is the grammar S → a S | a LL(1)? Why or why not?

Answer: No. FIRST(aS) = {a}, FIRST(a) = {a}. Cell M[S, a] has two productions → not LL(1). Fix with left factoring: S → a S', S' → S | ε. Q3: Eliminate left recursion from: A → A a | A b | c | d

Answer: A → c A' | d A', A' → a A' | b A' | ε Q4: Construct LL(1) table for: S → a B, B → b C | ε, C → c

Answer:

• FIRST(S) = {a}, FIRST(B) = {b, ε}, FIRST(C) = {c}
• FOLLOW(S) = {}, FOLLOW(B) = {}, FOLLOW(C) = {$}

Q5: What is the difference between a top-down and bottom-up parser?

Answer: Top-down (LL) starts from the start symbol and tries to match the input by predicting productions (builds parse tree from root to leaves). Bottom-up (LR) starts from the input and tries to reduce to the start symbol (builds from leaves to root). LR can handle more grammars (including left-recursive ones) but is harder to construct by hand.

7. 🔗 Cross-References

• Week 2 - Lexical Analysis: Token stream from lexer feeds parser
• Week 4 - LR Parsing: More powerful bottom-up parsing
• BSCS3021 (ToC): Context-free grammars, derivation, Chomsky hierarchy Join Discord PreviousLexical AnalysisNextLR Parsing