21-fyi-s-bucket-symbol-t-g.patch

[Akim Demaille]

Index: ChangeLog
from  Akim Demaille  <address@hidden>
        Rename all the `bucket's as `symbol_t'.
        
        * src/gram.c, src/gram.h, src/lex.c, src/lex.h, src/output.c,
        * src/reader.c, src/reader.h, src/reduce.c, src/state.h,
        * src/symtab.c, src/symtab.h (bucket): Rename as...
        (symbol_t): this.
        (symbol_list_new, bucket_check_defined, bucket_make_alias)
        (bucket_check_alias_consistence, bucket_pack, bucket_translation)
        (bucket_new, bucket_free, hash_compare_bucket, hash_bucket)
        (buckets_new, buckets_free, buckets_do): Rename as...
        (symbol_list_new, symbol_check_defined, symbol_make_alias)
        (symbol_check_alias_consistence, symbol_pack, symbol_translation)
        (symbol_new, symbol_free, hash_compare_symbol_t, hash_symbol_t)
        (symbols_new, symbols_free, symbols_do): these.
        
        
Index: src/gram.c
--- src/gram.c Sat, 06 Apr 2002 22:02:42 +0200 akim
+++ src/gram.c Sat, 06 Apr 2002 22:08:43 +0200 akim
@@ -38,7 +38,7 @@
 
 rule_t *rules = NULL;
 
-struct bucket **symbols = NULL;
+symbol_t **symbols = NULL;
 short *token_translations = NULL;
 
 int start_symbol = 0;
Index: src/gram.h
--- src/gram.h Sat, 06 Apr 2002 21:53:45 +0200 akim
+++ src/gram.h Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -125,14 +125,14 @@
      except if some rules are useless.  */
   short number;
 
-  bucket *lhs;
+  symbol_t *lhs;
   short *rhs;
 
   /* This symbol provides both the associativity, and the precedence. */
-  bucket *prec;
+  symbol_t *prec;
 
   /* This symbol was attached to the rule via %prec. */
-  bucket *precsym;
+  symbol_t *precsym;
 
   short line;
   bool useful;
@@ -147,7 +147,7 @@
 extern struct rule_s *rules;
 
 /* Table of the symbols, indexed by the symbol number. */
-extern struct bucket **symbols;
+extern symbol_t **symbols;
 
 /* token translation table: indexed by a token number as returned by
    the user's yylex routine, it yields the internal token number used
Index: src/lex.c
--- src/lex.c Sat, 06 Apr 2002 22:02:42 +0200 akim
+++ src/lex.c Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -32,12 +32,12 @@
 static struct obstack token_obstack;
 const char *token_buffer = NULL;
 
-bucket *symval = NULL;
+symbol_t *symval = NULL;
 int numval;
 
 /* A token to be reread, see unlex and lex. */
 static token_t unlexed = tok_undef;
-static bucket *unlexed_symval = NULL;
+static symbol_t *unlexed_symval = NULL;
 static const char *unlexed_token_buffer = NULL;
 
 void
Index: src/lex.h
--- src/lex.h Sun, 16 Dec 2001 11:40:41 +0100 akim
+++ src/lex.h Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -58,7 +58,7 @@
   } token_t;
 
 extern const char *token_buffer;
-extern bucket *symval;
+extern symbol_t *symval;
 extern int numval;
 
 void lex_init PARAMS ((void));
