Recursive-Descent Parsing

22 March 2019 OSU CSE 1

BL Compiler Structure

Code
Tokenizer Parser
Generator

string of string of abstract string of

characters tokens program integers
(source code) (“words”) (object code)

Note that the parser starts with a

string of tokens.

22 March 2019 OSU CSE 2

Plan for the BL Parser
• Design a context-free grammar (CFG) to
specify syntactically valid BL programs
• Use the grammar to implement a
recursive-descent parser (i.e., an
algorithm to parse a BL program and
construct the corresponding Program
object)

22 March 2019 OSU CSE 3

Parsing
• A CFG can be used to generate strings in
its language
– “Given the CFG, construct a string that is in
the language”
• A CFG can also be used to recognize
strings in its language
– “Given a string, decide whether it is in the
language”
– And, if it is, construct a derivation tree (or AST)
22 March 2019 OSU CSE 4
Parsing
Parsing generally refers to this last
• A CFG canstep,be used to generate
i.e., going strings
from a string in
(in the
its languagelanguage) to its derivation tree or—
for aconstruct
– “Given the CFG, programming language—
a string that is in
perhaps to an AST for the program.
the language”
• A CFG can also be used to recognize
strings in its language
– “Given a string, decide whether it is in the
language”
– And, if it is, construct a derivation tree (or AST)
22 March 2019 OSU CSE 5
A Recursive-Descent Parser
• One parse method per non-terminal symbol
• A non-terminal symbol on the right-hand side of
a rewrite rule leads to a call to the parse method
for that non-terminal
• A terminal symbol on the right-hand side of a
rewrite rule leads to “consuming” that token from
the input token string
• | in the CFG leads to “if-else” in the parser

22 March 2019 OSU CSE 6

Example: Arithmetic Expressions
expr → expr add-op term | term
term → term mult-op factor | factor
factor → ( expr ) | digit-seq
add-op →+|-
mult-op → * | DIV | REM
digit-seq → digit digit-seq | digit
digit →0|1|2|3|4|5|6|7|8|9

22 March 2019 OSU CSE 7

A Problem
expr → expr add-op term | term
term → term mult-op factor | factor
factor → ( expr ) | digit-seq
add-op →+|- Do you see a
mult-op → * | DIV | REM problem with a
digit-seq recursive descent
→ digit digit-seq | digit
digit → 0 | 1 | 2 | 3 | 4 | 5 | 6parser
| 7 | 8for
| 9this
CFG? (Hint!)

22 March 2019 OSU CSE 8

A Solution
expr → term { add-op term }
term → factor { mult-op factor }
factor → ( expr ) | digit-seq
add-op →+|-
mult-op → * | DIV | REM
digit-seq → digit digit-seq | digit
digit →0|1|2|3|4|5|6|7|8|9

22 March 2019 OSU CSE 9

A Solution
expr → term { add-op term }
term → factor { mult-op factor }
factor → ( expr ) | digit-seq
add-op →+|-
The special CFG symbols { and }
mult-op → * | DIV | REM
mean that the enclosed sequence of
digit-seq →symbols occurs| zero
digit digit-seq digit or more times;
digit 0 | 1helps
→ this |2|3 | 4 | 5 a| 6left-recursive
change |7|8|9
CFG into an equivalent CFG that can
be parsed by recursive descent.
22 March 2019 OSU CSE 10
A Solution
The special CFG symbols { and } also
simplify a non-terminal for a number
expr → term
that has no term
{ add-op leading
} zeroes.
term → factor { mult-op factor }
factor → ( expr ) | number
add-op →+|-
mult-op → * | DIV | REM
number → 0 | nz-digit { 0 | nz-digit }
nz-digit →1|2|3|4|5|6|7|8|9

22 March 2019 OSU CSE 11

A Recursive-Descent Parser
• One parse method per non-terminal symbol
• A non-terminal symbol on the right-hand side of
a rewrite rule leads to a call to the parse method
for that non-terminal
• A terminal symbol on the right-hand side of a
rewrite rule leads to “consuming” that token from
the input token string
• | in the CFG leads to “if-else” in the parser
• {...} in the CFG leads to “while” in the parser

