2007-01-30 Paolo Bonzini <bonzini@gnu.org>

[bison.git] / src / state.h

diff --git a/src/state.h b/src/state.h
index 32559cef4ba2441ff19aff2965493e03731876a4..a2ae217fa460d0a731f80d7fbcbd9d2525a8127d 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -1,5 +1,7 @@
-/* Type definitions for nondeterministic finite state machine for bison,
-   Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc.
+/* Type definitions for nondeterministic finite state machine for Bison.
+
+   Copyright (C) 1984, 1989, 2000, 2001, 2002, 2003, 2004 Free
+   Software Foundation, Inc.

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


@@ -15,8 +17,8 @@
 
    You should have received a copy of the GNU General Public License
    along with Bison; see the file COPYING.  If not, write to
 
    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.  */
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */

 
 
 /* These type definitions are used to represent a nondeterministic
 
 
 /* These type definitions are used to represent a nondeterministic


@@ -51,7 +53,7 @@
    lookahead token alone).  When the states are generated, these
    actions are represented in two other lists.
 
    lookahead token alone).  When the states are generated, these
    actions are represented in two other lists.
 

-   Each transition_t structure describes the possible transitions out
+   Each transition structure describes the possible transitions out

    of one state, the state whose number is in the number field.  Each
    contains a vector of numbers of the states that transitions can go
    to.  The accessing_symbol fields of those states' cores say what
    of one state, the state whose number is in the number field.  Each
    contains a vector of numbers of the states that transitions can go
    to.  The accessing_symbol fields of those states' cores say what


@@ -82,31 +84,38 @@
 #ifndef STATE_H_
 # define STATE_H_
 
 #ifndef STATE_H_
 # define STATE_H_
 

-# include "bitsetv.h"
+# include <bitset.h>
+
+# include "gram.h"
+# include "symtab.h"

 
 
 /*-------------------.
 | Numbering states.  |
 `-------------------*/
 
 
 
 /*-------------------.
 | Numbering states.  |
 `-------------------*/
 

-typedef short state_number_t;
-# define STATE_NUMBER_MAX ((state_number_t) SHRT_MAX)
+typedef int state_number;
+# define STATE_NUMBER_MAXIMUM INT_MAX

 
 

-/* Be ready to map a state_number_t to an int.  */
-# define state_number_as_int(Tok) ((int) (Tok))
+/* Be ready to map a state_number to an int.  */
+static inline int
+state_number_as_int (state_number s)
+{
+  return s;
+}

 
 
 
 

-typedef struct state_s state_t;
+typedef struct state state;

 
 /*--------------.
 | Transitions.  |
 `--------------*/
 
 
 /*--------------.
 | Transitions.  |
 `--------------*/
 

-typedef struct transtion_s
+typedef struct

 {
 {

-  short num;
-  state_t *states[1];
-} transitions_t;
+  int num;
+  state *states[1];
+} transitions;

 
 
 /* What is the symbol labelling the transition to
 
 
 /* What is the symbol labelling the transition to


@@ -151,112 +160,98 @@ typedef struct transtion_s
     if (!TRANSITION_IS_DISABLED (Transitions, Iter))
 
 
     if (!TRANSITION_IS_DISABLED (Transitions, Iter))
 
 

-/* Return the state such these TRANSITIONS contain a shift/goto to it on
-   SYMBOL.  Aborts if none found.  */
-struct state_s;
-struct state_s *transitions_to PARAMS ((transitions_t *state,
-                                       symbol_number_t s));
+/* Return the state such SHIFTS contain a shift/goto to it on SYM.
+   Abort if none found.  */
+struct state *transitions_to (transitions *shifts, symbol_number sym);

 
 
 /*-------.
 | Errs.  |
 `-------*/
 
 
 
 /*-------.
 | Errs.  |
 `-------*/
 

-typedef struct errs_s
+typedef struct

 {
 {

-  short num;
-  symbol_t *symbols[1];
-} errs_t;
+  int num;
+  symbol *symbols[1];
+} errs;

 
 

-errs_t *errs_new PARAMS ((int num, symbol_t **tokens));
+errs *errs_new (int num, symbol **tokens);

 
 
 /*-------------.
 | Reductions.  |
 `-------------*/
 
 
 
 /*-------------.
 | Reductions.  |
 `-------------*/
 