Index: src/output.c
--- src/output.c Thu, 04 Apr 2002 19:44:17 +0200 akim
+++ src/output.c Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -561,7 +561,7 @@
   int first = 1;
   for (i = 0; i < ntokens; ++i)
     {
-      bucket *symbol = symbols[i];
+      symbol_t *symbol = symbols[i];
       int number = symbol->user_token_number;
 
       if (number == SALIAS)
Index: src/reader.c
--- src/reader.c Sat, 06 Apr 2002 22:02:42 +0200 akim
+++ src/reader.c Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -38,7 +38,7 @@
 typedef struct symbol_list
 {
   struct symbol_list *next;
-  bucket *sym;
+  symbol_t *sym;
   int line;
 
   /* The action is attached to the LHS of a rule. */
@@ -48,13 +48,13 @@
   /* The guard is attached to the LHS of a rule. */
   const char *guard;
   int guard_line;
-  bucket *ruleprec;
+  symbol_t *ruleprec;
 } symbol_list;
 
 int lineno;
 static symbol_list *grammar = NULL;
 static int start_flag = 0;
-static bucket *startval = NULL;
+static symbol_t *startval = NULL;
 
 /* Nonzero if components of semantic values are used, implying
    they must be unions.  */
@@ -66,13 +66,13 @@
 /* Incremented for each %left, %right or %nonassoc seen */
 static int lastprec = 0;
 
-bucket *errtoken = NULL;
-bucket *undeftoken = NULL;
-bucket *eoftoken = NULL;
-bucket *axiom = NULL;
+symbol_t *errtoken = NULL;
+symbol_t *undeftoken = NULL;
+symbol_t *eoftoken = NULL;
+symbol_t *axiom = NULL;
 
 static symbol_list *
-symbol_list_new (bucket *sym)
+symbol_list_new (symbol_t *sym)
 {
   symbol_list *res = XMALLOC (symbol_list, 1);
   res->next = NULL;
@@ -87,7 +87,7 @@
 }
 
 /*------------------------.
-| Operations on buckets.  |
+| Operations on symbols.  |
 `------------------------*/
 
 
@@ -97,7 +97,7 @@
 `-----------------------------------------------------------*/
 
 static bool
-bucket_check_defined (bucket *this)
+symbol_check_defined (symbol_t *this)
 {
   if (this->class == unknown_sym)
     {
@@ -118,7 +118,7 @@
 `-------------------------------------------------------------------*/
 
 static bool
-bucket_make_alias (bucket *symbol, char *typename)
+symbol_make_alias (symbol_t *symbol, char *typename)
 {
   if (symval->alias)
     warn (_("symbol `%s' used more than once as a literal string"),
@@ -151,7 +151,7 @@
 `---------------------------------------------------------*/
 
 static bool
-bucket_check_alias_consistence (bucket *this)
+symbol_check_alias_consistence (symbol_t *this)
 {
   /* Check only those who _are_ the aliases. */
   if (this->alias && this->user_token_number == SALIAS)
@@ -188,7 +188,7 @@
 `-------------------------------------------------------------------*/
 
 static bool
-bucket_pack (bucket *this)
+symbol_pack (symbol_t *this)
 {
   if (getenv ("DEBUG"))
     fprintf (stderr, "Packing %s, %s, number = %d\n",
@@ -237,7 +237,7 @@
 `--------------------------------------------------*/
 
 static bool
-bucket_translation (bucket *this)
+symbol_translation (symbol_t *this)
 {
   if (getenv ("DEBUG"))
     fprintf (stderr, "Considering Setting UserVal %s = %d (val = %d)\n",
@@ -677,7 +677,7 @@
   char *typename = NULL;
 
   /* The symbol being defined.  */
-  struct bucket *symbol = NULL;
+  symbol_t *symbol = NULL;
 
   /* After `%token' and `%nterm', any number of symbols maybe be
      defined.  */
@@ -706,7 +706,7 @@
        }
       else if (token == tok_identifier && *symval->tag == '\"' && symbol)
        {
-         bucket_make_alias (symbol, typename);
+         symbol_make_alias (symbol, typename);
          symbol = NULL;
        }
       else if (token == tok_identifier)
@@ -1023,7 +1023,7 @@
 parse_thong_decl (void)
 {
   token_t token;
-  struct bucket *symbol;
+  symbol_t *symbol;
   char *typename = 0;
   int usrtoknum = SUNDEF;
 
@@ -1365,14 +1365,14 @@
 | with the user's names.                                             |
 `-------------------------------------------------------------------*/
 
-static bucket *
+static symbol_t *
 gensym (void)
 {
   /* Incremented for each generated symbol */
   static int gensym_count = 0;
   static char buf[256];
 
-  bucket *sym;
+  symbol_t *sym;
 
   sprintf (buf, "@%d", ++gensym_count);
   token_buffer = buf;
@@ -1404,7 +1404,7 @@
 readgram (void)
 {
   token_t t;
-  bucket *lhs = NULL;
+  symbol_t *lhs = NULL;
   symbol_list *p = NULL;
   symbol_list *p1 = NULL;
 
@@ -1423,7 +1423,7 @@
        /* Number of symbols in rhs of this rule so far */
        int rulelength = 0;
        int xactions = 0;       /* JF for error checking */
-       bucket *first_rhs = 0;
+       symbol_t *first_rhs = 0;
 
        if (t == tok_identifier)
          {
@@ -1494,7 +1494,7 @@
               If one does, exit this rule now.  */
            if (t == tok_identifier)
              {
-               bucket *ssave;
+               symbol_t *ssave;
                token_t t1;
 
                ssave = symval;
@@ -1523,7 +1523,7 @@
                   inserting the new rule before it.  */
 
                /* Make a dummy nonterminal, a gensym.  */
-               bucket *sdummy = gensym ();
+               symbol_t *sdummy = gensym ();
 
                /* Make a new rule, whose body is empty, before the
                   current one, so that the action just read can
@@ -1638,7 +1638,7 @@
     fatal (_("no rules in the input grammar"));
 
   /* Report any undefined symbols and consider them nonterminals.  */
-  buckets_do (bucket_check_defined, NULL);
+  symbols_do (symbol_check_defined, NULL);
 
   /* Insert the initial rule, which line is that of the first rule
      (not that of the start symbol):
@@ -1705,7 +1705,7 @@
   /* Set the user numbers. */
   for (i = 0; i < ntokens; ++i)
     {
-      bucket *this = symbols[i];
+      symbol_t *this = symbols[i];
       if (getenv ("DEBUG"))
        fprintf (stderr, "UserVal %s = %d (val = %d)\n",
                 this->tag, this->user_token_number, this->number);
@@ -1726,7 +1726,7 @@
   for (i = 0; i < max_user_token_number + 1; i++)
     token_translations[i] = 2;
 
-  buckets_do (bucket_translation, NULL);
+  symbols_do (symbol_translation, NULL);
 }
 
 
@@ -1738,10 +1738,10 @@
 static void
 packsymbols (void)
 {
-  symbols = XCALLOC (bucket *, nsyms);
+  symbols = XCALLOC (symbol_t *, nsyms);
 
-  buckets_do (bucket_check_alias_consistence, NULL);
-  buckets_do (bucket_pack, NULL);
+  symbols_do (symbol_check_alias_consistence, NULL);
+  symbols_do (symbol_pack, NULL);
 
   token_translations_init ();
 
@@ -1781,7 +1781,7 @@
   p = grammar;
   while (p)
     {
-      bucket *ruleprec = p->ruleprec;
+      symbol_t *ruleprec = p->ruleprec;
       rules[ruleno].user_number = ruleno;
       rules[ruleno].number = ruleno;
       rules[ruleno].lhs = p->sym;
@@ -1845,7 +1845,7 @@
   obstack_init (&muscle_obstack);
 
   /* Initialize the symbol table.  */
-  buckets_new ();
+  symbols_new ();
 
   /* Construct the axiom symbol. */
   axiom = getsym ("$axiom");
@@ -1913,5 +1913,5 @@
   XFREE (ritem);
   free (rules + 1);
   /* Free the symbol table data structure.  */
-  buckets_free ();
+  symbols_free ();
 }
Index: src/reader.h
--- src/reader.h Sat, 06 Apr 2002 21:48:00 +0200 akim
+++ src/reader.h Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -36,9 +36,9 @@
 
 extern int lineno;
 
-extern bucket *errtoken;
-extern bucket *undeftoken;
-extern bucket *eoftoken;
-extern bucket *axiom;
+extern symbol_t *errtoken;
+extern symbol_t *undeftoken;
+extern symbol_t *eoftoken;
+extern symbol_t *axiom;
 
 #endif /* !READER_H_ */
Index: src/reduce.c
--- src/reduce.c Sat, 06 Apr 2002 22:02:42 +0200 akim
+++ src/reduce.c Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -299,7 +299,7 @@
 
   /* Shuffle elements of tables indexed by symbol number.  */
   {
-    bucket **symbols_sorted = XMALLOC (bucket *, nvars) - ntokens;
+    symbol_t **symbols_sorted = XMALLOC (symbol_t *, nvars) - ntokens;
 
     for (i = ntokens; i < nsyms; i++)
       symbols[i]->number = nontermmap[i];
Index: src/state.h
--- src/state.h Fri, 28 Dec 2001 16:47:09 +0100 akim
+++ src/state.h Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -44,7 +44,7 @@
    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.
 
Index: src/symtab.c
--- src/symtab.c Sat, 06 Apr 2002 22:02:42 +0200 akim
+++ src/symtab.c Sat, 06 Apr 2002 22:08:44 +0200 akim
@@ -28,10 +28,10 @@
 | Create a new symbol, named TAG.  |
 `---------------------------------*/
 
-static bucket *
-bucket_new (const char *tag)
+static symbol_t *
+symbol_new (const char *tag)
 {
-  bucket *res = XMALLOC (bucket, 1);
+  symbol_t *res = XMALLOC (symbol_t, 1);
 
   res->tag = xstrdup (tag);
   res->type_name = NULL;
@@ -56,7 +56,7 @@
 `------------*/
 
 static void
-bucket_free (bucket *this)
+symbol_free (symbol_t *this)
 {
 #if 0
   /* This causes crashes because one string can appear more
@@ -70,39 +70,39 @@
 
 
 /*----------------------.
-| A bucket hash table.  |
+| A symbol_t hash table.  |
 `----------------------*/
 
-/* Initial capacity of buckets hash table.  */
+/* Initial capacity of symbols hash table.  */
 #define HT_INITIAL_CAPACITY 257
 
-static struct hash_table *bucket_table = NULL;
+static struct hash_table *symbol_table = NULL;
 
 static bool
-hash_compare_bucket (const bucket *m1, const bucket *m2)
+hash_compare_symbol_t (const symbol_t *m1, const symbol_t *m2)
 {
   return strcmp (m1->tag, m2->tag) ? FALSE : TRUE;
 }
 
 static unsigned int
-hash_bucket (const bucket *m, unsigned int tablesize)
+hash_symbol_t (const symbol_t *m, unsigned int tablesize)
 {
   return hash_string (m->tag, tablesize);
 }
 
 
 /*-------------------------------.
-| Create the bucket hash table.  |
+| Create the symbol_t hash table.  |
 `-------------------------------*/
 
 void
-buckets_new (void)
+symbols_new (void)
 {
-  bucket_table = hash_initialize (HT_INITIAL_CAPACITY,
+  symbol_table = hash_initialize (HT_INITIAL_CAPACITY,
                                  NULL,
-                                 (Hash_hasher) hash_bucket,
-                                 (Hash_comparator) hash_compare_bucket,
-                                 (Hash_data_freer) bucket_free);
+                                 (Hash_hasher) hash_symbol_t,
+                                 (Hash_comparator) hash_compare_symbol_t,
+                                 (Hash_data_freer) symbol_free);
 }
 
 
@@ -111,45 +111,45 @@
 | yet, create it.                                                 |
 `----------------------------------------------------------------*/
 
-bucket *
+symbol_t *
 getsym (const char *key)
 {
-  bucket probe;
-  bucket *entry;
+  symbol_t probe;
+  symbol_t *entry;
 
   (const char *) probe.tag = key;
-  entry = hash_lookup (bucket_table, &probe);
+  entry = hash_lookup (symbol_table, &probe);
 
   if (!entry)
     {
       /* First insertion in the hash. */
-      entry = bucket_new (key);
-      hash_insert (bucket_table, entry);
+      entry = symbol_new (key);
+      hash_insert (symbol_table, entry);
     }
   return entry;
 }
 
 
 /*-------------------.
-| Free the buckets.  |
+| Free the symbols.  |
 `-------------------*/
 
 void
-buckets_free (void)
+symbols_free (void)
 {
-  hash_free (bucket_table);
+  hash_free (symbol_table);
 }
 
 
 /*---------------------------------------------------------------.
-| Look for undefined buckets, report an error, and consider them |
+| Look for undefined symbols, report an error, and consider them |
 | terminals.                                                     |
 `---------------------------------------------------------------*/
 
 void
-buckets_do (bucket_processor processor, void *processor_data)
+symbols_do (symbol_processor processor, void *processor_data)
 {
-  hash_do_for_each (bucket_table,
+  hash_do_for_each (symbol_table,
                    (Hash_processor) processor,
                    processor_data);
 }
Index: src/symtab.h
--- src/symtab.h Sat, 06 Apr 2002 22:02:42 +0200 akim
+++ src/symtab.h Sat, 06 Apr 2002 22:09:06 +0200 akim
@@ -44,7 +44,7 @@
 #define SUNDEF  -1              /* For undefined user number. */
 #define SALIAS -9991           /* for symbol generated with an alias */
 
-typedef struct bucket
+struct symbol_s
 {
   /* The key, name of the symbol. */
   char *tag;
@@ -58,17 +58,19 @@
   /* Points to the other in the identifier-symbol pair for an
      alias. Special value SALIAS in the identifier half of the
      identifier-symbol pair for an alias.  */
-  struct bucket *alias;
+  struct symbol_s *alias;
   symbol_class class;
-} bucket;
+};
+
+typedef struct symbol_s symbol_t;
 
 /* A function to apply to each symbol. */
-typedef bool (*bucket_processor) PARAMS ((bucket *));
+typedef bool (*symbol_processor) PARAMS ((symbol_t *));
 
-bucket *getsym PARAMS ((const char *));
+symbol_t *getsym PARAMS ((const char *));
 
-void buckets_new PARAMS ((void));
-void buckets_do PARAMS ((bucket_processor processor, void *processor_data));
-void buckets_free PARAMS ((void));
+void symbols_new PARAMS ((void));
+void symbols_do PARAMS ((symbol_processor processor, void *processor_data));
+void symbols_free PARAMS ((void));
 
 #endif /* !SYMTAB_H_ */