- if (! glr_parser)
- return;
-
- for (j = 0; j < ntokens; j += 1)
- if (conflrow[j])
- {
- conflrow[j] = conflict_list_cnt;
-
- /* Find all reductions for token J, and record all that do not
- match ACTROW[J]. */
- for (i = 0; i < state->nlookaheads; i += 1)
- if (bitset_test (state->lookaheads[i], j)
- && (actrow[j]
- != rule_number_as_item_number (state->lookaheads_rule[i]->number)))
- {
- assert (conflict_list_free > 0);
- conflict_list[conflict_list_cnt]
- = state->lookaheads_rule[i]->number + 1;
- conflict_list_cnt += 1;
- conflict_list_free -= 1;
- }
-
- /* Leave a 0 at the end. */
- assert (conflict_list_free > 0);
- conflict_list_cnt += 1;
- conflict_list_free -= 1;
- }
-}
-
-
-/*------------------------------------------------------------------.
-| 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 |
-| ACTION_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 rule_t *
-action_row (state_t *state)
-{
- int i;
- rule_t *default_rule = NULL;
- reductions_t *redp = state->reductions;
- transitions_t *transitions = state->transitions;
- errs_t *errp = state->errs;
- /* Set to 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->num >= 1)
- {
- int j;
- bitset_iterator biter;
- /* 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 */
- BITSET_FOR_EACH (biter, state->lookaheads[i], j, 0)
- {
- /* and record this rule as the rule to use if that
- token follows. */
- if (actrow[j] != 0)
- conflicted = conflrow[j] = 1;
- actrow[j] = rule_number_as_item_number (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_EACH_SHIFT (transitions, i)
- {
- symbol_number_t symbol = TRANSITION_SYMBOL (transitions, i);
- state_t *shift_state = transitions->states[i];
-
- if (actrow[symbol] != 0)
- conflicted = conflrow[symbol] = 1;
- actrow[symbol] = state_number_as_int (shift_state->number);
-
- /* 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 ACTION_MIN as the action. */
- for (i = 0; i < errp->num; i++)
- {
- symbol_t *symbol = errp->symbols[i];
- actrow[symbol->number] = ACTION_MIN;
- }
-
- /* Now find the most common reduction and make it the default action
- for this state. */
-
- if (redp->num >= 1 && !nodefault)
- {
- if (state->consistent)
- default_rule = redp->rules[0];
- else
- {
- int max = 0;
- for (i = 0; i < state->nlookaheads; i++)
- {
- int count = 0;
- rule_t *rule = state->lookaheads_rule[i];
- symbol_number_t j;
-
- for (j = 0; j < ntokens; j++)
- if (actrow[j] == rule_number_as_item_number (rule->number))
- 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] == rule_number_as_item_number (default_rule->number)
- && ! (glr_parser && conflrow[j]))
- actrow[j] = 0;
- }
- }
- }
-
- /* Find the rules which are reduced. */
- if (!glr_parser)
- {
- for (i = 0; i < ntokens; i++)
- if (actrow[i] < 0 && actrow[i] != ACTION_MIN)
- rules[item_number_as_rule_number (actrow[i])].useful = TRUE;
- if (default_rule)
- default_rule->useful = TRUE;
- }
-
- /* If have no default rule, the default is an error.
- So replace any action which says "error" with "use default". */
-
- if (!default_rule)
- for (i = 0; i < ntokens; i++)
- if (actrow[i] == ACTION_MIN)
- actrow[i] = 0;
-
- if (conflicted)
- conflict_row (state);
-
- return default_rule;
projects / bison.git / blobdiff