Computing Follow(N)

Computing Follow(N)

1. If a grammar contains the rule N ₁ M R₂, then Follow(M) must contain the first symbols that might appear in strings derived from R. In addition, if R derives the empty string, then the first symbols that might be derived from ₂ will be in Follow(M).
2. The computation of the Follow set will depend on several other sub-computations.

   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 }

3. 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".
4. 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:
   • 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 ].

5. Consider how to determine nullable, First and Follow 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 }

6. 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.

Computing Follow(N)