09 1 TopDown

Topic 9: Top Down Parsing
9.1 Introduction
Top-down Analysis
Revision
Top-down Analysis Revision

Previously, we have looked at Syntactic Analysis in
terms of bottom up algorithms: LR, SLR, LALR
Now we will look at various top-down approaches.

We start with the START symbol
We apply expansions of non-terminal symbols.
Top-down Analysis
Revision
Top-down Analysis Revision
LL Parsing:
Left-to-Right processing of input

Expand Leftmost Nonterminal first
Depth-first vs. Breadth-First:
Depth-first: expand all children of node before
expanding sisters
Breadth-First: expand all nodes at same level
before descending to their children
3
Top-down Analysis
Revision
Top-down analysis
Top down analysis starts with the START symbol and
expands it
id
id
id
4
Top-down Analysis
Revision
Top-down analysis
Apply: E-> E+E
E
E
E
id
id
id
5
Top-down Analysis
Revision
Top-down analysis
Apply: E-> id
E
E
E
id
id
id
6
Top-down Analysis
Revision
Top-down analysis
Apply: E-> E*E
E
E
E
id
E
+
id
E
*
id
7
Top-down Analysis
Revision
Top-down analysis
Apply: E-> id
E
E
E
id
E
+
id
E
*
id
8
Top-down Analysis
Revision
Top-down analysis
Apply: E-> id
E
E
E
id
E
+
id
E
*
id
9
Topic 9: Top Down Parsing

9.2 Deterministic Topdown Parsing
(LL Parsers)
Top-down Analysis
Deterministic Topdown Parsing
Predictive Parsers
Some top-down parsers expand non-terminals
non-deterministically: they apply the first
alternative, and if later fail to parse, they go
back(backtrack) and try one of the other
expansions.
In this class, we will consider top-down parsers
which deterministically select a single production to
expand each nonterminal:
No backtracking required
But grammar restrictions required.
11
Top-down Analysis
Predictive Parsers
The class of grammars which permit this
deterministic topdown analysis are called LL()
grammars.
An LL(1) parser can determine which rule to select
based on one symbol of lookahead.
In other words, we can select which rule should
expand a nonterminal purely on the basis of the
next input symbol.
12
Top-down Analysis
LL Grammars
An LL Grammar is any grammar which can be put
into the parse table used by the LL parser without
conflict.
We can procede in two ways:
1. Given any CFG grammar, put it into the parse table
and if there are no conflicts, it is LL.
2. Apply a series of transformations to convert the
grammar into Greibach Normal Form (GNF) (and
some other minor transformations). If these
transformations can be applied, then the grammar
is guaranteed to be LL.
In this course, we will just use the first approach.

13
9.4 Building An LL Parser:

Hand-coded Approach
Building the parser

The simplest approach is to write this table directly as code.
Each LHS symbol has its own procedure
The procedure receives two arguments, the list of input
tokens, and an index to indicate which is the current token.
int U (char *cadena, int i)
The code consists of a switch/case statement which calls a

different function (to expand a RHS element) depending on
what the next input is.
switch (cadena[i]) {
case x:
i++;
i = X1 (cadena, i);
i = X2 (cadena, i);
15
Code for Recursive Descent Parser

Grammar: U:- X1 X2 X3 | Y1 Y2 Y3
int U (char *cadena, int i)
{
if (i<0) return i;
case x:
i++;
i = X1 (cadena, i);
i = X2 (cadena, i);
i = X3 (cadena, i);
break;
case y:
i++;
i = Y1 (cadena, i);
i = Y2 (cadena, i);
i = Y3 (cadena, i);
break;
default: return -n;
}
return i;
}
16
int T (char *cadena, int i)

{
if (i<0) return i;
case 'i':
i++;
i = U (cadena, i);
break;
case '(':
i++;
i = E (cadena, i);
i = C (cadena, i);
i = U (cadena, i);
break;
default: return -2;
}
return i;
}
Function returns
error code if none of
the rules match next
input token
17

{
if (i<0) return i;
case 'i':
i++;
i = U (cadena, i);
break;
case '(':
i++;
i = E (cadena, i);
i = C (cadena, i);
i = U (cadena, i);
break;
default: return -2;
}
return i;
}
Otherwise, function
returns pointer to
next input token
18

