LRk Parsing

1
LR(k) Parsing

• CPSC 388
• Ellen Walker
• Hiram College

2
Bottom Up Parsing

• Start with tokens
• Build up rule RHS (right side)
• Replace RHS by LHS
• Done when stack is only start symbol
• (Working from leaves of tree to root)

3
Operations in Bottom-up Parsing

• Shift
• Push the terminal from the beginning of the
  string to the top of the stack
• Reduce
• Replace the string xyz at the top of the stack by
  a nonterminal A (assuming A-xyz)
• Accept (when stack is S empty input)

4
Sample Parse

• S - S S- aSb bSa SS e
• String abba
• Stack , input abba shift
• Stack a input bba reduce S-e
• Stack aS input bba shift
• Stack aSb input ba reduce S-aSb
• Stack S input ba shift

5
Sample Parse (cont)

• Stack S input ba shift
• Stack Sb input a reduce S-e
• Stack SbS input a shift
• Stack SbSa input reduce S-bSa
• Stack SS input reduce S-SS
• Stack S input reduce S- S
• Stack S input accept

6
LR(k) Parsing

• LR(0) grammars can be parsed with no lookahead
  (stack only)
• LR(1) grammars need 1 character lookahead
• LR(k), k1 use multi-character lookahead
• Most real grammars are LR(1)

7
Shift vs. Reduce

• First, build NFA of LR(0) items
• Transform NFA to DFA
• If unambiguous, grammar is LR(0) - use DFA
  directly to parse (states indicate shift vs.
  reduce)
• Otherwise, use SLR(1) algorithm

8
LR(0) Items

• Rules with . between stack input
• For S-(S) a, the LR(0) items are
• S - .(S) S- (.S) S-(S.) S-(S).
• S- .a S- a.
• S - .(S) and S- .a are initial items
• S- (S). and S-a. are complete items

9
Building NFA

• Each LR(0) item is a state
• Shift transitions
• Change of goal transitions

10
More on NFA

• Initial state is S - .S
• No final state, but acceptance happens in S-S.
  state
• Complete LR(0) items have no outbound transitions
• Well worry about getting past them later
• No reduce transitions
• shift on non-terminal used during reduce

11
NFA S- (S) Ab A - aA e
12
NFA - DFA

• Compute e-closure (closure items)
• All are initial items
• Use subset construction (kernel items)
• Grammar kernel items are sufficient (closure
  items can be inferred)
• DFA is computed directly by YACC, etc.

13
DFA Construction Details

• For each symbol (terminal or nonterminal) after
  the marker, create a shift transition. These are
  kernel items.

S
S'- .S
S' - S.
14
DFA Construction Details

• If there are multiple shift transitions on the
  same symbol, these are combined into the same
  state.
• (Because the NFA will be in all those states at
  once).

15
Adding Closure Items

• When the marker is immediately before a
  non-terminal symbol, the closure items are all of
  the initial forms for the new symbol, e.g.
• S - .S (kernel item)
• S - .(S) (closure item)
• S - .Ab (closure item)
• These denote the change of goal transitions
  (which are all epsilon-transitions)

16
DFA Final States

• The DFA doesnt actually accept the string, so
  the concept of final isnt the same
• In JFLAP, mark any state where a reduction can
  take place as final

17
DFA S- (S) Ab A - aA e
18
LR(0) Parsing

• At each step, push a state onto the stack, and do
  an action based on the current state
• A-a.xb (not a complete item)
• If x is terminal, shift.
• A-aXb. (a complete item)
• Reduce by A-aXb

19
When Not LR(0)?

• Shift-reduce conflict
• State contains both a complete item and a shift
  item (with leading terminal)
• Reduce-reduce conflict
• State contains 2 or more complete items.
• Previous example is not LR(0)! (Why)?

20
Simple LR(1)

• If a shift is possible, do it
• Else if there is a complete item for A, and the
  next terminal is in Follow(A), reduce A. Compute
  the next state by taking the A link from the last
  state left on the stack before pushing A
• Otherwise, there is a parse error

21
SLR(1) Table

• Rows are states, columns are symbols (terminal
  and nonterminal)
• Table entries (3 types)
• sn shift goto state n
• (only for terminals)
• Rk reduce using rule k
• (rule s start at 0 in
  JFLAP)
• n Goto state n
• (only for nonterminals, after
  reduction)

22
Transitions and Table Entries

• Transition from state m to state n on terminal x
• Put sn in table mx
• Transition from state m to state n on nonterminal
  X
• Put n in table mX
• State m has a complete item for rule k, and
  terminal x is in FINAL of the LHS of rule k
• Put rk in tablemx
• State m is S-S
• Put acc (accept) in tablem

23
SLR(1) Example

• Grammar
• S- (S) Ab A- aA e
• Firsts
• S (,a,b A a,e
• Follows
• S ,) A b

24
SLR(1) Example Table
25
SLR(1) Example

• Stack input
• 0 (aab)
• 0(2 aab)
• 0(2a7 ab)
• 0(2a7a7 b)
• 0(2a7a7A8 b) A-e
• 0(2a7A8 b) A-e
• 0(2A5 b) A-aA

26
SLR(1) Example cont.

• 0(2A5 b)
• 0(2A5b6 )
• 0(2S3 )
• 0(2S3)4
• 0S1
• 0S accept!

27
Another SLR(1) Grammar to Try

• S - zMNz
• M - aMa
• M - z
• N - bNb
• N - z

28
Parsing Conflicts in SLR(1)

• Shift-reduce conflict
• Prefer shift over reduce
• Reduce-reduce conflicts
• Error in design of grammar (usually)
• Possible to designate a grammar-specific choice

29
Dangling Else

• Remember if C if C else S
• Shift-preference puts else with inner if!
• To put else with outer if, inner if C must be
  reduced to S first
• Good example of how language evolved to make it
  easy for the compiler!

30
More than SLR(1)

• SLR(k) Parsing
• Multiple-token lookahead (for shifts) and
  multiple-token follow information (for reductons)
• General LR(1) parsing
• Include lookaheads in DFA construction
• LALR(1) parsing
• Simplified state diagram for GLR(1)
• What YACC / Bison uses