X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/b1ae9233bc1ab111bbac4b427cc4397fa9ee0564..d2ffe11637313569116e8a9f891785b842ddb1e9:/src/tables.c diff --git a/src/tables.c b/src/tables.c index 17883e1f..0b43ce1c 100644 --- a/src/tables.c +++ b/src/tables.c @@ -1,5 +1,6 @@ -/* Output the generated parsing program for bison, - Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002 +/* Output the generated parsing program for Bison. + + Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -21,36 +22,44 @@ #include "system.h" -#include "bitsetv.h" -#include "quotearg.h" -#include "getargs.h" + +#include +#include + +#include "complain.h" +#include "conflicts.h" #include "files.h" +#include "getargs.h" #include "gram.h" -#include "complain.h" #include "lalr.h" #include "reader.h" #include "symtab.h" -#include "conflicts.h" #include "tables.h" -/* Several tables will be indexed both by state and nonterminal - numbers. We call `vector' such a thing (= either a state or a - symbol number. +/* Several tables are indexed both by state and nonterminal numbers. + We call such an index a `vector'; i.e., a vector is either a state + or a nonterminal number. Of course vector_number_t ought to be wide enough to contain - state_number_t and symbol_number_t. */ -typedef short vector_number_t; -#define VECTOR_NUMBER_MAX ((vector_number_t) SHRT_MAX) -#define VECTOR_NUMBER_MIN ((vector_number_t) SHRT_MIN) -#define state_number_to_vector_number(State) \ - ((vector_number_t) State) -#define symbol_number_to_vector_number(Symbol) \ - ((vector_number_t) (state_number_as_int (nstates) + Symbol - ntokens)) + state_number and symbol_number. */ +typedef short vector_number; + +static inline vector_number +state_number_to_vector_number (state_number s) +{ + return s; +} + +static inline vector_number +symbol_number_to_vector_number (symbol_number sym) +{ + return state_number_as_int (nstates) + sym - ntokens; +} int nvectors; -/* FROMS and TOS are indexed by vector_number_t. +/* FROMS and TOS are indexed by vector_number. If VECTOR is a nonterminal, (FROMS[VECTOR], TOS[VECTOR]) form an array of state numbers of the non defaulted GOTO on VECTOR. @@ -63,46 +72,45 @@ int nvectors; (FROMS[VECTOR][SIZE] - FROMS[VECTOR][0] + 1) where SIZE = TALLY[VECTOR]. - FROMS therefore contains symbol_number_t and action_number_t, - TOS state_number_t and action_number_t, + FROMS therefore contains symbol_number and action_number, + TOS state_number and action_number, TALLY sizes, WIDTH differences of FROMS. - Let base_t be the type of FROMS, TOS, and WIDTH. */ -#define BASE_MAX ((base_t) INT_MAX) -#define BASE_MIN ((base_t) INT_MIN) + Let base_number be the type of FROMS, TOS, and WIDTH. */ +#define BASE_MAXIMUM INT_MAX +#define BASE_MINIMUM INT_MIN -static base_t **froms = NULL; -static base_t **tos = NULL; +static base_number **froms = NULL; +static base_number **tos = NULL; static unsigned int **conflict_tos = NULL; static short *tally = NULL; -static base_t *width = NULL; +static base_number *width = NULL; /* For a given state, N = ACTROW[SYMBOL]: If N = 0, stands for `run the default action'. - If N = MIN, stands for `raise a parse error'. + If N = MIN, stands for `raise a syntax error'. If N > 0, stands for `shift SYMBOL and go to n'. If N < 0, stands for `reduce -N'. */ -typedef short action_t; -#define ACTION_MAX ((action_t) SHRT_MAX) -#define ACTION_MIN ((action_t) SHRT_MIN) +typedef short action_number; +#define ACTION_NUMBER_MINIMUM SHRT_MIN -static action_t *actrow = NULL; +static action_number *actrow = NULL; /* FROMS and TOS are reordered to be compressed. ORDER[VECTOR] is the new vector number of VECTOR. We skip `empty' vectors (i.e., TALLY[VECTOR] = 0), and call these `entries'. */ -static vector_number_t *order = NULL; +static vector_number *order = NULL; static int nentries; -base_t *base = NULL; +base_number *base = NULL; /* A distinguished value of BASE, negative infinite. During the - computation equals to BASE_MIN, later mapped to BASE_NINF to + computation equals to BASE_MINIMUM, later mapped to BASE_NINF to keep parser tables small. */ -base_t base_ninf = 0; -static base_t *pos = NULL; +base_number base_ninf = 0; +static base_number *pos = NULL; static unsigned int *conflrow = NULL; unsigned int *conflict_table = NULL; @@ -113,19 +121,19 @@ static int conflict_list_free; /* TABLE_SIZE is the allocated size of both TABLE and CHECK. We start with more or less the original hard-coded value (which was SHRT_MAX). */ -static size_t table_size = 32768; -base_t *table = NULL; -base_t *check = NULL; -/* The value used in TABLE to denote explicit parse errors - (%nonassoc), a negative infinite. First defaults to ACTION_MIN, +static int table_size = 32768; +base_number *table = NULL; +base_number *check = NULL; +/* The value used in TABLE to denote explicit syntax errors + (%nonassoc), a negative infinite. First defaults to ACTION_NUMBER_MININUM, but in order to keep small tables, renumbered as TABLE_ERROR, which is the smallest (non error) value minus 1. */ -base_t table_ninf = 0; +base_number table_ninf = 0; static int lowzero; int high; -state_number_t *yydefgoto; -rule_number_t *yydefact; +state_number *yydefgoto; +rule_number *yydefact; /*----------------------------------------------------------------. | If TABLE (and CHECK) appear to be small to be addressed at | @@ -134,9 +142,9 @@ rule_number_t *yydefact; `----------------------------------------------------------------*/ static void -table_grow (size_t desired) +table_grow (int desired) { - size_t old_size = table_size; + int old_size = table_size; while (table_size <= desired) table_size *= 2; @@ -145,9 +153,9 @@ table_grow (size_t desired) fprintf (stderr, "growing table and check from: %d to %d\n", old_size, table_size); - table = XREALLOC (table, base_t, table_size); - check = XREALLOC (check, base_t, table_size); - conflict_table = XREALLOC (conflict_table, unsigned int, table_size); + REALLOC (table, table_size); + REALLOC (check, table_size); + REALLOC (conflict_table, table_size); for (/* Nothing. */; old_size < table_size; ++old_size) { @@ -160,20 +168,20 @@ table_grow (size_t desired) /*-------------------------------------------------------------------. -| For GLR parsers, for each conflicted token in STATE, as indicated | +| For GLR parsers, for each conflicted token in S, as indicated | | by non-zero entries in CONFLROW, create a list of possible | | reductions that are alternatives to the shift or reduction | -| currently recorded for that token in STATE. Store the alternative | +| currently recorded for that token in S. Store the alternative | | reductions followed by a 0 in CONFLICT_LIST, updating | | CONFLICT_LIST_CNT, and storing an index to the start of the list | | back into CONFLROW. | `-------------------------------------------------------------------*/ static void -conflict_row (state_t *state) +conflict_row (state *s) { int i, j; - reductions_t *reds = state->reductions; + reductions *reds = s->reductions; if (! glr_parser) return; @@ -190,14 +198,16 @@ conflict_row (state_t *state) && (actrow[j] != rule_number_as_item_number (reds->rules[i]->number))) { - assert (conflict_list_free > 0); + if (conflict_list_free <= 0) + abort (); conflict_list[conflict_list_cnt] = reds->rules[i]->number + 1; conflict_list_cnt += 1; conflict_list_free -= 1; } /* Leave a 0 at the end. */ - assert (conflict_list_free > 0); + if (conflict_list_free <= 0) + abort (); conflict_list_cnt += 1; conflict_list_free -= 1; } @@ -210,8 +220,9 @@ conflict_row (state_t *state) | 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. | +| ACTION_NUMBER_MINIMUM, 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 | @@ -223,14 +234,14 @@ conflict_row (state_t *state) | that has any such conflicts. | `------------------------------------------------------------------*/ -static rule_t * -action_row (state_t *state) +static rule * +action_row (state *s) { int i; - rule_t *default_rule = NULL; - reductions_t *redp = state->reductions; - transitions_t *transitions = state->transitions; - errs_t *errp = state->errs; + rule *default_rule = NULL; + reductions *reds = s->reductions; + transitions *trans = s->transitions; + errs *errp = s->errs; /* Set to nonzero to inhibit having any default reduction. */ int nodefault = 0; int conflicted = 0; @@ -238,76 +249,77 @@ action_row (state_t *state) for (i = 0; i < ntokens; i++) actrow[i] = conflrow[i] = 0; - if (redp->lookaheads) + if (reds->lookaheads) { int j; bitset_iterator biter; /* loop over all the rules available here which require lookahead (in reverse order to give precedence to the first rule) */ - for (i = redp->num - 1; i >= 0; --i) + for (i = reds->num - 1; i >= 0; --i) /* and find each token which the rule finds acceptable to come next */ - BITSET_FOR_EACH (biter, redp->lookaheads[i], j, 0) + BITSET_FOR_EACH (biter, reds->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 (redp->rules[i]->number); + actrow[j] = rule_number_as_item_number (reds->rules[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) + FOR_EACH_SHIFT (trans, i) { - symbol_number_t symbol = TRANSITION_SYMBOL (transitions, i); - state_t *shift_state = transitions->states[i]; + symbol_number sym = TRANSITION_SYMBOL (trans, i); + state *shift_state = trans->states[i]; - if (actrow[symbol] != 0) - conflicted = conflrow[symbol] = 1; - actrow[symbol] = state_number_as_int (shift_state->number); + if (actrow[sym] != 0) + conflicted = conflrow[sym] = 1; + actrow[sym] = state_number_as_int (shift_state->number); /* Do not use any default reduction if there is a shift for error */ - if (symbol == errtoken->number) + if (sym == 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. */ + %nonassoc). For them, record ACTION_NUMBER_MINIMUM as the + action. */ for (i = 0; i < errp->num; i++) { - symbol_t *symbol = errp->symbols[i]; - actrow[symbol->number] = ACTION_MIN; + symbol *sym = errp->symbols[i]; + actrow[sym->number] = ACTION_NUMBER_MINIMUM; } /* Now find the most common reduction and make it the default action for this state. */ - if (redp->num >= 1 && !nodefault) + if (reds->num >= 1 && !nodefault) { - if (state->consistent) - default_rule = redp->rules[0]; + if (s->consistent) + default_rule = reds->rules[0]; else { int max = 0; - for (i = 0; i < redp->num; i++) + for (i = 0; i < reds->num; i++) { int count = 0; - rule_t *rule = redp->rules[i]; - symbol_number_t j; + rule *r = reds->rules[i]; + symbol_number j; for (j = 0; j < ntokens; j++) - if (actrow[j] == rule_number_as_item_number (rule->number)) + if (actrow[j] == rule_number_as_item_number (r->number)) count++; if (count > max) { max = count; - default_rule = rule; + default_rule = r; } } @@ -333,31 +345,31 @@ action_row (state_t *state) if (!default_rule) for (i = 0; i < ntokens; i++) - if (actrow[i] == ACTION_MIN) + if (actrow[i] == ACTION_NUMBER_MINIMUM) actrow[i] = 0; if (conflicted) - conflict_row (state); + conflict_row (s); return default_rule; } -/*--------------------------------------------. -| Set FROMS, TOS, TALLY and WIDTH for STATE. | -`--------------------------------------------*/ +/*----------------------------------------. +| Set FROMS, TOS, TALLY and WIDTH for S. | +`----------------------------------------*/ static void -save_row (state_number_t state) +save_row (state_number s) { - symbol_number_t i; + symbol_number i; int count; - base_t *sp = NULL; - base_t *sp1 = NULL; - base_t *sp2 = NULL; - unsigned int *sp3 = NULL; + base_number *sp; + base_number *sp1; + base_number *sp2; + unsigned int *sp3 IF_LINT (= NULL); - /* Number of non default actions in STATE. */ + /* Number of non default actions in S. */ count = 0; for (i = 0; i < ntokens; i++) if (actrow[i] != 0) @@ -367,12 +379,9 @@ save_row (state_number_t state) return; /* Allocate non defaulted actions. */ - froms[state] = sp1 = sp = XCALLOC (base_t, count); - tos[state] = sp2 = XCALLOC (base_t, count); - if (glr_parser) - conflict_tos[state] = sp3 = XCALLOC (unsigned int, count); - else - conflict_tos[state] = NULL; + froms[s] = sp = CALLOC (sp1, count); + tos[s] = CALLOC (sp2, count); + conflict_tos[s] = glr_parser ? CALLOC (sp3, count) : NULL; /* Store non defaulted actions. */ for (i = 0; i < ntokens; i++) @@ -384,8 +393,8 @@ save_row (state_number_t state) *sp3++ = conflrow[i]; } - tally[state] = count; - width[state] = sp1[-1] - sp[0] + 1; + tally[s] = count; + width[s] = sp1[-1] - sp[0] + 1; } @@ -400,18 +409,18 @@ save_row (state_number_t state) static void token_actions (void) { - state_number_t i; - symbol_number_t j; - rule_number_t r; + state_number i; + symbol_number j; + rule_number r; int nconflict = glr_parser ? conflicts_total_count () : 0; - yydefact = XCALLOC (rule_number_t, nstates); + CALLOC (yydefact, nstates); - actrow = XCALLOC (action_t, ntokens); - conflrow = XCALLOC (unsigned int, ntokens); + CALLOC (actrow, ntokens); + CALLOC (conflrow, ntokens); - conflict_list = XCALLOC (unsigned int, 1 + 2 * nconflict); + CALLOC (conflict_list, 1 + 2 * nconflict); conflict_list_free = 2 * nconflict; conflict_list_cnt = 1; @@ -422,7 +431,7 @@ token_actions (void) for (i = 0; i < nstates; ++i) { - rule_t *default_rule = action_row (states[i]); + rule *default_rule = action_row (states[i]); yydefact[i] = default_rule ? default_rule->number + 1 : 0; save_row (i); @@ -432,7 +441,7 @@ token_actions (void) if (!glr_parser) { for (j = 0; j < ntokens; ++j) - if (actrow[j] < 0 && actrow[j] != ACTION_MIN) + if (actrow[j] < 0 && actrow[j] != ACTION_NUMBER_MINIMUM) rules[item_number_as_rule_number (actrow[j])].useful = true; if (yydefact[i]) rules[yydefact[i] - 1].useful = true; @@ -447,24 +456,24 @@ token_actions (void) /*------------------------------------------------------------------. | Compute FROMS[VECTOR], TOS[VECTOR], TALLY[VECTOR], WIDTH[VECTOR], | | i.e., the information related to non defaulted GOTO on the nterm | -| SYMBOL. | +| SYM. | | | -| DEFAULT_STATE is the principal destination on SYMBOL, i.e., the | -| default GOTO destination on SYMBOL. | +| DEFAULT_STATE is the principal destination on SYM, i.e., the | +| default GOTO destination on SYM. | `------------------------------------------------------------------*/ static void -save_column (symbol_number_t symbol, state_number_t default_state) +save_column (symbol_number sym, state_number default_state) { int i; - base_t *sp; - base_t *sp1; - base_t *sp2; + base_number *sp; + base_number *sp1; + base_number *sp2; int count; - vector_number_t symno = symbol_number_to_vector_number (symbol); + vector_number symno = symbol_number_to_vector_number (sym); - goto_number_t begin = goto_map[symbol]; - goto_number_t end = goto_map[symbol + 1]; + goto_number begin = goto_map[sym - ntokens]; + goto_number end = goto_map[sym - ntokens + 1]; /* Number of non default GOTO. */ count = 0; @@ -476,8 +485,8 @@ save_column (symbol_number_t symbol, state_number_t default_state) return; /* Allocate room for non defaulted gotos. */ - froms[symno] = sp1 = sp = XCALLOC (base_t, count); - tos[symno] = sp2 = XCALLOC (base_t, count); + froms[symno] = sp = CALLOC (sp1, count); + tos[symno] = CALLOC (sp2, count); /* Store the state numbers of the non defaulted gotos. */ for (i = begin; i < end; i++) @@ -492,22 +501,22 @@ save_column (symbol_number_t symbol, state_number_t default_state) } -/*----------------------------------------------------------------. -| Return `the' most common destination GOTO on SYMBOL (a nterm). | -`----------------------------------------------------------------*/ +/*-------------------------------------------------------------. +| Return `the' most common destination GOTO on SYM (a nterm). | +`-------------------------------------------------------------*/ -static state_number_t -default_goto (symbol_number_t symbol, short state_count[]) +static state_number +default_goto (symbol_number sym, short state_count[]) { - state_number_t s; + state_number s; int i; - goto_number_t m = goto_map[symbol]; - goto_number_t n = goto_map[symbol + 1]; - state_number_t default_state = (state_number_t) -1; + goto_number m = goto_map[sym - ntokens]; + goto_number n = goto_map[sym - ntokens + 1]; + state_number default_state = -1; int max = 0; if (m == n) - return (state_number_t) -1; + return -1; for (s = 0; s < nstates; s++) state_count[s] = 0; @@ -538,15 +547,15 @@ default_goto (symbol_number_t symbol, short state_count[]) static void goto_actions (void) { - symbol_number_t i; - short *state_count = XCALLOC (short, nstates); - yydefgoto = XMALLOC (state_number_t, nvars); + symbol_number i; + short *state_count = CALLOC (state_count, nstates); + MALLOC (yydefgoto, nvars); /* For a given nterm I, STATE_COUNT[S] is the number of times there is a GOTO to S on I. */ for (i = ntokens; i < nsyms; ++i) { - state_number_t default_state = default_goto (i, state_count); + state_number default_state = default_goto (i, state_count); save_column (i, default_state); yydefgoto[i - ntokens] = default_state; } @@ -595,16 +604,16 @@ sort_actions (void) In any other case, return -1. */ -static state_number_t -matching_state (vector_number_t vector) +static state_number +matching_state (vector_number vector) { - vector_number_t i = order[vector]; + vector_number i = order[vector]; int t; int w; int prev; /* If VECTOR is a nterm, return -1. */ - if (i >= (int) nstates) + if (nstates <= i) return -1; t = tally[i]; @@ -621,7 +630,7 @@ matching_state (vector_number_t vector) for (prev = vector - 1; prev >= 0; prev--) { - vector_number_t j = order[prev]; + vector_number j = order[prev]; int k; int match = 1; @@ -643,28 +652,32 @@ matching_state (vector_number_t vector) } -static base_t -pack_vector (vector_number_t vector) +static base_number +pack_vector (vector_number vector) { - vector_number_t i = order[vector]; + vector_number i = order[vector]; int j; int t = tally[i]; int loc = 0; - base_t *from = froms[i]; - base_t *to = tos[i]; + base_number *from = froms[i]; + base_number *to = tos[i]; unsigned int *conflict_to = conflict_tos[i]; - assert (t); + if (! t) + abort (); - for (j = lowzero - from[0]; j < (int) table_size; j++) + for (j = lowzero - from[0]; ; j++) { int k; int ok = 1; + if (table_size <= j) + abort (); + for (k = 0; ok && k < t; k++) { loc = j + state_number_as_int (from[k]); - if (loc >= (int) table_size) + if (table_size <= loc) table_grow (loc); if (table[loc] != 0) @@ -692,13 +705,11 @@ pack_vector (vector_number_t vector) if (loc > high) high = loc; - assert (BASE_MIN <= j && j <= BASE_MAX); + if (! (BASE_MINIMUM <= j && j <= BASE_MAXIMUM)) + abort (); return j; } } -#define pack_vector_succeeded 0 - assert (pack_vector_succeeded); - return 0; } @@ -710,11 +721,11 @@ pack_vector (vector_number_t vector) | parsers. | `-------------------------------------------------------------*/ -static base_t -table_ninf_remap (base_t tab[], size_t size, base_t ninf) +static base_number +table_ninf_remap (base_number tab[], int size, base_number ninf) { - base_t res = 0; - size_t i; + base_number res = 0; + int i; for (i = 0; i < size; i++) if (tab[i] < res && tab[i] != ninf) @@ -734,40 +745,40 @@ pack_table (void) { int i; - base = XCALLOC (base_t, nvectors); - pos = XCALLOC (base_t, nentries); - table = XCALLOC (base_t, table_size); - conflict_table = XCALLOC (unsigned int, table_size); - check = XCALLOC (base_t, table_size); + CALLOC (base, nvectors); + CALLOC (pos, nentries); + CALLOC (table, table_size); + CALLOC (conflict_table, table_size); + CALLOC (check, table_size); lowzero = 0; high = 0; for (i = 0; i < nvectors; i++) - base[i] = BASE_MIN; + base[i] = BASE_MINIMUM; - for (i = 0; i < (int) table_size; i++) + for (i = 0; i < table_size; i++) check[i] = -1; for (i = 0; i < nentries; i++) { - state_number_t state = matching_state (i); - base_t place; + state_number s = matching_state (i); + base_number place; - if (state < 0) + if (s < 0) /* A new set of state actions, or a nonterminal. */ place = pack_vector (i); else - /* Action of I were already coded for STATE. */ - place = base[state]; + /* Action of I were already coded for S. */ + place = base[s]; pos[i] = place; base[order[i]] = place; } /* Use the greatest possible negative infinites. */ - base_ninf = table_ninf_remap (base, nvectors, BASE_MIN); - table_ninf = table_ninf_remap (table, high + 1, ACTION_MIN); + base_ninf = table_ninf_remap (base, nvectors, BASE_MINIMUM); + table_ninf = table_ninf_remap (table, high + 1, ACTION_NUMBER_MINIMUM); free (pos); } @@ -784,28 +795,29 @@ tables_generate (void) { int i; - /* That's a poor way to make sure the sizes are properly corelated, - in particular the signedness is not taking into account, but it's - not useless. */ - assert (sizeof (nvectors) >= sizeof (nstates)); - assert (sizeof (nvectors) >= sizeof (nvars)); + /* This is a poor way to make sure the sizes are properly + correlated. In particular the signedness is not taken into + account. But it's not useless. */ + verify (sizes_are_properly_correlated, + (sizeof nstates <= sizeof nvectors + && sizeof nvars <= sizeof nvectors)); nvectors = state_number_as_int (nstates) + nvars; - froms = XCALLOC (base_t *, nvectors); - tos = XCALLOC (base_t *, nvectors); - conflict_tos = XCALLOC (unsigned int *, nvectors); - tally = XCALLOC (short, nvectors); - width = XCALLOC (base_t, nvectors); + CALLOC (froms, nvectors); + CALLOC (tos, nvectors); + CALLOC (conflict_tos, nvectors); + CALLOC (tally, nvectors); + CALLOC (width, nvectors); token_actions (); goto_actions (); - free (goto_map + ntokens); + free (goto_map); free (from_state); free (to_state); - order = XCALLOC (vector_number_t, nvectors); + CALLOC (order, nvectors); sort_actions (); pack_table (); free (order);