Given a formal grammar and a string produced by that grammar, parsing is figuring out the production process for that string.

In the case of the context-free grammars, the production process takes the form of a parse tree. Before we begin, we always know two things about the parse tree: the root node, which is the initial symbol from which the string was originally derived, and the leaf nodes, which are all the characters of the string in order. What we don't know is the layout of nodes and branches between them.

For example, if the string is acddf , we know this much already:

S /|\ ??? | | | | | a c d d f

Example grammar for use in this article

S → xyz | a B C

→ | B → c | cd

→ | C → eg | df

Bottom-up parsing

This approach is not unlike solving a jigsaw puzzle. We start at the bottom of the parse tree with individual characters. We then use the rules to connect the characters together into larger tokens as we go. At the end of the string, everything should have been combined into a single big S , and S should be the only thing we have left. If not, it's necessary to backtrack and try combining tokens in different ways.

With bottom-up parsing, we typically maintain a stack, which is the list of characters and tokens we've seen so far. At each step, we shift a new character onto the stack, and then reduce as far as possible by combining characters into larger tokens.

Example

String is acddf .

Steps

ε can't be reduced

a can't be reduced

can't be reduced ac can be reduced, as follows:

reduce ac to a B a B can't be reduced a B d can't be reduced a B dd can't be reduced a B ddf can be reduced, as follows: reduce a B ddf to a B d C a B d C can't be reduced End of string. Stack is a B d C , not S . Failure! Must backtrack. a B ddf can't be reduced

to ac can't be reduced

can't be reduced acd can be reduced, as follows:

can be reduced, as follows: reduce acd to a B a B can't be reduced a B d can't be reduced a B df can be reduced, as follows: reduce a B df to a B C a B C can be reduced, as follows: reduce a B C to S End of string. Stack is S . Success!

to

Parse trees

| a

| | a c

B | | a c

B | | | a c d

B | | | | a c d d

B | | | | | a c d d f

B C | | | |\ a c d d f

| | a c

| | | a c d

B | /| a c d

B | /| | a c d d

B | /| | | a c d d f

B C | /| |\ a c d d f

S /|\ / | | / B C | /| |\ a c d d f

Example 2

If all combinations fail, then the string cannot be parsed.

String is acdg .

Steps

ε can't be reduced

a can't be reduced

can't be reduced ac can be reduced, as follows:

can be reduced, as follows: reduce ac to a B a B can't be reduced a B d can't be reduced a B dg can't be reduced End of string. Stack is a B dg , not S . Failure! Must backtrack.

to ac can't be reduced

can't be reduced acd can be reduced, as follows:

can be reduced, as follows: reduce acd to a B a B can't be reduced a B g can't be reduced End of string. stack is a B g , not S . Failure! Must backtrack.

to acd can't be reduced

can't be reduced acdg can't be reduced

can't be reduced End of string. Stack is is acdg , not S . No backtracking is possible. Failure!

Parse trees

| a

| | a c

B | | a c

B | | | a c d

B | | | | a c d g

| | a c

| | | a c d

B | /| a c d

B | /| | a c d g

| | | a c d

| | | | a c d g

Top-down parsing

For this approach we assume that the string matches S and look at the internal logical implications of this assumption. For example, the fact that the string matches S logically implies that either (1) the string matches xyz or (2) the string matches a B C . If we know that (1) is not true, then (2) must be true. But (2) has its own further logical implications. These must be examined as far as necessary to prove the base assertion.

Example

String is acddf .

Steps

Assertion 1: acddf matches S Assertion 2: acddf matches xyz : Assertion is false. Try another. Assertion 2: acddf matches a B C i.e. cddf matches B C : Assertion 3: cddf matches c C i.e. ddf matches C : Assertion 4: ddf matches eg : False. Assertion 4: ddf matches df : False. Assertion 3 is false. Try another. Assertion 3: cddf matches cd C i.e. df matches C : Assertion 4: df matches eg : False. Assertion 4: df matches df : Assertion 4 is true. Assertion 3 is true. Assertion 2 is true.

matches Assertion 1 is true. Success!

Parse trees

S |

S /|\ a B C | |

S /|\ a B C | | c

S /|\ a B C /| | c d

S /|\ a B C /| |\ c d d f

Example 2

If, after following every logical lead, we can't prove the basic hypothesis ("The string matches S ") then the string cannot be parsed.

String is acdg .

Steps

Assertion 1: acdg matches S : Assertion 2: acdg matches xyz : False. Assertion 2: acdg matches a B C i.e. cdg matches B C : Assertion 3: cdg matches c C i.e. dg matches C : Assertion 4: dg matches eg : False. Assertion 4: dg matches df : False. False. Assertion 3: cdg matches cd C i.e. g matches C : Assertion 4: g matches eg : False. Assertion 4: g matches df : False. False. False.

matches : Assertion 1 is false. Failure!

Parse trees

S |

S /|\ a B C | |

S /|\ a B C | | c

S /|\ a B C /| | c d

Why left-recursion is a problem for top-down parsers

If our rules were left-recursive, for example something like this:

S → S b

Then notice how our algorithm behaves:

Steps

Assertion 1: acddf matches S : Assertion 2: acddf matches S b : Assertion 3: acddf matches S bb : Assertion 4: acddf matches S bbb : ...and so on forever

matches :

Parse trees

S |

S |\ S b |

S |\ S b |\ S b |

S |\ S b |\ S b |\ S b |

...