X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/a737b2163c275761f32589bf7c249016452bb730..041308d0c03783c51ef362f888c957cd2a0e129a:/src/state.c?ds=sidebyside diff --git a/src/state.c b/src/state.c index 730427f3..666e0cc7 100644 --- a/src/state.c +++ b/src/state.c @@ -1,25 +1,23 @@ -/* Type definitions for nondeterministic finite state machine for Bison. +/* Type definitions for the finite state machine for Bison. - Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. + Copyright (C) 2001-2007, 2009-2012 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. - Bison is free software; you can redistribute it and/or modify + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - Bison is distributed in the hope that it will be useful, + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with Bison; see the file COPYING. If not, write to - the Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - + along with this program. If not, see . */ +#include #include "system.h" #include @@ -27,6 +25,7 @@ #include "complain.h" #include "gram.h" #include "state.h" +#include "print-xml.h" /*-------------------. @@ -58,10 +57,12 @@ state * transitions_to (transitions *shifts, symbol_number sym) { int j; - for (j = 0; j < shifts->num; j++) - if (TRANSITION_SYMBOL (shifts, j) == sym) - return shifts->states[j]; - abort (); + for (j = 0; ; j++) + { + aver (j < shifts->num); + if (TRANSITION_SYMBOL (shifts, j) == sym) + return shifts->states[j]; + } } @@ -102,7 +103,7 @@ reductions_new (int num, rule **reds) size_t rules_size = num * sizeof *reds; reductions *res = xmalloc (offsetof (reductions, rules) + rules_size); res->num = num; - res->lookaheads = NULL; + res->lookahead_tokens = NULL; memcpy (res->rules, reds, rules_size); return res; } @@ -132,8 +133,7 @@ state_new (symbol_number accessing_symbol, state *res; size_t items_size = nitems * sizeof *core; - if (STATE_NUMBER_MAXIMUM <= nstates) - abort (); + aver (nstates < STATE_NUMBER_MAXIMUM); res = xmalloc (offsetof (state, items) + items_size); res->number = nstates++; @@ -141,8 +141,10 @@ state_new (symbol_number accessing_symbol, res->transitions = NULL; res->reductions = NULL; res->errs = NULL; + res->state_list = NULL; res->consistent = 0; res->solved_conflicts = NULL; + res->solved_conflicts_xml = NULL; res->nitems = nitems; memcpy (res->items, core, items_size); @@ -152,6 +154,32 @@ state_new (symbol_number accessing_symbol, return res; } +state * +state_new_isocore (state const *s) +{ + state *res; + size_t items_size = s->nitems * sizeof *s->items; + + aver (nstates < STATE_NUMBER_MAXIMUM); + + res = xmalloc (offsetof (state, items) + items_size); + res->number = nstates++; + res->accessing_symbol = s->accessing_symbol; + res->transitions = + transitions_new (s->transitions->num, s->transitions->states); + res->reductions = reductions_new (s->reductions->num, s->reductions->rules); + res->errs = NULL; + res->state_list = NULL; + res->consistent = s->consistent; + res->solved_conflicts = NULL; + res->solved_conflicts_xml = NULL; + + res->nitems = s->nitems; + memcpy (res->items, s->items, items_size); + + return res; +} + /*---------. | Free S. | @@ -174,8 +202,7 @@ state_free (state *s) void state_transitions_set (state *s, int num, state **trans) { - if (s->transitions) - abort (); + aver (!s->transitions); s->transitions = transitions_new (num, trans); } @@ -187,8 +214,7 @@ state_transitions_set (state *s, int num, state **trans) void state_reductions_set (state *s, int num, rule **reds) { - if (s->reductions) - abort (); + aver (!s->reductions); s->reductions = reductions_new (num, reds); } @@ -212,44 +238,67 @@ state_reduction_find (state *s, rule *r) void state_errs_set (state *s, int num, symbol **tokens) { - if (s->errs) - abort (); + aver (!s->errs); s->errs = errs_new (num, tokens); } -/*-----------------------------------------------------. -| Print on OUT all the lookaheads such that S wants to | -| reduce R. | -`-----------------------------------------------------*/ +/*--------------------------------------------------. +| Print on OUT all the lookahead tokens such that S | +| wants to reduce R. | +`--------------------------------------------------*/ void -state_rule_lookaheads_print (state *s, rule *r, FILE *out) +state_rule_lookahead_tokens_print (state *s, rule *r, FILE *out) { /* Find the reduction we are handling. */ reductions *reds = s->reductions; int red = state_reduction_find (s, r); /* Print them if there are. */ - if (reds->lookaheads && red != -1) + if (reds->lookahead_tokens && red != -1) { bitset_iterator biter; int k; - int not_first = 0; + char const *sep = ""; fprintf (out, " ["); - BITSET_FOR_EACH (biter, reds->lookaheads[red], k, 0) - fprintf (out, "%s%s", - not_first++ ? ", " : "", - symbols[k]->tag); + BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0) + { + fprintf (out, "%s%s", sep, symbols[k]->tag); + sep = ", "; + } fprintf (out, "]"); } } +void +state_rule_lookahead_tokens_print_xml (state *s, rule *r, + FILE *out, int level) +{ + /* Find the reduction we are handling. */ + reductions *reds = s->reductions; + int red = state_reduction_find (s, r); + + /* Print them if there are. */ + if (reds->lookahead_tokens && red != -1) + { + bitset_iterator biter; + int k; + xml_puts (out, level, ""); + BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0) + { + xml_printf (out, level + 1, "%s", + xml_escape (symbols[k]->tag)); + } + xml_puts (out, level, ""); + } +} + -/*----------------------. +/*---------------------. | A state hash table. | -`----------------------*/ +`---------------------*/ /* Initial capacity of states hash table. */ #define HT_INITIAL_CAPACITY 257 @@ -260,7 +309,7 @@ static struct hash_table *state_table = NULL; static inline bool state_compare (state const *s1, state const *s2) { - int i; + size_t i; if (s1->nitems != s2->nitems) return false; @@ -278,19 +327,19 @@ state_comparator (void const *s1, void const *s2) return state_compare (s1, s2); } -static inline unsigned int -state_hash (state const *s, unsigned int tablesize) +static inline size_t +state_hash (state const *s, size_t tablesize) { /* Add up the state's item numbers to get a hash key. */ - unsigned int key = 0; - int i; + size_t key = 0; + size_t i; for (i = 0; i < s->nitems; ++i) key += s->items[i]; return key % tablesize; } -static unsigned int -state_hasher (void const *s, unsigned int tablesize) +static size_t +state_hasher (void const *s, size_t tablesize) { return state_hash (s, tablesize); } @@ -329,7 +378,8 @@ state_hash_free (void) void state_hash_insert (state *s) { - hash_insert (state_table, s); + if (!hash_insert (state_table, s)) + xalloc_die (); } @@ -352,6 +402,52 @@ state_hash_lookup (size_t nitems, item_number *core) return entry; } + +/*--------------------------------------------------------. +| Record S and all states reachable from S in REACHABLE. | +`--------------------------------------------------------*/ + +static void +state_record_reachable_states (state *s, bitset reachable) +{ + if (bitset_test (reachable, s->number)) + return; + bitset_set (reachable, s->number); + { + int i; + for (i = 0; i < s->transitions->num; ++i) + if (!TRANSITION_IS_DISABLED (s->transitions, i)) + state_record_reachable_states (s->transitions->states[i], reachable); + } +} + +void +state_remove_unreachable_states (state_number old_to_new[]) +{ + state_number nstates_reachable = 0; + bitset reachable = bitset_create (nstates, BITSET_FIXED); + state_record_reachable_states (states[0], reachable); + { + state_number i; + for (i = 0; i < nstates; ++i) + { + if (bitset_test (reachable, states[i]->number)) + { + states[nstates_reachable] = states[i]; + states[nstates_reachable]->number = nstates_reachable; + old_to_new[i] = nstates_reachable++; + } + else + { + state_free (states[i]); + old_to_new[i] = nstates; + } + } + } + nstates = nstates_reachable; + bitset_free (reachable); +} + /* All the decorated states, indexed by the state number. */ state **states = NULL;