• Top-of-stack is a nonterminal, and the parse table entry is empty: reject the input.
• Top-of-stack is a terminal but doesn't match the current token: reject the input.
• Stack is empty: accept the input.

Here's a very simple example, using a grammar that defines the language of balanced parentheses or square brackets, and running the parser on the input "( [ ] ) EOF". Note that in the examples in this set of notes we will use actual characters (such as: (, ), [, and ]) instead of the token names (LPAREN, RPAREN, etc). Also note that in the picture, the top of stack is to the left.

   grammar: S -> epsilon | ( S ) | [ S ]

   parse table:
      
           (         )       [        ]       EOF
       +--------------------------------------------
     S | ( S ) | epsilon | [ S ] | epsilon | epsilon
       +--------------------------------------------


   input seen so far   stack         action
   -----------------   -----         ------
         (              S EOF       pop, push "(S)"
	 (              (S) EOF     pop, scan (top-of-stack term matches curr token)
	 ([             S) EOF      pop, push "[S]"
	 ([             [S]) EOF    pop, scan (top-of-stack term matches curr token)
	 ([]            S]) EOF     pop, push epsilon (no push)
	 ([]            ]) EOF      pop, scan (top-of-stack term matches curr token)
	 ([])           ) EOF       pop, scan (top-of-stack term matches curr token)
	 ([]) EOF       EOF         pop, scan (top-of-stack term matches curr token)
	 ([]) EOF                   empty stack: input accepted!

       S -> ( S ) | [ S ] | ( ) | [ ]

We need to answer two important questions:

1. How to tell whether a grammar is LL(1).
2. How to build the parse (or selector) table for a predictive parser, given an LL(1) grammar.

It turns out that there is really just one answer: if we build the parse table and no element of the table contains more than one grammar rule right-hand side, then the grammar is LL(1).

Before saying how to build the table we will consider two properties that preclude a context-free grammar from being LL(1): left-recursive grammars and grammars that are not left factored. We will also consider some transformations that can be applied to such grammars to make them LL(1).

First, we will introduce one new definition:

A nonterminal X is useless if either:
1. You can't derive a sequence that includes X, or
2. You can't derive a string from X (where "string" means epsilon or a sequence of terminals).

 1. (for case 1) :
	
	S ->  A B
	A ->  + | - | epsilon
	B ->  digit | B digit
	C ->  . B
 
    	C is useless

 2. (for case 2) :

	S -> X | Y
	X -> ( )
	Y -> ( Y Y )

	Y just derives more and more nonterminals. 
	So it is useless.

• A grammar G is recursive in a nonterminal X if X can derive a sequence of symbols that includes X, in one or more steps: X ==>+ alpha X beta
• G is left recursive in nonterminal X if X can derive a sequence of symbols that starts with X, in one or more steps: X ==>+ X beta
• G is immediately left recursive in nonterminal X if X can derive a sequence of symbols that starts with X in one step: X ==> X beta (i.e., the grammar includes the production: X -> X beta).

In general, it is not a problem for a grammar to be recursive. However, if a grammar is left recursive, it is not LL(1). Fortunately, we can change a grammar to remove immediate left recursion without changing the language of the grammar. Here is how to do the transformation:

Given two productions of the form: A -> A alpha | beta where:
• A is a nonterminal
• alpha is a sequence of terminals and/or nonterminals
• beta is a sequence of terminals and/or nonterminals not starting with A
Replace those two productions with the following three productions:
A -> beta A'
A' -> alpha A' | epsilon
where A' is a new nonterminal.

To illustrate why the new grammar is equivalent to the original one, consider the parse trees that can be built using the original grammar:

       A           A               A            etc.
       |          / \             / \
     beta        A   alpha       A   alpha
                 |              / \
               beta            A  alpha
                               |
                             beta

1. beta
2. beta alpha
3. beta alpha alpha
4. etc.

       A               A              A               etc.
      / \             / \	     / \
   beta  A'        beta  A'	  beta  A'
         |              / \	       / \
       epsilon       alpha A'	    alpha A'
                           |             / \
			 epsilon      alpha A'
			                    |
					  epsilon

Example: Consider the grammar for arithmetic expressions involving only subtraction:

		exp    -> exp - factor | factor
		factor -> INTLITERAL   | ( exp )

Using the transformation defined above, we remove the immediate left recursion, producing the following new grammar:

		exp     -> factor exp'
		exp'    -> - factor exp' | epsilon
		factor  -> INTLITERAL    | ( exp )

• The predictive parser starts by pushing EOF, then exp onto the stack. Regardless of what the first token is, there is only one production with exp on the left-hand side, so it will always pop the exp from the stack and push factor exp' as its first action.
• Now the top-of-stack symbol is the nonterminal factor. Since the input is the INTLITERAL token (not the LPAREN token) it will pop the factor and push INTLITERAL.
• The top-of-stack symbol is now a terminal (INTLITERAL), which does match the current token, so the stack will be popped, and the scanner called to get the next token.
• Now the top-of-stack symbol is nonterminal exp'. We'll consider two cases:
  1. The next token is MINUS. In this case, we pop exp' and push - factor exp'.
  2. The next token is EOF. In this case, we pop exp' and push epsilon (i.e., push nothing).

Unfortunately, there is a major disadvantage of the new grammar, too. Consider the parse trees for the string 2 - 3 - 4 for the old and the new grammars:

              Parse tree using                     Parse tree using
            the original grammar:                  the new grammar:


                       exp                           exp
                       /|\                           / \
                      / | \                         /   \
                   exp  -  factor               factor  exp'
                   /|\       |                     |    /|\
                  / | \      4                     2   / | \
               exp  -  factor                         /  |  \
                |        |                           - factor exp'
              factor     3                               |    /|\
                |                                        3   / | \ 
                2                                           /  |  \ 
		                                           - factor exp'
                                                               |     |
                                                               |     |
                                                               4  epsilon

Note that the rule for removing immediate left recursion given above only handled a somewhat restricted case, where there was only one left-recursive production. Here's a more general rule for removing immediate left recursion:

• For every set of productions of the form:
  A -> A alpha₁ | A alpha₂ | .. | A alpha_m | beta₁ | .. | beta_n
• Replace them with the following productions:
  A -> beta₁ A' | beta₂ A' | .. | beta_n A'
  A' -> alpha₁ A' | .. | alpha_m A' | epsilon

Note also that there are rules for removing non-immediate left recursion; for example, you can read about how to do that in the compiler textbook by Aho, Sethi & Ullman, on page 177. However, we will not discuss that issue here.

A second property that precludes a grammar from being LL(1) is if it is not left factored, i.e., if a nonterminal has two productions whose right-hand sides have a common prefix. For example, the following grammar is not left factored:

exp -> ( exp ) | ( )

This problem is solved by left-factoring, as follows:

• Given a pair of productions of the form:
  A -> alpha beta₁ | alpha beta₂
  where alpha is a sequence of terminals and/or nonterminals, and beta₁ and beta₂ are sequences of terminals and/or nonterminals that do not have a common prefix (and one of the betas could be epsilon),

• Replace those two production with:
  A -> alpha A'
  A' -> beta₁ | beta₂

exp -> ( exp'
exp' -> exp ) | )

For each nonterminal A:
• Find the longest non-empty prefix alpha that is common to 2 or more production right-hand sides.
• Replace the productions:
  A -> alpha beta₁ | .. | alpha beta_m | y₁ | .. | y_n
  with:
  A -> alpha A' | y₁ | .. | y_n
  A' -> beta₁ | .. | beta_m
Repeat this process until no nonterminal has two productions with a common prefix.

Note that this transformation (like the one for removing immediate left recursion) has the disadvantage of making the grammar much harder to understand. However, it is necessary if you need an LL(1) grammar.

Here's an example that demonstrates both left-factoring and immediate left-recursion removal:

• The original grammar is:
  exp -> ( exp ) | exp exp | ( )

• After removing immediate left-recursion, the grammar becomes:
  exp -> ( exp ) exp' | ( ) exp'
  exp' -> exp exp' | epsilon

• After left-factoring, this new grammar becomes:
  exp -> ( exp''
  exp'' -> exp ) exp' | ) exp' exp' -> exp exp' | epsilon

Recall: A predictive parser can only be built for an LL(1) grammar. A grammar is not LL(1) if it is:

1. Left recursive, or
2. not left factored.

To build the table, we must must compute FIRST and FOLLOW sets for the grammar.

Ultimately, we want to define FIRST sets for the right-hand sides of each of the grammar's productions. To do that, we define FIRST sets for arbitrary sequences of terminals and/or nonterminals, or epsilon (since that's what can be on the right-hand side of a grammar production). The idea is that for sequence alpha, FIRST(alpha) is the set of terminals that begin the strings derivable from alpha, and also, if alpha can derive epsilon, then epsilon is in FIRST(alpha). Using derivation notation:

	FIRST(alpha) = { t | (t is a terminal and alpha ==>* t beta) or
			     (t = epsilon and alpha ==>* epsilon) }

1. X is a terminal: FIRST(X) = {X}
2. X is epsilon: FIRST(X) = {epsilon}
3. X is a nonterminal. In this case, we must look at all grammar productions with X on the left, i.e., productions of the form:
   X -> Y₁ Y₂ Y₃ ... Y_k
   where each Y_k is a single terminal or nonterminal (or there is just one Y, and it is epsilon). For each such production, we perform the following actions:
   • Put FIRST(Y₁) - {epsilon} into FIRST(X).
   • If epsilon is in FIRST(Y₁), then put FIRST(Y₂) - {epsilon} into FIRST(X).
   • If epsilon is in FIRST(Y₂), then put FIRST(Y₃) - {epsilon} into FIRST(X).
   • etc...
   • If epsilon is in FIRST(Y_i) for 1 <= i <= k (all production right-hand sides)) then put epsilon into FIRST(X).

