Skip to content
Related Articles

Related Articles

Construction of LL(1) Parsing Table

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 02 Aug, 2022

A top-down parser builds the parse tree from the top down, starting with the start non-terminal. There are two types of Top-Down Parsers: 

  1. Top-Down Parser with Backtracking
  2. Top-Down Parsers without Backtracking
Prerequisite - Classification of top-down parsers, FIRST Set, FOLLOW Set 

Top-Down Parsers without backtracking can further be divided into two parts: 

In this article, we are going to discuss Non-Recursive Descent which is also known as LL(1) Parser. 

LL(1) Parsing: Here the 1st L represents that the scanning of the Input will be done from Left to Right manner and the second L shows that in this parsing technique we are going to use Left most Derivation Tree. And finally, the 1 represents the number of look-ahead, which means how many symbols are you going to see when you want to make a decision.

Essential conditions to check first are as follows: 

  1. The grammar is free from left recursion.
  2. The grammar should not be ambiguous.
  3. The grammar has to be left factored in so that the grammar is deterministic grammar.

These conditions are necessary but not sufficient for proving a LL(1) parser.

Algorithm to construct LL(1) Parsing Table: 

Step 1:  First check all the essential conditions mentioned above and go to step 2.

Step 2: Calculate First() and Follow() for all non-terminals.

  1.  First(): If there is a variable, and from that variable, if we try to drive all the strings then the beginning Terminal Symbol is called the First. 
  2. Follow(): What is the Terminal Symbol which follows a variable in the process of derivation. 

Step 3: For each production A –> α. (A tends to alpha)

  1. Find First(α) and for each terminal in First(α), make entry A –> α in the table.
  2. If First(α) contains ε (epsilon) as terminal than, find the Follow(A) and for each terminal in Follow(A), make entry A –> α in the table.
  3. If the First(α) contains ε and Follow(A) contains $ as terminal, then make entry A –> α in the table for the $.
    To construct the parsing table, we have two functions:  

In the table, rows will contain the Non-Terminals and the column will contain the Terminal Symbols. All the Null Productions of the Grammars will go under the Follow elements and the remaining productions will lie under the elements of the First set. 

Now, let’s understand with an example. 

Example-1: Consider the Grammar: 

E --> TE'
E' --> +TE' | ε                
T --> FT'
T' --> *FT' | ε
F --> id | (E)

*ε denotes epsilon

Step1 – The grammar satisfies all properties in step 1

Step 2 calculating first() and follow()

Find their First and Follow sets:  

 FirstFollow
E –> TE’{ id, ( }{ $, ) }
E’ –> +TE’/ε{ +, ε }{ $, ) }
T –> FT’{ id, ( }{ +, $, ) }
T’ –> *FT’/ε{ *, ε }{ +, $, ) }
F –> id/(E){ id, ( }{ *, +, $, ) }

Step 3making parser table 

Now, the LL(1) Parsing Table is: 

 id+*()$
EE –> TE’  E –> TE’  
E’ E’ –> +TE’  E’ –> εE’ –> ε
TT –> FT’  T –> FT’  
T’ T’ –> εT’ –> *FT’ T’ –> εT’ –> ε
FF –> id  F –> (E)  

As you can see that all the null productions are put under the Follow set of that symbol and all the remaining productions lie under the First of that symbol. 

Note: Every grammar is not feasible for LL(1) Parsing table. It may be possible that one cell may contain more than one production. 

Let’s see an example. 

Example-2: 

Consider the Grammar 

S --> A | a
A --> a 

Step1 – The grammar does not satisfy all properties in step 1, as the grammar is ambiguous. Still, let’s try to make the parser table and see what happens

Step 2 – calculating first() and follow()

Find their First and Follow sets:

 FirstFollow
S –> A/a{ a }{ $ }
A –>a{ a }{ $ }

Step 3 – making parser table 

Parsing Table: 

 a$
SS –> A, S –> a 
AA –> a 

Here, we can see that there are two productions in the same cell. Hence, this grammar is not feasible for LL(1) Parser.

Trick –  Above grammar is ambiguous grammar. So the grammar does not satisfy the essential conditions. So we can say that this grammar is not feasible for LL(1) Parser even without making the parse table.

Example-3: Consider the Grammar 

S -> (L) | a
L -> SL'
L' -> )Sl' | ε

Step1 – The grammar satisfies all properties in step 1

Step 2 – calculating first() and follow()

 FirstFollow
S{ ( , a }{ ) }
L{ ( , a }{ ) }
L’{ ) , ε }{ ) }

Step 3 – making parser table 

Parsing Table: 

  (   a $
SS -> (L) S -> a 
LL -> SL’ L -> SL’ 
L’

L’ -> )Sl’  

L’ -> ε

   

Here, we can see that there are two productions in the same cell. Hence, this grammar is not feasible for LL(1) Parser. Here although the grammar satisfies all the essential conditions in step 1, it is still not feasible for LL(1) Parser.  We saw in example 2 that we must have these essential conditions and in example 3 we saw that those conditions are not sufficient to be a LL(1) parser. 

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!