Change @dircategory from "GNU programming tools" to "Software development".

[bison.git] / src / state.h

diff --git a/src/state.h b/src/state.h
index 32559cef4ba2441ff19aff2965493e03731876a4..36395d1640a25f22d066f4141c4cd9fa987a301c 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.
 


@@ -44,14 +46,14 @@
    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 two types of actions are shifts/gotos (push the lookahead token
+   The two types of actions are shifts/gotos (push the look-ahead token

    and read another/goto to the state designated by a nterm) and
    reductions (combine the last n things on the stack via a rule,
    replace them with the symbol that the rule derives, and leave the
    and read another/goto to the state designated by a nterm) and
    reductions (combine the last n things on the stack via a rule,
    replace them with the symbol that the rule derives, and leave the

-   lookahead token alone).  When the states are generated, these
+   look-ahead token alone).  When the states are generated, these

    actions are represented in two other lists.
 
    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 *look_ahead_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.  */
+  /* Nonzero if no look-ahead is needed to decide what to do in state S.  */

   char consistent;
 
   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 look-ahead tokens such that this STATE wants to
+   reduce R.  */
+void state_rule_look_ahead_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_ */