1 /* Symbol table manager for Bison.
3 Copyright (C) 1984, 1989, 2000-2002, 2004-2012 Free Software
6 This file is part of Bison, the GNU Compiler Compiler.
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 /*-------------------------------------------------------------------.
31 | Symbols sorted by tag. Allocated by the first invocation of |
32 | symbols_do, after which no more symbols should be created. |
33 `-------------------------------------------------------------------*/
35 static symbol **symbols_sorted = NULL;
37 /*------------------------.
38 | Distinguished symbols. |
39 `------------------------*/
41 symbol *errtoken = NULL;
42 symbol *undeftoken = NULL;
43 symbol *endtoken = NULL;
44 symbol *accept = NULL;
45 symbol *startsymbol = NULL;
46 location startsymbol_location;
48 /*---------------------------------------.
49 | Default %destructor's and %printer's. |
50 `---------------------------------------*/
52 static code_props default_tagged_destructor = CODE_PROPS_NONE_INIT;
53 static code_props default_tagless_destructor = CODE_PROPS_NONE_INIT;
54 static code_props default_tagged_printer = CODE_PROPS_NONE_INIT;
55 static code_props default_tagless_printer = CODE_PROPS_NONE_INIT;
57 /*---------------------------------.
58 | Create a new symbol, named TAG. |
59 `---------------------------------*/
62 symbol_new (uniqstr tag, location loc)
64 symbol *res = xmalloc (sizeof *res);
68 /* If the tag is not a string (starts with a double quote), check
69 that it is valid for Yacc. */
70 if (tag[0] != '\"' && tag[0] != '\'' && mbschr (tag, '-'))
71 yacc_at (loc, _("POSIX Yacc forbids dashes in symbol names: %s"),
77 res->type_name = NULL;
78 code_props_none_init (&res->destructor);
79 code_props_none_init (&res->printer);
81 res->number = NUMBER_UNDEFINED;
83 res->assoc = undef_assoc;
84 res->user_token_number = USER_NUMBER_UNDEFINED;
87 res->class = unknown_sym;
88 res->declared = false;
90 if (nsyms == SYMBOL_NUMBER_MAXIMUM)
91 fatal (_("too many symbols in input grammar (limit is %d)"),
92 SYMBOL_NUMBER_MAXIMUM);
97 /*----------------------------------------.
98 | Create a new semantic type, named TAG. |
99 `----------------------------------------*/
101 static semantic_type *
102 semantic_type_new (uniqstr tag)
104 semantic_type *res = xmalloc (sizeof *res);
106 uniqstr_assert (tag);
108 code_props_none_init (&res->destructor);
109 code_props_none_init (&res->printer);
119 #define SYMBOL_ATTR_PRINT(Attr) \
121 fprintf (f, " %s { %s }", #Attr, s->Attr)
123 #define SYMBOL_CODE_PRINT(Attr) \
125 fprintf (f, " %s { %s }", #Attr, s->Attr.code)
128 symbol_print (symbol *s, FILE *f)
132 fprintf (f, "\"%s\"", s->tag);
133 SYMBOL_ATTR_PRINT (type_name);
134 SYMBOL_CODE_PRINT (destructor);
135 SYMBOL_CODE_PRINT (printer);
138 fprintf (f, "<NULL>");
141 #undef SYMBOL_ATTR_PRINT
142 #undef SYMBOL_CODE_PRINT
144 /*------------------------------------------------------------------.
145 | Complain that S's WHAT is redeclared at SECOND, and was first set |
147 `------------------------------------------------------------------*/
150 symbol_redeclaration (symbol *s, const char *what, location first,
153 complain_at (second, _("%s redeclaration for %s"), what, s->tag);
154 complain_at (first, _("previous declaration"));
158 semantic_type_redeclaration (semantic_type *s, const char *what, location first,
161 complain_at (second, _("%s redeclaration for <%s>"), what, s->tag);
162 complain_at (first, _("previous declaration"));
167 /*-----------------------------------------------------------------.
168 | Set the TYPE_NAME associated with SYM. Does nothing if passed 0 |
170 `-----------------------------------------------------------------*/
173 symbol_type_set (symbol *sym, uniqstr type_name, location loc)
178 symbol_redeclaration (sym, "%type", sym->type_location, loc);
179 uniqstr_assert (type_name);
180 sym->type_name = type_name;
181 sym->type_location = loc;
185 /*-----------------------------------------.
186 | Set the DESTRUCTOR associated with SYM. |
187 `-----------------------------------------*/
190 symbol_destructor_set (symbol *sym, code_props const *destructor)
192 if (sym->destructor.code)
193 symbol_redeclaration (sym, "%destructor", sym->destructor.location,
194 destructor->location);
195 sym->destructor = *destructor;
198 /*------------------------------------------.
199 | Set the DESTRUCTOR associated with TYPE. |
200 `------------------------------------------*/
203 semantic_type_destructor_set (semantic_type *type,
204 code_props const *destructor)
206 if (type->destructor.code)
207 semantic_type_redeclaration (type, "%destructor",
208 type->destructor.location,
209 destructor->location);
210 type->destructor = *destructor;
213 /*---------------------------------------.
214 | Get the computed %destructor for SYM. |
215 `---------------------------------------*/
218 symbol_destructor_get (symbol const *sym)
220 /* Per-symbol %destructor. */
221 if (sym->destructor.code)
222 return &sym->destructor;
224 /* Per-type %destructor. */
227 code_props const *destructor =
228 &semantic_type_get (sym->type_name)->destructor;
229 if (destructor->code)
233 /* Apply default %destructor's only to user-defined symbols. */
234 if (sym->tag[0] == '$' || sym == errtoken)
235 return &code_props_none;
238 return &default_tagged_destructor;
239 return &default_tagless_destructor;
242 /*--------------------------------------.
243 | Set the PRINTER associated with SYM. |
244 `--------------------------------------*/
247 symbol_printer_set (symbol *sym, code_props const *printer)
249 if (sym->printer.code)
250 symbol_redeclaration (sym, "%printer",
251 sym->printer.location, printer->location);
252 sym->printer = *printer;
255 /*---------------------------------------.
256 | Set the PRINTER associated with TYPE. |
257 `---------------------------------------*/
260 semantic_type_printer_set (semantic_type *type, code_props const *printer)
262 if (type->printer.code)
263 semantic_type_redeclaration (type, "%printer",
264 type->printer.location, printer->location);
265 type->printer = *printer;
268 /*------------------------------------.
269 | Get the computed %printer for SYM. |
270 `------------------------------------*/
273 symbol_printer_get (symbol const *sym)
275 /* Per-symbol %printer. */
276 if (sym->printer.code)
277 return &sym->printer;
279 /* Per-type %printer. */
282 code_props const *printer = &semantic_type_get (sym->type_name)->printer;
287 /* Apply the default %printer only to user-defined symbols. */
288 if (sym->tag[0] == '$' || sym == errtoken)
289 return &code_props_none;
292 return &default_tagged_printer;
293 return &default_tagless_printer;
296 /*-----------------------------------------------------------------.
297 | Set the PRECEDENCE associated with SYM. Does nothing if invoked |
298 | with UNDEF_ASSOC as ASSOC. |
299 `-----------------------------------------------------------------*/
302 symbol_precedence_set (symbol *sym, int prec, assoc a, location loc)
304 if (a != undef_assoc)
307 symbol_redeclaration (sym, assoc_to_string (a), sym->prec_location,
311 sym->prec_location = loc;
314 /* Only terminals have a precedence. */
315 symbol_class_set (sym, token_sym, loc, false);
319 /*------------------------------------.
320 | Set the CLASS associated with SYM. |
321 `------------------------------------*/
324 symbol_class_set (symbol *sym, symbol_class class, location loc, bool declaring)
326 if (sym->class != unknown_sym && sym->class != class)
328 complain_at (loc, _("symbol %s redefined"), sym->tag);
329 sym->declared = false;
332 if (class == nterm_sym && sym->class != nterm_sym)
333 sym->number = nvars++;
334 else if (class == token_sym && sym->number == NUMBER_UNDEFINED)
335 sym->number = ntokens++;
342 warn_at (loc, _("symbol %s redeclared"), sym->tag);
343 sym->declared = true;
348 /*------------------------------------------------.
349 | Set the USER_TOKEN_NUMBER associated with SYM. |
350 `------------------------------------------------*/
353 symbol_user_token_number_set (symbol *sym, int user_token_number, location loc)
355 int *user_token_numberp;
357 if (sym->user_token_number != USER_NUMBER_HAS_STRING_ALIAS)
358 user_token_numberp = &sym->user_token_number;
360 user_token_numberp = &sym->alias->user_token_number;
361 if (*user_token_numberp != USER_NUMBER_UNDEFINED
362 && *user_token_numberp != user_token_number)
363 complain_at (loc, _("redefining user token number of %s"), sym->tag);
365 *user_token_numberp = user_token_number;
366 /* User defined $end token? */
367 if (user_token_number == 0)
370 /* It is always mapped to 0, so it was already counted in
372 if (endtoken->number != NUMBER_UNDEFINED)
374 endtoken->number = 0;
379 /*----------------------------------------------------------.
380 | If SYM is not defined, report an error, and consider it a |
382 `----------------------------------------------------------*/
385 symbol_check_defined (symbol *sym)
387 if (sym->class == unknown_sym)
391 _("symbol %s is used, but is not defined as a token and has no rules"),
393 sym->class = nterm_sym;
394 sym->number = nvars++;
401 symbol_check_defined_processor (void *sym, void *null ATTRIBUTE_UNUSED)
403 return symbol_check_defined (sym);
408 symbol_make_alias (symbol *sym, symbol *str, location loc)
411 warn_at (loc, _("symbol %s used more than once as a literal string"),
414 warn_at (loc, _("symbol %s given more than one literal string"),
418 str->class = token_sym;
419 str->user_token_number = sym->user_token_number;
420 sym->user_token_number = USER_NUMBER_HAS_STRING_ALIAS;
423 str->number = sym->number;
424 symbol_type_set (str, sym->type_name, loc);
429 /*---------------------------------------------------------.
430 | Check that THIS, and its alias, have same precedence and |
432 `---------------------------------------------------------*/
435 symbol_check_alias_consistency (symbol *this)
438 symbol *str = this->alias;
440 /* Check only the symbol in the symbol-string pair. */
442 && this->user_token_number == USER_NUMBER_HAS_STRING_ALIAS))
445 if (str->type_name != sym->type_name)
448 symbol_type_set (sym, str->type_name, str->type_location);
450 symbol_type_set (str, sym->type_name, sym->type_location);
454 if (str->destructor.code || sym->destructor.code)
456 if (str->destructor.code)
457 symbol_destructor_set (sym, &str->destructor);
459 symbol_destructor_set (str, &sym->destructor);
462 if (str->printer.code || sym->printer.code)
464 if (str->printer.code)
465 symbol_printer_set (sym, &str->printer);
467 symbol_printer_set (str, &sym->printer);
470 if (sym->prec || str->prec)
473 symbol_precedence_set (sym, str->prec, str->assoc,
476 symbol_precedence_set (str, sym->prec, sym->assoc,
482 symbol_check_alias_consistency_processor (void *this,
483 void *null ATTRIBUTE_UNUSED)
485 symbol_check_alias_consistency (this);
490 /*-------------------------------------------------------------------.
491 | Assign a symbol number, and write the definition of the token name |
492 | into FDEFINES. Put in SYMBOLS. |
493 `-------------------------------------------------------------------*/
496 symbol_pack (symbol *this)
498 aver (this->number != NUMBER_UNDEFINED);
499 if (this->class == nterm_sym)
500 this->number += ntokens;
501 else if (this->user_token_number == USER_NUMBER_HAS_STRING_ALIAS)
504 symbols[this->number] = this;
509 symbol_pack_processor (void *this, void *null ATTRIBUTE_UNUSED)
511 return symbol_pack (this);
516 user_token_number_redeclaration (int num, symbol *first, symbol *second)
518 /* User token numbers are not assigned during the parsing, but in a
519 second step, via a traversal of the symbol table sorted on tag.
521 However, error messages make more sense if we keep the first
522 declaration first. */
523 if (location_cmp (first->location, second->location) > 0)
529 complain_at (second->location,
530 _("user token number %d redeclaration for %s"),
532 complain_at (first->location, _("previous declaration for %s"),
536 /*--------------------------------------------------.
537 | Put THIS in TOKEN_TRANSLATIONS if it is a token. |
538 `--------------------------------------------------*/
541 symbol_translation (symbol *this)
544 if (this->class == token_sym
545 && this->user_token_number != USER_NUMBER_HAS_STRING_ALIAS)
547 /* A token which translation has already been set? */
548 if (token_translations[this->user_token_number] != undeftoken->number)
549 user_token_number_redeclaration
550 (this->user_token_number,
551 symbols[token_translations[this->user_token_number]],
554 token_translations[this->user_token_number] = this->number;
561 symbol_translation_processor (void *this, void *null ATTRIBUTE_UNUSED)
563 return symbol_translation (this);
567 /*---------------------------------------.
568 | Symbol and semantic type hash tables. |
569 `---------------------------------------*/
571 /* Initial capacity of symbol and semantic type hash table. */
572 #define HT_INITIAL_CAPACITY 257
574 static struct hash_table *symbol_table = NULL;
575 static struct hash_table *semantic_type_table = NULL;
578 hash_compare_symbol (const symbol *m1, const symbol *m2)
580 /* Since tags are unique, we can compare the pointers themselves. */
581 return UNIQSTR_EQ (m1->tag, m2->tag);
585 hash_compare_semantic_type (const semantic_type *m1, const semantic_type *m2)
587 /* Since names are unique, we can compare the pointers themselves. */
588 return UNIQSTR_EQ (m1->tag, m2->tag);
592 hash_symbol_comparator (void const *m1, void const *m2)
594 return hash_compare_symbol (m1, m2);
598 hash_semantic_type_comparator (void const *m1, void const *m2)
600 return hash_compare_semantic_type (m1, m2);
604 hash_symbol (const symbol *m, size_t tablesize)
606 /* Since tags are unique, we can hash the pointer itself. */
607 return ((uintptr_t) m->tag) % tablesize;
611 hash_semantic_type (const semantic_type *m, size_t tablesize)
613 /* Since names are unique, we can hash the pointer itself. */
614 return ((uintptr_t) m->tag) % tablesize;
618 hash_symbol_hasher (void const *m, size_t tablesize)
620 return hash_symbol (m, tablesize);
624 hash_semantic_type_hasher (void const *m, size_t tablesize)
626 return hash_semantic_type (m, tablesize);
629 /*-------------------------------.
630 | Create the symbol hash table. |
631 `-------------------------------*/
636 symbol_table = hash_initialize (HT_INITIAL_CAPACITY,
639 hash_symbol_comparator,
641 semantic_type_table = hash_initialize (HT_INITIAL_CAPACITY,
643 hash_semantic_type_hasher,
644 hash_semantic_type_comparator,
649 /*----------------------------------------------------------------.
650 | Find the symbol named KEY, and return it. If it does not exist |
652 `----------------------------------------------------------------*/
655 symbol_from_uniqstr (const uniqstr key, location loc)
661 entry = hash_lookup (symbol_table, &probe);
665 /* First insertion in the hash. */
666 aver (!symbols_sorted);
667 entry = symbol_new (key, loc);
668 if (!hash_insert (symbol_table, entry))
675 /*-----------------------------------------------------------------------.
676 | Find the semantic type named KEY, and return it. If it does not exist |
678 `-----------------------------------------------------------------------*/
681 semantic_type_from_uniqstr (const uniqstr key)
684 semantic_type *entry;
687 entry = hash_lookup (semantic_type_table, &probe);
691 /* First insertion in the hash. */
692 entry = semantic_type_new (key);
693 if (!hash_insert (semantic_type_table, entry))
700 /*----------------------------------------------------------------.
701 | Find the symbol named KEY, and return it. If it does not exist |
703 `----------------------------------------------------------------*/
706 symbol_get (const char *key, location loc)
708 return symbol_from_uniqstr (uniqstr_new (key), loc);
712 /*-----------------------------------------------------------------------.
713 | Find the semantic type named KEY, and return it. If it does not exist |
715 `-----------------------------------------------------------------------*/
718 semantic_type_get (const char *key)
720 return semantic_type_from_uniqstr (uniqstr_new (key));
724 /*------------------------------------------------------------------.
725 | Generate a dummy nonterminal, whose name cannot conflict with the |
727 `------------------------------------------------------------------*/
730 dummy_symbol_get (location loc)
732 /* Incremented for each generated symbol. */
733 static int dummy_count = 0;
734 static char buf[256];
738 sprintf (buf, "$@%d", ++dummy_count);
739 sym = symbol_get (buf, loc);
740 sym->class = nterm_sym;
741 sym->number = nvars++;
746 symbol_is_dummy (const symbol *sym)
748 return sym->tag[0] == '@' || (sym->tag[0] == '$' && sym->tag[1] == '@');
751 /*-------------------.
752 | Free the symbols. |
753 `-------------------*/
758 hash_free (symbol_table);
759 hash_free (semantic_type_table);
761 free (symbols_sorted);
765 /*---------------------------------------------------------------.
766 | Look for undefined symbols, report an error, and consider them |
768 `---------------------------------------------------------------*/
771 symbols_cmp (symbol const *a, symbol const *b)
773 return strcmp (a->tag, b->tag);
777 symbols_cmp_qsort (void const *a, void const *b)
779 return symbols_cmp (*(symbol * const *)a, *(symbol * const *)b);
783 symbols_do (Hash_processor processor, void *processor_data)
785 size_t count = hash_get_n_entries (symbol_table);
788 symbols_sorted = xnmalloc (count, sizeof *symbols_sorted);
789 hash_get_entries (symbol_table, (void**)symbols_sorted, count);
790 qsort (symbols_sorted, count, sizeof *symbols_sorted,
795 for (i = 0; i < count; ++i)
796 processor (symbols_sorted[i], processor_data);
800 /*--------------------------------------------------------------.
801 | Check that all the symbols are defined. Report any undefined |
802 | symbols and consider them nonterminals. |
803 `--------------------------------------------------------------*/
806 symbols_check_defined (void)
808 symbols_do (symbol_check_defined_processor, NULL);
811 /*------------------------------------------------------------------.
812 | Set TOKEN_TRANSLATIONS. Check that no two symbols share the same |
814 `------------------------------------------------------------------*/
817 symbols_token_translations_init (void)
819 bool num_256_available_p = true;
822 /* Find the highest user token number, and whether 256, the POSIX
823 preferred user token number for the error token, is used. */
824 max_user_token_number = 0;
825 for (i = 0; i < ntokens; ++i)
827 symbol *this = symbols[i];
828 if (this->user_token_number != USER_NUMBER_UNDEFINED)
830 if (this->user_token_number > max_user_token_number)
831 max_user_token_number = this->user_token_number;
832 if (this->user_token_number == 256)
833 num_256_available_p = false;
837 /* If 256 is not used, assign it to error, to follow POSIX. */
838 if (num_256_available_p
839 && errtoken->user_token_number == USER_NUMBER_UNDEFINED)
840 errtoken->user_token_number = 256;
842 /* Set the missing user numbers. */
843 if (max_user_token_number < 256)
844 max_user_token_number = 256;
846 for (i = 0; i < ntokens; ++i)
848 symbol *this = symbols[i];
849 if (this->user_token_number == USER_NUMBER_UNDEFINED)
850 this->user_token_number = ++max_user_token_number;
851 if (this->user_token_number > max_user_token_number)
852 max_user_token_number = this->user_token_number;
855 token_translations = xnmalloc (max_user_token_number + 1,
856 sizeof *token_translations);
858 /* Initialize all entries for literal tokens to 2, the internal
859 token number for $undefined, which represents all invalid inputs.
861 for (i = 0; i < max_user_token_number + 1; i++)
862 token_translations[i] = undeftoken->number;
863 symbols_do (symbol_translation_processor, NULL);
867 /*----------------------------------------------------------------.
868 | Assign symbol numbers, and write definition of token names into |
869 | FDEFINES. Set up vectors SYMBOL_TABLE, TAGS of symbols. |
870 `----------------------------------------------------------------*/
875 symbols_do (symbol_check_alias_consistency_processor, NULL);
877 symbols = xcalloc (nsyms, sizeof *symbols);
878 symbols_do (symbol_pack_processor, NULL);
880 /* Aliases leave empty slots in symbols, so remove them. */
884 int nsyms_old = nsyms;
885 for (writei = 0, readi = 0; readi < nsyms_old; readi += 1)
887 if (symbols[readi] == NULL)
894 symbols[writei] = symbols[readi];
895 symbols[writei]->number = writei;
896 if (symbols[writei]->alias)
897 symbols[writei]->alias->number = writei;
902 symbols = xnrealloc (symbols, nsyms, sizeof *symbols);
904 symbols_token_translations_init ();
906 if (startsymbol->class == unknown_sym)
907 fatal_at (startsymbol_location,
908 _("the start symbol %s is undefined"),
910 else if (startsymbol->class == token_sym)
911 fatal_at (startsymbol_location,
912 _("the start symbol %s is a token"),
917 /*--------------------------------------------------.
918 | Set default tagged/tagless %destructor/%printer. |
919 `--------------------------------------------------*/
922 default_tagged_destructor_set (code_props const *destructor)
924 if (default_tagged_destructor.code)
926 complain_at (destructor->location,
927 _("redeclaration for default tagged %%destructor"));
928 complain_at (default_tagged_destructor.location,
929 _("previous declaration"));
931 default_tagged_destructor = *destructor;
935 default_tagless_destructor_set (code_props const *destructor)
937 if (default_tagless_destructor.code)
939 complain_at (destructor->location,
940 _("redeclaration for default tagless %%destructor"));
941 complain_at (default_tagless_destructor.location,
942 _("previous declaration"));
944 default_tagless_destructor = *destructor;
948 default_tagged_printer_set (code_props const *printer)
950 if (default_tagged_printer.code)
952 complain_at (printer->location,
953 _("redeclaration for default tagged %%printer"));
954 complain_at (default_tagged_printer.location,
955 _("previous declaration"));
957 default_tagged_printer = *printer;
961 default_tagless_printer_set (code_props const *printer)
963 if (default_tagless_printer.code)
965 complain_at (printer->location,
966 _("redeclaration for default tagless %%printer"));
967 complain_at (default_tagless_printer.location,
968 _("previous declaration"));
970 default_tagless_printer = *printer;