]> git.saurik.com Git - bison.git/blame_incremental - src/symtab.c
maint: remove trailing blanks.
[bison.git] / src / symtab.c
... / ...
CommitLineData
1/* Symbol table manager for Bison.
2
3 Copyright (C) 1984, 1989, 2000-2002, 2004-2012 Free Software
4 Foundation, Inc.
5
6 This file is part of Bison, the GNU Compiler Compiler.
7
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.
12
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.
17
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/>. */
20
21#include <config.h>
22#include "system.h"
23
24#include <hash.h>
25#include <quotearg.h>
26
27#include "complain.h"
28#include "gram.h"
29#include "symtab.h"
30
31/*-------------------------------------------------------------------.
32| Symbols sorted by tag. Allocated by the first invocation of |
33| symbols_do, after which no more symbols should be created. |
34`-------------------------------------------------------------------*/
35
36static symbol **symbols_sorted = NULL;
37
38/*------------------------.
39| Distinguished symbols. |
40`------------------------*/
41
42symbol *errtoken = NULL;
43symbol *undeftoken = NULL;
44symbol *endtoken = NULL;
45symbol *accept = NULL;
46symbol *startsymbol = NULL;
47location startsymbol_location;
48
49/*---------------------------------------.
50| Default %destructor's and %printer's. |
51`---------------------------------------*/
52
53static code_props default_tagged_destructor = CODE_PROPS_NONE_INIT;
54static code_props default_tagless_destructor = CODE_PROPS_NONE_INIT;
55static code_props default_tagged_printer = CODE_PROPS_NONE_INIT;
56static code_props default_tagless_printer = CODE_PROPS_NONE_INIT;
57
58/*---------------------------------.
59| Create a new symbol, named TAG. |
60`---------------------------------*/
61
62static symbol *
63symbol_new (uniqstr tag, location loc)
64{
65 symbol *res = xmalloc (sizeof *res);
66
67 uniqstr_assert (tag);
68
69 /* If the tag is not a string (starts with a double quote), check
70 that it is valid for Yacc. */
71 if (tag[0] != '\"' && tag[0] != '\'' && mbschr (tag, '-'))
72 yacc_at (loc, _("POSIX Yacc forbids dashes in symbol names: %s"),
73 tag);
74
75 res->tag = tag;
76 res->location = loc;
77
78 res->type_name = NULL;
79 code_props_none_init (&res->destructor);
80 code_props_none_init (&res->printer);
81
82 res->number = NUMBER_UNDEFINED;
83 res->prec = 0;
84 res->assoc = undef_assoc;
85 res->user_token_number = USER_NUMBER_UNDEFINED;
86
87 res->alias = NULL;
88 res->class = unknown_sym;
89 res->declared = false;
90
91 if (nsyms == SYMBOL_NUMBER_MAXIMUM)
92 fatal (_("too many symbols in input grammar (limit is %d)"),
93 SYMBOL_NUMBER_MAXIMUM);
94 nsyms++;
95 return res;
96}
97
98/*----------------------------------------.
99| Create a new semantic type, named TAG. |
100`----------------------------------------*/
101
102static semantic_type *
103semantic_type_new (uniqstr tag)
104{
105 semantic_type *res = xmalloc (sizeof *res);
106
107 uniqstr_assert (tag);
108 res->tag = tag;
109 code_props_none_init (&res->destructor);
110 code_props_none_init (&res->printer);
111
112 return res;
113}
114
115
116/*-----------------.
117| Print a symbol. |
118`-----------------*/
119
120#define SYMBOL_ATTR_PRINT(Attr) \
121 if (s->Attr) \
122 fprintf (f, " %s { %s }", #Attr, s->Attr)
123
124#define SYMBOL_CODE_PRINT(Attr) \
125 if (s->Attr.code) \
126 fprintf (f, " %s { %s }", #Attr, s->Attr.code)
127
128void
129symbol_print (symbol *s, FILE *f)
130{
131 if (s)
132 {
133 fprintf (f, "\"%s\"", s->tag);
134 SYMBOL_ATTR_PRINT (type_name);
135 SYMBOL_CODE_PRINT (destructor);
136 SYMBOL_CODE_PRINT (printer);
137 }
138 else
139 fprintf (f, "<NULL>");
140}
141
142#undef SYMBOL_ATTR_PRINT
143#undef SYMBOL_CODE_PRINT
144
145/*------------------------------------------------------------------.
146| Complain that S's WHAT is redeclared at SECOND, and was first set |
147| at FIRST. |
148`------------------------------------------------------------------*/
149
150static void
151symbol_redeclaration (symbol *s, const char *what, location first,
152 location second)
153{
154 complain_at (second, _("%s redeclaration for %s"), what, s->tag);
155 complain_at (first, _("previous declaration"));
156}
157
158static void
159semantic_type_redeclaration (semantic_type *s, const char *what, location first,
160 location second)
161{
162 complain_at (second, _("%s redeclaration for <%s>"), what, s->tag);
163 complain_at (first, _("previous declaration"));
164}
165
166
167
168/*-----------------------------------------------------------------.
169| Set the TYPE_NAME associated with SYM. Does nothing if passed 0 |
170| as TYPE_NAME. |
171`-----------------------------------------------------------------*/
172
173void
174symbol_type_set (symbol *sym, uniqstr type_name, location loc)
175{
176 if (type_name)
177 {
178 if (sym->type_name)
179 symbol_redeclaration (sym, "%type", sym->type_location, loc);
180 uniqstr_assert (type_name);
181 sym->type_name = type_name;
182 sym->type_location = loc;
183 }
184}
185
186/*-----------------------------------------.
187| Set the DESTRUCTOR associated with SYM. |
188`-----------------------------------------*/
189
190void
191symbol_destructor_set (symbol *sym, code_props const *destructor)
192{
193 if (sym->destructor.code)
194 symbol_redeclaration (sym, "%destructor", sym->destructor.location,
195 destructor->location);
196 sym->destructor = *destructor;
197}
198
199/*------------------------------------------.
200| Set the DESTRUCTOR associated with TYPE. |
201`------------------------------------------*/
202
203void
204semantic_type_destructor_set (semantic_type *type,
205 code_props const *destructor)
206{
207 if (type->destructor.code)
208 semantic_type_redeclaration (type, "%destructor",
209 type->destructor.location,
210 destructor->location);
211 type->destructor = *destructor;
212}
213
214/*---------------------------------------.
215| Get the computed %destructor for SYM. |
216`---------------------------------------*/
217
218code_props const *
219symbol_destructor_get (symbol const *sym)
220{
221 /* Per-symbol %destructor. */
222 if (sym->destructor.code)
223 return &sym->destructor;
224
225 /* Per-type %destructor. */
226 if (sym->type_name)
227 {
228 code_props const *destructor =
229 &semantic_type_get (sym->type_name)->destructor;
230 if (destructor->code)
231 return destructor;
232 }
233
234 /* Apply default %destructor's only to user-defined symbols. */
235 if (sym->tag[0] == '$' || sym == errtoken)
236 return &code_props_none;
237
238 if (sym->type_name)
239 return &default_tagged_destructor;
240 return &default_tagless_destructor;
241}
242
243/*--------------------------------------.
244| Set the PRINTER associated with SYM. |
245`--------------------------------------*/
246
247void
248symbol_printer_set (symbol *sym, code_props const *printer)
249{
250 if (sym->printer.code)
251 symbol_redeclaration (sym, "%printer",
252 sym->printer.location, printer->location);
253 sym->printer = *printer;
254}
255
256/*---------------------------------------.
257| Set the PRINTER associated with TYPE. |
258`---------------------------------------*/
259
260void
261semantic_type_printer_set (semantic_type *type, code_props const *printer)
262{
263 if (type->printer.code)
264 semantic_type_redeclaration (type, "%printer",
265 type->printer.location, printer->location);
266 type->printer = *printer;
267}
268
269/*------------------------------------.
270| Get the computed %printer for SYM. |
271`------------------------------------*/
272
273code_props const *
274symbol_printer_get (symbol const *sym)
275{
276 /* Per-symbol %printer. */
277 if (sym->printer.code)
278 return &sym->printer;
279
280 /* Per-type %printer. */
281 if (sym->type_name)
282 {
283 code_props const *printer = &semantic_type_get (sym->type_name)->printer;
284 if (printer->code)
285 return printer;
286 }
287
288 /* Apply the default %printer only to user-defined symbols. */
289 if (sym->tag[0] == '$' || sym == errtoken)
290 return &code_props_none;
291
292 if (sym->type_name)
293 return &default_tagged_printer;
294 return &default_tagless_printer;
295}
296
297/*-----------------------------------------------------------------.
298| Set the PRECEDENCE associated with SYM. Does nothing if invoked |
299| with UNDEF_ASSOC as ASSOC. |
300`-----------------------------------------------------------------*/
301
302void
303symbol_precedence_set (symbol *sym, int prec, assoc a, location loc)
304{
305 if (a != undef_assoc)
306 {
307 if (sym->prec != 0)
308 symbol_redeclaration (sym, assoc_to_string (a), sym->prec_location,
309 loc);
310 sym->prec = prec;
311 sym->assoc = a;
312 sym->prec_location = loc;
313 }
314
315 /* Only terminals have a precedence. */
316 symbol_class_set (sym, token_sym, loc, false);
317}
318
319
320/*------------------------------------.
321| Set the CLASS associated with SYM. |
322`------------------------------------*/
323
324void
325symbol_class_set (symbol *sym, symbol_class class, location loc, bool declaring)
326{
327 if (sym->class != unknown_sym && sym->class != class)
328 {
329 complain_at (loc, _("symbol %s redefined"), sym->tag);
330 sym->declared = false;
331 }
332
333 if (class == nterm_sym && sym->class != nterm_sym)
334 sym->number = nvars++;
335 else if (class == token_sym && sym->number == NUMBER_UNDEFINED)
336 sym->number = ntokens++;
337
338 sym->class = class;
339
340 if (declaring)
341 {
342 if (sym->declared)
343 warn_at (loc, _("symbol %s redeclared"), sym->tag);
344 sym->declared = true;
345 }
346}
347
348
349/*------------------------------------------------.
350| Set the USER_TOKEN_NUMBER associated with SYM. |
351`------------------------------------------------*/
352
353void
354symbol_user_token_number_set (symbol *sym, int user_token_number, location loc)
355{
356 int *user_token_numberp;
357
358 if (sym->user_token_number != USER_NUMBER_HAS_STRING_ALIAS)
359 user_token_numberp = &sym->user_token_number;
360 else
361 user_token_numberp = &sym->alias->user_token_number;
362 if (*user_token_numberp != USER_NUMBER_UNDEFINED
363 && *user_token_numberp != user_token_number)
364 complain_at (loc, _("redefining user token number of %s"), sym->tag);
365
366 *user_token_numberp = user_token_number;
367 /* User defined $end token? */
368 if (user_token_number == 0)
369 {
370 endtoken = sym;
371 /* It is always mapped to 0, so it was already counted in
372 NTOKENS. */
373 if (endtoken->number != NUMBER_UNDEFINED)
374 --ntokens;
375 endtoken->number = 0;
376 }
377}
378
379
380/*----------------------------------------------------------.
381| If SYM is not defined, report an error, and consider it a |
382| nonterminal. |
383`----------------------------------------------------------*/
384
385static inline bool
386symbol_check_defined (symbol *sym)
387{
388 if (sym->class == unknown_sym)
389 {
390 complain_at
391 (sym->location,
392 _("symbol %s is used, but is not defined as a token and has no rules"),
393 sym->tag);
394 sym->class = nterm_sym;
395 sym->number = nvars++;
396 }
397
398 return true;
399}
400
401static bool
402symbol_check_defined_processor (void *sym, void *null ATTRIBUTE_UNUSED)
403{
404 return symbol_check_defined (sym);
405}
406
407
408void
409symbol_make_alias (symbol *sym, symbol *str, location loc)
410{
411 if (str->alias)
412 warn_at (loc, _("symbol '%s' used more than once as a literal string"),
413 str->tag);
414 else if (sym->alias)
415 warn_at (loc, _("symbol '%s' given more than one literal string"),
416 sym->tag);
417 else
418 {
419 str->class = token_sym;
420 str->user_token_number = sym->user_token_number;
421 sym->user_token_number = USER_NUMBER_HAS_STRING_ALIAS;
422 str->alias = sym;
423 sym->alias = str;
424 str->number = sym->number;
425 symbol_type_set (str, sym->type_name, loc);
426 }
427}
428
429
430/*---------------------------------------------------------.
431| Check that THIS, and its alias, have same precedence and |
432| associativity. |
433`---------------------------------------------------------*/
434
435static inline void
436symbol_check_alias_consistency (symbol *this)
437{
438 symbol *sym = this;
439 symbol *str = this->alias;
440
441 /* Check only the symbol in the symbol-string pair. */
442 if (!(this->alias
443 && this->user_token_number == USER_NUMBER_HAS_STRING_ALIAS))
444 return;
445
446 if (str->type_name != sym->type_name)
447 {
448 if (str->type_name)
449 symbol_type_set (sym, str->type_name, str->type_location);
450 else
451 symbol_type_set (str, sym->type_name, sym->type_location);
452 }
453
454
455 if (str->destructor.code || sym->destructor.code)
456 {
457 if (str->destructor.code)
458 symbol_destructor_set (sym, &str->destructor);
459 else
460 symbol_destructor_set (str, &sym->destructor);
461 }
462
463 if (str->printer.code || sym->printer.code)
464 {
465 if (str->printer.code)
466 symbol_printer_set (sym, &str->printer);
467 else
468 symbol_printer_set (str, &sym->printer);
469 }
470
471 if (sym->prec || str->prec)
472 {
473 if (str->prec)
474 symbol_precedence_set (sym, str->prec, str->assoc,
475 str->prec_location);
476 else
477 symbol_precedence_set (str, sym->prec, sym->assoc,
478 sym->prec_location);
479 }
480}
481
482static bool
483symbol_check_alias_consistency_processor (void *this,
484 void *null ATTRIBUTE_UNUSED)
485{
486 symbol_check_alias_consistency (this);
487 return true;
488}
489
490
491/*-------------------------------------------------------------------.
492| Assign a symbol number, and write the definition of the token name |
493| into FDEFINES. Put in SYMBOLS. |
494`-------------------------------------------------------------------*/
495
496static inline bool
497symbol_pack (symbol *this)
498{
499 aver (this->number != NUMBER_UNDEFINED);
500 if (this->class == nterm_sym)
501 this->number += ntokens;
502 else if (this->user_token_number == USER_NUMBER_HAS_STRING_ALIAS)
503 return true;
504
505 symbols[this->number] = this;
506 return true;
507}
508
509static bool
510symbol_pack_processor (void *this, void *null ATTRIBUTE_UNUSED)
511{
512 return symbol_pack (this);
513}
514
515
516static void
517user_token_number_redeclaration (int num, symbol *first, symbol *second)
518{
519 /* User token numbers are not assigned during the parsing, but in a
520 second step, via a traversal of the symbol table sorted on tag.
521
522 However, error messages make more sense if we keep the first
523 declaration first. */
524 if (location_cmp (first->location, second->location) > 0)
525 {
526 symbol* tmp = first;
527 first = second;
528 second = tmp;
529 }
530 complain_at (second->location,
531 _("user token number %d redeclaration for %s"),
532 num, second->tag);
533 complain_at (first->location, _("previous declaration for %s"),
534 first->tag);
535}
536
537/*--------------------------------------------------.
538| Put THIS in TOKEN_TRANSLATIONS if it is a token. |
539`--------------------------------------------------*/
540
541static inline bool
542symbol_translation (symbol *this)
543{
544 /* Non-terminal? */
545 if (this->class == token_sym
546 && this->user_token_number != USER_NUMBER_HAS_STRING_ALIAS)
547 {
548 /* A token which translation has already been set? */
549 if (token_translations[this->user_token_number] != undeftoken->number)
550 user_token_number_redeclaration
551 (this->user_token_number,
552 symbols[token_translations[this->user_token_number]],
553 this);
554
555 token_translations[this->user_token_number] = this->number;
556 }
557
558 return true;
559}
560
561static bool
562symbol_translation_processor (void *this, void *null ATTRIBUTE_UNUSED)
563{
564 return symbol_translation (this);
565}
566
567
568/*---------------------------------------.
569| Symbol and semantic type hash tables. |
570`---------------------------------------*/
571
572/* Initial capacity of symbol and semantic type hash table. */
573#define HT_INITIAL_CAPACITY 257
574
575static struct hash_table *symbol_table = NULL;
576static struct hash_table *semantic_type_table = NULL;
577
578static inline bool
579hash_compare_symbol (const symbol *m1, const symbol *m2)
580{
581 /* Since tags are unique, we can compare the pointers themselves. */
582 return UNIQSTR_EQ (m1->tag, m2->tag);
583}
584
585static inline bool
586hash_compare_semantic_type (const semantic_type *m1, const semantic_type *m2)
587{
588 /* Since names are unique, we can compare the pointers themselves. */
589 return UNIQSTR_EQ (m1->tag, m2->tag);
590}
591
592static bool
593hash_symbol_comparator (void const *m1, void const *m2)
594{
595 return hash_compare_symbol (m1, m2);
596}
597
598static bool
599hash_semantic_type_comparator (void const *m1, void const *m2)
600{
601 return hash_compare_semantic_type (m1, m2);
602}
603
604static inline size_t
605hash_symbol (const symbol *m, size_t tablesize)
606{
607 /* Since tags are unique, we can hash the pointer itself. */
608 return ((uintptr_t) m->tag) % tablesize;
609}
610
611static inline size_t
612hash_semantic_type (const semantic_type *m, size_t tablesize)
613{
614 /* Since names are unique, we can hash the pointer itself. */
615 return ((uintptr_t) m->tag) % tablesize;
616}
617
618static size_t
619hash_symbol_hasher (void const *m, size_t tablesize)
620{
621 return hash_symbol (m, tablesize);
622}
623
624static size_t
625hash_semantic_type_hasher (void const *m, size_t tablesize)
626{
627 return hash_semantic_type (m, tablesize);
628}
629
630/*-------------------------------.
631| Create the symbol hash table. |
632`-------------------------------*/
633
634void
635symbols_new (void)
636{
637 symbol_table = hash_initialize (HT_INITIAL_CAPACITY,
638 NULL,
639 hash_symbol_hasher,
640 hash_symbol_comparator,
641 free);
642 semantic_type_table = hash_initialize (HT_INITIAL_CAPACITY,
643 NULL,
644 hash_semantic_type_hasher,
645 hash_semantic_type_comparator,
646 free);
647}
648
649
650/*----------------------------------------------------------------.
651| Find the symbol named KEY, and return it. If it does not exist |
652| yet, create it. |
653`----------------------------------------------------------------*/
654
655symbol *
656symbol_from_uniqstr (const uniqstr key, location loc)
657{
658 symbol probe;
659 symbol *entry;
660
661 probe.tag = key;
662 entry = hash_lookup (symbol_table, &probe);
663
664 if (!entry)
665 {
666 /* First insertion in the hash. */
667 aver (!symbols_sorted);
668 entry = symbol_new (key, loc);
669 if (!hash_insert (symbol_table, entry))
670 xalloc_die ();
671 }
672 return entry;
673}
674
675
676/*-----------------------------------------------------------------------.
677| Find the semantic type named KEY, and return it. If it does not exist |
678| yet, create it. |
679`-----------------------------------------------------------------------*/
680
681semantic_type *
682semantic_type_from_uniqstr (const uniqstr key)
683{
684 semantic_type probe;
685 semantic_type *entry;
686
687 probe.tag = key;
688 entry = hash_lookup (semantic_type_table, &probe);
689
690 if (!entry)
691 {
692 /* First insertion in the hash. */
693 entry = semantic_type_new (key);
694 if (!hash_insert (semantic_type_table, entry))
695 xalloc_die ();
696 }
697 return entry;
698}
699
700
701/*----------------------------------------------------------------.
702| Find the symbol named KEY, and return it. If it does not exist |
703| yet, create it. |
704`----------------------------------------------------------------*/
705
706symbol *
707symbol_get (const char *key, location loc)
708{
709 return symbol_from_uniqstr (uniqstr_new (key), loc);
710}
711
712
713/*-----------------------------------------------------------------------.
714| Find the semantic type named KEY, and return it. If it does not exist |
715| yet, create it. |
716`-----------------------------------------------------------------------*/
717
718semantic_type *
719semantic_type_get (const char *key)
720{
721 return semantic_type_from_uniqstr (uniqstr_new (key));
722}
723
724
725/*------------------------------------------------------------------.
726| Generate a dummy nonterminal, whose name cannot conflict with the |
727| user's names. |
728`------------------------------------------------------------------*/
729
730symbol *
731dummy_symbol_get (location loc)
732{
733 /* Incremented for each generated symbol. */
734 static int dummy_count = 0;
735 static char buf[256];
736
737 symbol *sym;
738
739 sprintf (buf, "$@%d", ++dummy_count);
740 sym = symbol_get (buf, loc);
741 sym->class = nterm_sym;
742 sym->number = nvars++;
743 return sym;
744}
745
746bool
747symbol_is_dummy (const symbol *sym)
748{
749 return sym->tag[0] == '@' || (sym->tag[0] == '$' && sym->tag[1] == '@');
750}
751
752/*-------------------.
753| Free the symbols. |
754`-------------------*/
755
756void
757symbols_free (void)
758{
759 hash_free (symbol_table);
760 hash_free (semantic_type_table);
761 free (symbols);
762 free (symbols_sorted);
763}
764
765
766/*---------------------------------------------------------------.
767| Look for undefined symbols, report an error, and consider them |
768| terminals. |
769`---------------------------------------------------------------*/
770
771static int
772symbols_cmp (symbol const *a, symbol const *b)
773{
774 return strcmp (a->tag, b->tag);
775}
776
777static int
778symbols_cmp_qsort (void const *a, void const *b)
779{
780 return symbols_cmp (*(symbol * const *)a, *(symbol * const *)b);
781}
782
783static void
784symbols_do (Hash_processor processor, void *processor_data)
785{
786 size_t count = hash_get_n_entries (symbol_table);
787 if (!symbols_sorted)
788 {
789 symbols_sorted = xnmalloc (count, sizeof *symbols_sorted);
790 hash_get_entries (symbol_table, (void**)symbols_sorted, count);
791 qsort (symbols_sorted, count, sizeof *symbols_sorted,
792 symbols_cmp_qsort);
793 }
794 {
795 size_t i;
796 for (i = 0; i < count; ++i)
797 processor (symbols_sorted[i], processor_data);
798 }
799}
800
801/*--------------------------------------------------------------.
802| Check that all the symbols are defined. Report any undefined |
803| symbols and consider them nonterminals. |
804`--------------------------------------------------------------*/
805
806void
807symbols_check_defined (void)
808{
809 symbols_do (symbol_check_defined_processor, NULL);
810}
811
812/*------------------------------------------------------------------.
813| Set TOKEN_TRANSLATIONS. Check that no two symbols share the same |
814| number. |
815`------------------------------------------------------------------*/
816
817static void
818symbols_token_translations_init (void)
819{
820 bool num_256_available_p = true;
821 int i;
822
823 /* Find the highest user token number, and whether 256, the POSIX
824 preferred user token number for the error token, is used. */
825 max_user_token_number = 0;
826 for (i = 0; i < ntokens; ++i)
827 {
828 symbol *this = symbols[i];
829 if (this->user_token_number != USER_NUMBER_UNDEFINED)
830 {
831 if (this->user_token_number > max_user_token_number)
832 max_user_token_number = this->user_token_number;
833 if (this->user_token_number == 256)
834 num_256_available_p = false;
835 }
836 }
837
838 /* If 256 is not used, assign it to error, to follow POSIX. */
839 if (num_256_available_p
840 && errtoken->user_token_number == USER_NUMBER_UNDEFINED)
841 errtoken->user_token_number = 256;
842
843 /* Set the missing user numbers. */
844 if (max_user_token_number < 256)
845 max_user_token_number = 256;
846
847 for (i = 0; i < ntokens; ++i)
848 {
849 symbol *this = symbols[i];
850 if (this->user_token_number == USER_NUMBER_UNDEFINED)
851 this->user_token_number = ++max_user_token_number;
852 if (this->user_token_number > max_user_token_number)
853 max_user_token_number = this->user_token_number;
854 }
855
856 token_translations = xnmalloc (max_user_token_number + 1,
857 sizeof *token_translations);
858
859 /* Initialize all entries for literal tokens to 2, the internal
860 token number for $undefined, which represents all invalid inputs.
861 */
862 for (i = 0; i < max_user_token_number + 1; i++)
863 token_translations[i] = undeftoken->number;
864 symbols_do (symbol_translation_processor, NULL);
865}
866
867
868/*----------------------------------------------------------------.
869| Assign symbol numbers, and write definition of token names into |
870| FDEFINES. Set up vectors SYMBOL_TABLE, TAGS of symbols. |
871`----------------------------------------------------------------*/
872
873void
874symbols_pack (void)
875{
876 symbols_do (symbol_check_alias_consistency_processor, NULL);
877
878 symbols = xcalloc (nsyms, sizeof *symbols);
879 symbols_do (symbol_pack_processor, NULL);
880
881 /* Aliases leave empty slots in symbols, so remove them. */
882 {
883 int writei;
884 int readi;
885 int nsyms_old = nsyms;
886 for (writei = 0, readi = 0; readi < nsyms_old; readi += 1)
887 {
888 if (symbols[readi] == NULL)
889 {
890 nsyms -= 1;
891 ntokens -= 1;
892 }
893 else
894 {
895 symbols[writei] = symbols[readi];
896 symbols[writei]->number = writei;
897 if (symbols[writei]->alias)
898 symbols[writei]->alias->number = writei;
899 writei += 1;
900 }
901 }
902 }
903 symbols = xnrealloc (symbols, nsyms, sizeof *symbols);
904
905 symbols_token_translations_init ();
906
907 if (startsymbol->class == unknown_sym)
908 fatal_at (startsymbol_location,
909 _("the start symbol %s is undefined"),
910 startsymbol->tag);
911 else if (startsymbol->class == token_sym)
912 fatal_at (startsymbol_location,
913 _("the start symbol %s is a token"),
914 startsymbol->tag);
915}
916
917
918/*--------------------------------------------------.
919| Set default tagged/tagless %destructor/%printer. |
920`--------------------------------------------------*/
921
922void
923default_tagged_destructor_set (code_props const *destructor)
924{
925 if (default_tagged_destructor.code)
926 {
927 complain_at (destructor->location,
928 _("redeclaration for default tagged %%destructor"));
929 complain_at (default_tagged_destructor.location,
930 _("previous declaration"));
931 }
932 default_tagged_destructor = *destructor;
933}
934
935void
936default_tagless_destructor_set (code_props const *destructor)
937{
938 if (default_tagless_destructor.code)
939 {
940 complain_at (destructor->location,
941 _("redeclaration for default tagless %%destructor"));
942 complain_at (default_tagless_destructor.location,
943 _("previous declaration"));
944 }
945 default_tagless_destructor = *destructor;
946}
947
948void
949default_tagged_printer_set (code_props const *printer)
950{
951 if (default_tagged_printer.code)
952 {
953 complain_at (printer->location,
954 _("redeclaration for default tagged %%printer"));
955 complain_at (default_tagged_printer.location,
956 _("previous declaration"));
957 }
958 default_tagged_printer = *printer;
959}
960
961void
962default_tagless_printer_set (code_props const *printer)
963{
964 if (default_tagless_printer.code)
965 {
966 complain_at (printer->location,
967 _("redeclaration for default tagless %%printer"));
968 complain_at (default_tagless_printer.location,
969 _("previous declaration"));
970 }
971 default_tagless_printer = *printer;
972}