Items

• Fix a grammar \(G = (V,\Sigma,R,S)\) without useless nonterminals. For technical reason, we’ll always work with the augmented grammar \(G'\) that includes \(G\) and in extra also has a new start symbol \(S'\), and a new production \(S'\to S\).

• An LR(0) item (or simply item) is a production with a mark in it. A production \(A \to X_1X_2\cdots X_n\) with length-\(n\) body can give rise to \(n+1\) items. E.g., production \(A\to\epsilon\) gives item \([A\to ●]\) and production \(A\to aXY\) gives these four items

  [A → ●aXY]
  [A → a●XY]
  [A → aX●Y]
  [A → aXY●]

• Each item represents a state of the parser. For example, an item like [A → aX●Y] represents the state where the parser has already seen an input string derivable from aX and is hoping to see a string derivable from Y next. An item like [A → aXY●] represents the state where the parser has already seen the whole body aXY and perhaps it’s time to reduce it to A.
  # LR(0) automaton

• The LR(0) automaton of an augmented grammar \(G'\) is the NFA satisfying the following conditions.
  1. Its states are the items of \(G'\).
  2. Its alphabet consists of the grammar symbols of \(G'\).
  3. The start state is \([S'\to ●S]\).
  4. For each state \([A\to X_iX_2\cdots X_{j-1} ● X_j \cdots X_n]\) with a dot in front of \(X_j\), there’s an edge labeled \(X_j\) from it to the state \([A\to X_iX_2\cdots X_j ● X_{j+1}\cdots X_n]\) with the dot after \(X_j\).
  5. For each state \(I = [A\to X_iX_2\cdots X_{j-1} ● X_j \cdots X_n]\) such that \(X_j\) is a nonterminal, and for each \(X_j\)-production \(X_j\to \alpha\), there is an \(\epsilon\)-edge from \(I\) to state \([X_j\to ● \alpha]\).
  6. Every state is an accept state.
• We can convert this NFA into an equivalent DFA by doing these 3 things together: (i) taking the \(\epsilon\)-closure of states (ii) performing the subset construction, and (iii) eliminating states unreachable from the start state.

• The resulting DFA is the one described in the dragon book as the LR(0) automaton. Each state of the DFA is a set of LR(0) items. Its collection of states is called the canonical LR(0) collection. They also use the convention of deleting the dead state (or trap state) from the picture.

Example LR(0) automaton

Remarks

• The dragon book explains how to get an LR(0) automaton by using the CLOSURE(I) and GOTO(I,X) functions. Their CLOSURE function corresponds to “taking the \(\epsilon\)-closure while also eliminating states unreachable from the start state” in the NFA-to-DFA conversion, and their GOTO function corresponds to the transition function of the final DFA.
• One curious fact about every LR(0) automaton is that it has the spelling property: all the transitions entering any given state have the same label.
• The LR(0) automaton can be used to construct a parser by declaring that the parser should
  • reduce whenever a handle is on the stack
  • shift if that would still make the stack content viable
  • declare error if input is not empty but it can neither reduce nor shift
  • accept if it has just reduced \(S\) to \(S'\) and the input is empty
• A class of languages that allows this this parsing strategy to parse correctly is called LR(0), a limited class of languages.
• A more powerful parser needs to take context of the unexamined input and/or lookahead symbol(s) into consideration. This lecture note will describe the SLR(1) parser, the simplest improvement to the LR(0) parser.

Exercises

• Show that the language of the following grammar is in LR(0).

  E → E + T
  E → T
  T → (E)
  T → id

• Show that the language of the following grammar is not in LR(0).

  E → E + T 
  E → T
  T → (E) 
  T → id 
  T → id[E]

SLR parsing table

• Algorithm for constructing an SLR(1) table:

  1. Construct the collection of sets of LR(0) items for G'.
  2. Determine parsing actions for each state Ii as follows:
      (a) If a is a terminal and [A → α●aβ] is in Ii,
        and GOTO(Ii,a) = Ij, then set ACTION[i,a] to "shift j".
      (b) If A is a nonterminal different from S' and if [A → α●]
        is in Ii, then set ACTION[i,a] to "reduce A → α" for all
        a ∈ FOLLOW(A).
      (c) If [S' → S●] is in Ii, then set ACTION[i,$]  to "accept".
  3. For all nonterminal A, if GOTO(Ii,A) = Ij, set GOTO[i,A] to j.
  4. All entries not defined by rule (2) and (3) above are "error".
  5. The initial state of the parser is the one constructed from
     the set of items containing [S' → ●S].

• If any conflicting actions result from rule 2, that gives a proof that the grammar is not in SLR(1).

Sample SLR(1) parsing table

LR Parser architecture

• Every LR parser has a driver program. It reads input from left to right, uses a stack to keep track of the states of LR automaton, an ACTION table, and a GOTO table. All LR parsers have the same architecture and uses the same driver program. They differ only in how they construct their tables.

LR Parser architecture continued

• The states of the LR automaton that describes that stack content are numbered by small integers. So are the productions.
• The value of ACTION[i, a], where i is a state and a is a grammar symbol, can have one of four forms:
  • Shift j, written sj, tells the parser to shift state j onto the stack.
  • Reduce j, written rj, tells the parser to reduce by production j, i.e., popping off as many states on the stack as there are symbols on the body of production j, exposing state i on the stack. The parser then pushes onto to the stack the state determined by GOTO[i, A] where A is the head of production j.
  • Accept, written acc, tells the parser to accept the input and finish parsing.
  • Error, shown as a blank entry, tells the parser there’s an error in the input and that it should take a corrective action.

Sample parsing execution

• This shows execution of the SLR parser on id * id + id.