Compilers

Syntax Analysis

SITE : http://www.info.univ-tours.fr/˜mirian/

TLC - Mı́rian Halfeld-Ferrari – p. 1/7

 The Role of the Parser

The parser obtains a string of tokens from the lexical analyser and verifies that
the string can be generated by the grammar for the source language
The parser finds a derivation of a given sentence using the grammar or reports
that none exists.
The parser should
report any syntax errors in an intelligible fashion
recover from commonly occurring errors so that it can continue processing
the reminder of its input
Output of the parser: some representation of a parse tree for the stream of
tokens produced by the lexical analyser
token parse tree intermediate
lexical analyzer parser rest of front end representation
get next token

symbol table

TLC - Mı́rian Halfeld-Ferrari – p. 2/7

 The parsing problem

Consists of finding a derivation (if one exists) of a particular sentence

using a given grammar
Picture:
Considering that we have:
a sentence symbol (e.g., at the top of a sheet of paper) and
a sentence to be analysed (at the bottom of the sheet of paper)
the parsing problem consists of drawing a syntax tree (parse tree) to join the
sentence symbol and the sentence.

TLC - Mı́rian Halfeld-Ferrari – p. 3/7

 Types of parsers

A general algorithm for syntax analysis of CFG has a high cost in terms of time
complexity: O(n3 )
We need grammar classes allowing syntax analysis to be linear
In this context, there are two ways to build parse trees:
1. Top-down: build the parse trees from the top (root) to the bottom (leaves)
We have to decide which rule A → β should be applied to a node
labelled A
Expanding A results in new nodes (children of A) labelled by symbols
in β
2. Bottom-up: start from the leaves and work up to the root
We have to decide when rule A → β should be applied and we should
find neighbour nodes labelled by symbols in β
Reducing rule A → β results in adding a node A to the tree. A’s
children are the nodes labelled by the symbols in β.
In both cases, the input to the parser is scanned from left to right, one symbol at
a time.
TLC - Mı́rian Halfeld-Ferrari – p. 4/7
 Examples

We consider the grammar G1 = ({E, F, T }, {a, (, ), ∗, +}, P, E) where the productions

are:
E → E+T
E → T
T → T ∗F
T → F
F → (E)
F → a
and the string x = a + a ∗ a
Top-down method: rules are considered in the same order as a leftmost derivation
E ⇒E+T ⇒T +T ⇒a+T ⇒a+T ∗F ⇒a+F ∗F ⇒a+a∗F ⇒a+a∗a
Bottom-up method: rules are considered in the same order as a reverse rightmost
derivation
a+a∗a⇐F +a∗a⇐T +a∗a⇐E+a∗a⇐E+F ∗a⇐E+T ∗a⇐
E+T ∗F ⇐E+T ⇐E

TLC - Mı́rian Halfeld-Ferrari – p. 5/7

Although parse trees are used to describe parsing methods, in practise they are
not built.
Sometimes we need to construct syntactic trees - a summarised version of parse
trees.
In general, stacks are used.
Top-down analysis: Important nodes are those being expanded
Bottom-up analysis: Important nodes are roots of sub-trees that are not yet
assembled in a larger tree.

TLC - Mı́rian Halfeld-Ferrari – p. 6/7

 Top-down analysis: the use of stacks

The process is represented by configurations (α, y) where

α is the content of the stack and
y is the rest of the input, not analysed yet.
The top of the stack is on the left
There are two kinds of transitions from one configuration to another
1. Expanding a non terminal by using production A → β
Changes configuration (Aα, y) to (βα, y)
2. Verifying a terminal a
Changes configuration (aα, ay) to (α, y)
Used to pop an element from the stack (to find the next non terminal to be
expanded)
Initial configuration: (S, x) for an input string x
Final configuration: (ǫ, ǫ).
The stack is empty and the input has been completely considered

TLC - Mı́rian Halfeld-Ferrari – p. 7/7

Example: How to choose the production rule
to be applied?

Stack Rest of the input Leftmost derivation

E a+a∗a E
E+T a+a∗a ⇒E+T
T +T a+a∗a ⇒T +T
F +T a+a∗a ⇒F +T
a+T a+a∗a ⇒a+T
+T +a ∗ a
T a∗a
T ∗F a∗a ⇒a+T ∗F
F ∗F a∗a ⇒a+F ∗F
a∗F a∗a ⇒a+a∗F
∗F ∗a
F a
a a ⇒a+a∗a
ǫ ǫ TLC - Mı́rian Halfeld-Ferrari – p. 8/7
 Bottom-up analysis: the use of stacks

The process is represented by configurations (α, y) where

α is the content of the stack and
y is the rest of the input, not analysed yet.
The top of the stack is on the right
There are two kinds of transitions from one configuration to another
1. Reduction by using production A → β
Changes configuration (αβ, y) to (αA, y)
2. Putting terminal a in the stack
Changes configuration (α, ay) to (αa, y)
Used to push an element to the stack (allowing them to take part in the
reductions that take place on the top of the stack)
Initial configuration: (ǫ, x) for an input string x
Final configuration: (S, ǫ).
Indicates that all the input has been read and reduced for S

TLC - Mı́rian Halfeld-Ferrari – p. 9/7

Example: How to choose the production rule
to be applied?

Stack Rest of the input Rightmost derivation (in reverse)

a+a∗a a+a∗a
a +a ∗ a
F +a ∗ a ⇐F +a∗a
T +a ∗ a ⇐T +a∗a
E +a ∗ a ⇐E+a∗a
E+ a∗a
E+a ∗a
E+F ∗a ⇐E+F ∗a
E+T ∗a ⇐E+T ∗a
E + T∗ a
E+T ∗a ǫ
E+T ∗F ǫ ⇐E+T ∗F
E+T ǫ ⇐E+T
E ǫ ⇐E TLC - Mı́rian Halfeld-Ferrari – p. 10/7
 Writing a Grammar

