Renaming file to glr.c.

[bison.git] / src / state.h

diff --git a/src/state.h b/src/state.h
index 14017afedec657d3f4b67b1c6bfc713c226d39c4..1877ec48bfeef941dd3d6f12bc8f2639cf8280a5 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -30,21 +30,21 @@
    state.  These symbols at these items are the allowable inputs that
    can follow now.
 
-   A core represents one state.  States are numbered in the number
+   A core represents one state.  States are numbered in the NUMBER
    field.  When generate_states is finished, the starting state is
-   state 0 and nstates is the number of states.  (A transition to a
-   state whose state number is nstates indicates termination.)  All
-   the cores are chained together and first_state points to the first
-   one (state 0).
+   state 0 and NSTATES is the number of states.  (FIXME: This sentence
+   is no longer true: A transition to a state whose state number is
+   NSTATES indicates termination.)  All the cores are chained together
+   and FIRST_STATE points to the first one (state 0).
 
    For each state there is a particular symbol which must have been
    the last thing accepted to reach that state.  It is the
-   accessing_symbol of the core.
+   ACCESSING_SYMBOL of the core.
 
-   Each core contains a vector of nitems items which are the indices
-   in the ritems vector of the items that are selected in this state.
+   Each core contains a vector of NITEMS items which are the indices
+   in the RITEMS vector of the items that are selected in this state.
 
-   The link field is used for chaining buckets that hash states by
+   The link field is used for chaining symbols that hash states by
    their itemsets.  This is for recognizing equivalent states and
    combining them when the states are generated.
 
@@ -88,6 +88,7 @@
 #ifndef STATE_H_
 # define STATE_H_
 
+# include "bitsetv.h"
 
 /*---------.
 | Shifts.  |
@@ -107,7 +108,7 @@ shifts *shifts_new PARAMS ((int n));
    case of gotos.  */
 
 #define SHIFT_SYMBOL(Shifts, Shift) \
-  (state_table[Shifts->shifts[Shift]]->accessing_symbol)
+  (states[Shifts->shifts[Shift]]->accessing_symbol)
 
 /* Is the SHIFTS->shifts[Shift] a real shift? (as opposed to gotos.) */
 
@@ -122,7 +123,7 @@ shifts *shifts_new PARAMS ((int n));
 /* Is the SHIFTS->shifts[Shift] then handling of the error token?. */
 
 #define SHIFT_IS_ERROR(Shifts, Shift) \
-  (SHIFT_SYMBOL (Shifts, Shift) == error_token_number)
+  (SHIFT_SYMBOL (Shifts, Shift) == errtoken->number)
 
 /* When resolving a SR conflicts, if the reduction wins, the shift is
    disabled.  */
@@ -158,10 +159,7 @@ typedef struct reductions
   short rules[1];
 } reductions;
 
-#define REDUCTIONS_ALLOC(Nreductions)                                  \
-  (reductions *) xcalloc ((unsigned) (sizeof (reductions)              \
-                                  + (Nreductions - 1) * sizeof (short)), 1)
-
+reductions *reductions_new PARAMS ((int n));
 
 
 /*----------.
@@ -174,7 +172,7 @@ typedef struct state_s
   struct state_s *link;
 
   short number;
-  short accessing_symbol;
+  symbol_number_t accessing_symbol;
   shifts     *shifts;
   reductions *reductions;
   errs       *errs;
@@ -183,17 +181,28 @@ typedef struct state_s
   char consistent;
 
   /* Used in LALR, not LR(0). */
-  /* Pseudo pointer into LA. */
-  short lookaheadsp;
   int nlookaheads;
+  bitsetv lookaheads;
+  rule_t **lookaheads_rule;
+
+  /* If some conflicts were solved thanks to precedence/associativity,
+     a human readable description of the resolution.  */
+  const char *solved_conflicts;
 
-  /* Its items. */
-  short nitems;
-  short items[1];
+  /* Its items.  Must be last, since ITEMS can be arbitrarily large.
+     */
+  unsigned short nitems;
+  item_number_t items[1];
 } state_t;
 
 #define STATE_ALLOC(Nitems)                                            \
   (state_t *) xcalloc ((unsigned) (sizeof (state_t)                    \
-                                  + (Nitems - 1) * sizeof (short)), 1)
+                                  + (Nitems - 1) * sizeof (item_number_t)), 1)
+
+/* Print on OUT all the lookaheads such that this STATE wants to
+   reduce this RULE.  */
+
+void state_rule_lookaheads_print PARAMS ((state_t *state, rule_t *rule,
+                                         FILE *out));
 
 #endif /* !STATE_H_ */