COMPILER DESIGN- Syntax Analysis

COMPILER DESIGN- Syntax Analysis
Dr R Jegadeesan Prof-CSE
Jyothishmathi Institute of Technology and Science,
Karimnagar

SYLLABUS
UNIT - II
Syntax Analysis: Introduction, Context-Free Grammars, Writing a Grammar, Top-Down Parsing, Bottom-Up
Parsing, Introduction to LR Parsing: Simple LR, More Powerful LR Parsers, Using Ambiguous Grammars,
Parser Generators.

UNIT-II : SYNTAX ANALYSIS
Topic Name : Context free Grammars
Aim & Objective : To identify syntax errors.
Principle & Operation/ Detailed Explanation :
Context Free Grammars (CFG) can be classified on the basis of following two properties:
1) Based on number of strings it generates.
If CFG is generating finite number of strings, then CFG is Non-Recursive (or the grammar is said to
be Non-recursive grammar)
If CFG can generate infinite number of strings then the grammar is said to be Recursive grammar
During Compilation, the parser uses the grammar of the language to make a parse tree(or derivation
tree) out of the source code. The grammar used must be unambiguous. An ambiguous grammar must
not be used for parsing.

2) Based on number of derivation trees.
 If there is only 1 derivation tree then the CFG is unambiguous.
 If there are more than 1 derivation tree, then the CFG is ambiguous.
Examples of Recursive and Non-Recursive Grammars
Recursive Grammars
1) S->SaS S->b The language(set of strings) generated by the above grammar is :{b, bab, babab,…}, which
is infinite.
2) S-> Aa A->Ab|c The language generated by the above grammar is :{ca, cba, cbba …}, which is infinite.
Universities & Important Questions:
1. Explain ambiguous grammar with an example.

Top-Down parsing
Topic Name : Top down parsing
Principle & Operation/ Detailed Explanation :
Parsing is classified into two categories, i.e. Top Down Parsing and Bottom-Up Parsing. Top-Down
Parsing is based on Left Most Derivation.
The process of constructing the parse tree which starts from the root and goes down to the leaf is Top-
Down Parsing.
 Top-Down Parsers constructs from the Grammar which is free from ambiguity and left recursion.
 Top Down Parsers uses leftmost derivation to construct a parse tree.
 It allows a grammar which is free from Left Factoring.
Top –down parsing can be:
1.With Backtracking: Brute Force Technique
2.Without Backtracking:
1. Recursive Descent Parsing
2. Predictive Parsing or Non-Recursive Parsing or LL(1) Parsing or Table Driver Parsing

 Brute Force Technique or Recursive Descent Parsing –
Whenever a Non-terminal spend first time then go with the first alternative and compare with the
given I/P String
If matching doesn’t occur then go with the second alternative and compare with the given I/P String.
If matching again not found then go with the alternative and so on.
Moreover, If matching occurs for at least one alternative, then the I/P string is parsed successfully.
LL(1) or Table Driver or Predictive Parser –
 In LL1, first L stands for Left to Right and second L stands for Left-most Derivation. 1 stands for
number of Look Aheads token used by parser while parsing a sentence.
 LL(1) parsing is constructed from the grammar which is free from left recursion, common prefix, and
ambiguity.
 LL(1) parser depends on 1 look ahead symbol to predict the production to expand the parse tree.
 This parser is Non-Recursive.

BOTTOM –UP PARSING
Bottom Up Parsers / Shift Reduce Parsers
Build the parse tree from leaves to root. Bottom-up parsing can be defined as an attempt to reduce the
input string w to the start symbol of grammar by tracing out the rightmost derivations of w in reverse.
Eg.

 classification of bottom up parsers

A general shift reduce parsing is LR parsing. The L stands for scanning the input from left
to right and R stands for constructing a rightmost derivation in reverse.
Benefits of LR parsing:
 Many programming languages using some variations of an LR parser. It should be noted
that C++ and Perl are exceptions to it.
 LR Parser can be implemented very efficiently.
 Of all the Parsers that scan their symbols from left to right, LR Parsers detect syntactic
errors, as soon as possible.

LR Parser
We need two functions –
Closure()
Goto()
 Closure Operation:
If I is a set of items for a grammar G, then closure(I) is the set of items constructed from I by the two
rules:
Initially every item in I is added to closure(I).
If A -> α.Bβ is in closure(I) and B -> γ is a production then add the item B -> .γ to I, If it is not already
there. We apply this rule until no more items can be added to closure(I).
Eg:

Goto Operation :
Goto(I, X) = 1. Add I by moving dot after X.
2. Apply closure to first step.

 Eg:
Consider the grammar S ->AA
A -> aA | b
Augmented grammar S’ -> S
S -> AA
A -> aA | b
 The LR(0) parsing table for above GOTO graph will be –

Simple LR
 SLR Parser
The SLR parser is similar to LR(0) parser except that the reduced entry. The reduced productions are
written only in the FOLLOW of the variable whose production is reduced.
Construction of SLR parsing table –
 Construct C = { I0, I1, ……. In}, the collection of sets of LR(0) items for G’.
 State i is constructed from Ii. The parsing actions for state i are determined as follow
 If [ A -> ?.a? ] is in Ii and GOTO(Ii , a) = Ij , then set ACTION[i, a] to “shift j”. Here a must be
terminal.
 If [A -> ?.] is in Ii, then set ACTION[i, a] to “reduce A -> ?” for all a in FOLLOW(A); here A may not be
S’.
 Is [S -> S.] is in Ii, then set action[i, $] to “accept”. If any conflicting actions are generated by the above
rules we say that the grammar is not SLR.
The goto transitions for state i are constructed for all nonterminals A using the rule:
if GOTO( Ii , A ) = Ij then GOTO [i, A] = j. All entries not defined by rules 2 and 3 are made error.

 Eg:
If in the parsing table we have multiple entries then it is said to be a conflict.
Consider the grammar
E -> T+E | T T ->id
Augmented grammar –
E’ -> E E -> T+E | T T -> id

Canonical LR
In the SLR method we were working with LR(0)) items. In CLR parsing we will be using LR(1) items.
LR(k) item is defined to be an item using lookaheads of length k. So , the LR(1) item is comprised of
two parts : the LR(0) item and the lookahead associated with the item.
LR(1) parsers are more powerful parser.
For LR(1) items we modify the Closure and GOTO function.
Closure
Closure(I)
repeat
for (each item [ A -> ?.B?, a ] in I )
for (each production B -> ? in G’)
for (each terminal b in FIRST(?a))
add [ B -> .? , b ] to set I;
until no more items are added to I;
return I;

Goto Operation
Goto(I, X)
Initialise J to be the empty set;
for ( each item A -> ?.X?, a ] in I )
Add item A -> ?X.?, a ] to se J; /* move the dot one step */
return Closure(J); /* apply closure to the set */
Eg:

Lookahead LR
LALR PARSER
LALR parser are same as CLR parser with one difference. In CLR parser if two states differ only in
lookahead then we combine those states in LALR parser. After minimisation if the parsing table has no
conflict that the grammar is LALR also.
Eg:
consider the grammar
S ->AA
A -> aA | b
Augmented grammar - S’ -> S
S ->AA
A -> aA | b

COMPILER DESIGN- Syntax Analysis

More Related Content

What's hot

Similar to COMPILER DESIGN- Syntax Analysis

More from Jyothishmathi Institute of Technology and Science Karimnagar

Recently uploaded

COMPILER DESIGN- Syntax Analysis