Grammars are capable of describing most, but not all, of the syntax of
programming languages
Certain constraints on the input, such as the requirement that identifiers be
declared before being used, cannot be described by a CFG
Because each parsing method can handle grammars only of a certain form, the
initial grammar may have to be rewritten to make it parsable by the method
chosen
Eliminate ambiguity
Recursion
1. Left recursive grammar: It has a non terminal A such that there is a
+
derivation A ⇒ Aα for some string α
2. Right recursive grammar: It has a non terminal A such that there is a
+
derivation A ⇒ αA for some string α
Top-down parsing methods cannot handle left-recursive grammars, so a
transformation that eliminates left recursion is needed.

TLC - Mı́rian Halfeld-Ferrari – p. 11/7

 Backtracking and Predictive Analysers

Top-down parsing can be viewed as an attempt to find a leftmost derivation for an

input string
Recursive descent: a general form of top-down parsing that may involve
backtracking, i.e., making repeated scans of the input
Backtracking parser are not seen frequently
Backtracking is required in some cases

TLC - Mı́rian Halfeld-Ferrari – p. 12/7

 Example

Consider the grammar G2 below and the string w = cad

S → cAd
A → ab | a
S S S

d c d c d
c A A A

a b a

(a) (b) (c)

TLC - Mı́rian Halfeld-Ferrari – p. 13/7

 Example: To build the parse tree for w
top-down

1. Create a tree consisting of a single node S

2. An input pointer points to c (1st symbol of w)
3. Use the 1st production for S to expand the tree (figure (a))
4. Leftmost leaf (labelled c) matches the 1st symbol of w. Thus advance the input
pointer to a
5. Expand A with its first alternative (figure (b))
6. We have a match for the second input symbol and we advance the input pointer
to d
7. Compare the third input symbol d against the next leaf b. NO MATCH!
8. Report the failure and go back to A (looking for another alternative of expansion)
9. In going back to A, we must reset the input pointer in position 2
10. Try the second alternative for A: the leaf a matches the second input symbol of w
and the leaf d matches the third symbol (figure (c)).

TLC - Mı́rian Halfeld-Ferrari – p. 14/7

 Re-writting grammars

In many cases, by carefully writting a grammar, eliminating left recursion from it, and
left factoring the resulting grammar, we can obtain a grammar that can be parsed by
a recursive parser that needs no backtracking

TLC - Mı́rian Halfeld-Ferrari – p. 15/7

 Simple left recursion

The pair of production

A → Aα | β

can be replaced by the non-left-recursive productions

A→ βA′
A′ → αA′ | ǫ
No matter how many A-production there are, we can eliminate immediate left
recursion:
We group the A productions as

A → Aα1 | Aα2 . . . | Aαm | β1 | β2 . . . | βn

where no βi begins with an A.

Then we replace the A-productions by
A→ β1 A′ | β2 A′ | . . . βn A′
A′ → α1 A ′ | α2 A ′ | . . . α m A ′ | ǫ

TLC - Mı́rian Halfeld-Ferrari – p. 16/7

 Left Factoring

When it is not clear which of the two alternative productions to use to expand a
nonterminal A, we may be able to rewrite the A-productions to defer the decision
until we have seen enough of the input to make the right choice
stmt → if expr then stmt else stmt
if expr then stmt
In general, if A → αβ1 | αβ2 are two A-productions, and the input begins with a
non empty string derived from α, we do not know whether to expand A to αβ1 or
to αβ2 .
We may defer the decision by expanding A to αA′ . Then after seeing the input
derived from α, we expand A′ to β1 or to β2
A→ αA′
A′ → β1 | β2

TLC - Mı́rian Halfeld-Ferrari – p. 17/7

 Discussion

A left-recursive grammar can cause a recursive-descent parser (even one without

backtracking) to go to infinite loops
When we try to expand A, we may eventually find ourselves again trying to
expand A without having consumed any input
A general type of analysis, one capable of treating all kinds of grammars, is not
efficient
By carefully writing a grammar, we can obtain a grammar that can be parsed by a
recursive-descent parser that needs no backtracking
Predictive parser : to build one, we must know:
Given the current input symbol a and the non terminal A to be expanded,
the proper alternative (the good production rule) must be detectable by
looking at only the first symbol it derives
To have linear time complexity we cannot use backtracking
The grammars that can be analysed by a top-down predictive parser are called
LL(1)

TLC - Mı́rian Halfeld-Ferrari – p. 18/7

 Top-down and Bottom-up analysis

NOTATION

LL(n) Analysis
LR(n) Analysis

where
L: Left to right. The input string is analysed from left to right
L: Leftmost. Uses the leftmost derivation
R: Rightmost. Uses the rightmost derivation
n : the number of input symbols we need to know in order to perform the analysis
Example: LL(2) is a grammar having the following characteristics:

strings are analysed from the left to the right

derivation of the leftmost non terminal in the parse tree
knowledge of two tokens in order to choose the production rule to apply

TLC - Mı́rian Halfeld-Ferrari – p. 19/7

 Getting information about grammars

To decide which production rules to use during the syntax analysis, three kinds of
information about non terminals of CFG are requested:
For a non terminal A we want to know:

1. Whether A generates the empty string

2. The set of terminal symbols starting strings generated from A
∗
If A ⇒ α which terminals can appear as first symbol of α?
3. The set of terminal symbols following A
∗
If S ⇒ αAβ which terminals can appear as first symbols of β?

Remark: The algorithms we are going to present can be used to grammars that do not
have useless symbols or rules

TLC - Mı́rian Halfeld-Ferrari – p. 20/7

 Non terminals that derive the empty string