{
if (i<0) return i;
case 'i':
i++;
i = U (cadena, i);
break;
case '(':
i++;
i = E (cadena, i);
i = C (cadena, i);
i = U (cadena, i);
break;
default: return -2;
}
return i;
}
If one sub-call returns a

negative number (an error)
skip through remaining
elements without parsing
19
Using the parser

In order to analyse an input string x with this method, it is
enough to invoke the function corresponding to the Start
symbol of the grammar with arguments:
x (the chain to analyze) and

0 (the initial value of the counter).
E.g., E(x, 0).

If the value given back by the function agrees with the
length of the input string, the chain is recognised.
If not, the function gives back a negative number, that
indicates the type of error detected.
20
10
9.5 Building An LL Parser

Automatically Generated
Parse Tables
Use of Parse Tables
Rather than hand-writing code for the parser, it is

more usual to use a parser generator.
LL(1) grammar given as input.
General purpose LL(1) pre-processor loads in the
grammar, and builds a parse table for it.
The general purpose processor accepts input
strings and processes on the basis of the parse
table.
22
11
The Parse Table

Rows correspond to Nonterminals
Columns correspond to possible input tokens, and $
The cells contain:
The rule appropriate for the LHS and next token, or

Nothing (indicates an error in parsing)
a
P::=a
P::=iEtPP
P::=eP
P::=
P
E
P::=
E::=b
Note: note an LL(1)
grammar because
there is a conflict!
23
Top-down Analysis
Constructing the Table

The cells of the table are filled by applying the following
procedure:
For each production A:= of the grammar:

For each terminal symbol a First(),
Add the production A:= in the cell T[A,a]

If First(), for each terminal symbol b
Follow(A), add the production A:= in
the T[A,b ].
Note that b can be $.
24
12
Top-down Analysis
Constructing the Table: Example E := TE
E := +TE
Assume the following
E :=
Grammar:
T := FT
T := *FT
T :=
F := (E)
F := id
25
Top-down Analysis
E := +TE
E :=
Grammar:
T := FT
T := *FT
T :=
F := (E)
F := id
+
First, generate a
table for each NT vs.
possible inputs
)
id
E
E
T
T
F
26
13
Top-down Analysis
E := +TE
E :=
T := FT
T := *FT
T :=
F := (E)
F := id
+
First(F) = { (, id }
First(T) = { *, }
First(T) = First(F) = { (, id }
First(E) = { +, }
First(E) = First(T) = { (, id }
Next, calculate the
Firsts of each NT
id
E
E
T
T
F
27
Top-down Analysis
E := +TE
E :=
T := FT
T := *FT
T :=
F := (E)
F := id
+
E
(
E := TE
First(T) = { *, }
First(E) = { +, }
For each rule, place the rule
in the cell for the LHS and
each First of the rule
)
id
E := TE
E
T
T
F
28
14
Top-down Analysis
E := +TE
E :=
T := FT
T := *FT
T :=
F := (E)
F := id
+
E
E
First(T) = { *, }
First(E) = { +, }
Where the First includes
lambda, we need to put the rule
under all followers of the LHS!
id
E := TE
E := TE
E := +TE
T
T
F
29
Top-down Analysis
E := +TE
E :=
T := FT
Follow(E) = { $, ) }
T := *FT
Follow(T) = Follow(T)
T :=
= First(E)- +Follow(E)
F := (E)
F := id
= {+, $, ) }
+
E
E
(
E := TE
First(T) = { *, }
First(E) = { +, }
Calculate the Follow of these
NTs
)
id
E := TE
E := +TE
T
T
F
30
15
Top-down Analysis
E := +TE
E :=
T := FT
Follow(E) = { $, ) }
T := *FT
T :=
F := (E)
= {+, $, ) }
F := id
+
E
E
First(T) = { *, }
First(E) = { +, }
and place the rule under each
follow symbol
id
E := TE
E := +TE
E := TE
E :=
E :=
T
T
F
31
Top-down Analysis
E := +TE
E :=
T := FT
Follow(E) = { $, ) }
T := *FT
T :=
F := (E)
F := id
= {+, $, ) }
+
E
E
T
First(T) = { *, }
First(E) = { +, }
continuing
E := TE
E := +TE
id
E := TE
E :=
T := FT
$
E :=
T := FT
T
F
32
16
Top-down Analysis
E := +TE
E :=
Grammar:
T := FT
Follow(E) = { $, ) }
T := *FT
T :=
F := (E)
= {+, $, ) }
F := id
+
id
E := TE
E := +TE
T := FT
T :=
T := *FT
E := TE
E :=
T
T
continuing
E
E
First(T) = { *, }
First(E) = { +, }
E :=
T := FT
T :=
T :=
F
33
Top-down Analysis
E := +TE
E :=
Grammar:
T := FT
Follow(E) = { $, ) }
T := *FT
T :=
F := (E)
F := id
= {+, $, ) }
+
E
E
continuing
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
First(T) = { *, }
First(E) = { +, }
T :=
F := id
34
17
Top-down Analysis
E := +TE
E :=
Grammar:
T := FT
Follow(E) = { $, ) }
T := *FT
T :=
F := (E)
= {+, $, ) }
F := id
+
E := TE
E := +TE
T := *FT
E := TE
T := FT
T :=
id
E :=
T
T
Giving a completed table!
E
E
First(T) = { *, }
First(E) = { +, }
E :=
T := FT
T :=
F := (E)
T :=
F := id
35
Top-down Analysis
LL(1) Grammars
A grammar is LL(1) if the parse table produced by the

