Propagate more token_number_t.

[bison.git] / src / LR0.c

diff --git a/src/LR0.c b/src/LR0.c
index 2b78dd03c76c53a6242862283d7e10294614a1a9..a2a0788107cdb1a3a5f34602f2da92d5047c96e5 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -1,5 +1,5 @@
 /* Generate the nondeterministic finite state machine for bison,
 /* Generate the nondeterministic finite state machine for bison,

-   Copyright 1984, 1986, 1989, 2000, 2001  Free Software Foundation, Inc.
+   Copyright 1984, 1986, 1989, 2000, 2001, 2002  Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -23,7 +23,10 @@
    The entry point is generate_states.  */
 
 #include "system.h"
    The entry point is generate_states.  */
 
 #include "system.h"

+#include "bitset.h"
+#include "quotearg.h"

 #include "symtab.h"
 #include "symtab.h"

+#include "gram.h"

 #include "getargs.h"
 #include "reader.h"
 #include "gram.h"
 #include "getargs.h"
 #include "reader.h"
 #include "gram.h"


@@ -34,7 +37,7 @@
 #include "lalr.h"
 #include "reduce.h"
 
 #include "lalr.h"
 #include "reduce.h"
 

-int nstates;
+unsigned int nstates = 0;

 /* Initialize the final state to -1, otherwise, it might be set to 0
    by default, and since we don't compute the reductions of the final
    state, we end up not computing the reductions of the initial state,
 /* Initialize the final state to -1, otherwise, it might be set to 0
    by default, and since we don't compute the reductions of the final
    state, we end up not computing the reductions of the initial state,


@@ -49,14 +52,14 @@ static state_t *this_state = NULL;
 static state_t *last_state = NULL;
 
 static int nshifts;
 static state_t *last_state = NULL;
 
 static int nshifts;

-static short *shift_symbol = NULL;
+static token_number_t *shift_symbol = NULL;

 
 static short *redset = NULL;
 static short *shiftset = NULL;
 
 
 static short *redset = NULL;
 static short *shiftset = NULL;
 

-static short **kernel_base = NULL;
+static item_number_t **kernel_base = NULL;

 static int *kernel_size = NULL;
 static int *kernel_size = NULL;

-static short *kernel_items = NULL;
+static item_number_t *kernel_items = NULL;

 
 /* hash table for states, to recognize equivalent ones.  */
 
 
 /* hash table for states, to recognize equivalent ones.  */
 


@@ -67,7 +70,8 @@ static state_t **state_hash = NULL;
 static void
 allocate_itemsets (void)
 {
 static void
 allocate_itemsets (void)
 {

-  int i;
+  int i, r;
+  item_number_t *rhsp;

 
   /* Count the number of occurrences of all the symbols in RITEMS.
      Note that useless productions (hence useless nonterminals) are
 
   /* Count the number of occurrences of all the symbols in RITEMS.
      Note that useless productions (hence useless nonterminals) are


@@ -76,11 +80,11 @@ allocate_itemsets (void)
   int count = 0;
   short *symbol_count = XCALLOC (short, nsyms + nuseless_nonterminals);
 
   int count = 0;
   short *symbol_count = XCALLOC (short, nsyms + nuseless_nonterminals);
 

-  for (i = 0; i < nritems; ++i)
-    if (ritem[i] >= 0)
+  for (r = 1; r < nrules + 1; ++r)
+    for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)

       {
        count++;
       {
        count++;

-       symbol_count[ritem[i]]++;
+       symbol_count[*rhsp]++;

       }
 
   /* See comments before new_itemsets.  All the vectors of items
       }
 
   /* See comments before new_itemsets.  All the vectors of items


@@ -89,9 +93,9 @@ allocate_itemsets (void)
      appears as an item, which is symbol_count[symbol].
      We allocate that much space for each symbol.  */
 
      appears as an item, which is symbol_count[symbol].
      We allocate that much space for each symbol.  */
 

-  kernel_base = XCALLOC (short *, nsyms);
+  kernel_base = XCALLOC (item_number_t *, nsyms);

   if (count)
   if (count)

-    kernel_items = XCALLOC (short, count);
+    kernel_items = XCALLOC (item_number_t, count);

 
   count = 0;
   for (i = 0; i < nsyms; i++)
 
   count = 0;
   for (i = 0; i < nsyms; i++)


@@ -113,6 +117,7 @@ allocate_storage (void)
   shiftset = XCALLOC (short, nsyms);
   redset = XCALLOC (short, nrules + 1);
   state_hash = XCALLOC (state_t *, STATE_HASH_SIZE);
   shiftset = XCALLOC (short, nsyms);
   redset = XCALLOC (short, nrules + 1);
   state_hash = XCALLOC (state_t *, STATE_HASH_SIZE);

+  shift_symbol = XCALLOC (token_number_t, nsyms);

 }
 
 
 }
 
 