Input: A grammar G
Output: Non terminals that generate ǫ are marked yes;
otherwise they are marked no
Algorithm 1:
Non terminals that derive the empty string
If G does not have any production of the form A → ǫ (for some non terminal A)
then all non terminals are marked with no
else apply the following steps until no new information can be generated

1. L = list of all productions of G but those having one terminal at right-hand side
Productions whose right-hand side have a terminal do not derive ǫ
2. For each non terminal A without productions, mark it with no
3. While there is a production A → ǫ:
delete from L all productions with A at the left-hand side;
delete every occurrence of A in the right-hand side of the productions in L;
mark A with yes
Remark : The production B → C is replaced by B → ǫ if the occurrence of C in
TLC - Mı́rian Halfeld-Ferrari – p. 21/7
its right-hand side is deleted.
 Computing F IRST (A) for non terminal A -
Starting terminal symbols

Let G = (V, T, P, S) be a CFG. Formally, we define the set of starting terminal symbols
of a non terminal A ∈ V as:
∗
F IRST (A) = {a | a is a terminal and A ⇒ aα,
for some string α ∈ (V ∪ T )∗ }

TLC - Mı́rian Halfeld-Ferrari – p. 22/7

 Computing F IRST (A) : Basic points

If there is a production A→aα

then a ∈ F IRST (A).
The corresponding derivation is A ⇒ aα
∗
If there is a production A → B1 B2 . . . Bm a α and Bi ⇒ ǫ for 1 ≤ i ≤ m
then a ∈ F IRST (A).
In this case, a becomes the first symbol after the replacement of all Bi by ǫ.
∗
The corresponding derivation is A ⇒ B1 B2 . . . Bm aα ⇒ aα
If there is a production A → B α and if a ∈ F IRST (B)
then a ∈ F IRST (A).
∗
If a ∈ F IRST (B), we have B ⇒ aβ and the corresponding derivation is
∗
A ⇒ Bα ⇒ aβα
∗
If there is a production A → B1 B2 . . . Bm C α and Bi ⇒ ǫ for 1 ≤ i ≤ m
then if a ∈ F IRST (C)
then we also have a ∈ F IRST (A).
In this case, all Bi are replaced by ǫ.
∗ ∗
If C ⇒ aβ, the corresponding derivation is A ⇒ B1 B2 . . . Bm Cα ⇒ Cα ⇒ aβα

TLC - Mı́rian Halfeld-Ferrari – p. 23/7

 Computing F IRST (A) : Algorithm

Input: A grammar G
Output: The set of starting terminal symbols for all non terminals of G
Algorithm 2:
Computation of F IRST (A) for all non terminal A

1. For all non terminals A of G, F IRST (A) = ∅

2. Apply the following rules until no more terminals can be added to any F IRST
set:
(a) For each rule
A → aα
put a in F IRST (A)
(b) For each rule
A → B1 . . . Bm
∗
If for some i (1 ≤ i ≤ m) we have a ∈ F IRST (Bi ) and B1 , . . . , Bi−1 ⇒ ǫ
then put a in F IRST (A)
For example, everything in F IRST (B1 ) is surely in F IRST (A). If B1
∗
does not derive ǫ, then we add nothing more to F IRST (A), but if B1 ⇒ ǫ,
then we add F IRST (B2 ) and so on.
TLC - Mı́rian Halfeld-Ferrari – p. 24/7
 Starting symbols of a string

Given a grammar G, we also need to introduce the concept of the set of starting terminal
symbols for a string α ∈ (V ∪ T )∗ , F IRST (α):

If α = ǫ
then F IRST (α) = F IRST (ǫ) = ∅
If α is a terminal a
then F IRST (α) = F IRST (a) = {a}
If α is a non terminal
then F IRST (α) computed by Algorithm 2
If α is a string Aβ and A is a non terminal that derives ǫ
then F IRST (α) = F IRST (Aβ) = F IRST (A) ∪ F IRST (β)
If α is a string Aβ and A is a non terminal that does not derive ǫ
then F IRST (α) = F IRST (Aβ) = F IRST (A)
If α is a string aβ where a is a terminal
then F IRST (α) = F IRST (aβ) = {a}

TLC - Mı́rian Halfeld-Ferrari – p. 25/7

 Computing F OLLOW (A) for non terminal A -
Following terminal symbols

Let G = (V, T, P, S) be a CFG.

A non terminal can appear at the end of a string and, in this case, it does not
have a following symbol
Due to this fact and to treat this case as the others, we introduce a new terminal
symbol $ to indicate the end of a string
$ is a right endmarker and corresponds to the end of a file
This symbol is introduced as a production of S

Formally, we define the following symbols of a non terminal A ∈ V as:

∗
F OLLOW (A) = {a | a is a terminal and S ⇒ α A a β,
for strings α, β ∈ (V ∪ T )∗ }

TLC - Mı́rian Halfeld-Ferrari – p. 26/7

 Computing F OLLOW (A): Basic points

∗
We suppose that S$ ⇒ δAψ. Put $ in FOLLOW(S)

If there is a production A→αBγaβ

∗
where γ = B1 , . . . , Bm is a non terminal string deriving ǫ, i.e., γ ⇒ ǫ
then a ∈ F OLLOW (B).
∗ ∗ ∗
The corresponding derivation is: S$ ⇒ δ A ψ ⇒ δ α B γ a β ψ ⇒ δ α B a β ψ
If there is a production A→αBγCβ
∗
where γ = B1 , . . . , Bm is a non terminal string deriving ǫ, i.e., γ ⇒ ǫ
and if a ∈ F IRST (C)
then we have a ∈ F OLLOW (B)
∗
In this case, C ⇒ aµ and thus, the corresponding derivation is:
∗ ∗ ∗ ∗
S$ ⇒ δ A ψ ⇒ δ α B γ C β ψ ⇒ δ α B C β ψ ⇒ δ α B a µ β ψ
If there is a production A→αBγ
∗
where γ = B1 , . . . , Bm is a non terminal string deriving ǫ, i.e., γ ⇒ ǫ
and if a ∈ F OLLOW (A)
then we have a ∈ F OLLOW (B)
∗
In this case, S$ ⇒ δ A a ψ and thus, the corresponding derivation is:
∗ ∗ ∗
S$ ⇒ δ A a ψ ⇒ δ α B γ a ψ ⇒ δ α B a ψ TLC - Mı́rian Halfeld-Ferrari – p. 27/7
 F OLLOW (A): algorithm