previous procedure has at most one rule in each cell.
36
18
Comparison with Grammars produced in previous classes

The grammars produced in prior classes (converting to GNF
and thence to a S-Grammar) will always be LL(1) following
this definition.
However, note that many grammars which are not GNF can
be LL(1).
We only require that:
The selection between alternative expansion can be uniquely
determined by looking at the next input symbol.
The grammar is not left recursive.
Basically, if a grammar is not left recursive, and CAN BE

converted to an s-grammar, then it is LL(1).
37
Exercise:
Construct the parse table for the following grammar:
P ::=
P ::=
P::=
P::=
E ::=
iEtPP
a
eP
Is this grammar LL(1)?
38
19
7.6 Using the LL Parse Table
Top-down Analysis
Using the Parse Table
Assume the following input, and Start symbol E
id
id
E
E
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
T :=
F := id
40
20
Top-down Analysis
E
T
id
id
Given symbol E to expand and

next input=(, expansion is: TE
+
E
E
E := TE
E := +TE
E := TE
T := FT
T :=
id
E :=
T
T
T := *FT
E :=
T := FT
T :=
F := (E)
T :=
F := id
41
Top-down Analysis
E
T
id
id
Dont advance the input pointer,

Expand T
+
E
E
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
T :=
F := id
42
21
Top-down Analysis
E
T
id
id
E
T
Given symbol T to expand and

next input=(, expansion is FT
+
E
E
E := TE
E := +TE
E := TE
T := FT
T :=
id
E :=
T
T
T := *FT
E :=
T := FT
T :=
F := (E)
T :=
F := id
43
Top-down Analysis
E
T
id
id
E
T
Expand F
E
E
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
T :=
F := id
44
22
Top-down Analysis
E
T
id
id
$
(
Given symbol F to expand and

next input=(, expansion is (E)
+
E
E
id
E := TE
T := FT
T :=
E :=
T
T
T
)
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
T :=
F := (E)
F := id
45
Top-down Analysis
E
T
id
id
$
(
Leftmost symbol is terminal (, which

matches next input, so advance input
+
E
E
E := TE
E := +TE
id
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
E :=
T
T
T :=
F := id
46
23
Top-down Analysis
E

T
F
id
id
Expanding E with next input id, use

expansion: TE
+
id
E := TE
E := +TE
E := TE
E :=
T := FT
T :=
E :=
T
T
(
(
T
)
E
(
T := *FT
T := FT
T :=
T :=
F := (E)
F := id
47
Top-down Analysis
E

T
F
E
id
id
Expanding T with next input id, use

expansion: FT
+
E
E
)
E
E := TE
id
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
E :=
T := FT
T :=
E := +TE
T
T
T :=
F := id
48
24
Top-down Analysis
E

T
F
E
id
id
E
T
id
)
id
E := TE
E :=
E :=
T := FT
T :=
E := TE
E := +TE
T
T
(
(
E
E
T
)
Expanding F with next input id, use

expansion: id advance pointer
T := FT
T := *FT
T :=
T :=
F := (E)
F := id
49
Top-down Analysis
E

T
F
E
id
id
Expanding T with next input +, use

expansion:
+
E
E
id
id
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
E :=
T := FT
T :=
E := TE
E := +TE
T
T
T :=
F := id
50
25
Top-down Analysis
E

T
F
E
(
id
id
id
+
id
E := TE
E := +TE
E :=
E :=
T := FT
T :=
T E
E := TE
T
T
Expanding E with next input +, use

expansion: +TE
T := FT
T := *FT
T :=
T :=
F := (E)
F := id
51
Top-down Analysis
E

T
F
E
(
id
id
Match + and advance pointer

(
+
E
E
id
T E
+
id
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
E :=
T := FT
T :=
)
E
E := TE
E := +TE
T
T
T :=
F := id
52
26
Top-down Analysis
E

T
F
E
(
id
id
Expanding T with next input id, use

expansion: FT
+
E
E
(
(
id
E := TE
E := +TE
+
id
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
T E
E :=
T
T
)
E
T :=
F := id
53
Analysis using an Analysis Stack (rather than tree)

1. Initialize the Analysis Stack with 2 entries: $ and the Start symbol
2. Initialise the Input Queue with the string to analyse, terminated by $
3. Set the Input Pointer to the first item
4. Repeat the following procedure:
Compare the symbol on top of the Analysis Stack (P) with the
next input symbol, S.
If P==S:
If P == $, accept the input string and exit.

Otherwise, pop top of Stack and advance input pointer
If P S:
If S is a terminal emit error and return

If cell(P, S) is empty, emit error message and exit.
Otherwise replace top of stack with its expansion:
the cell contains an expansion of P:- X1 X2 Xn.
Pop P off the stack
Push the symbols X1 X2 Xn onto the stack in reverse order.
54
27
Top-down Analysis
Using the Parse Table with Analysis Stack: Example
P
INITIAL STATE
(
id
id
E
+
E
E
E := TE
E := +TE
T := FT
T :=
T := *FT
E := TE
E :=
T
T
id
E :=
T := FT
T :=
F := (E)
T :=
F := id
55
Top-down Analysis
E & ( not equal

(
id
id
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
Cell( E,( ) has rule

Replace on stack
E
+
T :=
F := id
56
28
Top-down Analysis
T & ( not equal

(
id
id
Cell( T,( ) has rule

Replace on stack
E
E
E := TE
E := +TE
T := FT
T :=
T := *FT
E := TE
E :=
T
T
id
E :=
T := FT
T :=
F := (E)
T :=
F := id
57
Top-down Analysis
F & ( not equal

(
id
id
Cell( F,( ) has rule

Replace on stack
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
E
E
T :=
F := id
58
29
Top-down Analysis
( & ( EQUAL!
(
id
id
Pop Stack
Advance pointer
(
(
E
E
E := TE
E := +TE
T := FT
T :=
T := *FT
E := TE
E :=
T
T
id
E :=
T := FT
T :=
F := (E)
T :=
F := id
59
Top-down Analysis
E & id not equal

(
id
id
)
*
E
E
Cell( E,id ) has rule

Replace on stack
E
(
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
T :=
F := id
60
30
Top-down Analysis
T & id not equal

(
id
id
Cell( T,id ) has rule

Replace on stack
T
(
E
E
id
E := TE
E := +TE
E := TE
E :=
T := FT
T :=
T := *FT
E :=
T := FT
T :=
F := (E)
T :=
F := id
61
Top-down Analysis
F & id not equal

(
id
id
)
*
E
E
Cell( F,id ) has rule
T
(
F
)
E := TE
E := +TE
id
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
Replace on stack
E :=
T
T
T :=
F := id
62
31
Top-down Analysis
id & id EQUAL!
(
id
id
Pop Stack
T
(
E
E
E := TE
E := +TE
T := *FT
E := TE
T := FT
T :=
id
E :=
T
T
Advance pointer
id
E :=
T := FT
T :=
F := (E)
T :=
F := id
63
Top-down Analysis
and so on!
(
id
id
)
*
E
E
T
(
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
T :=
F := id
64
32
Top-down Analysis
Eventually:
) and ) equal
(
id
id
Advance pointer
Pop Stack
)
+
E
E
E := TE
E := +TE
T := FT
T :=
T := *FT
E := TE
E :=
T
T
id
E :=
T := FT
T :=
F := (E)
T :=
F := id
65
Top-down Analysis
Eventually:
$ and $ equal
(
id
id
Top of stack is $
Accept and Exit!
$
+
E
E
E := TE
E := +TE
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
T := FT
T :=
id
E :=
T
T
T :=
F := id
66
33
Top-down Analysis
Using the Parse Table with Analysis Stack: Summary
Four Actions:
1. Accept: If P==S==$
2. Advance: If P==S $
3. Replace: If P S and Cell(S, P)
4. Error: If P S and Cell(S, P) == .
67
Top-down Analysis
Keeping track of the Analysis
One can use a chart like the following to record each step:
Step
Stack
Input
Action
$E
id+id$
Apply E::=TE
$ET
id+id$
Apply T::=FT
$ETF
id+id$
Apply F::=id
$ETid
id+id$
Advance
$ET
+id$
Apply T::=
$E
+id$
Apply E::=+TE
$ET+
+id$
Advance
$ET
id$
Apply T::=FT
$ETF
id$
Apply F::=id
10
$ETid
id$
Advance
11
$ET
Apply T::=
12
$E
Apply E::=
13
Input Accepted
68
34
Alternative Table
Row labels are symbols which can be on top of stack (term or nonterm)
Column labels are next input
Action given for current top of stack whether terminal or nonterm.
+
E := TE
E := +TE
T := FT
T :=
T := *FT
E :=
T := FT
T :=
F := (E)
E := TE
E :=
T
T
id
T :=
F := id
advance
advance
advance
advance
id
advance
accept
69
Alternative Table: error types

1. Next input does not match terminal on top of stack
2. Tree fully expanded, some input unconsumed
3. Tree incomplete, all input consumed
4. Next input cannot start nonterm on top of stack
+
id
E := TE
E := TE
E := +TE
E :=
E :=
T := FT
T := FT
T :=
T := *FT
T :=
T :=
F := (E)
F := id
advance
advance
advance
advance
id
advance
accept
70
35

09 1 TopDown

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

09 1 TopDown

Uploaded by

Copyright:

Available Formats

Topic 9: Top Down Parsing

Top-down Analysis Revision

Now we will look at various top-down approaches.

Top-down Analysis Revision

Left-to-Right processing of input

Apply: E-> E+E

Apply: E-> E*E

Topic 9: Top Down Parsing

In this course, we will just use the first approach.

9.4 Building An LL Parser:

Building the parser

The code consists of a switch/case statement which calls a

Code for Recursive Descent Parser

Code for Recursive Descent Parser

int T (char *cadena, int i)

Code for Recursive Descent Parser

int T (char *cadena, int i)

Code for Recursive Descent Parser

int T (char *cadena, int i)

If one sub-call returns a

Using the parser

x (the chain to analyze) and

E.g., E(x, 0).

9.5 Building An LL Parser

Use of Parse Tables

Rather than hand-writing code for the parser, it is

The Parse Table

The rule appropriate for the LHS and next token, or

Constructing the Table

For each production A:= of the grammar:

Add the production A:= in the cell T[A,a]

Giving a completed table!

A grammar is LL(1) if the parse table produced by the

Comparison with Grammars produced in previous classes

Basically, if a grammar is not left recursive, and CAN BE

Is this grammar LL(1)?

7.6 Using the LL Parse Table

Given symbol E to expand and

Dont advance the input pointer,

Given symbol T to expand and

Given symbol F to expand and

Leftmost symbol is terminal (, which

Deterministic Topdown Parsing

Expanding E with next input id, use

Deterministic Topdown Parsing

Expanding T with next input id, use

Deterministic Topdown Parsing

Expanding F with next input id, use

Deterministic Topdown Parsing

Expanding T with next input +, use

Deterministic Topdown Parsing

Expanding E with next input +, use

Deterministic Topdown Parsing

Match + and advance pointer

Deterministic Topdown Parsing

Expanding T with next input id, use

Analysis using an Analysis Stack (rather than tree)

If P == $, accept the input string and exit.

If S is a terminal emit error and return

E & ( not equal

Cell( E,( ) has rule

T & ( not equal

Cell( T,( ) has rule