-/*------------------------------------------------------------------.
-| Decide what to do for each type of token if seen as the lookahead |
-| token in specified state. The value returned is used as the |
-| default action (yydefact) for the state. In addition, actrow is |
-| filled with what to do for each kind of token, index by symbol |
-| number, with zero meaning do the default action. The value |
-| SHRT_MIN, a very negative number, means this situation is an |
-| error. The parser recognizes this value specially. |
-| |
-| This is where conflicts are resolved. The loop over lookahead |
-| rules considered lower-numbered rules last, and the last rule |
-| considered that likes a token gets to handle it. |
-| |
-| For GLR parsers, also sets conflrow[SYM] to an index into |
-| conflict_list iff there is an unresolved conflict (s/r or r/r) |
-| with symbol SYM. The default reduction is not used for a symbol |
-| that has any such conflicts. |
-`------------------------------------------------------------------*/
-
-static int
-action_row (state_t *state)
-{
- int i;
- int default_rule = 0;
- reductions_t *redp = state->reductions;
- shifts_t *shiftp = state->shifts;
- errs_t *errp = state->errs;
- /* set nonzero to inhibit having any default reduction */
- int nodefault = 0;
- int conflicted = 0;
-
- for (i = 0; i < ntokens; i++)
- actrow[i] = conflrow[i] = 0;
-
- if (redp->nreds >= 1)
- {
- int j;
- /* loop over all the rules available here which require
- lookahead */
- for (i = state->nlookaheads - 1; i >= 0; --i)
- /* and find each token which the rule finds acceptable
- to come next */
- for (j = 0; j < ntokens; j++)
- /* and record this rule as the rule to use if that
- token follows. */
- if (bitset_test (state->lookaheads[i], j))
- {
- if (actrow[j] != 0)
- conflicted = conflrow[j] = 1;
- actrow[j] = -state->lookaheads_rule[i]->number;
- }
- }
-
- /* Now see which tokens are allowed for shifts in this state. For
- them, record the shift as the thing to do. So shift is preferred
- to reduce. */
- for (i = 0; i < shiftp->nshifts; i++)
- {
- symbol_number_t symbol;
- state_number_t shift_state = shiftp->shifts[i];
- if (!shift_state)
- continue;
-
- symbol = states[shift_state]->accessing_symbol;
-
- if (ISVAR (symbol))
- break;
-
- if (actrow[symbol] != 0)
- conflicted = conflrow[symbol] = 1;
- actrow[symbol] = state_number_as_int (shift_state);
-
- /* Do not use any default reduction if there is a shift for
- error */
- if (symbol == errtoken->number)
- nodefault = 1;
- }
-
- /* See which tokens are an explicit error in this state (due to
- %nonassoc). For them, record SHRT_MIN as the action. */
- for (i = 0; i < errp->nerrs; i++)
- {
- int symbol = errp->errs[i];
- actrow[symbol] = SHRT_MIN;
- }
-
- /* Now find the most common reduction and make it the default action
- for this state. */
-
- if (redp->nreds >= 1 && !nodefault)
- {
- if (state->consistent)
- default_rule = redp->rules[0];
- else
- {
- int max = 0;
- for (i = 0; i < state->nlookaheads; i++)
- {
- int count = 0;
- int rule = -state->lookaheads_rule[i]->number;
- int j;
-
- for (j = 0; j < ntokens; j++)
- if (actrow[j] == rule)
- count++;
-
- if (count > max)
- {
- max = count;
- default_rule = rule;
- }
- }
-
- /* GLR parsers need space for conflict lists, so we can't
- default conflicted entries. For non-conflicted entries
- or as long as we are not building a GLR parser,
- actions that match the default are replaced with zero,
- which means "use the default". */
-
- if (max > 0)
- {
- int j;
- for (j = 0; j < ntokens; j++)
- if (actrow[j] == default_rule && ! (glr_parser && conflrow[j]))
- actrow[j] = 0;
- }
- default_rule = -default_rule;
- }
- }
-
- /* If have no default rule, the default is an error.
- So replace any action which says "error" with "use default". */
-
- if (default_rule == 0)
- for (i = 0; i < ntokens; i++)
- if (actrow[i] == SHRT_MIN)
- actrow[i] = 0;
-
- if (conflicted)
- conflict_row (state);
-
- return default_rule;
-}
projects / bison.git / blobdiff