Intel XENIX 286 Programmers Guide (86) - Tenox.tc

XENIX Programming yacc: Compiler-Compiler
It could then apply the rule to the rightmost three sy mbols, reducing them to expr and
leaving
expr - expr
Now the rule can be reduced once more; the effect is to take the right associative
interpretation. Thus, having read
expr - expr
the parser can do two legal things, a shift or a reduction, and has no way of deciding
between them. This is called a shift/reduce conflict. It may also happen that the parser
has a choice of two legal reductions; this is called a reduce/reduce conflict. Note that
there are never any shift/shift conflicts.
When there are shift/reduce or reduce/reduce conflicts, yacc still produces a parser. It
does this by selecting one of the valid steps wherever it has a choice. A rule describing
which choice to make in a given situation is called a disambiguating rule.
yacc invokes two disambiguating rules by default:
1. In a shift/reduce conflict, the default is to do the shift.
2. In a reduce/reduce conflict, the default is to reduce by the earlier gram mar rule
(in the input sequence).
Rule 1 implies that reductions are deferred whenever there is a choice, in favor of
shifts. Rule 2 gives the user rather crude control over the behavior of the parser in this
situation, but reduce/reduce conflicts should be avoided whenever possible.
Conflicts may arise because of mistakes in input or logic, or because the grammar rules,
while consistent, require a more complex parser than yacc can construct. The use of
actions within rules can also cause conflicts, if the action must be done before the
parser can be sure which rule is being recognized. In these cases, the application of
disambiguating rules is inappropriate and leads to an incorrect parser. For this reason,
yacc always reports the number of shift/reduce and reduce/reduce conflicts resolved by
Rule 1 and Rule 2.
In general, whenever it is possible to apply disambiguating rules to produce a correct
parser, it is also possible to rewrite the gram mar rules so that the same inputs are read
but there are no conflicts. For this reason, most previous parser generators have
considered conflicts to be fatal errors. Our experience has suggested that this rewriting
is somewhat unnatural, and produces slower parsers; thus, yacc will produce parsers
even in the presence of conflicts.
As an example of the power of disambiguating rules, consider a fragment from a
programming language involving an if-then-else construction:
stat I F I { I
cond I ) I stat
IF I { I
cond I ) I stat
ELSE stat
10-15