LL(1) Grammars

• (L)eft to right (L)eftmost derivation with 1 lookahead.
• With care, such grammars can cover most programming constructs
  • Remove left-recursion
  • Remove ambiguous elements.
  • And the following restriction
    • A → α | β
    • For no terminal a do both α =>^* a and β=>^* a
    • Either α =>^* ε or β=>^* ε but not both.
    • if β=>^* ε then α ≠>^* a such that a ∈ FOLLOW(A)
  • Really these conditions just force a single choice in the derivation.
• He points out that programming constructs such as while and if are distinguishable easily in LL(1) grammars

  stmt → if (expr) stmt else stmt
        | while ( expr) stmt
        | { stmt_list }
      

• Building a predictive parsing table
  • Compute the FIRST and FOLLOW sets for all elements in the grammar
  • m = |terminals|
  • n = |nonterminals|
  • Construct M[m,n] containing productions.
  • Algorithm 4.1

    Input G a grammar
    Output M a parse table
    
     for each production A→ α in G do
         for each terminal a ∈ FIRST(α)  do
              M[A,a] ← M[A,a] + A → α
         if ε ∈ FIRST(α) then
             for each terminal b ∈ FOLLOW(A) do
                 M[A,b] ← M[A,b] + A → α
         if ε ∈ FIRST(α)  and $ ∈ FOLLOW(A) then
                 M[A,$] ← M[A,$] + A → α
     if any M[A,a] is empty then
         M[A,a] → error
    
    	 

• Consider

  • E	→	TE'
    E'	→	+TE' | ε
    T	→	FT'
    T'	→	*FT' | ε
    F	→	(E) | id

• Symbol	FIRST	FOLLOW	Symbol	FIRST	FOLLOW
  E	{(,id}	{),$}	(	{(}
  E'	{+,ε}	{),$}	)	{)}
  T	{(,id}	{+,),$}	id	{id}
  T'	{*,ε}	{+,),$}	+	{+}
  F	{(,id}	{+,*,),$}	*	{*}

• E →  TE'
      For terminal in FIRST(T)  {(,id}
          M[E,(] ←  T→ TE'
          M[E,id] ←  T→ TE'
  E' →  +TE'
      For terminal in FIRST(+)   {+}
          M[E',+] ← E' → +TE'
  E' → ε
      No terminals
      For each terminal in FOLLOW(E') {),$}
          M[E',)] ← E' → ε
          M[E',$] ← E' → ε
      

• Do the other productions.

• 	id	+	*	(	)	$
  E	E → TE'			E→ TE'
  E'		E' → +TE'			E' → ε	E' → ε
  T	T → FT'			T → FT'
  T'		T' → ε	T' → *FT'		T'→ ε	T'→ ε
  F	F→ id			F → (E)

Nonrecursive Predictive Parsing

• Using the table above.
• Maintain S =>_lm^* wα
  • w is the input processed so far
• Input is stored in a buffer, marked at the end with a $
• A stack contains the sequence of grammar symbols
  • Initially set to S,$ (S is on the top)
• Pseudo algorithm
  • X is the top symbol on the stack and a is the current input symbol
  • If X is a nonterminal Apply production M[X,a]
    • This should include constructing parse tree node
  • If X is a terminal, it should match a.
  • Otherwise error
• ALGORITHM 4.34

  
   s.push($), s.push(S)
   a ← first (w)
   X ← s.top()
   while X ≠ $ do
       if X= a  then
           s.pop()
           a ← next(w)
       else if X ∈ terminals
           error()
       else if  M[X,a] = error
           error()
       else if M[X,a] = X ← Y1Y2 ... Yn
         Output  X ← Y1Y2 ... Yn
         s.pop()
         for i ← n downto 1 do
              s.push(Yi)
       X ← s.pop()