Some Preliminaries to LR(1) parsing

1. Consider the grammar

   < S > a < S > b < S >  | 

2. If we build the LR(0) machine for this grammar, we discover that it is not an LR(0) grammar because several states contain shift/reduce conflicts.
   • The initial state is composed of the items:

     [ < S' > . < S > $ ]
     [ < S > . a < S > b < S > ]
     [ < S > . ]

   • Starting from the initial state on input "a" we reach the the state:

     [ < S > a . < S > b < S > ]
     [ < S > . a < S > b < S > ]
     [ < S > . ]

   We can use this machine anyway, if we are willing to look ahead a bit.

   • In all the sentential forms you can generate from the grammar an "a" will never directly follows and S.
   • As a result, in either of the states shown, choosing to reduce when the next input is an "a" would definitely lead to a dead end.
3. In general, suppose that we find that after reading some prefix ₁ of an input ₁ x ₂ we end up in a state that contains a reduce item [ N . ] which conflicts with some other item.
   • If we decide to reduce using the production in this item, we are basically assuming that

     S N x ₂ x _{2 1} x ₂

   • That is, we are assuming that there is some sentential form in which an x can follow an N.
4. Preliminaries often involve definitions:

   nullable

   Given a grammar G, we say that a non-terminal N is nullable if N .

   first set

   Given a grammar G and (V_n U V_t)^* we define First() to be the set of terminals that might appear as the first symbol in a string derived from . First() will include if . Thus,

   First() = { a V_t  |  a , for some ( V_n U V_t )^* } U { if }

5. The set of nullable non-terminals can be computed by the following algorithm:
   1. Set "nullable" equal to the set of non-terminals appearing on the left side of productions of the form N .
   2. Until doing so adds no new non-terminals to "nullable", examine each production in the grammar adding to "nullable" all left-hand-sides of productions whose right-hand-side consist entirely of symbols in "nullable".
6. Given that we have computed the set of nullable non-terminal, we can compute First for each terminal and non-terminal using a "run until nothing changes" algorithm: to compute First().
   • We use a table called `FirstSet' with one entry for each terminal and non-terminal. Throughout the algorithm, for any x (V_t U V_n)

     First( x ) FirstSet[ x ]

   • FirstSet will be initialized as follows.
     1. Set FirstSet[ x ] to { } for all nullable non-terminals and to { } for all other non-terminals.
     2. Set FirstSet[ x ] equal to { x } for all terminals.
     3. For each production of the form N t add t to FirstSet[ N ].
   • For each production of the form N , write as = ' where is a string of nullable non-terminals, and ' is either the or a string of terminals and non-terminals beginning with a non-nullable symbol we will call M.
   • The approximations for the First sets stored in the FirstSet table are then improved until they become exact by repeating the following process until no further changes occur.
     • For each production N '
       1. For each x , add (FirstSet[ x ] - ) to FirstSet[ N ].
       2. If ' = then add to FirstSet[ N ] otherwise add (FirstSet[ M ] - ) to FirstSet[ N ].