Introduction to Computational Linguistics

22. Shift–Reduce–Parsing 90
< number > → < digit >|< number >< number >
This grammar has the NTS–property. Any digit is of category < digit >, and a
number can be broken down into two numbers at any point. The standard definition
is as follows.
(220)
< digit > → 0 | 1 | · · · | 9
< number > → < digit >|< digit >< number >
This grammar is not an NTS–grammar, because in the expression
(221) < digt >< digit >< digit >
the occurrence 〈< digit >, ε〉 of the string < digit >< digit > cannot be a
constituent occurrence under any parse. Finally, the language of strings has no
transparent grammar! This is because the string 732 possesses occurrences of the
strings 73 and 32. These occurrences must be occurrences under one and the same
parse if the grammar is transparent. But they overlap. Contradiction.
Now, the strategy above is deterministic. It is easy to see that there is a nondeterministic
algorithm implementing this idea that actually defines a machine
parsing exactly the CFLs. It is a machine where you only have a stack, and symbols
scanned are moved onto the stack. The top k symbols are visible (with PDAs
we had k = 1). If the last m symbols, m ≤ k, are the right hand side of a rule,
you are entitled to replace it by the corresponding left hand side. (This style of
parsing is called shift–reduce parsing. One can show that PDAs can emulate a
shift–reduce parser.) The stack gets cleared by m − 1 symbols, so you might end
up seeing more of the stack after this move. Then you may either decide that once
again there is a right hand side of a rule which you want to replace by the left hand
side (reduce), or you want to see one more symbol of the string (shift). In general,
like with PDAs, the nondeterminism is unavoidable.
There is an important class of languages, the so–called LR(k)–grammars. These
are languages where the question whether to shift or to reduce can be based on a
lookahead of k symbols. That is to say, the parser might not know directly if it
needs to shift or to reduce, but it can know for sure if it sees the next k symbols (or
whatever is left of the string). One can show that for a language which there is an
LR(k)–grammar with k > 0 there also is a LR(1)–grammar. So, a lookahead of just
one symbol is enough to make an informed guess (at least with respect to some
grammar, which however need not generate the constituents we are interested in).