CS424

Compiler Construction

LR Parsing

Recall the following terms

Rightmost Derivation

Reduction

Handle

Shift-Reduce Parsing

We now look at the class of grammars that

can be parsed using shift-reduce techniques

LR Parsing

The basic structure of an LR parser looks as

follows.

LR Parsing

The LR parsing algorithm follows a Finite

Automaton
GOTO is the transition function of the FA.
ACTION is a function that tells the parser what
action to take given the current state of the FA
and the next input symbol.
ACTION at any step can be Shift, Reduce,
Error, Accept.

LR Parsing

ACTION and GOTO together are the parsing table

of the LR parser.
There are multiple ways of constructing ACTION
and GOTO, called:

SLR or Simple LR

LR

LALR or Lookahead LR

Each of these corresponds to a different

construction of the Finite Automaton

SLR Parsing

We first look at the SLR method of

constructing parsing tables.
The corresponding automaton is called the
LR(0) automaton.
The states of this automaton are sets of LR(0)
items, which we describe next.

LR(0) Items

An item is a production plus an index in the right

hand side of the production which we will denote
by a dot.
The production A->XYZ yields the following items:

A->.XYZ

A->X.YZ

A->XY.Z

A->XYZ.

LR(0) Items

The dot in an item keeps track of where we

are in a parse.
The part of the production before the dot
corresponds to the part of input we have
already seen.
The part after the dot is what we expect to see
next.

LR(0) Items

For example, take the item A->X.YZ

This means that the parser has already seen some
input that can be derived from X.
Now it is waiting to see some string that can be derived
from Y. Once that happens it moves to the item A->XY.Z
Now it expects to see something derivable from Z so it
can move to A->XYZ.
Now it has seen something derived from XYZ, which
can be reduced to A.

Augmented Grammar

To construct the LR(0) automaton, we first

augment the grammar by adding a new start
symbol.
Given a CFG with start symbol S, we add a
new start symbol S' and a new production

S'->S

This will tell us when we can stop parsing and

accept.

Closure of Items

Suppose we have an item A->X.YZ and a

production Y-> ABC
The item tells us that we are waiting to see
something derived from Y, and the production
tells us that we are waiting to see something
derived from A.
Therefore we add the item Y->.ABC to the
closure of the original item.

Closure of Items

Given I, a set of items, compute Closure(I) as

follows:
Add everything in I to Closure(I)
If A->x.By is in Closure(I) and B->z is a
production then add B->.z to Closure(I), if not
already there.
Apply the previous step until no more items
can be added.

Closure Example

Consider the augmented expression grammar.

Given the item set, I = {E'->.E}, compute
Closure(I).

Closure Example
Closure(I) contains the items

E'->.E

E->.E+T

E->.T

T->.T*F

T->.F

F->.(E)

F->.id

Closure

Closures of item sets will be the states in the

finite automaton.
Next we see how to compute the transitions.
These correspond to the GOTO function.

GOTO Function

The intuitive idea is as follows.

Given an item A->X.YZ and grammar symbol
Y, the next item is A->XY.Z plus everything in
the closure of A->XY.Z
This means that we just saw a Y and now we
expect to see a Z and something derived from
Z.

GOTO Function

Formally, given I, a set of items and X a

grammar symbol.
GOTO(I, X) is the closure of the set of all items
[A->xX.y] such that [A->x.Xy] is in I.

GOTO Example

If I = {[E'->E.], [E->E.+T]}, then compute

GOTO(I, +)
This is the closure of E->E+.T

LR(0) Automaton For Expressions

The start state is the closure of [E'->.E]

Together with Closure and GOTO, we can now
build the automaton.

Using the LR(0) Automaton for

Parsing

Note that each state corresponds to a unique

grammar symbol, the one labeling the inputs.
So we can use states to mean grammar
symbols.
State 0 is the start state for the automaton

Using the LR(0) Automaton for

Parsing

Parsing with the LR(0) automaton is done with a stack,

which holds states.
Top of the stack is the current state.
If we are currently in the state j with input symbol a and
GOTO(j, a) is k then we shift a (or correspondingly state
k).
Otherwise we reduce using the item with a dot at the end.
Reduction corresponds to popping states on the right
hand side and pushing the state corresponding to the left
hand side.

Parsing Example

SLR Parsing Table

Rather than use the LR(0) automaton directly,

as just described, we code the information into
a parsing table.
The parsing table has two parts ACTION and
GOTO.
GOTO gives the next state.
ACTION tells us whether to shift or to reduce
using some production.

SLR Parsing Table

Label the productions in the expression

grammar as follows.

SLR Parsing Table

SLR Parsing Example

LR Parsing Algorithm

SLR Parsing Table Construction

SLR Parsing Table Construction

SLR Parsing

Any grammar for which the previous algorithm

results in a parsing action conflict is not SLR.
All ambiguous grammars are not SLR
parseable.
There are some non-ambiguous grammars that
cannot be parsed by SLR techniques.