+ symbol_precedence_set (str, sym->prec, sym->assoc,
+ sym->prec_location);
+ }
+}
+
+static bool
+symbol_check_alias_consistency_processor (void *this,
+ void *null ATTRIBUTE_UNUSED)
+{
+ symbol_check_alias_consistency (this);
+ return true;
+}
+
+
+/*-------------------------------------------------------------------.
+| Assign a symbol number, and write the definition of the token name |
+| into FDEFINES. Put in SYMBOLS. |
+`-------------------------------------------------------------------*/
+
+static inline bool
+symbol_pack (symbol *this)
+{
+ aver (this->number != NUMBER_UNDEFINED);
+ if (this->class == nterm_sym)
+ this->number += ntokens;
+ else if (this->user_token_number == USER_NUMBER_HAS_STRING_ALIAS)
+ return true;
+
+ symbols[this->number] = this;
+ return true;
+}
+
+static bool
+symbol_pack_processor (void *this, void *null ATTRIBUTE_UNUSED)
+{
+ return symbol_pack (this);
+}
+
+
+static void
+user_token_number_redeclaration (int num, symbol *first, symbol *second)
+{
+ /* User token numbers are not assigned during the parsing, but in a
+ second step, via a traversal of the symbol table sorted on tag.
+
+ However, error messages make more sense if we keep the first
+ declaration first. */
+ if (location_cmp (first->location, second->location) > 0)
+ {
+ symbol* tmp = first;
+ first = second;
+ second = tmp;
+ }
+ complain_at (second->location,
+ _("user token number %d redeclaration for %s"),
+ num, second->tag);
+ complain_at (first->location, _("previous declaration for %s"),
+ first->tag);
+}
+
+/*--------------------------------------------------.
+| Put THIS in TOKEN_TRANSLATIONS if it is a token. |
+`--------------------------------------------------*/
+
+static inline bool
+symbol_translation (symbol *this)
+{
+ /* Non-terminal? */
+ if (this->class == token_sym
+ && this->user_token_number != USER_NUMBER_HAS_STRING_ALIAS)
+ {
+ /* A token which translation has already been set? */
+ if (token_translations[this->user_token_number] != undeftoken->number)
+ user_token_number_redeclaration
+ (this->user_token_number,
+ symbols[token_translations[this->user_token_number]],
+ this);
+
+ token_translations[this->user_token_number] = this->number;
+ }
+
+ return true;
+}
+
+static bool
+symbol_translation_processor (void *this, void *null ATTRIBUTE_UNUSED)
+{
+ return symbol_translation (this);
+}
+
+
+/*---------------------------------------.
+| Symbol and semantic type hash tables. |
+`---------------------------------------*/
+
+/* Initial capacity of symbol and semantic type hash table. */
+#define HT_INITIAL_CAPACITY 257
+
+static struct hash_table *symbol_table = NULL;
+static struct hash_table *semantic_type_table = NULL;
+
+static inline bool
+hash_compare_symbol (const symbol *m1, const symbol *m2)
+{
+ /* Since tags are unique, we can compare the pointers themselves. */
+ return UNIQSTR_EQ (m1->tag, m2->tag);
+}
+
+static inline bool
+hash_compare_semantic_type (const semantic_type *m1, const semantic_type *m2)
+{
+ /* Since names are unique, we can compare the pointers themselves. */
+ return UNIQSTR_EQ (m1->tag, m2->tag);
+}
+
+static bool
+hash_symbol_comparator (void const *m1, void const *m2)
+{
+ return hash_compare_symbol (m1, m2);
+}
+
+static bool
+hash_semantic_type_comparator (void const *m1, void const *m2)
+{
+ return hash_compare_semantic_type (m1, m2);
+}
+
+static inline size_t
+hash_symbol (const symbol *m, size_t tablesize)
+{
+ /* Since tags are unique, we can hash the pointer itself. */
+ return ((uintptr_t) m->tag) % tablesize;
+}
+
+static inline size_t
+hash_semantic_type (const semantic_type *m, size_t tablesize)
+{
+ /* Since names are unique, we can hash the pointer itself. */
+ return ((uintptr_t) m->tag) % tablesize;
+}
+
+static size_t
+hash_symbol_hasher (void const *m, size_t tablesize)
+{
+ return hash_symbol (m, tablesize);
+}
+
+static size_t
+hash_semantic_type_hasher (void const *m, size_t tablesize)
+{
+ return hash_semantic_type (m, tablesize);
+}
+
+/*-------------------------------.
+| Create the symbol hash table. |
+`-------------------------------*/
+
+void
+symbols_new (void)
+{
+ symbol_table = hash_initialize (HT_INITIAL_CAPACITY,
+ NULL,
+ hash_symbol_hasher,
+ hash_symbol_comparator,
+ free);
+ semantic_type_table = hash_initialize (HT_INITIAL_CAPACITY,
+ NULL,
+ hash_semantic_type_hasher,
+ hash_semantic_type_comparator,
+ free);
+}
+
+
+/*----------------------------------------------------------------.
+| Find the symbol named KEY, and return it. If it does not exist |
+| yet, create it. |
+`----------------------------------------------------------------*/
+
+symbol *
+symbol_from_uniqstr (const uniqstr key, location loc)
+{
+ symbol probe;
+ symbol *entry;
+
+ probe.tag = key;
+ entry = hash_lookup (symbol_table, &probe);
+
+ if (!entry)
+ {
+ /* First insertion in the hash. */
+ aver (!symbols_sorted);
+ entry = symbol_new (key, loc);
+ if (!hash_insert (symbol_table, entry))
+ xalloc_die ();
+ }
+ return entry;
+}
+
+
+/*-----------------------------------------------------------------------.
+| Find the semantic type named KEY, and return it. If it does not exist |
+| yet, create it. |
+`-----------------------------------------------------------------------*/
+
+semantic_type *
+semantic_type_from_uniqstr (const uniqstr key)
+{
+ semantic_type probe;
+ semantic_type *entry;
+
+ probe.tag = key;
+ entry = hash_lookup (semantic_type_table, &probe);
+
+ if (!entry)
+ {
+ /* First insertion in the hash. */
+ entry = semantic_type_new (key);
+ if (!hash_insert (semantic_type_table, entry))
+ xalloc_die ();
+ }
+ return entry;
+}
+
+
+/*----------------------------------------------------------------.
+| Find the symbol named KEY, and return it. If it does not exist |
+| yet, create it. |
+`----------------------------------------------------------------*/
+
+symbol *
+symbol_get (const char *key, location loc)
+{
+ return symbol_from_uniqstr (uniqstr_new (key), loc);
+}
+
+
+/*-----------------------------------------------------------------------.
+| Find the semantic type named KEY, and return it. If it does not exist |
+| yet, create it. |
+`-----------------------------------------------------------------------*/
+
+semantic_type *
+semantic_type_get (const char *key)
+{
+ return semantic_type_from_uniqstr (uniqstr_new (key));
+}
+
+
+/*------------------------------------------------------------------.
+| Generate a dummy nonterminal, whose name cannot conflict with the |
+| user's names. |
+`------------------------------------------------------------------*/
+
+symbol *
+dummy_symbol_get (location loc)
+{
+ /* Incremented for each generated symbol. */
+ static int dummy_count = 0;
+ static char buf[256];
+
+ symbol *sym;
+
+ sprintf (buf, "$@%d", ++dummy_count);
+ sym = symbol_get (buf, loc);
+ sym->class = nterm_sym;
+ sym->number = nvars++;
+ return sym;
+}
+
+bool
+symbol_is_dummy (const symbol *sym)
+{
+ return sym->tag[0] == '@' || (sym->tag[0] == '$' && sym->tag[1] == '@');
+}
projects / bison.git / blobdiff