@@ -154,24 +159,22 @@ new_itemsets (void)
   for (i = 0; i < nsyms; i++)
     kernel_size[i] = 0;
 
   for (i = 0; i < nsyms; i++)
     kernel_size[i] = 0;
 

-  shift_symbol = XCALLOC (short, nsyms);

   nshifts = 0;
 
   nshifts = 0;
 

-  for (i = 0; i < nitemset; ++i)
-    {
-      int symbol = ritem[itemset[i]];
-      if (symbol >= 0)
-       {
-         if (!kernel_size[symbol])
-           {
-             shift_symbol[nshifts] = symbol;
-             nshifts++;
-           }
-
-         kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1;
-         kernel_size[symbol]++;
-       }
-    }
+  for (i = 0; i < nritemset; ++i)
+    if (ritem[itemset[i]] >= 0)
+      {
+       token_number_t symbol
+         = item_number_as_token_number (ritem[itemset[i]]);
+       if (!kernel_size[symbol])
+         {
+           shift_symbol[nshifts] = symbol;
+           nshifts++;
+         }
+
+       kernel_base[symbol][kernel_size[symbol]] = itemset[i] + 1;
+       kernel_size[symbol]++;
+      }

 }
 
 
 }
 
 


@@ -182,31 +185,38 @@ new_itemsets (void)
 `-----------------------------------------------------------------*/
 
 static state_t *
 `-----------------------------------------------------------------*/
 
 static state_t *

-new_state (int symbol)
+new_state (token_number_t symbol)

 {
   state_t *p;
 
   if (trace_flag)
     fprintf (stderr, "Entering new_state, state = %d, symbol = %d (%s)\n",
 {
   state_t *p;
 
   if (trace_flag)
     fprintf (stderr, "Entering new_state, state = %d, symbol = %d (%s)\n",

-            this_state->number, symbol, symbols[symbol]->tag);
+            nstates, symbol, quotearg_style (escape_quoting_style,
+                                             symbols[symbol]->tag));

 
 

-  if (nstates >= MAXSHORT)
-    fatal (_("too many states (max %d)"), MAXSHORT);
+  if (nstates >= SHRT_MAX)
+    fatal (_("too many states (max %d)"), SHRT_MAX);

 
   p = STATE_ALLOC (kernel_size[symbol]);
   p->accessing_symbol = symbol;
   p->number = nstates;
   p->nitems = kernel_size[symbol];
 
 
   p = STATE_ALLOC (kernel_size[symbol]);
   p->accessing_symbol = symbol;
   p->number = nstates;
   p->nitems = kernel_size[symbol];
 

-  shortcpy (p->items, kernel_base[symbol], kernel_size[symbol]);
+  memcpy (p->items, kernel_base[symbol],
+         kernel_size[symbol] * sizeof (kernel_base[symbol][0]));
+
+  /* If this is the eoftoken, and this is not the initial state, then
+     this is the final state.  */
+  if (symbol == 0 && first_state)
+    final_state = p->number;

 
 

-  last_state->next = p;
+  if (!first_state)
+    first_state = p;
+  if (last_state)
+    last_state->next = p;

   last_state = p;
   last_state = p;

-  nstates++;

 
 

-  /* If this is the eoftoken, then this is the final state. */
-  if (symbol == 0)
-    final_state = p->number;
+  nstates++;

 
   return p;
 }
 
   return p;
 }


@@ -219,7 +229,7 @@ new_state (int symbol)
 `--------------------------------------------------------------*/
 
 static int
 `--------------------------------------------------------------*/
 
 static int