For example, consider computing FIRST sets for each of the nonterminals in the following grammar:

	exp -> term exp'
	exp'-> - term exp' | epsilon
	term -> factor term'
	term'-> / factor term' | epsilon	
	factor -> INTLITERAL | ( exp )		

FIRST(factor) = { INTLITERAL, ( }
FIRST(term') = { /, epsilon }
FIRST(term) = { INTLITERAL, ( }// Note that FIRST(term) includes FIRST(factor);
                               // since FIRST(factor) does not include epsilon,
			       // that's all that is in FIRST(term).
FIRST(exp') = { -, epsilon }
FIRST(exp) = {INTLITERAL, ( }  // Note that FIRST(exp) include FIRST(term);   
                               // since FIRST(term) does not include epsilon,
			       // that's all that is in FIRST(exp).

Once we have computed FIRST(X) for each terminal and nonterminal X, we can compute FIRST(alpha) for every production's right-hand-side alpha. In general, alpha will be of the form:

X₁ X₂ ... X_n

1. Put FIRST(X₁) - {epsilon} into FIRST(alpha)
2. If epsilon is in FIRST(X₁) put FIRST(X₂) into FIRST(alpha).
3. etc...
4. If epsilon is in the FIRST set for every X_k, put epsilon into FIRST(alpha).

	FIRST( term exp' )      =  { INTLITERAL, ( }
	FIRST( - term exp' )    =  { - }
	FIRST( epsilon )        =  { epsilon }
	FIRST( factor term' )   =  { INTLITERAL, ( }
	FIRST( / factor term' ) =  { / }
	FIRST( epsilon )        =  { epsilon }
	FIRST( INTLITERAL )     =  { INTLITERAL }
	FIRST( ( exp ) )        =  { ( }

Why do we care about the FIRST(alpha) sets? During parsing, suppose the top-of-stack symbol is nonterminal A, that there are two productions:

A -> alpha
A -> beta

FOLLOW sets are only defined for single nonterminals. The definition is as follows:

For a nonterminal A, FOLLOW(A) is the set of terminals that can appear immediately to the right of A in some partial derivation; i.e., terminal t is in FOLLOW(A) if:

		     S ==>+ ... A t...  where t is a terminal

Furthermore, if A can be the rightmost symbol in a derivation, then EOF is in FOLLOW(A).

Using notation:

	     FOLLOW(A) = {t | (t is a terminal and S ==>+ alpha A t beta)
 		 	      or (t is EOF and S ==>* alpha A)}

          Fig. 1                      Fig. 2                     Fig. 3

	     S                           S                         S
            / \                         / \                       / \
           /   \                       /   \                     /   \
          /     \                     /  X Y\                   /     \
         /  /\   \                   /  /  | \                 /       \
           A  \                        /\  |                           (A)
              /\                      A  B /\                           |
             /  \                       / /  \                          |
           (a)b c                epsilon /    \                        /
            |                           /______\         EOF is in FOLLOW(A)
	    |                           (c)d e f
            a is in FOLLOW(A)                |
					 |
					  \
                                      c is in FOLLOW(A)

• If A is the start nonterminal, put EOF in FOLLOW(A) (like S in Fig. 3).
• Find the productions with A on the right-hand-side:
  • For each production X -> alpha A beta, put FIRST(beta) - {epsilon} in FOLLOW(A) -- see Fig. 1.
  • If epsilon is in FIRST(beta) then put FOLLOW(X) into FOLLOW(A) -- see Fig. 2.
  • For each production X -> alpha A, put FOLLOW(X) into FOLLOW(A) -- see Fig. 3, and Fig. 4 below:

                     Fig. 4
    
                         S
                        / \
                       /   \    Whatever follows X is also going to follow A
                      / X   \   
                       / \
                    alpha A
             

It is worth noting that:

• To compute FIRST(A) you must look for A on a production's left-hand side.
• To compute FOLLOW(A) you must look for A on a production's right-hand side.
• FIRST and FOLLOW sets are always sets of terminals (plus, perhaps, epsilon for FIRST sets, and EOF for follow sets). Nonterminals are never in a FIRST or a FOLLOW set.

Here's an example of FOLLOW sets (and the FIRST sets we need to compute them). In this example, nonterminals are upper-case letters, and terminals are lower-case letters.

S -> B c | D B
B -> a b | c S
D ->   d | epsilon

X   FIRST(X)         FOLLOW(X)
------------------------------
D   { d, epsilon }   { a, c }
B   { a, c }         { c, EOF }
S   { a, c, d }      { EOF, c }   Note: FOLLOW of S always includes EOF

Now let's consider why we care about FOLLOW sets:

• Suppose, during parsing, we have some X at the top-of-stack, and a is the current token.
• We need to replace X on the stack with the right-hand side of a production X -> alpha. Great. But what if X has two productions, say, X -> alpha and X -> beta. Which one should we use??
• Well, we've already said that if a is in FIRST(alpha) but not in FIRST(beta) then we want to choose X -> alpha.
• But what if a is not in FIRST of either alpha or beta? Well, if alpha or beta can derive epsilon, and a is in FOLLOW(X), then we still have hope that the input will be accepted: If alpha can derive epsilon (i.e., epsilon is in FIRST(alpha), then we want to choose X -> alpha (and similarly if beta can derive epsilon). The idea is that since alpha can derive epsilon, it will eventually be popped from the stack, and if we're lucky, the next symbol down (the one that was under the X) will be a.

Recall that the form of the parse table is:

      a     b     c...  (the current token)        
   +-----------------+
 X |     |     |     |
   |-----|-----|-----| 
 Y |     |     |     |   inside: the production right-hand side to push
   |-----|-----|-----| 
 Z |     |     |     |
   +-----------------+
 ^
 |
 (the nonterminal at the top-of-stack)

To build the table, we fill in the rows one at a time for each nonterminal X as follows:

for each production X -> alpha:
for each terminal t in First(alpha):
put alpha in Table[X,t]

if epsilon is in First(alpha) then:
for each terminal t in Follow(X):
put alpha in Table[X,t]

The grammar is not LL(1) iff there is more than one entry for any cell in the table.

Let's try building a parse table for the following grammar:

S -> B c | D B
B -> a b | c S
D ->   d | epsilon

X        FIRST(X)          FOLLOW(X)
------------------------------------
D        { d, epsilon }     { a, c }
B        { a, c }           { c, EOF }
S        { a, c, d }        { EOF, c }
Bc       { a, c }
DB       { d, a, c }
ab       { a }
cS       { c }
d        { d }
epsilon  { epsilon }

      a     b     c     d     EOF        
   +-----------------------------+
 S | B c |     | B c | D B |     |
   | D B |     | D B |     |     |
   |-----|-----|-----|-----|-----| 
 B |     |     |     |     |     |
   |     |     |     |     |     |
   |-----|-----|-----|-----|-----| 
 D |epsil|     |epsil|     |     |
   |     |     |     |     |     |
   +-----------------------------+

Here's how we filled in this much of the table:

1. First, we considered the production S -> B c. FIRST(Bc) = { a, c }, so we put the production's right-hand side (B c) in Table[S, a] and in Table[S, c]. FIRST(Bc) does not include epsilon, so we're done with that production.
2. Next, we considered the production S -> D B . FIRST(DB) = { d, a, c }, so we put the production's right-hand side (D B) in Table[S, d], Table[S, a], and Table[S, c].
3. Next, we considered the production D -> epsilon. FIRST(epsilon) = { epsilon }, so we must look at FOLLOW(D). FOLLOW(D) = { a, c }, so we put the production's right-hand side (epsilon) in Table[D, a] and Table[D, c}.

Now, suppose we actually want to code a predictive parser for a grammar that is LL(1). The simplest idea is to use a table-driven parser with an explicit stack. Here's pseudo-code for a table-driven predictive parser:

   Stack.push(EOF);
   Stack.push(start-nonterminal);
   currToken = scan();

   while (! Stack.empty()) {
     topOfStack = Stack.pop();
     if (isNonTerm(topOfStack)) {
       // top of stack symbol is a nonterminal
       p = table[topOfStack, currToken];
       if (p is empty) report syntax error and quit
       else {
         // p is a production's right-hand side
	 push p, one symbol at a time, from right to left
       }
     }
     else {
       // top of stack symbol is a terminal
       if (topOfStack == currToken) currToken = scan();
       else report syntax error and quit
     }
   }