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), k>1 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->.aS-> 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 –We’ll worry about getting past them later No “reduce transitions” –“shift” on non-terminal used during reduce

11. NFA: S-> (S) | Ab ; A -> aA | 

12. NFA -> DFA Compute  -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'->.SS' -> 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 doesn’t actually accept the string, so the concept of “final” isn’t the same In JFLAP, mark any state where a reduction can take place as final

17. DFA S-> (S) | Ab ; A -> aA | 

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): –snshift & goto state n (only for terminals) –Rkreduce using rule k (rule #’s start at 0 in JFLAP) –nGoto 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 [m][x] Transition from state m to state n on nonterminal X –Put n in table [m][X] State m has a complete item for rule k, and terminal x is in FINAL of the LHS of rule k –Put rk in table[m][x] State m is “S’->S” –Put acc (accept) in table[m][$]

23. SLR(1) Example Grammar –S-> (S) | Ab A-> aA |  Firsts –S: (,a,bA: a,  Follows –S: $,)A: b

24. SLR(1) Example Table Stat()ab$AS 0s2s3r471 1acc 2s2s3r475 3s3r44 4r3 5s6 6r1 7s8 8r2

25. SLR(1) Example Stackinput $0(aab)$ $0(2aab)$ $0(2a7ab)$ $0(2a7a7b)$ $0(2a7a7A8b)$A->  $0(2a7A8b)$A->  $0(2A5b)$A->aA

26. SLR(1) Example cont. $0(2A5b)$ $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