First and follow set

comprehensive presentation on first and follow set of compiler construction.

1. University of azad jammu & Kashmir muzaffarabad Dawood Faheem Abbasi BSCS-VI-05

2. First and follow set Compiler Construction

3. FIRST & FOLLOW The construction of a predictive parser is aided by two functions associated with a grammar G. These functions , FIRST and FOLLOW, allow us to fill in the entries of a predictive parsing table for G, W henever possible . Sets of tokens yielded by the FOLLOW function can also be used as synchronizing tokens during panic-mode error recovery.

4. First set If α is any string of grammar symbols, let FIRST( α ) be the set of terminals that begin the strings derived from a. If a => Ɛ then Ɛ is also in FIRST( α ). To compute FIRST(X) for all grammar symbols X, apply the following rules until no more terminals or Ɛ can be added to any FIRST set.

5. Rules for first set If X is terminal, then FIRST(X) is {X} . If X => Ɛ is a production, then add Ɛ to FIRST(X ). If X is nonterminal and X => Y 1 Y 2 ... Y k . is a production, then place a in FIRST(X) if for some i , a is in FIRST(Y i ), and Ɛ is in all of FIRST(Y 1 ), ... , FIRST(Y i -1 ); that is, Y 1 , ... ,Y i -1 => Ɛ . If Ɛ is in FIRST( Y j ) for all j = 1, 2, ... , k, then add Ɛ to FIRST(X). For example, everything in FIRST(Y 1 ) is surely in FIRST(X ). If Y 1 does not derive Ɛ , then we add nothing more to FIRST(X), but if Y 1 => Ɛ , then we add FIRST(Y 2 ) and so on.

6. Follow set Define FOLLOW(A), for nonterminal A, to be the set of terminals a that can appear immediately to the right of A in some sentential form, that is, the set of terminals a such that there exists a derivation of the form S => α A a β for some α and β . Note that there may, at some time during the derivation, have been symbols between A and a , but if so, they derived Ɛ and disappeared. If A can be the rightmost symbol in some sentential form, then $, representing the input right end marker, is in FOLLOW(A).

7. Rules for follow set Place $ in FOLLOW(S), where S is the start symbol and $ is the input right end marker. If there is a production A => α B β , then everything in FIRST( β ), except for Ɛ , is placed in FOLLOW(B). If there is a production A => α B , or a production A => α B β where FIRST( β ) contains Ɛ (i.e., β => Ɛ ), then everything in FOLLOW(A) is in FOLLOW(B).

8. examples E => T E’ E’=> + T E’ | Ɛ T => F T’ T’=> * F T’ | Ɛ F => ( E ) | id FIRST(E) = FIRST(T) = FIRST(F) = {( , id } FIRST(E’) = {+, Ɛ } FIRST(T’) = {*, Ɛ } FOLLOW(E) = FOLLOW(E’) = {) , $} FOLLOW(T) = FOLLOW(T’) = {+, ), $} FOLLOW(F) = {+, *, ), $}

9. example S => A a A => B D B => b | Ɛ D => d | Ɛ First(S) = {b , d, a} First(A) = {b , d, Ɛ } First(B) = {b, Ɛ } First(D) = {d, Ɛ } Follow(S) = {$ } Follow(A) = { a} Follow(B) = { d , a} Follow(D) = {a}

10. example C => P F class id X Y P => public | Ɛ F => final | Ɛ X => extends id | j Y => implements I | Ɛ I => id j J => , I | Ɛ

11. 1. C => P F class id X Y 2. P => public 3. P => Ɛ 4. F => final 5. F => Ɛ 6. X => extends id 7. X => Ɛ 8. Y => implements I 9. Y => Ɛ 10. I => id J 11. J => , I 12. J => Ɛ First(C) = { public , final , class} First(P) = { public , Ɛ } First(F) = {final , Ɛ } First(X) = { extends , Ɛ } First(Y) = { implements , Ɛ } First(I) = { id} First(J) = {‘,', Ɛ } Follow(C) = {$ } Follow(P) = {final , class} Follow(F) = {class} Follow(X) = { implements , $} Follow(Y) = {$ } Follow(I) = { $} Follow(J) = {$ }

12. Thank you