LR Parsing — LR(0), SLR(1), LR(1), LALR(1)

🎯 Learning Objectives

• Construct LR(0) items and DFA
• Build SLR(1) parsing tables
• Differentiate LR(0), SLR(1), LR(1), and LALR(1)
• Trace shift-reduce parsing on input

1. Shift-Reduce Parsing

1.1 Intuition

1.2 LR Parsing Algorithm

python
Run Inline
stack = [$]
input = w$
while True:
    action = TABLE[state(top)][input[i]]
    if action == shift s:
        push input[i]; push state s; i++
    elif action == reduce A → β:
        pop 2|β| (symbols + states)
        push A; push TABLE[state(top)][A]
    elif action == accept:
        break
    else:
        error

2. LR(0) Items

• $E \to \cdot E + T$ (about to parse E)
• $E \to E \cdot + T$ (parsed E, about to see +)
• $E \to E + \cdot T$ (parsed E+, about to parse T)
• $E \to E + T \cdot$ (fully parsed — reduce ready)

2.1 LR(0) DFA Construction

3. SLR(1) Parsing

3.1 SLR Table Construction

1. Shift: If $A \to \alpha \cdot a \beta \in I_i$ and GOTO($I_i, a$) = $I_j$: set ACTION[$i, a$] = shift $j$
2. Reduce: If $A \to \alpha \cdot \in I_i$: set ACTION[$i, a$] = reduce $A \to \alpha$ for all $a \in$ FOLLOW($A$)
3. Goto: If GOTO($I_i, A$) = $I_j$: set GOTO[$i, A$] = $j$

3.2 SLR vs LR(0)

3.3 Limitations of SLR

pseudo
S → L = R
S → R
L → *R
L → id
R → L

4. LR(1) Items

5. LALR(1)

6. 📝 Practice Questions

Q1: What is the difference between a shift action and a reduce action?

Answer: Shift pushes the next input symbol onto the stack and moves to a new state. Reduce pops the right-hand side of a production from the stack and pushes the left-hand side non-terminal, transitioning via GOTO. Q2: Why does LR(1) have more states than LALR(1)?

Answer: LR(1) states include specific lookahead terminals. States with the same core production but different lookaheads are kept separate. LALR(1) merges these states, combining their lookahead sets. This reduces the number of states but can introduce conflicts (rarely). Q3: What causes a shift-reduce conflict? Give an example.

Answer: A shift-reduce conflict occurs when the parser can't decide whether to shift the next token or reduce a production. Example: the dangling-else problem with grammar S → if E then S | if E then S else S. When seeing else, should the parser reduce the inner if or shift the else? Q4: How does FOLLOW information help SLR(1) reduce conflicts relative to LR(0)?

Answer: LR(0) reduces whenever the dot is at the end of an item. SLR(1) only reduces if the next input symbol is in FOLLOW of the left-hand side. This eliminates reductions that can never lead to a valid parse. Q5: Trace LR parsing of "id + id * id" using the expression grammar.

Answer: The trace shows a sequence of shift and reduce actions: shift id (F→id), reduce T→F, reduce E→T, shift +, shift id (F→id), reduce T→F, shift _, shift id (F→id), reduce T→T_F, reduce E→E+T, accept.

7. 🔗 Cross-References

• Week 3 - LL(1) Parsing: Compare with LR parsing
• Week 5 - Semantic Analysis: Parser feeds semantic analyzer
• BSCS3021 (ToC): CFG, LR languages Join Discord PreviousSyntax Analysis INextSemantic Analysis