Input: A grammar G
Output: The set of following terminal symbols for all non terminals of G
Algorithm 3:
Computation of F OLLOW (A) for all non terminal A

1. For all non terminals A 6= S of G, F OLLOW (A) = ∅. F OLLOW (S) = {$}

2. Apply the following rules until nothing can be added to any FOLLOW set
(a) For each production rule A → αBβ
Put every terminal of F IRST (β) in F OLLOW (B)
(b) For each production rule A → αB or A → αBγ such that
∗
γ = B1 . . . Bm ⇒ ǫ
Put every terminal of F OLLOW (A) in F OLLOW (B)

TLC - Mı́rian Halfeld-Ferrari – p. 28/7

 Construction of Predictive Parsing Tables

We can consider the problem of how to choose the production to be used during
the syntax analysis
To this end we use a predictive parsing table for a given grammar G
To build this table we use the following algorithm whose main ideas are:
1. Suppose A → α is a production with a in F IRST (α).
Then, the parser will expand A by α when the current input symbol is a
∗
2. Complication occurs when α = ǫ or α ⇒ ǫ. In this case, we should again
expand A by α if the current input symbol is in F OLLOW (A)

TLC - Mı́rian Halfeld-Ferrari – p. 29/7

 Algorithm: Construction of a predictive
parsing table

Input: Grammar G
Output: Parsing table M
Algorithm: Construction of a predictive parsing table

1. For each production A → α of G, do steps 2 and 3

2. For each terminal a in F IRST (α), add A → α to M [A, a]
∗
3. If α ⇒ ǫ, add A → α to M [A, b] for each terminal b in F OLLOW (A)
∗
If α ⇒ ǫ and $ is in F OLLOW (A), add A → α to M [A, $]
4. Make each undefined entry of M be error

TLC - Mı́rian Halfeld-Ferrari – p. 30/7

 Example : Syntax Analysis

Grammar G3 = ({E, E ′ , T, T ′ , F }, {a, ∗, +, (, )}, P, E) with the set of productions P :

E → T E′ T → FT′
F → (E) E′ → +T E ′
T′ → ∗F T ′ F → a
E′ → ǫ T′ → ǫ
Parsing table M :
( a + ∗ ) $
E E → T E′ E → T E′
T T → FT′ T → FT′
F F → (E) F →a
E′ E ′ → +T E ′ E′ → ǫ E′ → ǫ
T′ T′ → ǫ T ′ → ∗F T ′ T′ → ǫ T′ → ǫ

TLC - Mı́rian Halfeld-Ferrari – p. 31/7

Analyse the string a + a ∗ a

Stack Rest of the input Chosen rule

E a+a∗a M [E, a] = E → T E ′
T E′ a+a∗a M [T, a] = T → F T ′
F T ′E′ a+a∗a M [F, a] = F → a
aT ′ E ′ a+a∗a −
T ′E′ +a ∗ a M [T ′ , +] = T ′ → ǫ
E′ +a ∗ a M [E ′ , +] = E ′ → +T E ′
+T E ′ +a ∗ a −
T E′ a∗a M [T, a] = T → F T ′
F T E′ a∗a M [F, a] = F → a
aT ′ E ′ a∗a −

TLC - Mı́rian Halfeld-Ferrari – p. 32/7

Analyse the string a + a ∗ a (cont.)

Stack Rest of the input Chosen rule

T ′E′ ∗a M [T ′ , ∗] = T ′ → ∗F T ′
∗F T ′ E ′ ∗a −
F T ′E′ a M [F, a] = F → a
aT ′ E ′ a −
T ′E′ ǫ M [T ′ , $] = T ′ → ǫ
E′ ǫ M [E ′ , $] = E ′ → ǫ
ǫ ǫ −

TLC - Mı́rian Halfeld-Ferrari – p. 33/7

 LL(1) Grammars

The algorithm for constructing a predictive parsing table can be applied to any
grammar G to produce a parsing table M
For some grammars however, M may have some entries that are multiply-defined
If G is left recursive or ambiguous, then M will have at least one multiply-defined
entry
A grammar whose parsing table has no multiply-defined entries is said to be LL(1)
LL(1) grammars have several distinctive properties
No ambiguous or left-recursive grammar can be LL(1)
A grammar G is LL(1) iff whenever A → α | β are two distinct productions
of G the following conditions hold:
1. For no terminal a do both α and β derive strings with a
2. At most one of α and β can derive the empty string
∗
3. If β ⇒ ǫ, then α does not derive any string beginning with the terminal
in F OLLOW (A)

TLC - Mı́rian Halfeld-Ferrari – p. 34/7

 Examples

Grammar G1 is not LL(1)

Grammar G2 = ({E, E ′ , T, T ′ , F }, {a, ∗, +, (, )}, P, E) where P is the set of
productions:

E → T E′ T → FT′
F → (E) E′ → +T E ′
T′ → ∗F T ′ F → a
E′ → ǫ T′ → ǫ

is LL(1)

TLC - Mı́rian Halfeld-Ferrari – p. 35/7

 Remarks

What should be done when a parsing table has multiply-defined entries?

One recourse is to transform the grammar by eliminating left recursion and then
left factoring whenever possible, hoping to produce a grammar for which the
parsing table has no multiply-defined entries
There are grammars for which no amount of alteration will yield an LL(1) grammar

