src/state.c

   1 /* Type definitions for nondeterministic finite state machine for Bison.
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Free Software
   4    Foundation, Inc.
   5
   6    This file is part of Bison, the GNU Compiler Compiler.
   7
   8    Bison is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    Bison is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Bison; see the file COPYING.  If not, write to
  20    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include <config.h>
  24 #include "system.h"
  25
  26 #include <hash.h>
  27
  28 #include "complain.h"
  29 #include "gram.h"
  30 #include "state.h"
  31
  32
  33                         /*-------------------.
  34                         | Shifts and Gotos.  |
  35                         `-------------------*/
  36
  37
  38 /*-----------------------------------------.
  39 | Create a new array of NUM shifts/gotos.  |
  40 `-----------------------------------------*/
  41
  42 static transitions *
  43 transitions_new (int num, state **the_states)
  44 {
  45   size_t states_size = num * sizeof *the_states;
  46   transitions *res = xmalloc (offsetof (transitions, states) + states_size);
  47   res->num = num;
  48   memcpy (res->states, the_states, states_size);
  49   return res;
  50 }
  51
  52
  53 /*-------------------------------------------------------.
  54 | Return the state such that SHIFTS contain a shift/goto |
  55 | to it on SYM.  Abort if none found.                    |
  56 `-------------------------------------------------------*/
  57
  58 state *
  59 transitions_to (transitions *shifts, symbol_number sym)
  60 {
  61   int j;
  62   for (j = 0; ; j++)
  63     {
  64       aver (j < shifts->num);
  65       if (TRANSITION_SYMBOL (shifts, j) == sym)
  66         return shifts->states[j];
  67     }
  68 }
  69
  70
  71                         /*--------------------.
  72                         | Error transitions.  |
  73                         `--------------------*/
  74
  75
  76 /*---------------------------------.
  77 | Create a new array of NUM errs.  |
  78 `---------------------------------*/
  79
  80 errs *
  81 errs_new (int num, symbol **tokens)
  82 {
  83   size_t symbols_size = num * sizeof *tokens;
  84   errs *res = xmalloc (offsetof (errs, symbols) + symbols_size);
  85   res->num = num;
  86   memcpy (res->symbols, tokens, symbols_size);
  87   return res;
  88 }
  89
  90
  91
  92
  93                         /*-------------.
  94                         | Reductions.  |
  95                         `-------------*/
  96
  97
  98 /*---------------------------------------.
  99 | Create a new array of NUM reductions.  |
 100 `---------------------------------------*/
 101
 102 static reductions *
 103 reductions_new (int num, rule **reds)
 104 {
 105   size_t rules_size = num * sizeof *reds;
 106   reductions *res = xmalloc (offsetof (reductions, rules) + rules_size);
 107   res->num = num;
 108   res->lookahead_tokens = NULL;
 109   memcpy (res->rules, reds, rules_size);
 110   return res;
 111 }
 112
 113
 114
 115                         /*---------.
 116                         | States.  |
 117                         `---------*/
 118
 119
 120 state_number nstates = 0;
 121 /* FINAL_STATE is properly set by new_state when it recognizes its
 122    accessing symbol: $end.  */
 123 state *final_state = NULL;
 124
 125
 126 /*------------------------------------------------------------------.
 127 | Create a new state with ACCESSING_SYMBOL, for those items.  Store |
 128 | it in the state hash table.                                       |
 129 `------------------------------------------------------------------*/
 130
 131 state *
 132 state_new (symbol_number accessing_symbol,
 133            size_t nitems, item_number *core)
 134 {
 135   state *res;
 136   size_t items_size = nitems * sizeof *core;
 137
 138   aver (nstates < STATE_NUMBER_MAXIMUM);
 139
 140   res = xmalloc (offsetof (state, items) + items_size);
 141   res->number = nstates++;
 142   res->accessing_symbol = accessing_symbol;
 143   res->transitions = NULL;
 144   res->reductions = NULL;
 145   res->errs = NULL;
 146   res->consistent = 0;
 147   res->solved_conflicts = NULL;
 148   res->reachable = false;
 149
 150   res->nitems = nitems;
 151   memcpy (res->items, core, items_size);
 152
 153   state_hash_insert (res);
 154
 155   return res;
 156 }
 157
 158
 159 /*---------.
 160 | Free S.  |
 161 `---------*/
 162
 163 static void
 164 state_free (state *s)
 165 {
 166   free (s->transitions);
 167   free (s->reductions);
 168   free (s->errs);
 169   free (s);
 170 }
 171
 172
 173 /*---------------------------.
 174 | Set the transitions of S.  |
 175 `---------------------------*/
 176
 177 void
 178 state_transitions_set (state *s, int num, state **trans)
 179 {
 180   aver (!s->transitions);
 181   s->transitions = transitions_new (num, trans);
 182 }
 183
 184
 185 /*--------------------------.
 186 | Set the reductions of S.  |
 187 `--------------------------*/
 188
 189 void
 190 state_reductions_set (state *s, int num, rule **reds)
 191 {
 192   aver (!s->reductions);
 193   s->reductions = reductions_new (num, reds);
 194 }
 195
 196
 197 int
 198 state_reduction_find (state *s, rule *r)
 199 {
 200   int i;
 201   reductions *reds = s->reductions;
 202   for (i = 0; i < reds->num; ++i)
 203     if (reds->rules[i] == r)
 204       return i;
 205   return -1;
 206 }
 207
 208
 209 /*--------------------.
 210 | Set the errs of S.  |
 211 `--------------------*/
 212
 213 void
 214 state_errs_set (state *s, int num, symbol **tokens)
 215 {
 216   aver (!s->errs);
 217   s->errs = errs_new (num, tokens);
 218 }
 219
 220
 221
 222 /*--------------------------------------------------.
 223 | Print on OUT all the lookahead tokens such that S |
 224 | wants to reduce R.                                |
 225 `--------------------------------------------------*/
 226
 227 void
 228 state_rule_lookahead_tokens_print (state *s, rule *r, FILE *out)
 229 {
 230   /* Find the reduction we are handling.  */
 231   reductions *reds = s->reductions;
 232   int red = state_reduction_find (s, r);
 233
 234   /* Print them if there are.  */
 235   if (reds->lookahead_tokens && red != -1)
 236     {
 237       bitset_iterator biter;
 238       int k;
 239       char const *sep = "";
 240       fprintf (out, "  [");
 241       BITSET_FOR_EACH (biter, reds->lookahead_tokens[red], k, 0)
 242         {
 243           fprintf (out, "%s%s", sep, symbols[k]->tag);
 244           sep = ", ";
 245         }
 246       fprintf (out, "]");
 247     }
 248 }
 249
 250
 251 /*---------------------.
 252 | A state hash table.  |
 253 `---------------------*/
 254
 255 /* Initial capacity of states hash table.  */
 256 #define HT_INITIAL_CAPACITY 257
 257
 258 static struct hash_table *state_table = NULL;
 259
 260 /* Two states are equal if they have the same core items.  */
 261 static inline bool
 262 state_compare (state const *s1, state const *s2)
 263 {
 264   size_t i;
 265
 266   if (s1->nitems != s2->nitems)
 267     return false;
 268
 269   for (i = 0; i < s1->nitems; ++i)
 270     if (s1->items[i] != s2->items[i])
 271       return false;
 272
 273   return true;
 274 }
 275
 276 static bool
 277 state_comparator (void const *s1, void const *s2)
 278 {
 279   return state_compare (s1, s2);
 280 }
 281
 282 static inline size_t
 283 state_hash (state const *s, size_t tablesize)
 284 {
 285   /* Add up the state's item numbers to get a hash key.  */
 286   size_t key = 0;
 287   size_t i;
 288   for (i = 0; i < s->nitems; ++i)
 289     key += s->items[i];
 290   return key % tablesize;
 291 }
 292
 293 static size_t
 294 state_hasher (void const *s, size_t tablesize)
 295 {
 296   return state_hash (s, tablesize);
 297 }
 298
 299
 300 /*-------------------------------.
 301 | Create the states hash table.  |
 302 `-------------------------------*/
 303
 304 void
 305 state_hash_new (void)
 306 {
 307   state_table = hash_initialize (HT_INITIAL_CAPACITY,
 308                                  NULL,
 309                                  state_hasher,
 310                                  state_comparator,
 311                                  NULL);
 312 }
 313
 314
 315 /*---------------------------------------------.
 316 | Free the states hash table, not the states.  |
 317 `---------------------------------------------*/
 318
 319 void
 320 state_hash_free (void)
 321 {
 322   hash_free (state_table);
 323 }
 324
 325
 326 /*-----------------------------------.
 327 | Insert S in the state hash table.  |
 328 `-----------------------------------*/
 329
 330 void
 331 state_hash_insert (state *s)
 332 {
 333   hash_insert (state_table, s);
 334 }
 335
 336
 337 /*------------------------------------------------------------------.
 338 | Find the state associated to the CORE, and return it.  If it does |
 339 | not exist yet, return NULL.                                       |
 340 `------------------------------------------------------------------*/
 341
 342 state *
 343 state_hash_lookup (size_t nitems, item_number *core)
 344 {
 345   size_t items_size = nitems * sizeof *core;
 346   state *probe = xmalloc (offsetof (state, items) + items_size);
 347   state *entry;
 348
 349   probe->nitems = nitems;
 350   memcpy (probe->items, core, items_size);
 351   entry = hash_lookup (state_table, probe);
 352   free (probe);
 353   return entry;
 354 }
 355
 356
 357 /*------------------------------------------------------.
 358 | Mark S and all states reachable from S as reachable.  |
 359 `------------------------------------------------------*/
 360
 361 static void
 362 state_mark_reachable_states (state *s)
 363 {
 364   if (s->reachable)
 365     return;
 366   s->reachable = true;
 367   for (int i = 0; i < s->transitions->num; ++i)
 368     if (!TRANSITION_IS_DISABLED (s->transitions, i))
 369       state_mark_reachable_states (s->transitions->states[i]);
 370 }
 371
 372 void
 373 state_remove_unreachable_states (state_number old_to_new[])
 374 {
 375   state_number nstates_reachable = 0;
 376   state_mark_reachable_states (states[0]);
 377   for (state_number i = 0; i < nstates; ++i)
 378     {
 379       if (states[i]->reachable)
 380         {
 381           states[nstates_reachable] = states[i];
 382           states[nstates_reachable]->number = nstates_reachable;
 383           old_to_new[i] = nstates_reachable++;
 384         }
 385       else
 386         {
 387           state_free (states[i]);
 388           old_to_new[i] = nstates;
 389         }
 390     }
 391   nstates = nstates_reachable;
 392 }
 393
 394 /* All the decorated states, indexed by the state number.  */
 395 state **states = NULL;
 396
 397
 398 /*----------------------.
 399 | Free all the states.  |
 400 `----------------------*/
 401
 402 void
 403 states_free (void)
 404 {
 405   state_number i;
 406   for (i = 0; i < nstates; ++i)
 407     state_free (states[i]);
 408   free (states);
 409 }