-get_state (int symbol)
+get_state (token_number_t symbol)

 {
   int key;
   int i;
 {
   int key;
   int i;


@@ -227,7 +237,8 @@ get_state (int symbol)
 
   if (trace_flag)
     fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",
 
   if (trace_flag)
     fprintf (stderr, "Entering get_state, state = %d, symbol = %d (%s)\n",

-            this_state->number, symbol, symbols[symbol]->tag);
+            this_state->number, symbol, quotearg_style (escape_quoting_style,
+                                             symbols[symbol]->tag));

 
   /* Add up the target state's active item numbers to get a hash key.
      */
 
   /* Add up the target state's active item numbers to get a hash key.
      */


@@ -287,7 +298,7 @@ append_states (void)
 {
   int i;
   int j;
 {
   int i;
   int j;

-  int symbol;
+  token_number_t symbol;

 
   if (trace_flag)
     fprintf (stderr, "Entering append_states, state = %d\n",
 
   if (trace_flag)
     fprintf (stderr, "Entering append_states, state = %d\n",


@@ -315,8 +326,10 @@ append_states (void)
 static void
 new_states (void)
 {
 static void
 new_states (void)
 {

-  first_state = last_state = this_state = STATE_ALLOC (0);
-  nstates = 1;
+  /* The 0 at the lhs is the index of the item of this initial rule.  */
+  kernel_base[0][0] = 0;
+  kernel_size[0] = 1;
+  this_state = new_state (0);

 }
 
 
 }
 
 


@@ -328,7 +341,7 @@ static void
 save_shifts (void)
 {
   shifts *p = shifts_new (nshifts);
 save_shifts (void)
 {
   shifts *p = shifts_new (nshifts);

-  shortcpy (p->shifts, shiftset, nshifts);
+  memcpy (p->shifts, shiftset, nshifts * sizeof (shiftset[0]));

   this_state->shifts = p;
 }
 
   this_state->shifts = p;
 }
 


@@ -351,7 +364,7 @@ save_reductions (void)
     return;
 
   /* Find and count the active items that represent ends of rules. */
     return;
 
   /* Find and count the active items that represent ends of rules. */

-  for (i = 0; i < nitemset; ++i)
+  for (i = 0; i < nritemset; ++i)

     {
       int item = ritem[itemset[i]];
       if (item < 0)
     {
       int item = ritem[itemset[i]];
       if (item < 0)


@@ -360,19 +373,19 @@ save_reductions (void)
 
   /* Make a reductions structure and copy the data into it.  */
   this_state->reductions = reductions_new (count);
 
   /* Make a reductions structure and copy the data into it.  */
   this_state->reductions = reductions_new (count);

-  shortcpy (this_state->reductions->rules, redset, count);
+  memcpy (this_state->reductions->rules, redset, count * sizeof (redset[0]));

 }
 
 \f
 }
 
 \f

-/*--------------------.
-| Build STATE_TABLE.  |
-`--------------------*/
+/*---------------.
+| Build STATES.  |
+`---------------*/

 
 static void
 
 static void

-set_state_table (void)
+set_states (void)

 {
   state_t *sp;
 {
   state_t *sp;

-  state_table = XCALLOC (state_t *, nstates);
+  states = XCALLOC (state_t *, nstates);

 
   for (sp = first_state; sp; sp = sp->next)
     {
 
   for (sp = first_state; sp; sp = sp->next)
     {


@@ -386,7 +399,7 @@ set_state_table (void)
       if (!sp->reductions)
        sp->reductions = reductions_new (0);
 
       if (!sp->reductions)
        sp->reductions = reductions_new (0);
 

-      state_table[sp->number] = sp;
+      states[sp->number] = sp;

     }
 }
 
     }
 }
 


@@ -407,7 +420,8 @@ generate_states (void)
       if (trace_flag)
        fprintf (stderr, "Processing state %d (reached by %s)\n",
                 this_state->number,
       if (trace_flag)
        fprintf (stderr, "Processing state %d (reached by %s)\n",
                 this_state->number,

-                symbols[this_state->accessing_symbol]->tag);
+                quotearg_style (escape_quoting_style,
+                                symbols[this_state->accessing_symbol]->tag));

       /* Set up ruleset and itemset for the transitions out of this
          state.  ruleset gets a 1 bit for each rule that could reduce
          now.  itemset gets a vector of all the items that could be
       /* Set up ruleset and itemset for the transitions out of this
          state.  ruleset gets a 1 bit for each rule that could reduce
          now.  itemset gets a vector of all the items that could be


@@ -432,6 +446,6 @@ generate_states (void)
   free_closure ();
   free_storage ();
 
   free_closure ();
   free_storage ();
 

-  /* Set up STATE_TABLE. */
-  set_state_table ();
+  /* Set up STATES. */
+  set_states ();

 }
 }