Some Preliminaries to LR(1) parsing (cont.)

1. 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 }

2. 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 ].

3. Consider how to construct these sets for the grammar:

   S A B C

   A a  |  CB

   B C  |  A d  |

   C f  |

   • All the non-terminals are nullable:
     • B and C are directly nullable.
     • The production A B C, then implies A is nullable.
     • Then, the production S A B C implies S is nullable.
   • The productions break down as:

     S	A B C
     A		a
     A	CB
     B	C
     B	A	d
     B
     C		f
     C

   • The FirstSet values start out as shown in the table below and can be refined by iterating over the production table.

     S	A	B	C	a	d	f
     { }	{ , a }	{ }	{ , f }	{ a }	{ d }	{ f }
     { }	{ }	{ }	{ }	{ a }	{ d }	{ f }
     { }	{ }	{ }	{ }	{ a }	{ d }	{ f }
     { }	{ }	{ }	{ }	{ a }	{ d }	{ f }

4. The final preliminary is the definition of Follow:

   Follow( N ) = { x V_t  | A N x } U { if S N }

5. The computation of Follow(N) depends of the First sets defined earlier. If

   M N

   then Follow(N) must contains First( ) . If is nullable, then Follow(N) must also contain Follow(M). These observations are enough to give us an approximation algorithm for computing Follow. See the books on reserve for details.