TLC - Mı́rian Halfeld-Ferrari – p. 36/7

 Bottom-Up Parsing

Constructs a parse tree for an input string beginning at the leaves (the bottom)
and working up towards the root (the top)
Reduction of a string w to the start symbol of a grammar
At each reduction step a particular substring matching the right side of a
production is replaced by the symbol on the left of that production
If the substring is chosen correctly at each step, a rightmost derivation is traced
out in reverse
Handles: A handle of a string is a substring that matches the right side of a
production and whose reduction to the nonterminal on the left side of the
production represents one step along the reverse of a rightmost derivation

Grammar:
S → aABe A → Abc | b B→ d
The sentence abbcde can be reduced as follows:
abbcde
aAbcde
aAde
aABe TLC - Mı́rian Halfeld-Ferrari – p. 37/7
 LR Parsers

Technique that can be used to parse a large class of CFG

Technique called LR(k) parsing
L: left-to-right scanning of the input
R: construction the rightmost derivation in reverse
k: number of input symbols of lookahead
LR parsing is attractive for a variety of reasons:
LR parsers can be constructed to recognise virtually all programming
language constructs for which CFG can be written
The class of grammars that can be parsed using LR methods is a proper
superset of the class of grammars that can be parsed with predictive
parsers
The LR parsing method can be implemented efficiently
Drawback
Too much complicate to construct an LR parser by hand for a typical
programming language grammar
One needs a specialised tools - an LR parser generator (as Yacc)
TLC - Mı́rian Halfeld-Ferrari – p. 38/7
 The LR Parsing Algorithm

a1 a2 ... ai an $

sm

Xm LR Parsing Program OUTPUT

sm−1

Xm−i

...
s0 action goto

An LR parser consists of:

1. An input
2. An output
3. A stack
4. A driver program
5. A parsing table that has two parts: action and goto

TLC - Mı́rian Halfeld-Ferrari – p. 39/7

 The LR Parsing Algorithm

The driver program is the same for all LR parsers ; only the parsing table
changes from one parser to another.
The program uses a stack to store a string of the form

s0 X1 s1 X2 s2 . . . Xm sm

where sm is on the top

Each Xi is a grammar symbol
Each si is a state
Each state summarises the information contained in the stack below it
The combination of the state on the top of the stack and the current input
symbol are used to index the parsing table and determine the shift-reduce
parsing decision

TLC - Mı́rian Halfeld-Ferrari – p. 40/7

 The LR Parsing Algorithm

The program driving the LR parser behaves as follows:

1. It determines sm (the state currently on the top of the stack) and ai (the
current input symbol)
2. It consults action[sm , ai ] (the parsing action table entry for state sm and
input ai ) which can have one of the four values:
shift s, where s is a state
reduce by a grammar production A → β
accept, and
error
The function goto takes a state and a grammar symbol as arguments and
produces a state.
A configuration of an LR parser is a pair whose first component is the stack
contents and whose second component is the unexpected input
(s0 X1 s1 X2 . . . Xm sm , ai ai+1 an $)
The next move of the parser is determined by reading ai (the current input
symbol) and sm (the state on the top of the stack), and then consulting the
parsing action table entry action[sm , ai ].
TLC - Mı́rian Halfeld-Ferrari – p. 41/7
 The LR Parsing Algorithm: configuration
resulting after each of the four types or
move

1. If action[sm , ai ] = shift s, then the parser executes a shift move, entering the
configuration
(s0 X1 s1 X2 . . . Xm sm ai s , ai+1 an $)
The parser shifts both the current input symbol ai and the next state s,
which is given by action[sm , ai ], onto the stack.
ai+1 becomes the current input symbol
2. If action[sm , ai ] = reduce A → β then the parser executes a reduce move,
entering the configuration (s0 X1 s1 X2 . . . Xm−r sm−r A s , ai ai+1 an $)
where s = goto[sm−r , A] and r is the length of β
The parser first popped 2r symbols off the stack (r state symbols and r
grammar symbols), exposing state sm−r
The parser pushed both A (the left side of the production) and s (the entry
goto[sm−r , A]) onto the stack
The current input symbol is not changed in a reduce move
3. If action[sm , ai ] = accept, parsing is completed
4. If action[sm , ai ] = error, the parser has discovered an error
TLC - Mı́rian Halfeld-Ferrari – p. 42/7
 Algorithm: LR parsing

Input: An input string w and an LR parsing table with functions action and goto for
grammar G.

Output: If w is in L(G), a bottom-up parse for w; otherwise, an error indication

Method: Initially, the parser has s0 on its stack, where s0 is the initial state, and w$ in
the input buffer.
The parser executes the following program until an accept or error action is encountered.

TLC - Mı́rian Halfeld-Ferrari – p. 43/7

Algorithm: LR parsing

set ip to point to the first symbol of w;

repeat forever begin
let s be the state on the top of the stack and
a the symbol pointed by ip;
if action[s, a] = shift s′ then begin
push a then s′ on top of the stack;
advance ip to the next input symbol;
end
else if action[s, a] = reduce A → β then begin
pop 2∗ | β | symbols off the stack;
let s′ be the state now on top of the stack;
push then goto[s′ , A] on top of the stack;
output the production A → β;
end
else if action[s, a] = accept then return
else error()
end

TLC - Mı́rian Halfeld-Ferrari – p. 44/7

 Example

We consider the grammar G1 = ({E, F, T }, {id, (, ), ∗, +}, P, E) where the productions

are:
(1) E → E+T
(2) E → T
(3) T → T ∗F
(4) T → F
(5) F → (E)
(6) F → id
and the input id ∗ id + id
In the table:
si : shift and stack state i
rj : reduce by production numbered j
acc: accept
blank means error

TLC - Mı́rian Halfeld-Ferrari – p. 45/7

Example: grammar G1 and input id ∗ id + id

