Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-09 20:33:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename all the bucket's as symbol_t'.

Browse Source 
* 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.
This commit is contained in:
Akim Demaille
2002-04-07 17:43:41 +00:00
parent 72a23c9797
commit db8837cbe1
12 changed files with 102 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
ChangeLog
View File

@@ -1,3 +1,21 @@
2002-04-07 Akim Demaille <akim@epita.fr>
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 <akim@epita.fr>
Use lib/hash for the symbol table.

2
src/gram.c
View File

@@ -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;

8
src/gram.h
View File

@@ -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

4
src/lex.c
View File

@@ -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

2
src/lex.h
View File

@@ -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));

2
src/output.c
View File

@@ -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)

64
src/reader.c
View File

@@ -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 ();
}

8
src/reader.h
View File

@@ -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_ */

2
src/reduce.c
View File

@@ -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];

2
src/state.h
View File

@@ -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.

54
src/symtab.c
View File

@@ -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);
}

18
src/symtab.h
View File

@@ -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_ */