22 March 2019 OSU CSE 12

More Improvements
If we treat every number as a token,
expr → term { add-op
then thingsterm }
get simpler for the
term → factor { mult-op
parser: now therefactor
are} only 5 non-
factor → ( exprterminals
) | numberto worry about.
add-op →+|-
mult-op → * | DIV | REM
number → 0 | nz-digit { 0 | nz-digit }
nz-digit →1|2|3|4|5|6|7|8|9

22 March 2019 OSU CSE 13

More Improvements
If we treat every add-op and mult-op
expr → term
as a{ token,
add-opthen
termit’s
} even simpler:
term → factor { mult-op
there are onlyfactor }
3 non-terminals.
factor → ( expr ) | number
add-op →+|-
mult-op → * | DIV | REM
number → 0 | nz-digit { 0 | nz-digit }
nz-digit →1|2|3|4|5|6|7|8|9

22 March 2019 OSU CSE 14

Can you writeImprovements
the tokenizer for this language, so
every number, add-op, and mult-op is a token?
expr → term { add-op term }
term → factor { mult-op factor }
factor → ( expr ) | number
add-op →+|-
mult-op → * | DIV | REM
number → 0 | nz-digit { 0 | nz-digit }
nz-digit →1|2|3|4|5|6|7|8|9

22 March 2019 OSU CSE 15

Evaluating Arithmetic Expressions
• For this problem, parsing an arithmetic
expression means evaluating it
• The parser goes from a string of tokens in
the language of the CFG on the previous
slide, to the value of that expression as an
int

22 March 2019 OSU CSE 16

Structure of Solution
"4 + 29 DIV 3"

<"4", "+", "29",

"DIV", "3", "EOI">
13
Tokenizer Parser

string of string of value of

characters tokens arithmetic
(arithmetic expression
expression)

22 March 2019 OSU CSE 17

Structure
We will use a of Solution to hold
Queue<String>
a mathematical value like this.
"4 + 29 DIV 3"

<"4", "+", "29",

"DIV", "3", "EOI">
13
Tokenizer Parser

string of string of value of

characters tokens arithmetic
(arithmetic expression
expression)

22 March 2019 OSU CSE 18

Structure of Solution
We will also assume the tokenizer adds
an “end-of-input” token at the end.
"4 + 29 DIV 3"

<"4", "+", "29",

"DIV", "3", "EOI">
13
Tokenizer Parser

string of string of value of

characters tokens arithmetic
(arithmetic expression
expression)

22 March 2019 OSU CSE 19

Parsing an expr
• We want to parse an expr, which must
start with a term and must be followed by
zero or more (pairs of) add-ops and terms:
expr → term { add-op term }
• An expr has an int value, which is what
we want returned by the method to parse
an expr

22 March 2019 OSU CSE 20

Contract for Parser for expr
/**
* Evaluates an expression and returns its value.
* ...
* @updates ts
* @requires
* [an expr string is a proper prefix of ts]
* @ensures
* valueOfExpr = [value of longest expr string at
* start of #ts] and
* #ts = [longest expr string at start of #ts] * ts
*/
private static int valueOfExpr(Queue<String> ts) {...}

22 March 2019 OSU CSE 21

Parsing a term
• We want to parse a term, which must start
with a factor and must be followed by zero
or more (pairs of) mult-ops and factors:
term → factor { mult-op factor }
• A term has an int value, which is what
we want returned by the method to parse
a term

22 March 2019 OSU CSE 22

Contract for Parser for term
/**
* Evaluates a term and returns its value.
* ...
* @updates ts
* @requires
* [a term string is a proper prefix of ts]
* @ensures
* valueOfTerm = [value of longest term string at
* start of #ts] and
* #ts = [longest term string at start of #ts] * ts
*/
private static int valueOfTerm(Queue<String> ts) {...}

22 March 2019 OSU CSE 23