Parsing table for expression grammar

State action goto
id + ∗ ( ) $ E T F
0 s5 s4 1 2 3
1 s6 acc
2 r2 s7 r2 r2
3 r4 r4 r4 r4
4 s5 s4 r4 r4 8 2 3
5 r6 r6 r6 r6
6 s5 s4 r4 r4 9 3
7 s5 s4 r4 r4 10
8 s6 s11
9 r1 s7 r1 r1
10 r3 r3 r3 r3
11 r5 r5 r5 r5
TLC - Mı́rian Halfeld-Ferrari – p. 46/7
 Remarks

The value of goto[s, a] for terminal a is found in the action field connected with
the shift action on input a for state s
The goto fields gives goto[s, A] for non terminals A
We have not yet seen how the entries for the parsing table were selected

TLC - Mı́rian Halfeld-Ferrari – p. 47/7

 LR Parsing Methods

Three methods varying in their power of implementation

1. SLR : simple LR
The weakest of the three in terms of number of grammars for which it succeeds,
but is the easiest to implement
SLR table: parsing table constructed by this method
SLR parser
SLR grammar
2. Canonical LR : the most powerful and the most expensive
3. LALR (Lookahead LR): Intermediate in power and cost
LALR method works on most programming-language grammars and, with some
effort can be implemented efficiently

TLC - Mı́rian Halfeld-Ferrari – p. 48/7

 Building SLR Parsing Table

Definitions
LR(0) item or item (for short) of a grammar G:
A production of G with a dot at some position at the right side.

Example: Production A → XY Z yields the four items:

A → .XY Z
A → X.Y Z
A → XY.Z
A → XY Z.
Production A → ǫ generates one item A → .

Intuitively: an item indicates how much of a production we have seen at a given point in
the parsing process

Example:
A → X.Y Z
indicates that we have just seen on the input a string derivable from X and that we hope
next to see a string derivable from Y Z

TLC - Mı́rian Halfeld-Ferrari – p. 49/7

 Augmented grammar

If G is a grammar with a start symbol S, then G′ , the augmented grammar for G is G

with a new start symbol S ′ and production S ′ → S.
Indicates to the parser when it should stop parsing and announce the acceptance of the
input.

TLC - Mı́rian Halfeld-Ferrari – p. 50/7

 The 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 two rules:

1. Initially, every item in I is added to closure(I)

2. 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 new items can be added to closure(I)

Why do we include B → .γ in closure(I)?

Intuitively:
(i) A → α.Bβ in closure(I) indicates that, at this point of the parsing, we think we might
next see a substring derivable from Bβ as input.
(ii) If B → γ is a production we expect we might see a substring derivable from γ at this
point.

TLC - Mı́rian Halfeld-Ferrari – p. 51/7

 Example

We consider the augmented G1 :

E′ → E
E → E+T
E → T
T → T ∗F
T → F
F → (E)
F → id
If I is the set of one item {[E ′ → .E]} then closure(I) contains the items
E′ → .E
E → .E + T
E → .T
T → .T ∗ F
T → .F
F → .(E)
F → .id TLC - Mı́rian Halfeld-Ferrari – p. 52/7
 The Goto Operation

goto(I, X), where I is a set of items and X is a grammar symbol

goto(I, X) is the closure of the set of all items [A → αX.β] such that [A → α.Xβ] is in I

Example: If I is the set of two items {[E ′ → E.], [E → E. + T ]} then goto(I, +)

consists of

E → E + .T
T → .T ∗ F
T → .F
F → .(E)
F → .id

We compute goto(I, +) by examining I for items with + immediately to the right of the
dot

TLC - Mı́rian Halfeld-Ferrari – p. 53/7

 The Sets-of-Items Construction

Construction of C, the canonical collection of sets of LR(0) items for an augmented

grammar G′
procedure items(G’);
begin
C := {closure({[S ′ → .S]})}
repeat
for each set of items I in C and each grammar symbol X
such that goto(I, X) is not empty and not in C do
add goto(I, X) to C
until no more sets of items can be added to C
end

TLC - Mı́rian Halfeld-Ferrari – p. 54/7

 Remarks

For every grammar G, the goto function of the canonical collection of sets of
items defines a deterministic finite state automaton D
The DFA D is obtained from a NFA N by the subset construction
States of N are the items
There is a transition from A → α.Xβ to A → αX.β labelled X, and there is
a transition from A → α.Bβ to B → .γ labelled ǫ
The closure(I) for a set of items (states of N ) I is the ǫ-closure of a set of
states of NFA states
goto(I, X) gives the transition from I on symbol X in the DFA constructed from
N by the subset construction

TLC - Mı́rian Halfeld-Ferrari – p. 55/7

 SLR Parsing Tables

We construct the SLR parsing action and goto functions

The algorithm will not produce uniquely defined parsing action tables for all
grammars, but it succeed on many grammars for programming languages
Given a grammar G we augment G to produce G′ , and for G′ we construct C,
the canonical collection of sets of items for G′
We construct action and goto from C using the following algorithm
The algorithm requires us to know F OLLOW (A) for each non terminal A of a
grammar

TLC - Mı́rian Halfeld-Ferrari – p. 56/7

 Algorithm SLR: Constructing SLR parsing
table

Input: An augmented grammar G′ .

Output: The SLR parsing table functions action and goto for G′

TLC - Mı́rian Halfeld-Ferrari – p. 57/7

 Algorithm SLR: method

1. Construct C = {I0 , I1 , . . . , In }, the collection of sets of LR(0) items for G′

