]> git.saurik.com Git - bison.git/blob - src/reader.c
* src/output.c (output_parser): Compute the `#line' lines when
[bison.git] / src / reader.c
1 /* Input parser for bison
2 Copyright 1984, 1986, 1989, 1992, 1998, 2000
3 Free Software Foundation, Inc.
4
5 This file is part of Bison, the GNU Compiler Compiler.
6
7 Bison is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 Bison is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Bison; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22
23 #include "system.h"
24 #include "obstack.h"
25 #include "quotearg.h"
26 #include "quote.h"
27 #include "getargs.h"
28 #include "files.h"
29 #include "xalloc.h"
30 #include "symtab.h"
31 #include "lex.h"
32 #include "gram.h"
33 #include "complain.h"
34 #include "output.h"
35 #include "reader.h"
36 #include "conflicts.h"
37
38 /* Number of slots allocated (but not necessarily used yet) in `rline' */
39 static int rline_allocated;
40
41 typedef struct symbol_list
42 {
43 struct symbol_list *next;
44 bucket *sym;
45 bucket *ruleprec;
46 }
47 symbol_list;
48
49 int lineno;
50 char **tags;
51 short *user_toknums;
52 static symbol_list *grammar;
53 static int start_flag;
54 static bucket *startval;
55
56 /* Nonzero if components of semantic values are used, implying
57 they must be unions. */
58 static int value_components_used;
59
60 /* Nonzero if %union has been seen. */
61 static int typed;
62
63 /* Incremented for each %left, %right or %nonassoc seen */
64 static int lastprec;
65
66 /* Incremented for each generated symbol */
67 static int gensym_count;
68
69 static bucket *errtoken;
70 static bucket *undeftoken;
71 \f
72
73 /*===================\
74 | Low level lexing. |
75 \===================*/
76
77 static void
78 skip_to_char (int target)
79 {
80 int c;
81 if (target == '\n')
82 complain (_(" Skipping to next \\n"));
83 else
84 complain (_(" Skipping to next %c"), target);
85
86 do
87 c = skip_white_space ();
88 while (c != target && c != EOF);
89 if (c != EOF)
90 ungetc (c, finput);
91 }
92
93
94 /*---------------------------------------------------------.
95 | Read a signed integer from STREAM and return its value. |
96 `---------------------------------------------------------*/
97
98 static inline int
99 read_signed_integer (FILE *stream)
100 {
101 int c = getc (stream);
102 int sign = 1;
103 int n = 0;
104
105 if (c == '-')
106 {
107 c = getc (stream);
108 sign = -1;
109 }
110
111 while (isdigit (c))
112 {
113 n = 10 * n + (c - '0');
114 c = getc (stream);
115 }
116
117 ungetc (c, stream);
118
119 return sign * n;
120 }
121 \f
122 /*--------------------------------------------------------------.
123 | Get the data type (alternative in the union) of the value for |
124 | symbol N in rule RULE. |
125 `--------------------------------------------------------------*/
126
127 static char *
128 get_type_name (int n, symbol_list * rule)
129 {
130 int i;
131 symbol_list *rp;
132
133 if (n < 0)
134 {
135 complain (_("invalid $ value"));
136 return NULL;
137 }
138
139 rp = rule;
140 i = 0;
141
142 while (i < n)
143 {
144 rp = rp->next;
145 if (rp == NULL || rp->sym == NULL)
146 {
147 complain (_("invalid $ value"));
148 return NULL;
149 }
150 i++;
151 }
152
153 return rp->sym->type_name;
154 }
155 \f
156 /*-----------------------------------------------------------------.
157 | Dump the string from FIN to FOUT and OOUT if non null. MATCH is |
158 | the delimiter of the string (either ' or "). |
159 `-----------------------------------------------------------------*/
160
161 static inline void
162 copy_string (FILE *fin, FILE *fout, struct obstack *oout, int match)
163 {
164 int c;
165
166 if (fout)
167 putc (match, fout);
168 if (oout)
169 obstack_1grow (oout, match);
170
171 c = getc (fin);
172
173 while (c != match)
174 {
175 if (c == EOF)
176 fatal (_("unterminated string at end of file"));
177 if (c == '\n')
178 {
179 complain (_("unterminated string"));
180 ungetc (c, fin);
181 c = match; /* invent terminator */
182 continue;
183 }
184
185 if (fout)
186 putc (c, fout);
187 if (oout)
188 obstack_1grow (oout, c);
189
190 if (c == '\\')
191 {
192 c = getc (fin);
193 if (c == EOF)
194 fatal (_("unterminated string at end of file"));
195 if (fout)
196 putc (c, fout);
197 if (oout)
198 obstack_1grow (oout, c);
199
200 if (c == '\n')
201 lineno++;
202 }
203
204 c = getc (fin);
205 }
206
207 if (fout)
208 putc (c, fout);
209 if (oout)
210 obstack_1grow (oout, c);
211 }
212
213
214 /*----------------------------------------------------------------.
215 | Dump the wannabee comment from IN to OUT1 and OUT2. In fact we |
216 | just saw a `/', which might or might not be a comment. In any |
217 | case, copy what we saw. |
218 | |
219 | OUT2 might be NULL. |
220 `----------------------------------------------------------------*/
221
222 static inline void
223 copy_comment2 (FILE *fin, FILE *out1,
224 struct obstack *oout2, struct obstack *oout)
225 {
226 int cplus_comment;
227 int ended;
228 int c;
229
230 /* We read a `/', output it. */
231 if (out1)
232 putc ('/', out1);
233 if (oout)
234 obstack_1grow (oout, '/');
235 if (oout2)
236 obstack_1grow (oout2, '/');
237
238 switch ((c = getc (fin)))
239 {
240 case '/':
241 cplus_comment = 1;
242 break;
243 case '*':
244 cplus_comment = 0;
245 break;
246 default:
247 ungetc (c, fin);
248 return;
249 }
250
251 if (out1)
252 putc (c, out1);
253 if (oout)
254 obstack_1grow (oout, c);
255 if (oout2)
256 obstack_1grow (oout2, c);
257 c = getc (fin);
258
259 ended = 0;
260 while (!ended)
261 {
262 if (!cplus_comment && c == '*')
263 {
264 while (c == '*')
265 {
266 if (out1)
267 putc (c, out1);
268 if (oout)
269 obstack_1grow (oout, c);
270 if (oout2)
271 obstack_1grow (oout2, c);
272 c = getc (fin);
273 }
274
275 if (c == '/')
276 {
277 if (out1)
278 putc (c, out1);
279 if (oout)
280 obstack_1grow (oout, c);
281 if (oout2)
282 obstack_1grow (oout2, c);
283 ended = 1;
284 }
285 }
286 else if (c == '\n')
287 {
288 lineno++;
289 if (out1)
290 putc (c, out1);
291 if (oout)
292 obstack_1grow (oout, c);
293 if (oout2)
294 obstack_1grow (oout2, c);
295 if (cplus_comment)
296 ended = 1;
297 else
298 c = getc (fin);
299 }
300 else if (c == EOF)
301 fatal (_("unterminated comment"));
302 else
303 {
304 if (out1)
305 putc (c, out1);
306 if (oout)
307 obstack_1grow (oout, c);
308 if (oout2)
309 obstack_1grow (oout2, c);
310 c = getc (fin);
311 }
312 }
313 }
314
315
316 /*-------------------------------------------------------------------.
317 | Dump the comment (actually the current string starting with a `/') |
318 | from FIN to FOUT. |
319 `-------------------------------------------------------------------*/
320
321 static inline void
322 copy_comment (FILE *fin, FILE *fout, struct obstack *oout)
323 {
324 copy_comment2 (fin, fout, NULL, oout);
325 }
326
327
328 /*-----------------------------------------------------------------.
329 | FIN is pointing to a location (i.e., a `@'). Output to FOUT a |
330 | reference to this location. STACK_OFFSET is the number of values |
331 | in the current rule so far, which says where to find `$0' with |
332 | respect to the top of the stack. |
333 `-----------------------------------------------------------------*/
334
335 static inline void
336 copy_at (FILE *fin, FILE *fout, struct obstack *oout, int stack_offset)
337 {
338 int c;
339
340 c = getc (fin);
341 if (c == '$')
342 {
343 if (fout)
344 fprintf (fout, "yyloc");
345 if (oout)
346 obstack_grow_literal_string (oout, "yyloc");
347 locations_flag = 1;
348 }
349 else if (isdigit (c) || c == '-')
350 {
351 int n;
352 char buf[4096];
353
354 ungetc (c, fin);
355 n = read_signed_integer (fin);
356
357 sprintf (buf, "yylsp[%d]", n - stack_offset);
358 if (fout)
359 fputs (buf, fout);
360 if (oout)
361 obstack_grow (oout, buf, strlen (buf));
362 locations_flag = 1;
363 }
364 else
365 {
366 char buf[] = "@c";
367 buf[1] = c;
368 complain (_("%s is invalid"), quote (buf));
369 }
370 }
371
372
373 /*-------------------------------------------------------------------.
374 | FIN is pointing to a wannabee semantic value (i.e., a `$'). |
375 | |
376 | Possible inputs: $[<TYPENAME>]($|integer) |
377 | |
378 | Output to FOUT a reference to this semantic value. STACK_OFFSET is |
379 | the number of values in the current rule so far, which says where |
380 | to find `$0' with respect to the top of the stack. |
381 `-------------------------------------------------------------------*/
382
383 static inline void
384 copy_dollar (FILE *fin, FILE *fout, struct obstack *oout,
385 symbol_list *rule, int stack_offset)
386 {
387 int c = getc (fin);
388 char *type_name = NULL;
389
390 /* Get the type name if explicit. */
391 if (c == '<')
392 {
393 read_type_name (fin);
394 type_name = token_buffer;
395 value_components_used = 1;
396 c = getc (fin);
397 }
398
399 if (c == '$')
400 {
401 if (fout)
402 fputs ("yyval", fout);
403 if (oout)
404 obstack_grow_literal_string (oout, "yyval");
405
406 if (!type_name)
407 type_name = get_type_name (0, rule);
408 if (type_name)
409 {
410 if (fout)
411 fprintf (fout, ".%s", type_name);
412 if (oout)
413 obstack_fgrow1 (oout, ".%s", type_name);
414 }
415 if (!type_name && typed)
416 complain (_("$$ of `%s' has no declared type"),
417 rule->sym->tag);
418 }
419 else if (isdigit (c) || c == '-')
420 {
421 int n;
422 ungetc (c, fin);
423 n = read_signed_integer (fin);
424
425 if (!type_name && n > 0)
426 type_name = get_type_name (n, rule);
427
428 if (fout)
429 fprintf (fout, "yyvsp[%d]", n - stack_offset);
430 if (oout)
431 obstack_fgrow1 (oout, "yyvsp[%d]", n - stack_offset);
432
433 if (type_name)
434 {
435 if (fout)
436 fprintf (fout, ".%s", type_name);
437 if (oout)
438 obstack_fgrow1 (oout, ".%s", type_name);
439 }
440 if (!type_name && typed)
441 complain (_("$%d of `%s' has no declared type"),
442 n, rule->sym->tag);
443 }
444 else
445 {
446 char buf[] = "$c";
447 buf[1] = c;
448 complain (_("%s is invalid"), quote (buf));
449 }
450 }
451 \f
452 /*-------------------------------------------------------------------.
453 | Copy the contents of a `%{ ... %}' into the definitions file. The |
454 | `%{' has already been read. Return after reading the `%}'. |
455 `-------------------------------------------------------------------*/
456
457 static void
458 copy_definition (void)
459 {
460 int c;
461 /* -1 while reading a character if prev char was %. */
462 int after_percent;
463
464 if (!no_lines_flag)
465 obstack_fgrow2 (&attrs_obstack, "#line %d %s\n",
466 lineno, quotearg_style (c_quoting_style, infile));
467
468 after_percent = 0;
469
470 c = getc (finput);
471
472 for (;;)
473 {
474 switch (c)
475 {
476 case '\n':
477 obstack_1grow (&attrs_obstack, c);
478 lineno++;
479 break;
480
481 case '%':
482 after_percent = -1;
483 break;
484
485 case '\'':
486 case '"':
487 copy_string (finput, 0, &attrs_obstack, c);
488 break;
489
490 case '/':
491 copy_comment (finput, 0, &attrs_obstack);
492 break;
493
494 case EOF:
495 fatal ("%s", _("unterminated `%{' definition"));
496
497 default:
498 obstack_1grow (&attrs_obstack, c);
499 }
500
501 c = getc (finput);
502
503 if (after_percent)
504 {
505 if (c == '}')
506 return;
507 obstack_1grow (&attrs_obstack, '%');
508 }
509 after_percent = 0;
510 }
511 }
512
513
514 /*-------------------------------------------------------------------.
515 | Parse what comes after %token or %nterm. For %token, WHAT_IS is |
516 | token_sym and WHAT_IS_NOT is nterm_sym. For %nterm, the arguments |
517 | are reversed. |
518 `-------------------------------------------------------------------*/
519
520 static void
521 parse_token_decl (symbol_class what_is, symbol_class what_is_not)
522 {
523 int token = 0;
524 char *typename = 0;
525
526 /* The symbol being defined. */
527 struct bucket *symbol = NULL;
528
529 /* After `%token' and `%nterm', any number of symbols maybe be
530 defined. */
531 for (;;)
532 {
533 int tmp_char = ungetc (skip_white_space (), finput);
534
535 /* `%' (for instance from `%token', or from `%%' etc.) is the
536 only valid means to end this declaration. */
537 if (tmp_char == '%')
538 return;
539 if (tmp_char == EOF)
540 fatal (_("Premature EOF after %s"), token_buffer);
541
542 token = lex ();
543 if (token == COMMA)
544 {
545 symbol = NULL;
546 continue;
547 }
548 if (token == TYPENAME)
549 {
550 typename = xstrdup (token_buffer);
551 value_components_used = 1;
552 symbol = NULL;
553 }
554 else if (token == IDENTIFIER && *symval->tag == '\"' && symbol)
555 {
556 if (symval->alias)
557 warn (_("symbol `%s' used more than once as a literal string"),
558 symval->tag);
559 else if (symbol->alias)
560 warn (_("symbol `%s' given more than one literal string"),
561 symbol->tag);
562 else
563 {
564 symval->class = token_sym;
565 symval->type_name = typename;
566 symval->user_token_number = symbol->user_token_number;
567 symbol->user_token_number = SALIAS;
568 symval->alias = symbol;
569 symbol->alias = symval;
570 /* symbol and symval combined are only one symbol */
571 nsyms--;
572 }
573 translations = 1;
574 symbol = NULL;
575 }
576 else if (token == IDENTIFIER)
577 {
578 int oldclass = symval->class;
579 symbol = symval;
580
581 if (symbol->class == what_is_not)
582 complain (_("symbol %s redefined"), symbol->tag);
583 symbol->class = what_is;
584 if (what_is == nterm_sym && oldclass != nterm_sym)
585 symbol->value = nvars++;
586
587 if (typename)
588 {
589 if (symbol->type_name == NULL)
590 symbol->type_name = typename;
591 else if (strcmp (typename, symbol->type_name) != 0)
592 complain (_("type redeclaration for %s"), symbol->tag);
593 }
594 }
595 else if (symbol && token == NUMBER)
596 {
597 symbol->user_token_number = numval;
598 translations = 1;
599 }
600 else
601 {
602 complain (_("`%s' is invalid in %s"),
603 token_buffer, (what_is == token_sym) ? "%token" : "%nterm");
604 skip_to_char ('%');
605 }
606 }
607
608 }
609
610
611 /*------------------------------.
612 | Parse what comes after %start |
613 `------------------------------*/
614
615 static void
616 parse_start_decl (void)
617 {
618 if (start_flag)
619 complain (_("multiple %s declarations"), "%start");
620 if (lex () != IDENTIFIER)
621 complain (_("invalid %s declaration"), "%start");
622 else
623 {
624 start_flag = 1;
625 startval = symval;
626 }
627 }
628
629 /*-----------------------------------------------------------.
630 | read in a %type declaration and record its information for |
631 | get_type_name to access |
632 `-----------------------------------------------------------*/
633
634 static void
635 parse_type_decl (void)
636 {
637 char *name;
638
639 if (lex () != TYPENAME)
640 {
641 complain ("%s", _("%type declaration has no <typename>"));
642 skip_to_char ('%');
643 return;
644 }
645
646 name = xstrdup (token_buffer);
647
648 for (;;)
649 {
650 int t;
651 int tmp_char = ungetc (skip_white_space (), finput);
652
653 if (tmp_char == '%')
654 return;
655 if (tmp_char == EOF)
656 fatal (_("Premature EOF after %s"), token_buffer);
657
658 t = lex ();
659
660 switch (t)
661 {
662
663 case COMMA:
664 case SEMICOLON:
665 break;
666
667 case IDENTIFIER:
668 if (symval->type_name == NULL)
669 symval->type_name = name;
670 else if (strcmp (name, symval->type_name) != 0)
671 complain (_("type redeclaration for %s"), symval->tag);
672
673 break;
674
675 default:
676 complain (_("invalid %%type declaration due to item: %s"),
677 token_buffer);
678 skip_to_char ('%');
679 }
680 }
681 }
682
683
684
685 /*----------------------------------------------------------------.
686 | Read in a %left, %right or %nonassoc declaration and record its |
687 | information. |
688 `----------------------------------------------------------------*/
689
690 static void
691 parse_assoc_decl (associativity assoc)
692 {
693 char *name = NULL;
694 int prev = 0;
695
696 lastprec++; /* Assign a new precedence level, never 0. */
697
698 for (;;)
699 {
700 int t;
701 int tmp_char = ungetc (skip_white_space (), finput);
702
703 if (tmp_char == '%')
704 return;
705 if (tmp_char == EOF)
706 fatal (_("Premature EOF after %s"), token_buffer);
707
708 t = lex ();
709
710 switch (t)
711 {
712 case TYPENAME:
713 name = xstrdup (token_buffer);
714 break;
715
716 case COMMA:
717 break;
718
719 case IDENTIFIER:
720 if (symval->prec != 0)
721 complain (_("redefining precedence of %s"), symval->tag);
722 symval->prec = lastprec;
723 symval->assoc = assoc;
724 if (symval->class == nterm_sym)
725 complain (_("symbol %s redefined"), symval->tag);
726 symval->class = token_sym;
727 if (name)
728 { /* record the type, if one is specified */
729 if (symval->type_name == NULL)
730 symval->type_name = name;
731 else if (strcmp (name, symval->type_name) != 0)
732 complain (_("type redeclaration for %s"), symval->tag);
733 }
734 break;
735
736 case NUMBER:
737 if (prev == IDENTIFIER)
738 {
739 symval->user_token_number = numval;
740 translations = 1;
741 }
742 else
743 {
744 complain (_
745 ("invalid text (%s) - number should be after identifier"),
746 token_buffer);
747 skip_to_char ('%');
748 }
749 break;
750
751 case SEMICOLON:
752 return;
753
754 default:
755 complain (_("unexpected item: %s"), token_buffer);
756 skip_to_char ('%');
757 }
758
759 prev = t;
760
761 }
762 }
763
764
765
766 /*--------------------------------------------------------------.
767 | Copy the union declaration into ATTRS_OBSTACK (and fdefines), |
768 | where it is made into the definition of YYSTYPE, the type of |
769 | elements of the parser value stack. |
770 `--------------------------------------------------------------*/
771
772 static void
773 parse_union_decl (void)
774 {
775 int c;
776 int count = 0;
777
778 if (typed)
779 complain (_("multiple %s declarations"), "%union");
780
781 typed = 1;
782
783 if (!no_lines_flag)
784 obstack_fgrow2 (&attrs_obstack, "\n#line %d %s\n",
785 lineno, quotearg_style (c_quoting_style, infile));
786 else
787 obstack_1grow (&attrs_obstack, '\n');
788
789 obstack_grow_literal_string (&attrs_obstack, "typedef union");
790 if (defines_flag)
791 obstack_grow_literal_string (&defines_obstack, "typedef union");
792
793 c = getc (finput);
794
795 while (c != EOF)
796 {
797 obstack_1grow (&attrs_obstack, c);
798 if (defines_flag)
799 obstack_1grow (&defines_obstack, c);
800
801 switch (c)
802 {
803 case '\n':
804 lineno++;
805 break;
806
807 case '/':
808 copy_comment2 (finput, 0, &defines_obstack, &attrs_obstack);
809 break;
810
811 case '{':
812 count++;
813 break;
814
815 case '}':
816 if (count == 0)
817 complain (_("unmatched %s"), "`}'");
818 count--;
819 if (count <= 0)
820 {
821 obstack_grow_literal_string (&attrs_obstack, " YYSTYPE;\n");
822 if (defines_flag)
823 obstack_grow_literal_string (&defines_obstack, " YYSTYPE;\n");
824 /* JF don't choke on trailing semi */
825 c = skip_white_space ();
826 if (c != ';')
827 ungetc (c, finput);
828 return;
829 }
830 }
831
832 c = getc (finput);
833 }
834 }
835
836
837 /*-------------------------------------------------------.
838 | Parse the declaration %expect N which says to expect N |
839 | shift-reduce conflicts. |
840 `-------------------------------------------------------*/
841
842 static void
843 parse_expect_decl (void)
844 {
845 int c = skip_white_space ();
846 ungetc (c, finput);
847
848 if (!isdigit (c))
849 complain (_("argument of %%expect is not an integer"));
850 else
851 expected_conflicts = read_signed_integer (finput);
852 }
853
854
855 /*-------------------------------------------------------------------.
856 | Parse what comes after %thong. the full syntax is |
857 | |
858 | %thong <type> token number literal |
859 | |
860 | the <type> or number may be omitted. The number specifies the |
861 | user_token_number. |
862 | |
863 | Two symbols are entered in the table, one for the token symbol and |
864 | one for the literal. Both are given the <type>, if any, from the |
865 | declaration. The ->user_token_number of the first is SALIAS and |
866 | the ->user_token_number of the second is set to the number, if |
867 | any, from the declaration. The two symbols are linked via |
868 | pointers in their ->alias fields. |
869 | |
870 | During OUTPUT_DEFINES_TABLE, the symbol is reported thereafter, |
871 | only the literal string is retained it is the literal string that |
872 | is output to yytname |
873 `-------------------------------------------------------------------*/
874
875 static void
876 parse_thong_decl (void)
877 {
878 int token;
879 struct bucket *symbol;
880 char *typename = 0;
881 int usrtoknum;
882
883 translations = 1;
884 token = lex (); /* fetch typename or first token */
885 if (token == TYPENAME)
886 {
887 typename = xstrdup (token_buffer);
888 value_components_used = 1;
889 token = lex (); /* fetch first token */
890 }
891
892 /* process first token */
893
894 if (token != IDENTIFIER)
895 {
896 complain (_("unrecognized item %s, expected an identifier"),
897 token_buffer);
898 skip_to_char ('%');
899 return;
900 }
901 symval->class = token_sym;
902 symval->type_name = typename;
903 symval->user_token_number = SALIAS;
904 symbol = symval;
905
906 token = lex (); /* get number or literal string */
907
908 if (token == NUMBER)
909 {
910 usrtoknum = numval;
911 token = lex (); /* okay, did number, now get literal */
912 }
913 else
914 usrtoknum = 0;
915
916 /* process literal string token */
917
918 if (token != IDENTIFIER || *symval->tag != '\"')
919 {
920 complain (_("expected string constant instead of %s"), token_buffer);
921 skip_to_char ('%');
922 return;
923 }
924 symval->class = token_sym;
925 symval->type_name = typename;
926 symval->user_token_number = usrtoknum;
927
928 symval->alias = symbol;
929 symbol->alias = symval;
930
931 /* symbol and symval combined are only one symbol. */
932 nsyms--;
933 }
934
935
936 /*----------------------------------------------------------------.
937 | Read from finput until `%%' is seen. Discard the `%%'. Handle |
938 | any `%' declarations, and copy the contents of any `%{ ... %}' |
939 | groups to ATTRS_OBSTACK. |
940 `----------------------------------------------------------------*/
941
942 static void
943 read_declarations (void)
944 {
945 int c;
946 int tok;
947
948 for (;;)
949 {
950 c = skip_white_space ();
951
952 if (c == '%')
953 {
954 tok = parse_percent_token ();
955
956 switch (tok)
957 {
958 case TWO_PERCENTS:
959 return;
960
961 case PERCENT_LEFT_CURLY:
962 copy_definition ();
963 break;
964
965 case TOKEN:
966 parse_token_decl (token_sym, nterm_sym);
967 break;
968
969 case NTERM:
970 parse_token_decl (nterm_sym, token_sym);
971 break;
972
973 case TYPE:
974 parse_type_decl ();
975 break;
976
977 case START:
978 parse_start_decl ();
979 break;
980
981 case UNION:
982 parse_union_decl ();
983 break;
984
985 case EXPECT:
986 parse_expect_decl ();
987 break;
988 case THONG:
989 parse_thong_decl ();
990 break;
991
992 case LEFT:
993 parse_assoc_decl (left_assoc);
994 break;
995
996 case RIGHT:
997 parse_assoc_decl (right_assoc);
998 break;
999
1000 case NONASSOC:
1001 parse_assoc_decl (non_assoc);
1002 break;
1003
1004 case SEMANTIC_PARSER:
1005 if (!semantic_parser)
1006 fguard = xfopen (guardfile, "w");
1007 semantic_parser = 1;
1008 break;
1009
1010 case PURE_PARSER:
1011 pure_parser = 1;
1012 break;
1013
1014 case NOOP:
1015 break;
1016
1017 default:
1018 complain (_("unrecognized: %s"), token_buffer);
1019 skip_to_char ('%');
1020 }
1021 }
1022 else if (c == EOF)
1023 fatal (_("no input grammar"));
1024 else
1025 {
1026 char buf[] = "c";
1027 buf[0] = c;
1028 complain (_("unknown character: %s"), quote (buf));
1029 skip_to_char ('%');
1030 }
1031 }
1032 }
1033 \f
1034 /*-------------------------------------------------------------------.
1035 | Assuming that a `{' has just been seen, copy everything up to the |
1036 | matching `}' into the actions file. STACK_OFFSET is the number of |
1037 | values in the current rule so far, which says where to find `$0' |
1038 | with respect to the top of the stack. |
1039 `-------------------------------------------------------------------*/
1040
1041 static void
1042 copy_action (symbol_list *rule, int stack_offset)
1043 {
1044 int c;
1045 int count;
1046 char buf[4096];
1047
1048 /* offset is always 0 if parser has already popped the stack pointer */
1049 if (semantic_parser)
1050 stack_offset = 0;
1051
1052 sprintf (buf, "\ncase %d:\n", nrules);
1053 obstack_grow (&action_obstack, buf, strlen (buf));
1054
1055 if (!no_lines_flag)
1056 {
1057 sprintf (buf, "#line %d %s\n",
1058 lineno, quotearg_style (c_quoting_style, infile));
1059 obstack_grow (&action_obstack, buf, strlen (buf));
1060 }
1061 obstack_1grow (&action_obstack, '{');
1062
1063 count = 1;
1064 c = getc (finput);
1065
1066 while (count > 0)
1067 {
1068 while (c != '}')
1069 {
1070 switch (c)
1071 {
1072 case '\n':
1073 obstack_1grow (&action_obstack, c);
1074 lineno++;
1075 break;
1076
1077 case '{':
1078 obstack_1grow (&action_obstack, c);
1079 count++;
1080 break;
1081
1082 case '\'':
1083 case '"':
1084 copy_string (finput, 0, &action_obstack, c);
1085 break;
1086
1087 case '/':
1088 copy_comment (finput, 0, &action_obstack);
1089 break;
1090
1091 case '$':
1092 copy_dollar (finput, 0, &action_obstack,
1093 rule, stack_offset);
1094 break;
1095
1096 case '@':
1097 copy_at (finput, 0, &action_obstack,
1098 stack_offset);
1099 break;
1100
1101 case EOF:
1102 fatal (_("unmatched %s"), "`{'");
1103
1104 default:
1105 obstack_1grow (&action_obstack, c);
1106 }
1107
1108 c = getc (finput);
1109 }
1110
1111 /* above loop exits when c is '}' */
1112
1113 if (--count)
1114 {
1115 obstack_1grow (&action_obstack, c);
1116 c = getc (finput);
1117 }
1118 }
1119
1120 obstack_grow_literal_string (&action_obstack,
1121 ";\n break;}");
1122 }
1123 \f
1124 /*-------------------------------------------------------------------.
1125 | After `%guard' is seen in the input file, copy the actual guard |
1126 | into the guards file. If the guard is followed by an action, copy |
1127 | that into the actions file. STACK_OFFSET is the number of values |
1128 | in the current rule so far, which says where to find `$0' with |
1129 | respect to the top of the stack, for the simple parser in which |
1130 | the stack is not popped until after the guard is run. |
1131 `-------------------------------------------------------------------*/
1132
1133 static void
1134 copy_guard (symbol_list *rule, int stack_offset)
1135 {
1136 int c;
1137 int count;
1138 int brace_flag = 0;
1139
1140 /* offset is always 0 if parser has already popped the stack pointer */
1141 if (semantic_parser)
1142 stack_offset = 0;
1143
1144 fprintf (fguard, "\ncase %d:\n", nrules);
1145 if (!no_lines_flag)
1146 fprintf (fguard, "#line %d %s\n",
1147 lineno, quotearg_style (c_quoting_style, infile));
1148 putc ('{', fguard);
1149
1150 count = 0;
1151 c = getc (finput);
1152
1153 while (brace_flag ? (count > 0) : (c != ';'))
1154 {
1155 switch (c)
1156 {
1157 case '\n':
1158 putc (c, fguard);
1159 lineno++;
1160 break;
1161
1162 case '{':
1163 putc (c, fguard);
1164 brace_flag = 1;
1165 count++;
1166 break;
1167
1168 case '}':
1169 putc (c, fguard);
1170 if (count > 0)
1171 count--;
1172 else
1173 {
1174 complain (_("unmatched %s"), "`}'");
1175 c = getc (finput); /* skip it */
1176 }
1177 break;
1178
1179 case '\'':
1180 case '"':
1181 copy_string (finput, fguard, 0, c);
1182 break;
1183
1184 case '/':
1185 copy_comment (finput, fguard, 0);
1186 break;
1187
1188 case '$':
1189 copy_dollar (finput, fguard, 0, rule, stack_offset);
1190 break;
1191
1192 case '@':
1193 copy_at (finput, fguard, 0, stack_offset);
1194 break;
1195
1196 case EOF:
1197 fatal ("%s", _("unterminated %guard clause"));
1198
1199 default:
1200 putc (c, fguard);
1201 }
1202
1203 if (c != '}' || count != 0)
1204 c = getc (finput);
1205 }
1206
1207 c = skip_white_space ();
1208
1209 fprintf (fguard, ";\n break;}");
1210 if (c == '{')
1211 copy_action (rule, stack_offset);
1212 else if (c == '=')
1213 {
1214 c = getc (finput); /* why not skip_white_space -wjh */
1215 if (c == '{')
1216 copy_action (rule, stack_offset);
1217 }
1218 else
1219 ungetc (c, finput);
1220 }
1221 \f
1222
1223 static void
1224 record_rule_line (void)
1225 {
1226 /* Record each rule's source line number in rline table. */
1227
1228 if (nrules >= rline_allocated)
1229 {
1230 rline_allocated = nrules * 2;
1231 rline = XREALLOC (rline, short, rline_allocated);
1232 }
1233 rline[nrules] = lineno;
1234 }
1235
1236
1237 /*-------------------------------------------------------------------.
1238 | Generate a dummy symbol, a nonterminal, whose name cannot conflict |
1239 | with the user's names. |
1240 `-------------------------------------------------------------------*/
1241
1242 static bucket *
1243 gensym (void)
1244 {
1245 bucket *sym;
1246
1247 sprintf (token_buffer, "@%d", ++gensym_count);
1248 sym = getsym (token_buffer);
1249 sym->class = nterm_sym;
1250 sym->value = nvars++;
1251 return sym;
1252 }
1253
1254 #if 0
1255 /*------------------------------------------------------------------.
1256 | read in a %type declaration and record its information for |
1257 | get_type_name to access. This is unused. It is only called from |
1258 | the #if 0 part of readgram |
1259 `------------------------------------------------------------------*/
1260
1261 static int
1262 get_type (void)
1263 {
1264 int k;
1265 int t;
1266 char *name;
1267
1268 t = lex ();
1269
1270 if (t != TYPENAME)
1271 {
1272 complain (_("invalid %s declaration"), "%type");
1273 return t;
1274 }
1275
1276 name = xstrdup (token_buffer);
1277
1278 for (;;)
1279 {
1280 t = lex ();
1281
1282 switch (t)
1283 {
1284 case SEMICOLON:
1285 return lex ();
1286
1287 case COMMA:
1288 break;
1289
1290 case IDENTIFIER:
1291 if (symval->type_name == NULL)
1292 symval->type_name = name;
1293 else if (strcmp (name, symval->type_name) != 0)
1294 complain (_("type redeclaration for %s"), symval->tag);
1295
1296 break;
1297
1298 default:
1299 return t;
1300 }
1301 }
1302 }
1303
1304 #endif
1305 \f
1306 /*------------------------------------------------------------------.
1307 | Parse the input grammar into a one symbol_list structure. Each |
1308 | rule is represented by a sequence of symbols: the left hand side |
1309 | followed by the contents of the right hand side, followed by a |
1310 | null pointer instead of a symbol to terminate the rule. The next |
1311 | symbol is the lhs of the following rule. |
1312 | |
1313 | All guards and actions are copied out to the appropriate files, |
1314 | labelled by the rule number they apply to. |
1315 `------------------------------------------------------------------*/
1316
1317 static void
1318 readgram (void)
1319 {
1320 int t;
1321 bucket *lhs = NULL;
1322 symbol_list *p;
1323 symbol_list *p1;
1324 bucket *bp;
1325
1326 /* Points to first symbol_list of current rule. its symbol is the
1327 lhs of the rule. */
1328 symbol_list *crule;
1329 /* Points to the symbol_list preceding crule. */
1330 symbol_list *crule1;
1331
1332 p1 = NULL;
1333
1334 t = lex ();
1335
1336 while (t != TWO_PERCENTS && t != ENDFILE)
1337 {
1338 if (t == IDENTIFIER || t == BAR)
1339 {
1340 int action_flag = 0;
1341 /* Number of symbols in rhs of this rule so far */
1342 int rulelength = 0;
1343 int xactions = 0; /* JF for error checking */
1344 bucket *first_rhs = 0;
1345
1346 if (t == IDENTIFIER)
1347 {
1348 lhs = symval;
1349
1350 if (!start_flag)
1351 {
1352 startval = lhs;
1353 start_flag = 1;
1354 }
1355
1356 t = lex ();
1357 if (t != COLON)
1358 {
1359 complain (_("ill-formed rule: initial symbol not followed by colon"));
1360 unlex (t);
1361 }
1362 }
1363
1364 if (nrules == 0 && t == BAR)
1365 {
1366 complain (_("grammar starts with vertical bar"));
1367 lhs = symval; /* BOGUS: use a random symval */
1368 }
1369 /* start a new rule and record its lhs. */
1370
1371 nrules++;
1372 nitems++;
1373
1374 record_rule_line ();
1375
1376 p = XCALLOC (symbol_list, 1);
1377 p->sym = lhs;
1378
1379 crule1 = p1;
1380 if (p1)
1381 p1->next = p;
1382 else
1383 grammar = p;
1384
1385 p1 = p;
1386 crule = p;
1387
1388 /* mark the rule's lhs as a nonterminal if not already so. */
1389
1390 if (lhs->class == unknown_sym)
1391 {
1392 lhs->class = nterm_sym;
1393 lhs->value = nvars;
1394 nvars++;
1395 }
1396 else if (lhs->class == token_sym)
1397 complain (_("rule given for %s, which is a token"), lhs->tag);
1398
1399 /* read the rhs of the rule. */
1400
1401 for (;;)
1402 {
1403 t = lex ();
1404 if (t == PREC)
1405 {
1406 t = lex ();
1407 crule->ruleprec = symval;
1408 t = lex ();
1409 }
1410
1411 if (!(t == IDENTIFIER || t == LEFT_CURLY))
1412 break;
1413
1414 /* If next token is an identifier, see if a colon follows it.
1415 If one does, exit this rule now. */
1416 if (t == IDENTIFIER)
1417 {
1418 bucket *ssave;
1419 int t1;
1420
1421 ssave = symval;
1422 t1 = lex ();
1423 unlex (t1);
1424 symval = ssave;
1425 if (t1 == COLON)
1426 break;
1427
1428 if (!first_rhs) /* JF */
1429 first_rhs = symval;
1430 /* Not followed by colon =>
1431 process as part of this rule's rhs. */
1432 }
1433
1434 /* If we just passed an action, that action was in the middle
1435 of a rule, so make a dummy rule to reduce it to a
1436 non-terminal. */
1437 if (action_flag)
1438 {
1439 bucket *sdummy;
1440
1441 /* Since the action was written out with this rule's
1442 number, we must give the new rule this number by
1443 inserting the new rule before it. */
1444
1445 /* Make a dummy nonterminal, a gensym. */
1446 sdummy = gensym ();
1447
1448 /* Make a new rule, whose body is empty,
1449 before the current one, so that the action
1450 just read can belong to it. */
1451 nrules++;
1452 nitems++;
1453 record_rule_line ();
1454 p = XCALLOC (symbol_list, 1);
1455 if (crule1)
1456 crule1->next = p;
1457 else
1458 grammar = p;
1459 p->sym = sdummy;
1460 crule1 = XCALLOC (symbol_list, 1);
1461 p->next = crule1;
1462 crule1->next = crule;
1463
1464 /* Insert the dummy generated by that rule into this
1465 rule. */
1466 nitems++;
1467 p = XCALLOC (symbol_list, 1);
1468 p->sym = sdummy;
1469 p1->next = p;
1470 p1 = p;
1471
1472 action_flag = 0;
1473 }
1474
1475 if (t == IDENTIFIER)
1476 {
1477 nitems++;
1478 p = XCALLOC (symbol_list, 1);
1479 p->sym = symval;
1480 p1->next = p;
1481 p1 = p;
1482 }
1483 else /* handle an action. */
1484 {
1485 copy_action (crule, rulelength);
1486 action_flag = 1;
1487 xactions++; /* JF */
1488 }
1489 rulelength++;
1490 } /* end of read rhs of rule */
1491
1492 /* Put an empty link in the list to mark the end of this rule */
1493 p = XCALLOC (symbol_list, 1);
1494 p1->next = p;
1495 p1 = p;
1496
1497 if (t == PREC)
1498 {
1499 complain (_("two @prec's in a row"));
1500 t = lex ();
1501 crule->ruleprec = symval;
1502 t = lex ();
1503 }
1504 if (t == GUARD)
1505 {
1506 if (!semantic_parser)
1507 complain (_("%%guard present but %%semantic_parser not specified"));
1508
1509 copy_guard (crule, rulelength);
1510 t = lex ();
1511 }
1512 else if (t == LEFT_CURLY)
1513 {
1514 /* This case never occurs -wjh */
1515 if (action_flag)
1516 complain (_("two actions at end of one rule"));
1517 copy_action (crule, rulelength);
1518 action_flag = 1;
1519 xactions++; /* -wjh */
1520 t = lex ();
1521 }
1522 /* If $$ is being set in default way, report if any type
1523 mismatch. */
1524 else if (!xactions
1525 && first_rhs && lhs->type_name != first_rhs->type_name)
1526 {
1527 if (lhs->type_name == 0
1528 || first_rhs->type_name == 0
1529 || strcmp (lhs->type_name, first_rhs->type_name))
1530 complain (_("type clash (`%s' `%s') on default action"),
1531 lhs->type_name ? lhs->type_name : "",
1532 first_rhs->type_name ? first_rhs->type_name : "");
1533 }
1534 /* Warn if there is no default for $$ but we need one. */
1535 else if (!xactions && !first_rhs && lhs->type_name != 0)
1536 complain (_("empty rule for typed nonterminal, and no action"));
1537 if (t == SEMICOLON)
1538 t = lex ();
1539 }
1540 #if 0
1541 /* these things can appear as alternatives to rules. */
1542 /* NO, they cannot.
1543 a) none of the documentation allows them
1544 b) most of them scan forward until finding a next %
1545 thus they may swallow lots of intervening rules
1546 */
1547 else if (t == TOKEN)
1548 {
1549 parse_token_decl (token_sym, nterm_sym);
1550 t = lex ();
1551 }
1552 else if (t == NTERM)
1553 {
1554 parse_token_decl (nterm_sym, token_sym);
1555 t = lex ();
1556 }
1557 else if (t == TYPE)
1558 {
1559 t = get_type ();
1560 }
1561 else if (t == UNION)
1562 {
1563 parse_union_decl ();
1564 t = lex ();
1565 }
1566 else if (t == EXPECT)
1567 {
1568 parse_expect_decl ();
1569 t = lex ();
1570 }
1571 else if (t == START)
1572 {
1573 parse_start_decl ();
1574 t = lex ();
1575 }
1576 #endif
1577
1578 else
1579 {
1580 complain (_("invalid input: %s"), token_buffer);
1581 t = lex ();
1582 }
1583 }
1584
1585 /* grammar has been read. Do some checking */
1586
1587 if (nsyms > MAXSHORT)
1588 fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
1589 MAXSHORT);
1590 if (nrules == 0)
1591 fatal (_("no rules in the input grammar"));
1592
1593 /* JF put out same default YYSTYPE as YACC does */
1594 if (typed == 0
1595 && !value_components_used)
1596 {
1597 /* We used to use `unsigned long' as YYSTYPE on MSDOS,
1598 but it seems better to be consistent.
1599 Most programs should declare their own type anyway. */
1600 obstack_grow_literal_string (&attrs_obstack,
1601 "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
1602 if (defines_flag)
1603 obstack_grow_literal_string (&defines_obstack, "\
1604 #ifndef YYSTYPE\n\
1605 # define YYSTYPE int\n\
1606 #endif\n");
1607 }
1608
1609 /* Report any undefined symbols and consider them nonterminals. */
1610
1611 for (bp = firstsymbol; bp; bp = bp->next)
1612 if (bp->class == unknown_sym)
1613 {
1614 complain (_
1615 ("symbol %s is used, but is not defined as a token and has no rules"),
1616 bp->tag);
1617 bp->class = nterm_sym;
1618 bp->value = nvars++;
1619 }
1620
1621 ntokens = nsyms - nvars;
1622 }
1623 \f
1624 /*--------------------------------------------------------------.
1625 | For named tokens, but not literal ones, define the name. The |
1626 | value is the user token number. |
1627 `--------------------------------------------------------------*/
1628
1629 static void
1630 output_token_defines (struct obstack *oout)
1631 {
1632 bucket *bp;
1633 char *cp, *symbol;
1634 char c;
1635
1636 for (bp = firstsymbol; bp; bp = bp->next)
1637 {
1638 symbol = bp->tag; /* get symbol */
1639
1640 if (bp->value >= ntokens)
1641 continue;
1642 if (bp->user_token_number == SALIAS)
1643 continue;
1644 if ('\'' == *symbol)
1645 continue; /* skip literal character */
1646 if (bp == errtoken)
1647 continue; /* skip error token */
1648 if ('\"' == *symbol)
1649 {
1650 /* use literal string only if given a symbol with an alias */
1651 if (bp->alias)
1652 symbol = bp->alias->tag;
1653 else
1654 continue;
1655 }
1656
1657 /* Don't #define nonliteral tokens whose names contain periods. */
1658 cp = symbol;
1659 while ((c = *cp++) && c != '.');
1660 if (c != '\0')
1661 continue;
1662
1663 obstack_fgrow2 (oout, "#define\t%s\t%d\n",
1664 symbol,
1665 ((translations && !raw_flag)
1666 ? bp->user_token_number : bp->value));
1667 if (semantic_parser)
1668 obstack_fgrow2 (oout, "#define\tT%s\t%d\n", symbol, bp->value);
1669 }
1670
1671 obstack_1grow (oout, '\n');
1672 }
1673
1674
1675 /*------------------------------------------------------------------.
1676 | Assign symbol numbers, and write definition of token names into |
1677 | FDEFINES. Set up vectors TAGS and SPREC of names and precedences |
1678 | of symbols. |
1679 `------------------------------------------------------------------*/
1680
1681 static void
1682 packsymbols (void)
1683 {
1684 bucket *bp;
1685 int tokno = 1;
1686 int i;
1687 int last_user_token_number;
1688 static char DOLLAR[] = "$";
1689
1690 /* int lossage = 0; JF set but not used */
1691
1692 tags = XCALLOC (char *, nsyms + 1);
1693 tags[0] = DOLLAR;
1694 user_toknums = XCALLOC (short, nsyms + 1);
1695 user_toknums[0] = 0;
1696
1697 sprec = XCALLOC (short, nsyms);
1698 sassoc = XCALLOC (short, nsyms);
1699
1700 max_user_token_number = 256;
1701 last_user_token_number = 256;
1702
1703 for (bp = firstsymbol; bp; bp = bp->next)
1704 {
1705 if (bp->class == nterm_sym)
1706 {
1707 bp->value += ntokens;
1708 }
1709 else if (bp->alias)
1710 {
1711 /* this symbol and its alias are a single token defn.
1712 allocate a tokno, and assign to both check agreement of
1713 ->prec and ->assoc fields and make both the same */
1714 if (bp->value == 0)
1715 bp->value = bp->alias->value = tokno++;
1716
1717 if (bp->prec != bp->alias->prec)
1718 {
1719 if (bp->prec != 0 && bp->alias->prec != 0
1720 && bp->user_token_number == SALIAS)
1721 complain (_("conflicting precedences for %s and %s"),
1722 bp->tag, bp->alias->tag);
1723 if (bp->prec != 0)
1724 bp->alias->prec = bp->prec;
1725 else
1726 bp->prec = bp->alias->prec;
1727 }
1728
1729 if (bp->assoc != bp->alias->assoc)
1730 {
1731 if (bp->assoc != 0 && bp->alias->assoc != 0
1732 && bp->user_token_number == SALIAS)
1733 complain (_("conflicting assoc values for %s and %s"),
1734 bp->tag, bp->alias->tag);
1735 if (bp->assoc != 0)
1736 bp->alias->assoc = bp->assoc;
1737 else
1738 bp->assoc = bp->alias->assoc;
1739 }
1740
1741 if (bp->user_token_number == SALIAS)
1742 continue; /* do not do processing below for SALIASs */
1743
1744 }
1745 else /* bp->class == token_sym */
1746 {
1747 bp->value = tokno++;
1748 }
1749
1750 if (bp->class == token_sym)
1751 {
1752 if (translations && !(bp->user_token_number))
1753 bp->user_token_number = ++last_user_token_number;
1754 if (bp->user_token_number > max_user_token_number)
1755 max_user_token_number = bp->user_token_number;
1756 }
1757
1758 tags[bp->value] = bp->tag;
1759 user_toknums[bp->value] = bp->user_token_number;
1760 sprec[bp->value] = bp->prec;
1761 sassoc[bp->value] = bp->assoc;
1762
1763 }
1764
1765 if (translations)
1766 {
1767 int j;
1768
1769 token_translations = XCALLOC (short, max_user_token_number + 1);
1770
1771 /* initialize all entries for literal tokens to 2, the internal
1772 token number for $undefined., which represents all invalid
1773 inputs. */
1774 for (j = 0; j <= max_user_token_number; j++)
1775 token_translations[j] = 2;
1776
1777 for (bp = firstsymbol; bp; bp = bp->next)
1778 {
1779 if (bp->value >= ntokens)
1780 continue; /* non-terminal */
1781 if (bp->user_token_number == SALIAS)
1782 continue;
1783 if (token_translations[bp->user_token_number] != 2)
1784 complain (_("tokens %s and %s both assigned number %d"),
1785 tags[token_translations[bp->user_token_number]],
1786 bp->tag, bp->user_token_number);
1787 token_translations[bp->user_token_number] = bp->value;
1788 }
1789 }
1790
1791 error_token_number = errtoken->value;
1792
1793 if (!no_parser_flag)
1794 output_token_defines (&table_obstack);
1795
1796 if (startval->class == unknown_sym)
1797 fatal (_("the start symbol %s is undefined"), startval->tag);
1798 else if (startval->class == token_sym)
1799 fatal (_("the start symbol %s is a token"), startval->tag);
1800
1801 start_symbol = startval->value;
1802
1803 if (defines_flag)
1804 {
1805 output_token_defines (&defines_obstack);
1806
1807 if (!pure_parser)
1808 {
1809 if (spec_name_prefix)
1810 obstack_fgrow1 (&defines_obstack, "\nextern YYSTYPE %slval;\n",
1811 spec_name_prefix);
1812 else
1813 obstack_grow_literal_string (&defines_obstack,
1814 "\nextern YYSTYPE yylval;\n");
1815 }
1816
1817 if (semantic_parser)
1818 for (i = ntokens; i < nsyms; i++)
1819 {
1820 /* don't make these for dummy nonterminals made by gensym. */
1821 if (*tags[i] != '@')
1822 obstack_fgrow2 (&defines_obstack,
1823 "#define\tNT%s\t%d\n", tags[i], i);
1824 }
1825 #if 0
1826 /* `fdefines' is now a temporary file, so we need to copy its
1827 contents in `done', so we can't close it here. */
1828 fclose (fdefines);
1829 fdefines = NULL;
1830 #endif
1831 }
1832 }
1833
1834
1835 /*---------------------------------------------------------------.
1836 | Convert the rules into the representation using RRHS, RLHS and |
1837 | RITEMS. |
1838 `---------------------------------------------------------------*/
1839
1840 static void
1841 packgram (void)
1842 {
1843 int itemno;
1844 int ruleno;
1845 symbol_list *p;
1846
1847 bucket *ruleprec;
1848
1849 ritem = XCALLOC (short, nitems + 1);
1850 rlhs = XCALLOC (short, nrules) - 1;
1851 rrhs = XCALLOC (short, nrules) - 1;
1852 rprec = XCALLOC (short, nrules) - 1;
1853 rprecsym = XCALLOC (short, nrules) - 1;
1854 rassoc = XCALLOC (short, nrules) - 1;
1855
1856 itemno = 0;
1857 ruleno = 1;
1858
1859 p = grammar;
1860 while (p)
1861 {
1862 rlhs[ruleno] = p->sym->value;
1863 rrhs[ruleno] = itemno;
1864 ruleprec = p->ruleprec;
1865
1866 p = p->next;
1867 while (p && p->sym)
1868 {
1869 ritem[itemno++] = p->sym->value;
1870 /* A rule gets by default the precedence and associativity
1871 of the last token in it. */
1872 if (p->sym->class == token_sym)
1873 {
1874 rprec[ruleno] = p->sym->prec;
1875 rassoc[ruleno] = p->sym->assoc;
1876 }
1877 if (p)
1878 p = p->next;
1879 }
1880
1881 /* If this rule has a %prec,
1882 the specified symbol's precedence replaces the default. */
1883 if (ruleprec)
1884 {
1885 rprec[ruleno] = ruleprec->prec;
1886 rassoc[ruleno] = ruleprec->assoc;
1887 rprecsym[ruleno] = ruleprec->value;
1888 }
1889
1890 ritem[itemno++] = -ruleno;
1891 ruleno++;
1892
1893 if (p)
1894 p = p->next;
1895 }
1896
1897 ritem[itemno] = 0;
1898 }
1899 \f
1900 /*-------------------------------------------------------------------.
1901 | Read in the grammar specification and record it in the format |
1902 | described in gram.h. All guards are copied into the FGUARD file |
1903 | and all actions into ACTION_OBSTACK, in each case forming the body |
1904 | of a C function (YYGUARD or YYACTION) which contains a switch |
1905 | statement to decide which guard or action to execute. |
1906 `-------------------------------------------------------------------*/
1907
1908 void
1909 reader (void)
1910 {
1911 start_flag = 0;
1912 startval = NULL; /* start symbol not specified yet. */
1913
1914 #if 0
1915 /* initially assume token number translation not needed. */
1916 translations = 0;
1917 #endif
1918 /* Nowadays translations is always set to 1, since we give `error' a
1919 user-token-number to satisfy the Posix demand for YYERRCODE==256.
1920 */
1921 translations = 1;
1922
1923 nsyms = 1;
1924 nvars = 0;
1925 nrules = 0;
1926 nitems = 0;
1927 rline_allocated = 10;
1928 rline = XCALLOC (short, rline_allocated);
1929
1930 typed = 0;
1931 lastprec = 0;
1932
1933 gensym_count = 0;
1934
1935 semantic_parser = 0;
1936 pure_parser = 0;
1937
1938 grammar = NULL;
1939
1940 init_lex ();
1941 lineno = 1;
1942
1943 /* Initialize the symbol table. */
1944 tabinit ();
1945 /* Construct the error token */
1946 errtoken = getsym ("error");
1947 errtoken->class = token_sym;
1948 errtoken->user_token_number = 256; /* Value specified by POSIX. */
1949 /* Construct a token that represents all undefined literal tokens.
1950 It is always token number 2. */
1951 undeftoken = getsym ("$undefined.");
1952 undeftoken->class = token_sym;
1953 undeftoken->user_token_number = 2;
1954
1955 /* Read the declaration section. Copy %{ ... %} groups to
1956 TABLE_OBSTACK and FDEFINES file. Also notice any %token, %left,
1957 etc. found there. */
1958 obstack_1grow (&table_obstack, '\n');
1959 obstack_fgrow3 (&table_obstack, "\
1960 /* %s, made from %s\n\
1961 by GNU bison %s. */\n\
1962 \n",
1963 no_parser_flag ? "Bison-generated parse tables" : "A Bison parser",
1964 infile, VERSION);
1965
1966 obstack_grow_literal_string (&table_obstack,
1967 "#define YYBISON 1 /* Identify Bison output. */\n\n");
1968 read_declarations ();
1969 /* Start writing the guard and action files, if they are needed. */
1970 output_headers ();
1971 /* Read in the grammar, build grammar in list form. Write out
1972 guards and actions. */
1973 readgram ();
1974 /* Now we know whether we need the line-number stack. If we do,
1975 write its type into the .tab.h file. */
1976 if (defines_flag)
1977 reader_output_yylsp (&defines_obstack);
1978 /* Write closing delimiters for actions and guards. */
1979 output_trailers ();
1980 if (locations_flag)
1981 obstack_grow_literal_string (&table_obstack, "#define YYLSP_NEEDED 1\n\n");
1982 /* Assign the symbols their symbol numbers. Write #defines for the
1983 token symbols into FDEFINES if requested. */
1984 packsymbols ();
1985 /* Convert the grammar into the format described in gram.h. */
1986 packgram ();
1987 /* Free the symbol table data structure since symbols are now all
1988 referred to by symbol number. */
1989 free_symtab ();
1990 }
1991
1992
1993 /*------------------------------------------------------------------.
1994 | Define YYLTYPE. Cannot be in the skeleton since we might have to |
1995 | output it in the headers if --defines is used. |
1996 `------------------------------------------------------------------*/
1997
1998 void
1999 reader_output_yylsp (struct obstack *oout)
2000 {
2001 if (locations_flag)
2002 obstack_grow_literal_string (oout, "\
2003 \n\
2004 #ifndef YYLTYPE\n\
2005 typedef struct yyltype\n\
2006 {\n\
2007 int first_line;\n\
2008 int first_column;\n\
2009 \n\
2010 int last_line;\n\
2011 int last_column;\n\
2012 } yyltype;\n\
2013 \n\
2014 # define YYLTYPE yyltype\n\
2015 #endif\n\
2016 \n");
2017 }