-typedef struct reductions_s
+typedef struct

 {
 {

-  short num;
-  rule_t *rules[1];
-} reductions_t;
+  int num;
+  bitset *lookahead_tokens;
+  rule *rules[1];
+} reductions;

 
 
 
 /*---------.
 
 
 
 /*---------.

-| States.  |
+| states.  |

 `---------*/
 
 `---------*/
 

-struct state_s
+struct state

 {
 {

-  state_number_t number;
-  symbol_number_t accessing_symbol;
-  transitions_t     *transitions;
-  reductions_t *reductions;
-  errs_t       *errs;
+  state_number number;
+  symbol_number accessing_symbol;
+  transitions *transitions;
+  reductions *reductions;
+  errs *errs;

 
   /* Nonzero if no lookahead is needed to decide what to do in state S.  */
   char consistent;
 
 
   /* Nonzero if no lookahead is needed to decide what to do in state S.  */
   char consistent;
 

-  /* Used in LALR, not LR(0).
-
-     When a state is not consistent (there is an S/R or R/R conflict),
-     lookaheads are needed to enable the reductions.  NLOOKAHEADS is
-     the number of lookahead guarded reductions of the
-     LOOKAHEADS_RULE.  For each rule LOOKAHEADS_RULE[R], LOOKAHEADS[R]
-     is the bitset of the lookaheads enabling this reduction.  */
-  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.  Must be last, since ITEMS can be arbitrarily large.
      */
   /* If some conflicts were solved thanks to precedence/associativity,
      a human readable description of the resolution.  */
   const char *solved_conflicts;
 
   /* Its items.  Must be last, since ITEMS can be arbitrarily large.
      */

-  unsigned short nitems;
-  item_number_t items[1];
+  size_t nitems;
+  item_number items[1];

 };
 
 };
 

-extern state_number_t nstates;
-extern state_t *final_state;
+extern state_number nstates;
+extern state *final_state;

 
 /* Create a new state with ACCESSING_SYMBOL for those items.  */
 
 /* Create a new state with ACCESSING_SYMBOL for those items.  */

-state_t *state_new PARAMS ((symbol_number_t accessing_symbol,
-                           size_t core_size, item_number_t *core));
+state *state_new (symbol_number accessing_symbol,
+                 size_t core_size, item_number *core);

 
 /* Set the transitions of STATE.  */
 
 /* Set the transitions of STATE.  */

-void state_transitions_set PARAMS ((state_t *state,
-                                   int num, state_t **transitions));
+void state_transitions_set (state *s, int num, state **trans);

 
 /* Set the reductions of STATE.  */
 
 /* Set the reductions of STATE.  */

-void state_reductions_set PARAMS ((state_t *state,
-                                  int num, rule_t **reductions));
+void state_reductions_set (state *s, int num, rule **reds);
+
+int state_reduction_find (state *s, rule *r);

 
 /* Set the errs of STATE.  */
 
 /* Set the errs of STATE.  */

-void state_errs_set PARAMS ((state_t *state,
-                            int num, symbol_t **errs));
+void state_errs_set (state *s, int num, symbol **errors);

 
 

-/* 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));
+/* Print on OUT all the lookahead tokens such that this STATE wants to
+   reduce R.  */
+void state_rule_lookahead_tokens_print (state *s, rule *r, FILE *out);

 
 /* Create/destroy the states hash table.  */
 
 /* Create/destroy the states hash table.  */

-void state_hash_new PARAMS ((void));
-void state_hash_free PARAMS ((void));
+void state_hash_new (void);
+void state_hash_free (void);

 
 /* Find the state associated to the CORE, and return it.  If it does
    not exist yet, return NULL.  */
 
 /* Find the state associated to the CORE, and return it.  If it does
    not exist yet, return NULL.  */

-state_t *state_hash_lookup PARAMS ((size_t core_size, item_number_t *core));
+state *state_hash_lookup (size_t core_size, item_number *core);

 
 /* Insert STATE in the state hash table.  */
 
 /* Insert STATE in the state hash table.  */

-void state_hash_insert PARAMS ((state_t *state));
+void state_hash_insert (state *s);

 
 /* All the states, indexed by the state number.  */
 
 /* All the states, indexed by the state number.  */

-extern state_t **states;
+extern state **states;

 
 /* Free all the states.  */
 
 /* Free all the states.  */

-void states_free PARAMS ((void));
+void states_free (void);

 #endif /* !STATE_H_ */
 #endif /* !STATE_H_ */