Manual

76 Bison 2.3
terminal and nonterminal symbols at or near the top of the stack. The current state collects
all the information about previous input which is relevant to deciding what to do next.
Each time a look-ahead token is read, the current parser state together with the type of
look-ahead token are looked up in a table. This table entry can say, “Shift the look-ahead
token.” In this case, it also specifies the new parser state, which is pushed onto the top
of the parser stack. Or it can say, “Reduce using rule number n.” This means that a
certain number of tokens or groupings are taken off the top of the stack, and replaced by
one grouping. In other words, that number of states are popped from the stack, and one
new state is pushed.
There is one other alternative: the table can say that the look-ahead token is erroneous
in the current state. This causes error processing to begin (see Chapter 6 [Error Recovery],
page 83).
5.6 Reduce/Reduce Conflicts
A reduce/reduce conflict occurs if there are two or more rules that apply to the same
sequence of input. This usually indicates a serious error in the grammar.
For example, here is an erroneous attempt to define a sequence of zero or more word
groupings.
sequence: /* empty */
{ printf ("empty sequence\n"); }
| maybeword
| sequence word
{ printf ("added word %s\n", $2); }
;
maybeword: /* empty */
{ printf ("empty maybeword\n"); }
| word
{ printf ("single word %s\n", $1); }
;
The error is an ambiguity: there is more than one way to parse a single word into a
sequence. It could be reduced to a maybeword and then into a sequence via the second
rule. Alternatively, nothing-at-all could be reduced into a sequence via the first rule, and
this could be combined with the word using the third rule for sequence.
There is also more than one way to reduce nothing-at-all into a sequence. This can be
done directly via the first rule, or indirectly via maybeword and then the second rule.
You might think that this is a distinction without a difference, because it does not change
whether any particular input is valid or not. But it does affect which actions are run. One
parsing order runs the second rule’s action; the other runs the first rule’s action and the
third rule’s action. In this example, the output of the program changes.
Bison resolves a reduce/reduce conflict by choosing to use the rule that appears first in
the grammar, but it is very risky to rely on this. Every reduce/reduce conflict must be
studied and usually eliminated. Here is the proper way to define sequence:
sequence: /* empty */