Construction of LL(1) Parsing Table

03 Jun, 2021
Prerequisite – Classification of top-down parsers, FIRST Set, FOLLOW Set 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:  
Top-Down Parser with BacktrackingTop-Down Parsers without Backtracking
Top-Down Parser with Backtracking
Top-Down Parsers without Backtracking
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.
 
Algorithm to construct LL(1) Parsing Table: 
Step 1:  First check for left recursion in the grammar, if there is left recursion in the grammar remove that and go to step 2.
Step 2: Calculate First() and Follow() for all non-terminals.
 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. Follow(): What is the Terminal Symbol which follows a variable in the process of derivation. 
 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. 
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)
Find First(α) and for each terminal in First(α), make entry A –> α in the table.If First(α) contains ε (epsilon) as terminal than, find the Follow(A) and for each terminal in Follow(A), make entry A –> α in the table.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:  
Find First(α) and for each terminal in First(α), make entry A –> α in the table.
If First(α) contains ε (epsilon) as terminal than, find the Follow(A) and for each terminal in Follow(A), make entry A –> α in the table.
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
Find their First and Follow sets: 
 
Now, the LL(1) Parsing Table is: 
 
As you can see that all the null productions are put under the Follow set of that symbol and all the remaining productions are 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 with an example. 
Example-2: Consider the Grammar  
S --> A | a
A --> a 
Find their First and Follow sets: 
 
Parsing Table: 
 
Here, we can see that there are two productions into the same cell. Hence, this grammar is not feasible for LL(1) Parser. 
himanii1621
amnindersingh1414
Compiler Design
GATE CS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Issues in the design of a code generator
Peephole Optimization in Compiler Design
Directed Acyclic graph in Compiler Design (with examples)
Type Checking in Compiler Design
Difference between Compiler and Interpreter
Layers of OSI Model
ACID Properties in DBMS
TCP/IP Model
Types of Operating Systems
Normal Forms in DBMS