2. State i is constructed from Ii . The parsing actions for state i are determined as
follows:
(a) If [A → α.aβ] is in Ii and goto(Ii , a) = Ij , then set action[i, a] to ”shift j”.
Here a must be a terminal.
(b) If [A → α.] is in Ii , then set action[i, a] to reduce A → α for all
a ∈ F OLLOW (A). Here A may not be S ′
(c) If [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(1). The algorithm fails to produce a parser in this case.
3. The goto transitions for state i are constructed for all non terminals A using the
rule:
if goto(Ii , A) = Ij then goto[i, A] = j
4. All entries not defined by rules (2) and (3) are made ”error”
5. The initial state of the parser is the one constructed from the set of items
containing [S → .S ′ ]
TLC - Mı́rian Halfeld-Ferrari – p. 58/7
SLR(1) Table for G: parsing table determined by the above algorithm
SLR(1) Parser: an LR parser using the SLR(1) table for G
SLR(1) Grammar: a grammar having an SLR(1) parsing table
We usually omit the ”(1)” after SLR, since we shall not deal with parsers having
more than one symbol of lookahead
Every SLR grammar is unambiguous, but there are many unambiguous
grammars that are not SLR

TLC - Mı́rian Halfeld-Ferrari – p. 59/7

 Constructing Canonical LR Parsing Tables

In SLR method:
State i calls for reduction by A → α if:
the set of items Ii contains item [A → α.] and
a ∈ F OLLOW (A)
In some situations, when state i appears on the top of the stack, the viable prefix
βα on the stack is such that βA cannot be followed by a in a right-sentential form
Thus, the reduction A → α would be invalid on input a

TLC - Mı́rian Halfeld-Ferrari – p. 60/7

 Example

We consider the grammar G4 with productions:

S → L=R
S → R
L → ∗R
L → id
R → L

In state 2: we have item R → L.

• Corresponds to A → α: a is = in F OLLOW (R).
• SLR parser calls for reduction by R → L in state 2 with = as the next input
• There is no right-sentential form of G4 that begins with R = . . .

State 2 (which is the state corresponding to viable prefix L only) should not call
for reduction of that L to R

Remarks

TLC - Mı́rian Halfeld-Ferrari – p. 61/7

 Remarks...

It is possible to carry more information in the state to rule out some invalid
reductions
By splitting states when necessary we can arrange to have each state of an LR
parse indicate exactly which input symbols can follow α such that there is a
possible reduction to A
The extra information is incorporated into the state by redefining items to include
a terminal symbol as a second component
LR(1) item: [A → α.β, a] where A → α.β is a production and a is a terminal or
the right endmarker $
In LR(1), the 1 refers to the length of the second component (lookahead of the
item)
The lookahead has no effect in an item of the form [A → α.β, a], where β is not ǫ
An item of the form [A → α., a] calls for reduction by A → α only if the next input
symbol is a
Thus, we reduce by A → α only on those input symbols a for which [A → α., a]
is in an LR(1) item in the state on the top of the stack
TLC - Mı́rian Halfeld-Ferrari – p. 62/7
The set of a’s will always be a subset of F OLLOW (A), but it could be a proper
Formally:
LR(1) item [A → α.β, a] is valid for a viable prefix γ if there is a rightmost
derivation:

∗ ∗
S ⇒ δAw ⇒ δαβw

where:
1. γ = δα and
2. either a is the first symbol of w, or
w is ǫ and a is $
Method for constructing the collection of sets of valid LR(1) items is essentially
the same as the way we built the canonical collection of sets of LR(0) items. We
only need to modify the two procedures closure and goto

TLC - Mı́rian Halfeld-Ferrari – p. 63/7

The basis of the new closure operation:
Consider item [A → α.Bβ, a] in the set of items valid for some viable prefix
γ
∗ ∗
Then there is a rightmost derivation S ⇒ δAax ⇒ δαBβax where γ = δα
Suppose βax derives terminal string by
For each production of the for B → µ (form some µ) we have

∗ ∗
S ⇒ γBby ⇒ γµby

Thus [B → .µ, b] is valid for γ

Note:
1. b can be the first terminal derived from β, or
∗
2. β can derive ǫ in the derivation βax ⇒ by (and b can therefore be a)
Thus, to summarise:
b can be any terminal in F IRST (βax)
Remark: As x cannot contain the first terminal of by

F IRST (βax) = F IRST (βa) TLC - Mı́rian Halfeld-Ferrari – p. 64/7

 Algorithm: Construction of the sets of LR(1)
items

Input: An augmented grammar G′ .

Output: The sets of LR(1) items that are the set of items valid for one or more viable
prefixes of G′

Method: The procedure closure and goto and the main routine items for constructing the
sets of items are shown in the following
function closure(I);
begin
repeat
for each item [A → α.Bβ, a] in I,
each production B → γ in G′ , and
each terminal b ∈ F IRST (βa) such that [B → .γ, b] 6∈ I do
add [B → .γ, b] to I;
until no more items can be added to I;
return (I)
end

TLC - Mı́rian Halfeld-Ferrari – p. 65/7

function goto(I, X);
begin
let J be the set of items [A → αX.β, a] such that
[A → α.Xβ, a] is in I;
return closure(J)
end

procedure items(G’);
begin
C := {closure({[S ′ → .S, $]})}
repeat
for each set of items I in C and each grammar symbol X
such that goto(I, X) is not empty and not in C do
add goto(I, X) to C
until no more sets of items can be added to C
end

TLC - Mı́rian Halfeld-Ferrari – p. 66/7

 Algorithm: Canonical LR parsing table

Input: An augmented grammar G′ .

Output: The canonical LR parsing table functions action and goto for G′

TLC - Mı́rian Halfeld-Ferrari – p. 67/7

 Algorithm: Method

1. Construct C = {I0 , I1 , . . . , In }, the collection of sets of LR(1) items for G′

2. State i is constructed from Ii . The parsing actions for state i are determined as
follows:
(a) If [A → α.aβ, b] is in Ii and goto(Ii , a) = Ij , then set action[i, a] to ”shift j”.
Here a must be a terminal.
(b) If [A → α., a] is in Ii , then set action[i, a] to reduce A → α. Here A may
not be S ′
(c) If [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 LR(1). The algorithm fails to produce a parser in this case.
3. The goto transitions for state i are constructed for all non terminals A using the
rule:
if goto(Ii , A) = Ij then goto[i, A] = j
4. All entries not defined by rules (2) and (3) are made ”error”
5. The initial state of the parser is the one constructed from the set of items
containing [S → S ′ , $]
TLC - Mı́rian Halfeld-Ferrari – p. 68/7
 Examples

We consider the grammar G = ({S, C}, { c, d}, P, S) where the productions are:
(1) S → CC (2) C → cC (3) C → d
The augmented grammar G has also rule S ′ → S
Canonical parsing table for grammar
State action goto
c d $ S C
0 s3 s4 1 2
1 accept
2 s6 s7 5
3 s3 s4 8
4 r3 r3
5 r1
6 s6 s7 9
7 r3
8 r2 r2
9 r2 TLC - Mı́rian Halfeld-Ferrari – p. 69/7
 Construction LALR Parsing Tables

Lookahead-LR technique
Often used in practise because the tables obtained by it are considerably smaller
that the canonical LR tables
Common syntactic constructs of programming languages can be expressed
conveniently by an LALR grammar
The same is almost true for SLR grammars - but there are a few constructs that
cannot be conveniently handled by SLR techniques
Parser size
SLR and LALR tables for a grammar: always have the same number of
states
For a language like Pascal
SLR and LALR: several hundred states
LR: several thousand states

TLC - Mı́rian Halfeld-Ferrari – p. 70/7

Consider G = ({S, C}, { c, d}, P, S) with productions:
(1) S → CC (2) C → cC (3) C → d
and its sets of LR(1) items. Take a pair of similar looking states such as I4 and I7 :
I4 : C → d., c/d I7 : C → d., $
• Each of these states has only items with first component

C → d.

TLC - Mı́rian Halfeld-Ferrari – p. 71/7

Difference between the roles of I4 and I7 in the parser:

The grammar generates the regular set c∗ dc∗ d

When reading an input cc . . . cdcc . . . cd the parser shifts the first group of c′ s and
their following d onto stack, entering the state 4 after reading d
The parser then calls for a reduction by C → d, provided the next input symbol is
c or d
The requirement that c or d follow makes sense, since these are the symbols that
could begin strings in c∗ d
If $ follows the first d, we have an input like ccd, which is not in the language, and
state 4 correctly declares an error
The parser enters state 7 after reading the second d
Then the parser must see $ on the input. It thus make sense that state 7 should
reduce by C → d on input $ and declare error on inputs c or d

TLC - Mı́rian Halfeld-Ferrari – p. 72/7

Stack Input Action
0 cccdcccd$ action[0, c] = s3
0c3 ccdccd$ action[3, c] = s3
0c3c3 cdcc . . . cd$ action[3, c] = s3
0c3c3c3 dccd$ action[3, d] = s4
0c3c3c3d4 ccd$ action[4, c] = r3 (C → d)
goto[3, C] = 8
0c3c3c3C8 ccd$ action[8, c] = r2 (C → cC)
goto[3, C] = 8
0c3c3C8 ccd$ action[8, c] = r2 (C → cC)
goto[3, C] = 8
0c3C8 ccd$ action[8, c] = r2 (C → cC)
goto[0, C] = 2
0C2 ccd$ action[2, c] = s6

TLC - Mı́rian Halfeld-Ferrari – p. 73/7

Stack Input Action
0C2c6 cd$ action[6, c] = s6
0C2c6c6 d$ action[6, d] = s7
0C2c6c6d7 $ action[7, $] = r3 (C → d)
goto[6, C] = 9
0C2c6c6C9 $ action[9, $] = r2 (C → cC)
goto[6, C] = 9
0C2c6C9 $ action[9, $] = r2 (C → cC)
goto[2, C] = 5
0C2C5 $ action[5, $] = r1 (S → CC)
goto[0, S] = 1
0S1 $ action[1, $] = accept

TLC - Mı́rian Halfeld-Ferrari – p. 74/7

Replace I4 and I7 by I47 , the union of I4 and I7 , consisting of the set of three
items represented by [C → d., c/d/$]
The goto on d to I4 or I7 from I0 , I2 , I3 and I6 now enter I47
The action of I47 is to reduce in any input
The revised parser behaves essentially like the original, although it might reduce
d to C in circumstances where the original would declare error, for example, on
input like ccd or cdcdc
The error will eventually be caught; in fact, it will be caught before any more
input symbols are shifted

TLC - Mı́rian Halfeld-Ferrari – p. 75/7

 More generally ...

We can look for sets of LR(1) items having the same core (set of first
components) and we may merge these sets
A core is a set of LR(0) items for the grammar at hand, and an LR(1) grammar
may produce more than two sets of items with the same core
Suppose we have an LR(1) grammar (i.e., one whose sets of LR(1) items
produce no parsing action conflicts)
If we replace all states having the same core with their union, it is possible that
the resulting union will have a conflict
But a reduce/shift conflict is unlikely
Suppose in the union a conflict on lookahead a:
[A → α., a] calling for a reduction by A → a
[B → β.aγ, b] calling for a shift
Then for some set of items from which the union was formed has item
[A → α., a], and since the cores of all these states are the same, it must
have an item [B → β.aγ, c] for same c.
But then this state has the same shift/reduce conflict on a and the grammar
was no LR(1) as we assumed
TLC - Mı́rian Halfeld-Ferrari – p. 76/7
Thus:
1. The merging of states with common cores can never produce a
shift/reduce conflict, because shift actions depend only on the core, not to
the lookahead
2. It is possible that a merger will produce a reduce/reduce conflict

TLC - Mı́rian Halfeld-Ferrari – p. 77/7