+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.
rule_t *rules = NULL;
-struct bucket **symbols = NULL;
+symbol_t **symbols = NULL;
short *token_translations = NULL;
int start_symbol = 0;
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;
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
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
} token_t;
extern const char *token_buffer;
-extern bucket *symval;
+extern symbol_t *symval;
extern int numval;
void lex_init PARAMS ((void));
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)
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. */
/* 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. */
/* 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;
}
/*------------------------.
-| Operations on buckets. |
+| Operations on symbols. |
`------------------------*/
`-----------------------------------------------------------*/
static bool
-bucket_check_defined (bucket *this)
+symbol_check_defined (symbol_t *this)
{
if (this->class == unknown_sym)
{
`-------------------------------------------------------------------*/
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"),
`---------------------------------------------------------*/
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)
`-------------------------------------------------------------------*/
static bool
-bucket_pack (bucket *this)
+symbol_pack (symbol_t *this)
{
if (getenv ("DEBUG"))
fprintf (stderr, "Packing %s, %s, number = %d\n",
`--------------------------------------------------*/
static bool
-bucket_translation (bucket *this)
+symbol_translation (symbol_t *this)
{
if (getenv ("DEBUG"))
fprintf (stderr, "Considering Setting UserVal %s = %d (val = %d)\n",
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. */
}
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)
parse_thong_decl (void)
{
token_t token;
- struct bucket *symbol;
+ symbol_t *symbol;
char *typename = 0;
int usrtoknum = SUNDEF;
| 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;
readgram (void)
{
token_t t;
- bucket *lhs = NULL;
+ symbol_t *lhs = NULL;
symbol_list *p = NULL;
symbol_list *p1 = NULL;
/* 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)
{
If one does, exit this rule now. */
if (t == tok_identifier)
{
- bucket *ssave;
+ symbol_t *ssave;
token_t t1;
ssave = symval;
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
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):
/* 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);
for (i = 0; i < max_user_token_number + 1; i++)
token_translations[i] = 2;
- buckets_do (bucket_translation, NULL);
+ symbols_do (symbol_translation, NULL);
}
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 ();
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;
obstack_init (&muscle_obstack);
/* Initialize the symbol table. */
- buckets_new ();
+ symbols_new ();
/* Construct the axiom symbol. */
axiom = getsym ("$axiom");
XFREE (ritem);
free (rules + 1);
/* Free the symbol table data structure. */
- buckets_free ();
+ symbols_free ();
}
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_ */
/* 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];
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.
| 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;
`------------*/
static void
-bucket_free (bucket *this)
+symbol_free (symbol_t *this)
{
#if 0
/* This causes crashes because one string can appear more
/*----------------------.
-| 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);
}
| 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);
}
#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;
/* 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_ */
projects / bison.git / commitdiff
