From db8837cbe1210e9df3da80472abee9b9896fd152 Mon Sep 17 00:00:00 2001 From: Akim Demaille Date: Sun, 7 Apr 2002 17:43:41 +0000 Subject: [PATCH] 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. --- ChangeLog | 18 +++++++++++++++ src/gram.c | 2 +- src/gram.h | 8 +++---- src/lex.c | 4 ++-- src/lex.h | 2 +- src/output.c | 2 +- src/reader.c | 64 ++++++++++++++++++++++++++-------------------------- src/reader.h | 8 +++---- src/reduce.c | 2 +- src/state.h | 2 +- src/symtab.c | 54 ++++++++++++++++++++++---------------------- src/symtab.h | 18 ++++++++------- 12 files changed, 102 insertions(+), 82 deletions(-) diff --git a/ChangeLog b/ChangeLog index 214267fe..401bea13 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,21 @@ +2002-04-07 Akim Demaille + + 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. + + 2002-04-07 Akim Demaille Use lib/hash for the symbol table. diff --git a/src/gram.c b/src/gram.c index 78764d1c..e3638d39 100644 --- a/src/gram.c +++ b/src/gram.c @@ -38,7 +38,7 @@ int nritems = 0; rule_t *rules = NULL; -struct bucket **symbols = NULL; +symbol_t **symbols = NULL; short *token_translations = NULL; int start_symbol = 0; diff --git a/src/gram.h b/src/gram.h index c6988460..d22be7a9 100644 --- a/src/gram.h +++ b/src/gram.h @@ -125,14 +125,14 @@ typedef struct rule_s 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 @@ typedef struct rule_s 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 diff --git a/src/lex.c b/src/lex.c index cb7b2127..2d5caef1 100644 --- a/src/lex.c +++ b/src/lex.c @@ -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 diff --git a/src/lex.h b/src/lex.h index 9f3cfe3a..c3dc66d7 100644 --- a/src/lex.h +++ b/src/lex.h @@ -58,7 +58,7 @@ typedef enum token_e } token_t; extern const char *token_buffer; -extern bucket *symval; +extern symbol_t *symval; extern int numval; void lex_init PARAMS ((void)); diff --git a/src/output.c b/src/output.c index b813b537..9b3aedb5 100644 --- a/src/output.c +++ b/src/output.c @@ -561,7 +561,7 @@ token_definitions_output (FILE *out) 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) diff --git a/src/reader.c b/src/reader.c index a37f2d4a..df7415d1 100644 --- a/src/reader.c +++ b/src/reader.c @@ -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 @@ typedef struct symbol_list /* 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 @@ static int typed = 0; /* 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 @@ symbol_list_new (bucket *sym) } /*------------------------. -| Operations on buckets. | +| Operations on symbols. | `------------------------*/ @@ -97,7 +97,7 @@ symbol_list_new (bucket *sym) `-----------------------------------------------------------*/ static bool -bucket_check_defined (bucket *this) +symbol_check_defined (symbol_t *this) { if (this->class == unknown_sym) { @@ -118,7 +118,7 @@ bucket_check_defined (bucket *this) `-------------------------------------------------------------------*/ 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 @@ bucket_make_alias (bucket *symbol, char *typename) `---------------------------------------------------------*/ 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 @@ bucket_check_alias_consistence (bucket *this) `-------------------------------------------------------------------*/ 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 @@ bucket_pack (bucket *this) `--------------------------------------------------*/ 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 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not) 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 @@ parse_token_decl (symbol_class what_is, symbol_class what_is_not) } 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 @@ static void parse_thong_decl (void) { token_t token; - struct bucket *symbol; + symbol_t *symbol; char *typename = 0; int usrtoknum = SUNDEF; @@ -1365,14 +1365,14 @@ parse_guard (symbol_list *rule, int stack_offset) | 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 @@ static void readgram (void) { token_t t; - bucket *lhs = NULL; + symbol_t *lhs = NULL; symbol_list *p = NULL; symbol_list *p1 = NULL; @@ -1423,7 +1423,7 @@ readgram (void) /* 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 @@ readgram (void) 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 @@ readgram (void) 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 @@ readgram (void) 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 @@ token_translations_init (void) /* 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 @@ token_translations_init (void) 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 @@ token_translations_init (void) 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 @@ packgram (void) 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 @@ reader (void) obstack_init (&muscle_obstack); /* Initialize the symbol table. */ - buckets_new (); + symbols_new (); /* Construct the axiom symbol. */ axiom = getsym ("$axiom"); @@ -1913,5 +1913,5 @@ grammar_free (void) XFREE (ritem); free (rules + 1); /* Free the symbol table data structure. */ - buckets_free (); + symbols_free (); } diff --git a/src/reader.h b/src/reader.h index abff0d38..ce5e2dc7 100644 --- a/src/reader.h +++ b/src/reader.h @@ -36,9 +36,9 @@ void grammar_free PARAMS ((void)); 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_ */ diff --git a/src/reduce.c b/src/reduce.c index 2b322726..ba605df4 100644 --- a/src/reduce.c +++ b/src/reduce.c @@ -299,7 +299,7 @@ nonterminals_reduce (void) /* 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]; diff --git a/src/state.h b/src/state.h index c2d66f3f..9446f4f6 100644 --- a/src/state.h +++ b/src/state.h @@ -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. diff --git a/src/symtab.c b/src/symtab.c index 59adf1f6..12aabb72 100644 --- a/src/symtab.c +++ b/src/symtab.c @@ -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 @@ bucket_new (const char *tag) `------------*/ 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 @@ bucket_free (bucket *this) /*----------------------. -| 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 @@ buckets_new (void) | 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); } diff --git a/src/symtab.h b/src/symtab.h index fd355e1f..f56bc3b1 100644 --- a/src/symtab.h +++ b/src/symtab.h @@ -44,7 +44,7 @@ typedef enum #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 @@ typedef struct bucket /* 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_ */ -- 2.47.2