Parsing a factor
• We want to parse a factor, which must
start with the token "(" followed by an
expr followed by the token ")"; or it must
be a number token:
factor → ( expr ) | number
• A factor has an int value, which is what
we want returned by the method to parse
a factor

22 March 2019 OSU CSE 24

Contract for Parser for factor
/**
* Evaluates a factor and returns its value.
* ...
* @updates ts
* @requires
* [a factor string is a proper prefix of ts]
* @ensures
* valueOfFactor = [value of longest factor string at
* start of #ts] and
* #ts = [longest factor string at start of #ts] * ts
*/
private static int valueOfFactor(Queue<String> ts){
...
}

22 March 2019 OSU CSE 25

Code for Parser for expr
private static int valueOfExpr(Queue<String> ts) {
int value = valueOfTerm(ts);
while (ts.front().equals("+") ||
ts.front().equals("-")) {
String op = ts.dequeue();
int nextTerm = valueOfTerm(ts);
if (op.equals("+")) {
value = value + nextTerm;
} else /* "-" */ {
value = value - nextTerm;
}
}
return value;
}
22 March 2019 OSU CSE 26
Code
expr
add-op
for
→
→
Parser for expr
term { add-op term }
+|-
private static int valueOfExpr(Queue<String> ts) {
int value = valueOfTerm(ts);
while (ts.front().equals("+") ||
ts.front().equals("-")) {
String op = ts.dequeue();
int nextTerm = valueOfTerm(ts);
if (op.equals("+")) {
value = value + nextTerm;
} else /* "-" */ {
value = value - nextTerm;
}
}
return value;
}
22 March 2019 OSU CSE 27
Code for Parser for expr
private static int valueOfExpr(Queue<String> ts) {
int value = valueOfTerm(ts);
while (ts.front().equals("+") || This method is
ts.front().equals("-")) {
String op = ts.dequeue(); very similar to
int nextTerm = valueOfTerm(ts); valueOfExpr.
if (op.equals("+")) {
value = value + nextTerm;
} else /* "-" */ {
value = value - nextTerm;
}
}
return value;
}
22 March 2019 OSU CSE 28
Code for Parser for expr
private static int valueOfExpr(Queue<String> ts) {
int value = valueOfTerm(ts);
while (ts.front().equals("+") || Look ahead
ts.front().equals("-")) { one token in
String op = ts.dequeue(); ts to see
int nextTerm = valueOfTerm(ts);
if (op.equals("+")) {
what’s next.
value = value + nextTerm;
} else /* "-" */ {
value = value - nextTerm;
}
}
return value;
}
22 March 2019 OSU CSE 29
Code for Parser for expr
private static int valueOfExpr(Queue<String> ts) {
int value = valueOfTerm(ts);
while (ts.front().equals("+") || “Consume”
ts.front().equals("-")) {
String op = ts.dequeue(); the next token
int nextTerm = valueOfTerm(ts); from ts.
if (op.equals("+")) {
value = value + nextTerm;
} else /* "-" */ {
value = value - nextTerm;
}
}
return value;
}
22 March 2019 OSU CSE 30
Code for Parser for expr
private static int valueOfExpr(Queue<String> ts) {
int value = valueOfTerm(ts);
while (ts.front().equals("+") || Evaluate next
ts.front().equals("-")) { term.
String op = ts.dequeue();
int nextTerm = valueOfTerm(ts);
if (op.equals("+")) {
value = value + nextTerm;
} else /* "-" */ {
value = value - nextTerm;
}
}
return value;
}
22 March 2019 OSU CSE 31
Code for Parser for expr
private static int valueOfExpr(Queue<String> ts) {
int value = valueOfTerm(ts);
while (ts.front().equals("+") || Evaluate
ts.front().equals("-")) { (some of) the
String op = ts.dequeue(); expression.
int nextTerm = valueOfTerm(ts);
if (op.equals("+")) {
value = value + nextTerm;
} else /* "-" */ {
value = value - nextTerm;
}
}
return value;
}
22 March 2019 OSU CSE 32
Code for Parser for term
private static int valueOfTerm(Queue<String> ts) {

Can you write the body,

using valueOfExpr as
a guide?

22 March 2019 OSU CSE 33

Code for Parser for factor
private static int valueOfFactor(
Queue<String> ts) {
int value;
if (ts.front().equals("(")) {
ts.dequeue();
value = valueOfExpr(ts);
ts.dequeue();
} else {
String number = ts.dequeue();
value = Integer.parseInt(number);
}
return value;
}

22 March 2019 OSU CSE 34

Code
factor for
→ Parser
( expr ) for factor
| number
private static int valueOfFactor(
Queue<String> ts) {
int value;
if (ts.front().equals("(")) {
ts.dequeue();
value = valueOfExpr(ts);
ts.dequeue();
} else {
String number = ts.dequeue();
value = Integer.parseInt(number);
}
return value;
}

22 March 2019 OSU CSE 35

Code for Parser for factor
private static int valueOfFactor(
Queue<String> ts) {
int value; Look ahead
if (ts.front().equals("(")) {
one token in
ts.dequeue();
value = valueOfExpr(ts);
ts to see
ts.dequeue(); what’s next.
} else {
String number = ts.dequeue();
value = Integer.parseInt(number);
}
return value;
}

22 March 2019 OSU CSE 36

Code for Parser for factor
private static int valueOfFactor(
Queue<String> ts) {
int value;
if (ts.front().equals("(")) {
ts.dequeue(); What token
value = valueOfExpr(ts); does this
ts.dequeue(); throw away?
} else {
String number = ts.dequeue();
value = Integer.parseInt(number);
}
return value;
}

22 March 2019 OSU CSE 37

Though method is called parseInt, it
Code for Parser for factor
is not one of our parser methods; it is a
private static int valueOfFactor(
static method from the Java library’s
Queue<String> ts) {
Integer class (with int utilities).
int value;
if (ts.front().equals("(")) {
ts.dequeue();
value = valueOfExpr(ts);
ts.dequeue();
} else {
String number = ts.dequeue();
value = Integer.parseInt(number);
}
return value;
}

22 March 2019 OSU CSE 38

Code for Parser for factor
private static int valueOfFactor(
Queue<String> ts) {
int value;
if (ts.front().equals("(")) {
ts.dequeue();
value = valueOfExpr(ts);
ts.dequeue();
} else {
String number = ts.dequeue();
Recursive descent: notice that
value = valueOfExpr
Integer.parseInt(number);
calls valueOfTerm,
}
which calls valueOfFactor,
return value;
} which here may call valueOfExpr.

22 March 2019 OSU CSE 39

Code for Parser for factor
private static int valueOfFactor(
Queue<String> ts) {
int value; How do you
if (ts.front().equals("(")) { know this
ts.dequeue(); (indirect)
value = valueOfExpr(ts); recursion
ts.dequeue();
terminates?
} else {
String number = ts.dequeue();
value = Integer.parseInt(number);
}
return value;
}

22 March 2019 OSU CSE 40

A Recursive-Descent Parser
• One parse method per non-terminal symbol
• A non-terminal symbol on the right-hand side of
a rewrite rule leads to a call to the parse method
for that non-terminal
• A terminal symbol on the right-hand side of a
rewrite rule leads to “consuming” that token from
the input token string
• | in the CFG leads to “if-else” in the parser
• {...} in the CFG leads to “while” in the parser

22 March 2019 OSU CSE 41

Observations
• This is so formulaic that tools are available
that can generate RDPs from CFGs
• In the lab, you will write an RDP for a
language similar to the one illustrated here
– The CFG will be a bit different
– There will be no tokenizer, so you will parse a
string of characters in a Java StringBuilder
• See methods charAt and deleteCharAt

22 March 2019 OSU CSE 42

Resources
• Wikipedia: Recursive Descent Parser
– http://en.wikipedia.org/wiki/Recursive_descent_parser
• Java Libraries API: StringBuilder
– http://docs.oracle.com/javase/8/docs/api/

22 March 2019 OSU CSE 43