Merge branch 'vendor/GMP' into gcc441
[dragonfly.git] / usr.bin / yacc / reader.c
1 /*
2  * Copyright (c) 1989 The Regents of the University of California.
3  * All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Robert Paul Corbett.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * $FreeBSD: src/usr.bin/yacc/reader.c,v 1.8.2.1 2001/10/05 03:00:44 obrien Exp $
37  * $DragonFly: src/usr.bin/yacc/reader.c,v 1.5 2005/01/05 15:26:05 joerg Exp $
38  *
39  * @(#)reader.c 5.7 (Berkeley) 1/20/91
40  */
41
42 #include <stdlib.h>
43 #include <string.h>
44 #include "defs.h"
45
46 /*  The line size must be a positive integer.  One hundred was chosen   */
47 /*  because few lines in Yacc input grammars exceed 100 characters.     */
48 /*  Note that if a line exceeds LINESIZE characters, the line buffer    */
49 /*  will be expanded to accomodate it.                                  */
50
51 #define LINESIZE 100
52
53 char *cache;
54 int cinc, cache_size;
55
56 int ntags, tagmax;
57 char **tag_table;
58
59 char saw_eof, unionized;
60 const char *cptr;
61 char *line;
62 int linesize;
63
64 bucket *goal;
65 int prec;
66 int gensym;
67 char last_was_action;
68
69 int maxitems;
70 bucket **pitem;
71
72 int maxrules;
73 bucket **plhs;
74
75 int name_pool_size;
76 char *name_pool;
77
78 static const char line_format[] = "#line %d \"%s\"\n";
79
80 static void add_symbol(void);
81 static void advance_to_start(void);
82 static void cachec(int);
83 static void check_symbols(void);
84 static void copy_action(void);
85 static void copy_ident(void);
86 static void copy_text(void);
87 static void copy_union(void);
88 static void declare_start(void);
89 static void declare_tokens(int);
90 static void declare_types(void);
91 static char *dup_line(void);
92 static void end_rule(void);
93 static void expand_items(void);
94 static void expand_rules(void);
95 static void free_tags(void);
96 static void get_line(void);
97 static bucket *get_literal(void);
98 static bucket *get_name(void);
99 static int get_number(void);
100 static char *get_tag(void);
101 static int hexval(int);
102 static void initialize_grammar(void);
103 static void insert_empty_rule(void);
104 static int is_reserved(char *);
105 static int keyword(void);
106 static int mark_symbol(void);
107 static int nextc(void);
108 static void pack_grammar(void);
109 static void pack_names(void);
110 static void pack_symbols(void);
111 static void print_grammar(void);
112 static void read_declarations(void);
113 static void read_grammar(void);
114 static void skip_comment(void);
115 static void start_rule(bucket *, int);
116
117 static void
118 cachec(int c)
119 {
120     assert(cinc >= 0);
121     if (cinc >= cache_size)
122     {
123         cache_size += 256;
124         cache = REALLOC(cache, cache_size);
125         if (cache == 0) no_space();
126     }
127     cache[cinc] = c;
128     ++cinc;
129 }
130
131
132 static void
133 get_line(void)
134 {
135     FILE *f = input_file;
136     int c;
137     int i;
138
139     if (saw_eof || (c = getc(f)) == EOF)
140     {
141         if (line) { FREE(line); line = NULL; }
142         cptr = NULL;
143         saw_eof = 1;
144         return;
145     }
146
147     if (line == 0 || linesize != (LINESIZE + 1))
148     {
149         if (line) FREE(line);
150         linesize = LINESIZE + 1;
151         line = MALLOC(linesize);
152         if (line == 0) no_space();
153     }
154
155     i = 0;
156     ++lineno;
157     for (;;)
158     {
159         line[i]  =  c;
160         if (c == '\n') { cptr = line; return; }
161         if (++i >= linesize)
162         {
163             linesize += LINESIZE;
164             line = REALLOC(line, linesize);
165             if (line ==  0) no_space();
166         }
167         c = getc(f);
168         if (c ==  EOF)
169         {
170             line[i] = '\n';
171             saw_eof = 1;
172             cptr = line;
173             return;
174         }
175     }
176 }
177
178
179 static char *
180 dup_line(void)
181 {
182     char *p, *s, *t;
183
184     if (line == 0) return (0);
185     s = line;
186     while (*s != '\n') ++s;
187     p = MALLOC(s - line + 1);
188     if (p == 0) no_space();
189
190     s = line;
191     t = p;
192     while ((*t++ = *s++) != '\n') continue;
193     return (p);
194 }
195
196
197 static void
198 skip_comment(void)
199 {
200     const char *s;
201
202     int st_lineno = lineno;
203     char *st_line = dup_line();
204     char *st_cptr = st_line + (cptr - line);
205
206     s = cptr + 2;
207     for (;;)
208     {
209         if (*s == '*' && s[1] == '/')
210         {
211             cptr = s + 2;
212             FREE(st_line);
213             return;
214         }
215         if (*s == '\n')
216         {
217             get_line();
218             if (line == NULL)
219                 unterminated_comment(st_lineno, st_line, st_cptr);
220             s = cptr;
221         }
222         else
223             ++s;
224     }
225 }
226
227
228 static int
229 nextc(void)
230 {
231     const char *s;
232
233     if (line == 0)
234     {
235         get_line();
236         if (line == 0)
237             return (EOF);
238     }
239
240     s = cptr;
241     for (;;)
242     {
243         switch (*s)
244         {
245         case '\n':
246             get_line();
247             if (line == 0) return (EOF);
248             s = cptr;
249             break;
250
251         case ' ':
252         case '\t':
253         case '\f':
254         case '\r':
255         case '\v':
256         case ',':
257         case ';':
258             ++s;
259             break;
260
261         case '\\':
262             cptr = s;
263             return ('%');
264
265         case '/':
266             if (s[1] == '*')
267             {
268                 cptr = s;
269                 skip_comment();
270                 s = cptr;
271                 break;
272             }
273             else if (s[1] == '/')
274             {
275                 get_line();
276                 if (line == 0) return (EOF);
277                 s = cptr;
278                 break;
279             }
280             /* fall through */
281
282         default:
283             cptr = s;
284             return (*s);
285         }
286     }
287 }
288
289
290 static int
291 keyword(void)
292 {
293     int c;
294     const char *t_cptr = cptr;
295
296     c = *++cptr;
297     if (isalpha(c))
298     {
299         cinc = 0;
300         for (;;)
301         {
302             if (isalpha(c))
303             {
304                 if (isupper(c)) c = tolower(c);
305                 cachec(c);
306             }
307             else if (isdigit(c) || c == '_' || c == '.' || c == '$')
308                 cachec(c);
309             else
310                 break;
311             c = *++cptr;
312         }
313         cachec(NUL);
314
315         if (strcmp(cache, "token") == 0 || strcmp(cache, "term") == 0)
316             return (TOKEN);
317         if (strcmp(cache, "type") == 0)
318             return (TYPE);
319         if (strcmp(cache, "left") == 0)
320             return (LEFT);
321         if (strcmp(cache, "right") == 0)
322             return (RIGHT);
323         if (strcmp(cache, "nonassoc") == 0 || strcmp(cache, "binary") == 0)
324             return (NONASSOC);
325         if (strcmp(cache, "start") == 0)
326             return (START);
327         if (strcmp(cache, "union") == 0)
328             return (UNION);
329         if (strcmp(cache, "ident") == 0)
330             return (IDENT);
331         if (strcmp(cache, "expect") == 0)
332             return (EXPECT);
333     }
334     else
335     {
336         ++cptr;
337         if (c == '{')
338             return (TEXT);
339         if (c == '%' || c == '\\')
340             return (MARK);
341         if (c == '<')
342             return (LEFT);
343         if (c == '>')
344             return (RIGHT);
345         if (c == '0')
346             return (TOKEN);
347         if (c == '2')
348             return (NONASSOC);
349     }
350     syntax_error(lineno, line, t_cptr);
351     /*NOTREACHED*/
352     return (0);
353 }
354
355
356 static void
357 copy_ident(void)
358 {
359     int c;
360     FILE *f = output_file;
361
362     c = nextc();
363     if (c == EOF) unexpected_EOF();
364     if (c != '"') syntax_error(lineno, line, cptr);
365     ++outline;
366     fprintf(f, "#ident \"");
367     for (;;)
368     {
369         c = *++cptr;
370         if (c == '\n')
371         {
372             fprintf(f, "\"\n");
373             return;
374         }
375         putc(c, f);
376         if (c == '"')
377         {
378             putc('\n', f);
379             ++cptr;
380             return;
381         }
382     }
383 }
384
385
386 static void
387 copy_text(void)
388 {
389     int c;
390     int quote;
391     FILE *f = text_file;
392     int need_newline = 0;
393     int t_lineno = lineno;
394     char *t_line = dup_line();
395     const char *t_cptr = t_line + (cptr - line - 2);
396
397     if (*cptr == '\n')
398     {
399         get_line();
400         if (line == 0)
401             unterminated_text(t_lineno, t_line, t_cptr);
402     }
403     if (!lflag) fprintf(f, line_format, lineno, input_file_name);
404
405 loop:
406     c = *cptr++;
407     switch (c)
408     {
409     case '\n':
410     next_line:
411         putc('\n', f);
412         need_newline = 0;
413         get_line();
414         if (line) goto loop;
415         unterminated_text(t_lineno, t_line, t_cptr);
416
417     case '\'':
418     case '"':
419         {
420             int s_lineno = lineno;
421             char *s_line = dup_line();
422             const char *s_cptr = s_line + (cptr - line - 1);
423
424             quote = c;
425             putc(c, f);
426             for (;;)
427             {
428                 c = *cptr++;
429                 putc(c, f);
430                 if (c == quote)
431                 {
432                     need_newline = 1;
433                     FREE(s_line);
434                     goto loop;
435                 }
436                 if (c == '\n')
437                     unterminated_string(s_lineno, s_line, s_cptr);
438                 if (c == '\\')
439                 {
440                     c = *cptr++;
441                     putc(c, f);
442                     if (c == '\n')
443                     {
444                         get_line();
445                         if (line == 0)
446                             unterminated_string(s_lineno, s_line, s_cptr);
447                     }
448                 }
449             }
450         }
451
452     case '/':
453         putc(c, f);
454         need_newline = 1;
455         c = *cptr;
456         if (c == '/')
457         {
458             putc('*', f);
459             while ((c = *++cptr) != '\n')
460             {
461                 if (c == '*' && cptr[1] == '/')
462                     fprintf(f, "* ");
463                 else
464                     putc(c, f);
465             }
466             fprintf(f, "*/");
467             goto next_line;
468         }
469         if (c == '*')
470         {
471             int c_lineno = lineno;
472             char *c_line = dup_line();
473             const char *c_cptr = c_line + (cptr - line - 1);
474
475             putc('*', f);
476             ++cptr;
477             for (;;)
478             {
479                 c = *cptr++;
480                 putc(c, f);
481                 if (c == '*' && *cptr == '/')
482                 {
483                     putc('/', f);
484                     ++cptr;
485                     FREE(c_line);
486                     goto loop;
487                 }
488                 if (c == '\n')
489                 {
490                     get_line();
491                     if (line == 0)
492                         unterminated_comment(c_lineno, c_line, c_cptr);
493                 }
494             }
495         }
496         need_newline = 1;
497         goto loop;
498
499     case '%':
500     case '\\':
501         if (*cptr == '}')
502         {
503             if (need_newline) putc('\n', f);
504             ++cptr;
505             FREE(t_line);
506             return;
507         }
508         /* fall through */
509
510     default:
511         putc(c, f);
512         need_newline = 1;
513         goto loop;
514     }
515 }
516
517
518 static void
519 copy_union(void)
520 {
521     int c;
522     int quote;
523     int depth;
524     int u_lineno = lineno;
525     char *u_line = dup_line();
526     const char *u_cptr = u_line + (cptr - line - 6);
527
528     if (unionized) over_unionized(cptr - 6);
529     unionized = 1;
530
531     if (!lflag)
532         fprintf(text_file, line_format, lineno, input_file_name);
533
534     fprintf(text_file, "typedef union");
535     if (dflag) fprintf(union_file, "typedef union");
536
537     depth = 0;
538 loop:
539     c = *cptr++;
540     putc(c, text_file);
541     if (dflag) putc(c, union_file);
542     switch (c)
543     {
544     case '\n':
545     next_line:
546         get_line();
547         if (line == 0) unterminated_union(u_lineno, u_line, u_cptr);
548         goto loop;
549
550     case '{':
551         ++depth;
552         goto loop;
553
554     case '}':
555         if (--depth == 0)
556         {
557             fprintf(text_file, " YYSTYPE;\n");
558             FREE(u_line);
559             return;
560         }
561         goto loop;
562
563     case '\'':
564     case '"':
565         {
566             int s_lineno = lineno;
567             char *s_line = dup_line();
568             const char *s_cptr = s_line + (cptr - line - 1);
569
570             quote = c;
571             for (;;)
572             {
573                 c = *cptr++;
574                 putc(c, text_file);
575                 if (dflag) putc(c, union_file);
576                 if (c == quote)
577                 {
578                     FREE(s_line);
579                     goto loop;
580                 }
581                 if (c == '\n')
582                     unterminated_string(s_lineno, s_line, s_cptr);
583                 if (c == '\\')
584                 {
585                     c = *cptr++;
586                     putc(c, text_file);
587                     if (dflag) putc(c, union_file);
588                     if (c == '\n')
589                     {
590                         get_line();
591                         if (line == 0)
592                             unterminated_string(s_lineno, s_line, s_cptr);
593                     }
594                 }
595             }
596         }
597
598     case '/':
599         c = *cptr;
600         if (c == '/')
601         {
602             putc('*', text_file);
603             if (dflag) putc('*', union_file);
604             while ((c = *++cptr) != '\n')
605             {
606                 if (c == '*' && cptr[1] == '/')
607                 {
608                     fprintf(text_file, "* ");
609                     if (dflag) fprintf(union_file, "* ");
610                 }
611                 else
612                 {
613                     putc(c, text_file);
614                     if (dflag) putc(c, union_file);
615                 }
616             }
617             fprintf(text_file, "*/\n");
618             if (dflag) fprintf(union_file, "*/\n");
619             goto next_line;
620         }
621         if (c == '*')
622         {
623             int c_lineno = lineno;
624             char *c_line = dup_line();
625             const char *c_cptr = c_line + (cptr - line - 1);
626
627             putc('*', text_file);
628             if (dflag) putc('*', union_file);
629             ++cptr;
630             for (;;)
631             {
632                 c = *cptr++;
633                 putc(c, text_file);
634                 if (dflag) putc(c, union_file);
635                 if (c == '*' && *cptr == '/')
636                 {
637                     putc('/', text_file);
638                     if (dflag) putc('/', union_file);
639                     ++cptr;
640                     FREE(c_line);
641                     goto loop;
642                 }
643                 if (c == '\n')
644                 {
645                     get_line();
646                     if (line == 0)
647                         unterminated_comment(c_lineno, c_line, c_cptr);
648                 }
649             }
650         }
651         goto loop;
652
653     default:
654         goto loop;
655     }
656 }
657
658
659 static int
660 hexval(int c)
661 {
662     if (c >= '0' && c <= '9')
663         return (c - '0');
664     if (c >= 'A' && c <= 'F')
665         return (c - 'A' + 10);
666     if (c >= 'a' && c <= 'f')
667         return (c - 'a' + 10);
668     return (-1);
669 }
670
671
672 static bucket *
673 get_literal(void)
674 {
675     int c, quote;
676     int i;
677     int n;
678     char *s;
679     bucket *bp;
680     int s_lineno = lineno;
681     char *s_line = dup_line();
682     const char *s_cptr = s_line + (cptr - line);
683
684     quote = *cptr++;
685     cinc = 0;
686     for (;;)
687     {
688         c = *cptr++;
689         if (c == quote) break;
690         if (c == '\n') unterminated_string(s_lineno, s_line, s_cptr);
691         if (c == '\\')
692         {
693             const char *c_cptr = cptr - 1;
694
695             c = *cptr++;
696             switch (c)
697             {
698             case '\n':
699                 get_line();
700                 if (line == 0) unterminated_string(s_lineno, s_line, s_cptr);
701                 continue;
702
703             case '0': case '1': case '2': case '3':
704             case '4': case '5': case '6': case '7':
705                 n = c - '0';
706                 c = *cptr;
707                 if (IS_OCTAL(c))
708                 {
709                     n = (n << 3) + (c - '0');
710                     c = *++cptr;
711                     if (IS_OCTAL(c))
712                     {
713                         n = (n << 3) + (c - '0');
714                         ++cptr;
715                     }
716                 }
717                 if (n > MAXCHAR) illegal_character(c_cptr);
718                 c = n;
719                 break;
720
721             case 'x':
722                 c = *cptr++;
723                 n = hexval(c);
724                 if (n < 0 || n >= 16)
725                     illegal_character(c_cptr);
726                 for (;;)
727                 {
728                     c = *cptr;
729                     i = hexval(c);
730                     if (i < 0 || i >= 16) break;
731                     ++cptr;
732                     n = (n << 4) + i;
733                     if (n > MAXCHAR) illegal_character(c_cptr);
734                 }
735                 c = n;
736                 break;
737
738             case 'a': c = 7; break;
739             case 'b': c = '\b'; break;
740             case 'f': c = '\f'; break;
741             case 'n': c = '\n'; break;
742             case 'r': c = '\r'; break;
743             case 't': c = '\t'; break;
744             case 'v': c = '\v'; break;
745             }
746         }
747         cachec(c);
748     }
749     FREE(s_line);
750
751     n = cinc;
752     s = MALLOC(n);
753     if (s == 0) no_space();
754
755     for (i = 0; i < n; ++i)
756         s[i] = cache[i];
757
758     cinc = 0;
759     if (n == 1)
760         cachec('\'');
761     else
762         cachec('"');
763
764     for (i = 0; i < n; ++i)
765     {
766         c = ((unsigned char *)s)[i];
767         if (c == '\\' || c == cache[0])
768         {
769             cachec('\\');
770             cachec(c);
771         }
772         else if (isprint(c))
773             cachec(c);
774         else
775         {
776             cachec('\\');
777             switch (c)
778             {
779             case 7: cachec('a'); break;
780             case '\b': cachec('b'); break;
781             case '\f': cachec('f'); break;
782             case '\n': cachec('n'); break;
783             case '\r': cachec('r'); break;
784             case '\t': cachec('t'); break;
785             case '\v': cachec('v'); break;
786             default:
787                 cachec(((c >> 6) & 7) + '0');
788                 cachec(((c >> 3) & 7) + '0');
789                 cachec((c & 7) + '0');
790                 break;
791             }
792         }
793     }
794
795     if (n == 1)
796         cachec('\'');
797     else
798         cachec('"');
799
800     cachec(NUL);
801     bp = lookup(cache);
802     bp->class = TERM;
803     if (n == 1 && bp->value == UNDEFINED)
804         bp->value = *(unsigned char *)s;
805     FREE(s);
806
807     return (bp);
808 }
809
810
811 static int
812 is_reserved(char *name)
813 {
814     char *s;
815
816     if (strcmp(name, ".") == 0 ||
817             strcmp(name, "$accept") == 0 ||
818             strcmp(name, "$end") == 0)
819         return (1);
820
821     if (name[0] == '$' && name[1] == '$' && isdigit(name[2]))
822     {
823         s = name + 3;
824         while (isdigit(*s)) ++s;
825         if (*s == NUL) return (1);
826     }
827
828     return (0);
829 }
830
831
832 static bucket *
833 get_name(void)
834 {
835     int c;
836
837     cinc = 0;
838     for (c = *cptr; IS_IDENT(c); c = *++cptr)
839         cachec(c);
840     cachec(NUL);
841
842     if (is_reserved(cache)) used_reserved(cache);
843
844     return (lookup(cache));
845 }
846
847
848 static int
849 get_number(void)
850 {
851     int c;
852     int n;
853
854     n = 0;
855     for (c = *cptr; isdigit(c); c = *++cptr)
856         n = 10*n + (c - '0');
857
858     return (n);
859 }
860
861
862 static char *
863 get_tag(void)
864 {
865     int c;
866     int i;
867     char *s;
868     int t_lineno = lineno;
869     char *t_line = dup_line();
870     const char *t_cptr = t_line + (cptr - line);
871
872     ++cptr;
873     c = nextc();
874     if (c == EOF) unexpected_EOF();
875     if (!isalpha(c) && c != '_' && c != '$')
876         illegal_tag(t_lineno, t_line, t_cptr);
877
878     cinc = 0;
879     do { cachec(c); c = *++cptr; } while (IS_IDENT(c));
880     cachec(NUL);
881
882     c = nextc();
883     if (c == EOF) unexpected_EOF();
884     if (c != '>')
885         illegal_tag(t_lineno, t_line, t_cptr);
886     ++cptr;
887
888     for (i = 0; i < ntags; ++i)
889     {
890         if (strcmp(cache, tag_table[i]) == 0)
891             return (tag_table[i]);
892     }
893
894     if (ntags >= tagmax)
895     {
896         tagmax += 16;
897         tag_table = (char **)
898                         (tag_table ? REALLOC(tag_table, tagmax*sizeof(char *))
899                                    : MALLOC(tagmax*sizeof(char *)));
900         if (tag_table == 0) no_space();
901     }
902
903     s = MALLOC(cinc);
904     if  (s == 0) no_space();
905     strcpy(s, cache);
906     tag_table[ntags] = s;
907     ++ntags;
908     FREE(t_line);
909     return (s);
910 }
911
912
913 static void
914 declare_tokens(int assoc)
915 {
916     int c;
917     bucket *bp;
918     int value;
919     char *tag = 0;
920
921     if (assoc != TOKEN) ++prec;
922
923     c = nextc();
924     if (c == EOF) unexpected_EOF();
925     if (c == '<')
926     {
927         tag = get_tag();
928         c = nextc();
929         if (c == EOF) unexpected_EOF();
930     }
931
932     for (;;)
933     {
934         if (isalpha(c) || c == '_' || c == '.' || c == '$')
935             bp = get_name();
936         else if (c == '\'' || c == '"')
937             bp = get_literal();
938         else
939             return;
940
941         if (bp == goal) tokenized_start(bp->name);
942         bp->class = TERM;
943
944         if (tag)
945         {
946             if (bp->tag && tag != bp->tag)
947                 retyped_warning(bp->name);
948             bp->tag = tag;
949         }
950
951         if (assoc != TOKEN)
952         {
953             if (bp->prec && prec != bp->prec)
954                 reprec_warning(bp->name);
955             bp->assoc = assoc;
956             bp->prec = prec;
957         }
958
959         c = nextc();
960         if (c == EOF) unexpected_EOF();
961         value = UNDEFINED;
962         if (isdigit(c))
963         {
964             value = get_number();
965             if (bp->value != UNDEFINED && value != bp->value)
966                 revalued_warning(bp->name);
967             bp->value = value;
968             c = nextc();
969             if (c == EOF) unexpected_EOF();
970         }
971     }
972 }
973
974
975 /*
976  * %expect requires special handling
977  * as it really isn't part of the yacc
978  * grammar only a flag for yacc proper.
979  */
980 static void
981 declare_expect(int assoc)
982 {
983     int c;
984
985     if (assoc != EXPECT) ++prec;
986
987     /*
988      * Stay away from nextc - doesn't
989      * detect EOL and will read to EOF.
990      */
991     c = *++cptr;
992     if (c == EOF) unexpected_EOF();
993
994     for(;;)
995     {
996         if (isdigit(c))
997         {
998             SRexpect = get_number();
999             break;
1000         }
1001         /*
1002          * Looking for number before EOL.
1003          * Spaces, tabs, and numbers are ok,
1004          * words, punc., etc. are syntax errors.
1005          */
1006         else if (c == '\n' || isalpha(c) || !isspace(c))
1007         {
1008             syntax_error(lineno, line, cptr);
1009         }
1010         else
1011         {
1012             c = *++cptr;
1013             if (c == EOF) unexpected_EOF();
1014         }
1015     }
1016 }
1017
1018
1019 static void
1020 declare_types(void)
1021 {
1022     int c;
1023     bucket *bp;
1024     char *tag;
1025
1026     c = nextc();
1027     if (c == EOF) unexpected_EOF();
1028     if (c != '<') syntax_error(lineno, line, cptr);
1029     tag = get_tag();
1030
1031     for (;;)
1032     {
1033         c = nextc();
1034         if (isalpha(c) || c == '_' || c == '.' || c == '$')
1035             bp = get_name();
1036         else if (c == '\'' || c == '"')
1037             bp = get_literal();
1038         else
1039             return;
1040
1041         if (bp->tag && tag != bp->tag)
1042             retyped_warning(bp->name);
1043         bp->tag = tag;
1044     }
1045 }
1046
1047
1048 static void
1049 declare_start(void)
1050 {
1051     int c;
1052     bucket *bp;
1053
1054     c = nextc();
1055     if (c == EOF) unexpected_EOF();
1056     if (!isalpha(c) && c != '_' && c != '.' && c != '$')
1057         syntax_error(lineno, line, cptr);
1058     bp = get_name();
1059     if (bp->class == TERM)
1060         terminal_start(bp->name);
1061     if (goal && goal != bp)
1062         restarted_warning();
1063     goal = bp;
1064 }
1065
1066
1067 static void
1068 read_declarations(void)
1069 {
1070     int c, k;
1071
1072     cache_size = 256;
1073     cache = MALLOC(cache_size);
1074     if (cache == 0) no_space();
1075
1076     for (;;)
1077     {
1078         c = nextc();
1079         if (c == EOF) unexpected_EOF();
1080         if (c != '%') syntax_error(lineno, line, cptr);
1081         switch (k = keyword())
1082         {
1083         case MARK:
1084             return;
1085
1086         case IDENT:
1087             copy_ident();
1088             break;
1089
1090         case TEXT:
1091             copy_text();
1092             break;
1093
1094         case UNION:
1095             copy_union();
1096             break;
1097
1098         case TOKEN:
1099         case LEFT:
1100         case RIGHT:
1101         case NONASSOC:
1102             declare_tokens(k);
1103             break;
1104
1105         case EXPECT:
1106             declare_expect(k);
1107             break;
1108
1109         case TYPE:
1110             declare_types();
1111             break;
1112
1113         case START:
1114             declare_start();
1115             break;
1116         }
1117     }
1118 }
1119
1120
1121 static void
1122 initialize_grammar(void)
1123 {
1124     nitems = 4;
1125     maxitems = 300;
1126     pitem = (bucket **) MALLOC(maxitems*sizeof(bucket *));
1127     if (pitem == 0) no_space();
1128     pitem[0] = 0;
1129     pitem[1] = 0;
1130     pitem[2] = 0;
1131     pitem[3] = 0;
1132
1133     nrules = 3;
1134     maxrules = 100;
1135     plhs = (bucket **) MALLOC(maxrules*sizeof(bucket *));
1136     if (plhs == 0) no_space();
1137     plhs[0] = 0;
1138     plhs[1] = 0;
1139     plhs[2] = 0;
1140     rprec = (short *) MALLOC(maxrules*sizeof(short));
1141     if (rprec == 0) no_space();
1142     rprec[0] = 0;
1143     rprec[1] = 0;
1144     rprec[2] = 0;
1145     rassoc = (char *) MALLOC(maxrules*sizeof(char));
1146     if (rassoc == 0) no_space();
1147     rassoc[0] = TOKEN;
1148     rassoc[1] = TOKEN;
1149     rassoc[2] = TOKEN;
1150 }
1151
1152
1153 static void
1154 expand_items(void)
1155 {
1156     maxitems += 300;
1157     pitem = (bucket **) REALLOC(pitem, maxitems*sizeof(bucket *));
1158     if (pitem == 0) no_space();
1159 }
1160
1161
1162 static void
1163 expand_rules(void)
1164 {
1165     maxrules += 100;
1166     plhs = (bucket **) REALLOC(plhs, maxrules*sizeof(bucket *));
1167     if (plhs == 0) no_space();
1168     rprec = (short *) REALLOC(rprec, maxrules*sizeof(short));
1169     if (rprec == 0) no_space();
1170     rassoc = (char *) REALLOC(rassoc, maxrules*sizeof(char));
1171     if (rassoc == 0) no_space();
1172 }
1173
1174
1175 static void
1176 advance_to_start(void)
1177 {
1178     int c;
1179     bucket *bp;
1180     const char *s_cptr;
1181     int s_lineno;
1182
1183     for (;;)
1184     {
1185         c = nextc();
1186         if (c != '%') break;
1187         s_cptr = cptr;
1188         switch (keyword())
1189         {
1190         case MARK:
1191             no_grammar();
1192
1193         case TEXT:
1194             copy_text();
1195             break;
1196
1197         case START:
1198             declare_start();
1199             break;
1200
1201         default:
1202             syntax_error(lineno, line, s_cptr);
1203         }
1204     }
1205
1206     c = nextc();
1207     if (!isalpha(c) && c != '_' && c != '.' && c != '_')
1208         syntax_error(lineno, line, cptr);
1209     bp = get_name();
1210     if (goal == 0)
1211     {
1212         if (bp->class == TERM)
1213             terminal_start(bp->name);
1214         goal = bp;
1215     }
1216
1217     s_lineno = lineno;
1218     c = nextc();
1219     if (c == EOF) unexpected_EOF();
1220     if (c != ':') syntax_error(lineno, line, cptr);
1221     start_rule(bp, s_lineno);
1222     ++cptr;
1223 }
1224
1225
1226 static void
1227 start_rule(bucket *bp, int s_lineno)
1228 {
1229     if (bp->class == TERM)
1230         terminal_lhs(s_lineno);
1231     bp->class = NONTERM;
1232     if (nrules >= maxrules)
1233         expand_rules();
1234     plhs[nrules] = bp;
1235     rprec[nrules] = UNDEFINED;
1236     rassoc[nrules] = TOKEN;
1237 }
1238
1239
1240 static void
1241 end_rule(void)
1242 {
1243     int i;
1244
1245     if (!last_was_action && plhs[nrules]->tag)
1246     {
1247         for (i = nitems - 1; pitem[i]; --i) continue;
1248         if (pitem[i+1] == 0 || pitem[i+1]->tag != plhs[nrules]->tag)
1249             default_action_warning();
1250     }
1251
1252     last_was_action = 0;
1253     if (nitems >= maxitems) expand_items();
1254     pitem[nitems] = 0;
1255     ++nitems;
1256     ++nrules;
1257 }
1258
1259
1260 static void
1261 insert_empty_rule(void)
1262 {
1263     bucket *bp, **bpp;
1264
1265     assert(cache);
1266     sprintf(cache, "$$%d", ++gensym);
1267     bp = make_bucket(cache);
1268     last_symbol->next = bp;
1269     last_symbol = bp;
1270     bp->tag = plhs[nrules]->tag;
1271     bp->class = NONTERM;
1272
1273     if ((nitems += 2) > maxitems)
1274         expand_items();
1275     bpp = pitem + nitems - 1;
1276     *bpp-- = bp;
1277     while ((bpp[0] = bpp[-1])) --bpp;
1278
1279     if (++nrules >= maxrules)
1280         expand_rules();
1281     plhs[nrules] = plhs[nrules-1];
1282     plhs[nrules-1] = bp;
1283     rprec[nrules] = rprec[nrules-1];
1284     rprec[nrules-1] = 0;
1285     rassoc[nrules] = rassoc[nrules-1];
1286     rassoc[nrules-1] = TOKEN;
1287 }
1288
1289
1290 static void
1291 add_symbol(void)
1292 {
1293     int c;
1294     bucket *bp;
1295     int s_lineno = lineno;
1296
1297     c = *cptr;
1298     if (c == '\'' || c == '"')
1299         bp = get_literal();
1300     else
1301         bp = get_name();
1302
1303     c = nextc();
1304     if (c == ':')
1305     {
1306         end_rule();
1307         start_rule(bp, s_lineno);
1308         ++cptr;
1309         return;
1310     }
1311
1312     if (last_was_action)
1313         insert_empty_rule();
1314     last_was_action = 0;
1315
1316     if (++nitems > maxitems)
1317         expand_items();
1318     pitem[nitems-1] = bp;
1319 }
1320
1321
1322 static void
1323 copy_action(void)
1324 {
1325     int c;
1326     int i, n;
1327     int depth;
1328     int quote;
1329     char *tag;
1330     FILE *f = action_file;
1331     int a_lineno = lineno;
1332     char *a_line = dup_line();
1333     char *a_cptr = a_line + (cptr - line);
1334
1335     if (last_was_action)
1336         insert_empty_rule();
1337     last_was_action = 1;
1338
1339     fprintf(f, "case %d:\n", nrules - 2);
1340     if (!lflag)
1341         fprintf(f, line_format, lineno, input_file_name);
1342     if (*cptr == '=') ++cptr;
1343
1344     n = 0;
1345     for (i = nitems - 1; pitem[i]; --i) ++n;
1346
1347     depth = 0;
1348 loop:
1349     c = *cptr;
1350     if (c == '$')
1351     {
1352         if (cptr[1] == '<')
1353         {
1354             int d_lineno = lineno;
1355             char *d_line = dup_line();
1356             char *d_cptr = d_line + (cptr - line);
1357
1358             ++cptr;
1359             tag = get_tag();
1360             c = *cptr;
1361             if (c == '$')
1362             {
1363                 fprintf(f, "yyval.%s", tag);
1364                 ++cptr;
1365                 FREE(d_line);
1366                 goto loop;
1367             }
1368             else if (isdigit(c))
1369             {
1370                 i = get_number();
1371                 if (i > n) dollar_warning(d_lineno, i);
1372                 fprintf(f, "yyvsp[%d].%s", i - n, tag);
1373                 FREE(d_line);
1374                 goto loop;
1375             }
1376             else if (c == '-' && isdigit(cptr[1]))
1377             {
1378                 ++cptr;
1379                 i = -get_number() - n;
1380                 fprintf(f, "yyvsp[%d].%s", i, tag);
1381                 FREE(d_line);
1382                 goto loop;
1383             }
1384             else
1385                 dollar_error(d_lineno, d_line, d_cptr);
1386         }
1387         else if (cptr[1] == '$')
1388         {
1389             if (ntags)
1390             {
1391                 tag = plhs[nrules]->tag;
1392                 if (tag == 0) untyped_lhs();
1393                 fprintf(f, "yyval.%s", tag);
1394             }
1395             else
1396                 fprintf(f, "yyval");
1397             cptr += 2;
1398             goto loop;
1399         }
1400         else if (isdigit(cptr[1]))
1401         {
1402             ++cptr;
1403             i = get_number();
1404             if (ntags)
1405             {
1406                 if (i <= 0 || i > n)
1407                     unknown_rhs(i);
1408                 tag = pitem[nitems + i - n - 1]->tag;
1409                 if (tag == 0) untyped_rhs(i, pitem[nitems + i - n - 1]->name);
1410                 fprintf(f, "yyvsp[%d].%s", i - n, tag);
1411             }
1412             else
1413             {
1414                 if (i > n)
1415                     dollar_warning(lineno, i);
1416                 fprintf(f, "yyvsp[%d]", i - n);
1417             }
1418             goto loop;
1419         }
1420         else if (cptr[1] == '-')
1421         {
1422             cptr += 2;
1423             i = get_number();
1424             if (ntags)
1425                 unknown_rhs(-i);
1426             fprintf(f, "yyvsp[%d]", -i - n);
1427             goto loop;
1428         }
1429     }
1430     if (isalpha(c) || c == '_' || c == '$')
1431     {
1432         do
1433         {
1434             putc(c, f);
1435             c = *++cptr;
1436         } while (isalnum(c) || c == '_' || c == '$');
1437         goto loop;
1438     }
1439     putc(c, f);
1440     ++cptr;
1441     switch (c)
1442     {
1443     case '\n':
1444     next_line:
1445         get_line();
1446         if (line) goto loop;
1447         unterminated_action(a_lineno, a_line, a_cptr);
1448
1449     case ';':
1450         if (depth > 0) goto loop;
1451         fprintf(f, "\nbreak;\n");
1452         return;
1453
1454     case '{':
1455         ++depth;
1456         goto loop;
1457
1458     case '}':
1459         if (--depth > 0) goto loop;
1460         fprintf(f, "\nbreak;\n");
1461         return;
1462
1463     case '\'':
1464     case '"':
1465         {
1466             int s_lineno = lineno;
1467             char *s_line = dup_line();
1468             char *s_cptr = s_line + (cptr - line - 1);
1469
1470             quote = c;
1471             for (;;)
1472             {
1473                 c = *cptr++;
1474                 putc(c, f);
1475                 if (c == quote)
1476                 {
1477                     FREE(s_line);
1478                     goto loop;
1479                 }
1480                 if (c == '\n')
1481                     unterminated_string(s_lineno, s_line, s_cptr);
1482                 if (c == '\\')
1483                 {
1484                     c = *cptr++;
1485                     putc(c, f);
1486                     if (c == '\n')
1487                     {
1488                         get_line();
1489                         if (line == 0)
1490                             unterminated_string(s_lineno, s_line, s_cptr);
1491                     }
1492                 }
1493             }
1494         }
1495
1496     case '/':
1497         c = *cptr;
1498         if (c == '/')
1499         {
1500             putc('*', f);
1501             while ((c = *++cptr) != '\n')
1502             {
1503                 if (c == '*' && cptr[1] == '/')
1504                     fprintf(f, "* ");
1505                 else
1506                     putc(c, f);
1507             }
1508             fprintf(f, "*/\n");
1509             goto next_line;
1510         }
1511         if (c == '*')
1512         {
1513             int c_lineno = lineno;
1514             char *c_line = dup_line();
1515             char *c_cptr = c_line + (cptr - line - 1);
1516
1517             putc('*', f);
1518             ++cptr;
1519             for (;;)
1520             {
1521                 c = *cptr++;
1522                 putc(c, f);
1523                 if (c == '*' && *cptr == '/')
1524                 {
1525                     putc('/', f);
1526                     ++cptr;
1527                     FREE(c_line);
1528                     goto loop;
1529                 }
1530                 if (c == '\n')
1531                 {
1532                     get_line();
1533                     if (line == 0)
1534                         unterminated_comment(c_lineno, c_line, c_cptr);
1535                 }
1536             }
1537         }
1538         goto loop;
1539
1540     default:
1541         goto loop;
1542     }
1543 }
1544
1545
1546 static int
1547 mark_symbol(void)
1548 {
1549     int c;
1550     bucket *bp = NULL;
1551
1552     c = cptr[1];
1553     if (c == '%' || c == '\\')
1554     {
1555         cptr += 2;
1556         return (1);
1557     }
1558
1559     if (c == '=')
1560         cptr += 2;
1561     else if ((c == 'p' || c == 'P') &&
1562              ((c = cptr[2]) == 'r' || c == 'R') &&
1563              ((c = cptr[3]) == 'e' || c == 'E') &&
1564              ((c = cptr[4]) == 'c' || c == 'C') &&
1565              ((c = cptr[5], !IS_IDENT(c))))
1566         cptr += 5;
1567     else
1568         syntax_error(lineno, line, cptr);
1569
1570     c = nextc();
1571     if (isalpha(c) || c == '_' || c == '.' || c == '$')
1572         bp = get_name();
1573     else if (c == '\'' || c == '"')
1574         bp = get_literal();
1575     else
1576     {
1577         syntax_error(lineno, line, cptr);
1578         /*NOTREACHED*/
1579     }
1580
1581     if (rprec[nrules] != UNDEFINED && bp->prec != rprec[nrules])
1582         prec_redeclared();
1583
1584     rprec[nrules] = bp->prec;
1585     rassoc[nrules] = bp->assoc;
1586     return (0);
1587 }
1588
1589
1590 static void
1591 read_grammar(void)
1592 {
1593     int c;
1594
1595     initialize_grammar();
1596     advance_to_start();
1597
1598     for (;;)
1599     {
1600         c = nextc();
1601         if (c == EOF) break;
1602         if (isalpha(c) || c == '_' || c == '.' || c == '$' || c == '\'' ||
1603                 c == '"')
1604             add_symbol();
1605         else if (c == '{' || c == '=')
1606             copy_action();
1607         else if (c == '|')
1608         {
1609             end_rule();
1610             start_rule(plhs[nrules-1], 0);
1611             ++cptr;
1612         }
1613         else if (c == '%')
1614         {
1615             if (mark_symbol()) break;
1616         }
1617         else
1618             syntax_error(lineno, line, cptr);
1619     }
1620     end_rule();
1621 }
1622
1623
1624 static void
1625 free_tags(void)
1626 {
1627     int i;
1628
1629     if (tag_table == 0) return;
1630
1631     for (i = 0; i < ntags; ++i)
1632     {
1633         assert(tag_table[i]);
1634         FREE(tag_table[i]);
1635     }
1636     FREE(tag_table);
1637 }
1638
1639
1640 static void
1641 pack_names(void)
1642 {
1643     bucket *bp;
1644     char *p, *s, *t;
1645
1646     name_pool_size = 13;  /* 13 == sizeof("$end") + sizeof("$accept") */
1647     for (bp = first_symbol; bp; bp = bp->next)
1648         name_pool_size += strlen(bp->name) + 1;
1649     name_pool = MALLOC(name_pool_size);
1650     if (name_pool == 0) no_space();
1651
1652     strcpy(name_pool, "$accept");
1653     strcpy(name_pool+8, "$end");
1654     t = name_pool + 13;
1655     for (bp = first_symbol; bp; bp = bp->next)
1656     {
1657         p = t;
1658         s = bp->name;
1659         while ((*t++ = *s++)) continue;
1660         FREE(bp->name);
1661         bp->name = p;
1662     }
1663 }
1664
1665
1666 static void
1667 check_symbols(void)
1668 {
1669     bucket *bp;
1670
1671     if (goal->class == UNKNOWN)
1672         undefined_goal(goal->name);
1673
1674     for (bp = first_symbol; bp; bp = bp->next)
1675     {
1676         if (bp->class == UNKNOWN)
1677         {
1678             undefined_symbol_warning(bp->name);
1679             bp->class = TERM;
1680         }
1681     }
1682 }
1683
1684
1685 static void
1686 pack_symbols(void)
1687 {
1688     bucket *bp;
1689     bucket **v;
1690     int i, j, k, n;
1691
1692     nsyms = 2;
1693     ntokens = 1;
1694     for (bp = first_symbol; bp; bp = bp->next)
1695     {
1696         ++nsyms;
1697         if (bp->class == TERM) ++ntokens;
1698     }
1699     start_symbol = ntokens;
1700     nvars = nsyms - ntokens;
1701
1702     symbol_name = (char **) MALLOC(nsyms*sizeof(char *));
1703     if (symbol_name == 0) no_space();
1704     symbol_value = (short *) MALLOC(nsyms*sizeof(short));
1705     if (symbol_value == 0) no_space();
1706     symbol_prec = (short *) MALLOC(nsyms*sizeof(short));
1707     if (symbol_prec == 0) no_space();
1708     symbol_assoc = MALLOC(nsyms);
1709     if (symbol_assoc == 0) no_space();
1710
1711     v = (bucket **) MALLOC(nsyms*sizeof(bucket *));
1712     if (v == 0) no_space();
1713
1714     v[0] = 0;
1715     v[start_symbol] = 0;
1716
1717     i = 1;
1718     j = start_symbol + 1;
1719     for (bp = first_symbol; bp; bp = bp->next)
1720     {
1721         if (bp->class == TERM)
1722             v[i++] = bp;
1723         else
1724             v[j++] = bp;
1725     }
1726     assert(i == ntokens && j == nsyms);
1727
1728     for (i = 1; i < ntokens; ++i)
1729         v[i]->index = i;
1730
1731     goal->index = start_symbol + 1;
1732     k = start_symbol + 2;
1733     while (++i < nsyms)
1734         if (v[i] != goal)
1735         {
1736             v[i]->index = k;
1737             ++k;
1738         }
1739
1740     goal->value = 0;
1741     k = 1;
1742     for (i = start_symbol + 1; i < nsyms; ++i)
1743     {
1744         if (v[i] != goal)
1745         {
1746             v[i]->value = k;
1747             ++k;
1748         }
1749     }
1750
1751     k = 0;
1752     for (i = 1; i < ntokens; ++i)
1753     {
1754         n = v[i]->value;
1755         if (n > 256)
1756         {
1757             for (j = k++; j > 0 && symbol_value[j-1] > n; --j)
1758                 symbol_value[j] = symbol_value[j-1];
1759             symbol_value[j] = n;
1760         }
1761     }
1762
1763     if (v[1]->value == UNDEFINED)
1764         v[1]->value = 256;
1765
1766     j = 0;
1767     n = 257;
1768     for (i = 2; i < ntokens; ++i)
1769     {
1770         if (v[i]->value == UNDEFINED)
1771         {
1772             while (j < k && n == symbol_value[j])
1773             {
1774                 while (++j < k && n == symbol_value[j]) continue;
1775                 ++n;
1776             }
1777             v[i]->value = n;
1778             ++n;
1779         }
1780     }
1781
1782     symbol_name[0] = name_pool + 8;
1783     symbol_value[0] = 0;
1784     symbol_prec[0] = 0;
1785     symbol_assoc[0] = TOKEN;
1786     for (i = 1; i < ntokens; ++i)
1787     {
1788         symbol_name[i] = v[i]->name;
1789         symbol_value[i] = v[i]->value;
1790         symbol_prec[i] = v[i]->prec;
1791         symbol_assoc[i] = v[i]->assoc;
1792     }
1793     symbol_name[start_symbol] = name_pool;
1794     symbol_value[start_symbol] = -1;
1795     symbol_prec[start_symbol] = 0;
1796     symbol_assoc[start_symbol] = TOKEN;
1797     for (++i; i < nsyms; ++i)
1798     {
1799         k = v[i]->index;
1800         symbol_name[k] = v[i]->name;
1801         symbol_value[k] = v[i]->value;
1802         symbol_prec[k] = v[i]->prec;
1803         symbol_assoc[k] = v[i]->assoc;
1804     }
1805
1806     FREE(v);
1807 }
1808
1809
1810 static void
1811 pack_grammar(void)
1812 {
1813     int i, j;
1814     int assoc, loc_prec;
1815
1816     ritem = (short *) MALLOC(nitems*sizeof(short));
1817     if (ritem == 0) no_space();
1818     rlhs = (short *) MALLOC(nrules*sizeof(short));
1819     if (rlhs == 0) no_space();
1820     rrhs = (short *) MALLOC((nrules+1)*sizeof(short));
1821     if (rrhs == 0) no_space();
1822     rprec = (short *) REALLOC(rprec, nrules*sizeof(short));
1823     if (rprec == 0) no_space();
1824     rassoc = REALLOC(rassoc, nrules);
1825     if (rassoc == 0) no_space();
1826
1827     ritem[0] = -1;
1828     ritem[1] = goal->index;
1829     ritem[2] = 0;
1830     ritem[3] = -2;
1831     rlhs[0] = 0;
1832     rlhs[1] = 0;
1833     rlhs[2] = start_symbol;
1834     rrhs[0] = 0;
1835     rrhs[1] = 0;
1836     rrhs[2] = 1;
1837
1838     j = 4;
1839     for (i = 3; i < nrules; ++i)
1840     {
1841         rlhs[i] = plhs[i]->index;
1842         rrhs[i] = j;
1843         assoc = TOKEN;
1844         loc_prec = 0;
1845         while (pitem[j])
1846         {
1847             ritem[j] = pitem[j]->index;
1848             if (pitem[j]->class == TERM)
1849             {
1850                 loc_prec = pitem[j]->prec;
1851                 assoc = pitem[j]->assoc;
1852             }
1853             ++j;
1854         }
1855         ritem[j] = -i;
1856         ++j;
1857         if (rprec[i] == UNDEFINED)
1858         {
1859             rprec[i] = loc_prec;
1860             rassoc[i] = assoc;
1861         }
1862     }
1863     rrhs[i] = j;
1864
1865     FREE(plhs);
1866     FREE(pitem);
1867 }
1868
1869
1870 static void
1871 print_grammar(void)
1872 {
1873     int i, j, k;
1874     int spacing = 0;
1875     FILE *f = verbose_file;
1876
1877     if (!vflag) return;
1878
1879     k = 1;
1880     for (i = 2; i < nrules; ++i)
1881     {
1882         if (rlhs[i] != rlhs[i-1])
1883         {
1884             if (i != 2) fprintf(f, "\n");
1885             fprintf(f, "%4d  %s :", i - 2, symbol_name[rlhs[i]]);
1886             spacing = strlen(symbol_name[rlhs[i]]) + 1;
1887         }
1888         else
1889         {
1890             fprintf(f, "%4d  ", i - 2);
1891             j = spacing;
1892             while (--j >= 0) putc(' ', f);
1893             putc('|', f);
1894         }
1895
1896         while (ritem[k] >= 0)
1897         {
1898             fprintf(f, " %s", symbol_name[ritem[k]]);
1899             ++k;
1900         }
1901         ++k;
1902         putc('\n', f);
1903     }
1904 }
1905
1906
1907 void
1908 reader(void)
1909 {
1910     write_section(banner);
1911     create_symbol_table();
1912     read_declarations();
1913     read_grammar();
1914     free_symbol_table();
1915     free_tags();
1916     pack_names();
1917     check_symbols();
1918     pack_symbols();
1919     pack_grammar();
1920     free_symbols();
1921     print_grammar();
1922 }