xref: /freebsd/contrib/byacc/reader.c (revision 5dae51da3da0cc94d17bd67b308fad304ebec7e0) 
1 /* $Id: reader.c,v 1.63 2016/06/07 00:17:51 tom Exp $ */
2 
3 #include "defs.h"
4 
5 /*  The line size must be a positive integer.  One hundred was chosen	*/
6 /*  because few lines in Yacc input grammars exceed 100 characters.	*/
7 /*  Note that if a line exceeds LINESIZE characters, the line buffer	*/
8 /*  will be expanded to accomodate it.					*/
9 
10 #define LINESIZE 100
11 
12 #define L_CURL  '{'
13 #define R_CURL  '}'
14 #define L_PAREN '('
15 #define R_PAREN ')'
16 #define L_BRAC  '['
17 #define R_BRAC  ']'
18 
19 /* the maximum number of arguments (inherited attributes) to a non-terminal */
20 /* this is a hard limit, but seems more than adequate */
21 #define MAXARGS	20
22 
23 static void start_rule(bucket *bp, int s_lineno);
24 #if defined(YYBTYACC)
25 static void copy_destructor(void);
26 static char *process_destructor_XX(char *code, char *tag);
27 #endif
28 
29 #define CACHE_SIZE 256
30 static char *cache;
31 static int cinc, cache_size;
32 
33 int ntags;
34 static int tagmax, havetags;
35 static char **tag_table;
36 
37 static char saw_eof;
38 char unionized;
39 char *cptr, *line;
40 static int linesize;
41 
42 static bucket *goal;
43 static Value_t prec;
44 static int gensym;
45 static char last_was_action;
46 #if defined(YYBTYACC)
47 static int trialaction;
48 #endif
49 
50 static int maxitems;
51 static bucket **pitem;
52 
53 static int maxrules;
54 static bucket **plhs;
55 
56 static size_t name_pool_size;
57 static char *name_pool;
58 
59 char line_format[] = "#line %d \"%s\"\n";
60 
61 param *lex_param;
62 param *parse_param;
63 
64 #if defined(YYBTYACC)
65 int destructor = 0;	/* =1 if at least one %destructor */
66 
67 static bucket *default_destructor[3] =
68 {0, 0, 0};
69 
70 #define UNTYPED_DEFAULT 0
71 #define TYPED_DEFAULT   1
72 #define TYPE_SPECIFIED  2
73 
74 static bucket *
75 lookup_type_destructor(char *tag)
76 {
77     const char fmt[] = "%.*s destructor";
78     char name[1024] = "\0";
79     bucket *bp, **bpp = &default_destructor[TYPE_SPECIFIED];
80 
81     while ((bp = *bpp) != NULL)
82     {
83 	if (bp->tag == tag)
84 	    return (bp);
85 	bpp = &bp->link;
86     }
87 
88     sprintf(name, fmt, (int)(sizeof(name) - sizeof(fmt)), tag);
89     *bpp = bp = make_bucket(name);
90     bp->tag = tag;
91 
92     return (bp);
93 }
94 #endif /* defined(YYBTYACC) */
95 
96 static void
97 cachec(int c)
98 {
99     assert(cinc >= 0);
100     if (cinc >= cache_size)
101     {
102 	cache_size += CACHE_SIZE;
103 	cache = TREALLOC(char, cache, cache_size);
104 	NO_SPACE(cache);
105     }
106     cache[cinc] = (char)c;
107     ++cinc;
108 }
109 
110 static void
111 get_line(void)
112 {
113     FILE *f = input_file;
114     int c;
115     int i;
116 
117     if (saw_eof || (c = getc(f)) == EOF)
118     {
119 	if (line)
120 	{
121 	    FREE(line);
122 	    line = 0;
123 	}
124 	cptr = 0;
125 	saw_eof = 1;
126 	return;
127     }
128 
129     if (line == NULL || linesize != (LINESIZE + 1))
130     {
131 	if (line)
132 	    FREE(line);
133 	linesize = LINESIZE + 1;
134 	line = TMALLOC(char, linesize);
135 	NO_SPACE(line);
136     }
137 
138     i = 0;
139     ++lineno;
140     for (;;)
141     {
142 	line[i++] = (char)c;
143 	if (c == '\n')
144 	    break;
145 	if ((i + 3) >= linesize)
146 	{
147 	    linesize += LINESIZE;
148 	    line = TREALLOC(char, line, linesize);
149 	    NO_SPACE(line);
150 	}
151 	c = getc(f);
152 	if (c == EOF)
153 	{
154 	    line[i++] = '\n';
155 	    saw_eof = 1;
156 	    break;
157 	}
158     }
159     line[i] = '\0';
160     cptr = line;
161     return;
162 }
163 
164 static char *
165 dup_line(void)
166 {
167     char *p, *s, *t;
168 
169     if (line == NULL)
170 	return (NULL);
171     s = line;
172     while (*s != '\n')
173 	++s;
174     p = TMALLOC(char, s - line + 1);
175     NO_SPACE(p);
176 
177     s = line;
178     t = p;
179     while ((*t++ = *s++) != '\n')
180 	continue;
181     return (p);
182 }
183 
184 static void
185 skip_comment(void)
186 {
187     char *s;
188 
189     int st_lineno = lineno;
190     char *st_line = dup_line();
191     char *st_cptr = st_line + (cptr - line);
192 
193     s = cptr + 2;
194     for (;;)
195     {
196 	if (*s == '*' && s[1] == '/')
197 	{
198 	    cptr = s + 2;
199 	    FREE(st_line);
200 	    return;
201 	}
202 	if (*s == '\n')
203 	{
204 	    get_line();
205 	    if (line == NULL)
206 		unterminated_comment(st_lineno, st_line, st_cptr);
207 	    s = cptr;
208 	}
209 	else
210 	    ++s;
211     }
212 }
213 
214 static int
215 next_inline(void)
216 {
217     char *s;
218 
219     if (line == NULL)
220     {
221 	get_line();
222 	if (line == NULL)
223 	    return (EOF);
224     }
225 
226     s = cptr;
227     for (;;)
228     {
229 	switch (*s)
230 	{
231 	case '/':
232 	    if (s[1] == '*')
233 	    {
234 		cptr = s;
235 		skip_comment();
236 		s = cptr;
237 		break;
238 	    }
239 	    else if (s[1] == '/')
240 	    {
241 		get_line();
242 		if (line == NULL)
243 		    return (EOF);
244 		s = cptr;
245 		break;
246 	    }
247 	    /* FALLTHRU */
248 
249 	default:
250 	    cptr = s;
251 	    return (*s);
252 	}
253     }
254 }
255 
256 static int
257 nextc(void)
258 {
259     int ch;
260     int finish = 0;
261 
262     do
263     {
264 	switch (ch = next_inline())
265 	{
266 	case '\n':
267 	    get_line();
268 	    break;
269 	case ' ':
270 	case '\t':
271 	case '\f':
272 	case '\r':
273 	case '\v':
274 	case ',':
275 	case ';':
276 	    ++cptr;
277 	    break;
278 	case '\\':
279 	    ch = '%';
280 	    /* FALLTHRU */
281 	default:
282 	    finish = 1;
283 	    break;
284 	}
285     }
286     while (!finish);
287 
288     return ch;
289 }
290 /* *INDENT-OFF* */
291 static struct keyword
292 {
293     char name[13];
294     int token;
295 }
296 keywords[] = {
297     { "binary",      NONASSOC },
298 #if defined(YYBTYACC)
299     { "destructor",  DESTRUCTOR },
300 #endif
301     { "expect",      EXPECT },
302     { "expect-rr",   EXPECT_RR },
303     { "ident",       IDENT },
304     { "left",        LEFT },
305     { "lex-param",   LEX_PARAM },
306 #if defined(YYBTYACC)
307     { "locations",   LOCATIONS },
308 #endif
309     { "nonassoc",    NONASSOC },
310     { "parse-param", PARSE_PARAM },
311     { "pure-parser", PURE_PARSER },
312     { "right",       RIGHT },
313     { "start",       START },
314     { "term",        TOKEN },
315     { "token",       TOKEN },
316     { "token-table", TOKEN_TABLE },
317     { "type",        TYPE },
318     { "union",       UNION },
319     { "yacc",        POSIX_YACC },
320 };
321 /* *INDENT-ON* */
322 
323 static int
324 compare_keys(const void *a, const void *b)
325 {
326     const struct keyword *p = (const struct keyword *)a;
327     const struct keyword *q = (const struct keyword *)b;
328     return strcmp(p->name, q->name);
329 }
330 
331 static int
332 keyword(void)
333 {
334     int c;
335     char *t_cptr = cptr;
336     struct keyword *key;
337 
338     c = *++cptr;
339     if (isalpha(c))
340     {
341 	cinc = 0;
342 	for (;;)
343 	{
344 	    if (isalpha(c))
345 	    {
346 		if (isupper(c))
347 		    c = tolower(c);
348 		cachec(c);
349 	    }
350 	    else if (isdigit(c)
351 		     || c == '-'
352 		     || c == '.'
353 		     || c == '$')
354 	    {
355 		cachec(c);
356 	    }
357 	    else if (c == '_')
358 	    {
359 		/* treat keywords spelled with '_' as if it were '-' */
360 		cachec('-');
361 	    }
362 	    else
363 	    {
364 		break;
365 	    }
366 	    c = *++cptr;
367 	}
368 	cachec(NUL);
369 
370 	if ((key = bsearch(cache, keywords,
371 			   sizeof(keywords) / sizeof(*key),
372 			   sizeof(*key), compare_keys)))
373 	    return key->token;
374     }
375     else
376     {
377 	++cptr;
378 	if (c == L_CURL)
379 	    return (TEXT);
380 	if (c == '%' || c == '\\')
381 	    return (MARK);
382 	if (c == '<')
383 	    return (LEFT);
384 	if (c == '>')
385 	    return (RIGHT);
386 	if (c == '0')
387 	    return (TOKEN);
388 	if (c == '2')
389 	    return (NONASSOC);
390     }
391     syntax_error(lineno, line, t_cptr);
392     /*NOTREACHED */
393 }
394 
395 static void
396 copy_ident(void)
397 {
398     int c;
399     FILE *f = output_file;
400 
401     c = nextc();
402     if (c == EOF)
403 	unexpected_EOF();
404     if (c != '"')
405 	syntax_error(lineno, line, cptr);
406     ++outline;
407     fprintf(f, "#ident \"");
408     for (;;)
409     {
410 	c = *++cptr;
411 	if (c == '\n')
412 	{
413 	    fprintf(f, "\"\n");
414 	    return;
415 	}
416 	putc(c, f);
417 	if (c == '"')
418 	{
419 	    putc('\n', f);
420 	    ++cptr;
421 	    return;
422 	}
423     }
424 }
425 
426 static char *
427 copy_string(int quote)
428 {
429     struct mstring *temp = msnew();
430     int c;
431     int s_lineno = lineno;
432     char *s_line = dup_line();
433     char *s_cptr = s_line + (cptr - line - 1);
434 
435     for (;;)
436     {
437 	c = *cptr++;
438 	mputc(temp, c);
439 	if (c == quote)
440 	{
441 	    FREE(s_line);
442 	    return msdone(temp);
443 	}
444 	if (c == '\n')
445 	    unterminated_string(s_lineno, s_line, s_cptr);
446 	if (c == '\\')
447 	{
448 	    c = *cptr++;
449 	    mputc(temp, c);
450 	    if (c == '\n')
451 	    {
452 		get_line();
453 		if (line == NULL)
454 		    unterminated_string(s_lineno, s_line, s_cptr);
455 	    }
456 	}
457     }
458 }
459 
460 static char *
461 copy_comment(void)
462 {
463     struct mstring *temp = msnew();
464     int c;
465 
466     c = *cptr;
467     if (c == '/')
468     {
469 	mputc(temp, '*');
470 	while ((c = *++cptr) != '\n')
471 	{
472 	    mputc(temp, c);
473 	    if (c == '*' && cptr[1] == '/')
474 		mputc(temp, ' ');
475 	}
476 	mputc(temp, '*');
477 	mputc(temp, '/');
478     }
479     else if (c == '*')
480     {
481 	int c_lineno = lineno;
482 	char *c_line = dup_line();
483 	char *c_cptr = c_line + (cptr - line - 1);
484 
485 	mputc(temp, c);
486 	++cptr;
487 	for (;;)
488 	{
489 	    c = *cptr++;
490 	    mputc(temp, c);
491 	    if (c == '*' && *cptr == '/')
492 	    {
493 		mputc(temp, '/');
494 		++cptr;
495 		FREE(c_line);
496 		return msdone(temp);
497 	    }
498 	    if (c == '\n')
499 	    {
500 		get_line();
501 		if (line == NULL)
502 		    unterminated_comment(c_lineno, c_line, c_cptr);
503 	    }
504 	}
505     }
506     return msdone(temp);
507 }
508 
509 static void
510 copy_text(void)
511 {
512     int c;
513     FILE *f = text_file;
514     int need_newline = 0;
515     int t_lineno = lineno;
516     char *t_line = dup_line();
517     char *t_cptr = t_line + (cptr - line - 2);
518 
519     if (*cptr == '\n')
520     {
521 	get_line();
522 	if (line == NULL)
523 	    unterminated_text(t_lineno, t_line, t_cptr);
524     }
525     if (!lflag)
526 	fprintf(f, line_format, lineno, input_file_name);
527 
528   loop:
529     c = *cptr++;
530     switch (c)
531     {
532     case '\n':
533 	putc('\n', f);
534 	need_newline = 0;
535 	get_line();
536 	if (line)
537 	    goto loop;
538 	unterminated_text(t_lineno, t_line, t_cptr);
539 
540     case '\'':
541     case '"':
542 	putc(c, f);
543 	{
544 	    char *s = copy_string(c);
545 	    fputs(s, f);
546 	    free(s);
547 	}
548 	need_newline = 1;
549 	goto loop;
550 
551     case '/':
552 	putc(c, f);
553 	{
554 	    char *s = copy_comment();
555 	    fputs(s, f);
556 	    free(s);
557 	}
558 	need_newline = 1;
559 	goto loop;
560 
561     case '%':
562     case '\\':
563 	if (*cptr == R_CURL)
564 	{
565 	    if (need_newline)
566 		putc('\n', f);
567 	    ++cptr;
568 	    FREE(t_line);
569 	    return;
570 	}
571 	/* FALLTHRU */
572 
573     default:
574 	putc(c, f);
575 	need_newline = 1;
576 	goto loop;
577     }
578 }
579 
580 static void
581 puts_both(const char *s)
582 {
583     fputs(s, text_file);
584     if (dflag)
585 	fputs(s, union_file);
586 }
587 
588 static void
589 putc_both(int c)
590 {
591     putc(c, text_file);
592     if (dflag)
593 	putc(c, union_file);
594 }
595 
596 static void
597 copy_union(void)
598 {
599     int c;
600     int depth;
601     int u_lineno = lineno;
602     char *u_line = dup_line();
603     char *u_cptr = u_line + (cptr - line - 6);
604 
605     if (unionized)
606 	over_unionized(cptr - 6);
607     unionized = 1;
608 
609     puts_both("#ifdef YYSTYPE\n");
610     puts_both("#undef  YYSTYPE_IS_DECLARED\n");
611     puts_both("#define YYSTYPE_IS_DECLARED 1\n");
612     puts_both("#endif\n");
613     puts_both("#ifndef YYSTYPE_IS_DECLARED\n");
614     puts_both("#define YYSTYPE_IS_DECLARED 1\n");
615 
616     if (!lflag)
617 	fprintf(text_file, line_format, lineno, input_file_name);
618     puts_both("typedef union");
619 
620     depth = 0;
621   loop:
622     c = *cptr++;
623     putc_both(c);
624     switch (c)
625     {
626     case '\n':
627 	get_line();
628 	if (line == NULL)
629 	    unterminated_union(u_lineno, u_line, u_cptr);
630 	goto loop;
631 
632     case L_CURL:
633 	++depth;
634 	goto loop;
635 
636     case R_CURL:
637 	if (--depth == 0)
638 	{
639 	    puts_both(" YYSTYPE;\n");
640 	    puts_both("#endif /* !YYSTYPE_IS_DECLARED */\n");
641 	    FREE(u_line);
642 	    return;
643 	}
644 	goto loop;
645 
646     case '\'':
647     case '"':
648 	{
649 	    char *s = copy_string(c);
650 	    puts_both(s);
651 	    free(s);
652 	}
653 	goto loop;
654 
655     case '/':
656 	{
657 	    char *s = copy_comment();
658 	    puts_both(s);
659 	    free(s);
660 	}
661 	goto loop;
662 
663     default:
664 	goto loop;
665     }
666 }
667 
668 static char *
669 after_blanks(char *s)
670 {
671     while (*s != '\0' && isspace(UCH(*s)))
672 	++s;
673     return s;
674 }
675 
676 /*
677  * Trim leading/trailing blanks, and collapse multiple embedded blanks to a
678  * single space.  Return index to last character in the buffer.
679  */
680 static int
681 trim_blanks(char *buffer)
682 {
683     if (*buffer != '\0')
684     {
685 	char *d = buffer;
686 	char *s = after_blanks(d);
687 
688 	while ((*d++ = *s++) != '\0')
689 	{
690 	    ;
691 	}
692 
693 	--d;
694 	while ((--d != buffer) && isspace(UCH(*d)))
695 	    *d = '\0';
696 
697 	for (s = d = buffer; (*d++ = *s++) != '\0';)
698 	{
699 	    if (isspace(UCH(*s)))
700 	    {
701 		*s = ' ';
702 		while (isspace(UCH(*s)))
703 		{
704 		    *s++ = ' ';
705 		}
706 		--s;
707 	    }
708 	}
709     }
710 
711     return (int)strlen(buffer) - 1;
712 }
713 
714 /*
715  * Scan forward in the current line-buffer looking for a right-curly bracket.
716  *
717  * Parameters begin with a left-curly bracket, and continue until there are no
718  * more interesting characters after the last right-curly bracket on the
719  * current line.  Bison documents parameters as separated like this:
720  *	{type param1} {type2 param2}
721  * but also accepts commas (although some versions of bison mishandle this)
722  *	{type param1,  type2 param2}
723  */
724 static int
725 more_curly(void)
726 {
727     char *save = cptr;
728     int result = 0;
729     int finish = 0;
730     do
731     {
732 	switch (next_inline())
733 	{
734 	case 0:
735 	case '\n':
736 	    finish = 1;
737 	    break;
738 	case R_CURL:
739 	    finish = 1;
740 	    result = 1;
741 	    break;
742 	}
743 	++cptr;
744     }
745     while (!finish);
746     cptr = save;
747     return result;
748 }
749 
750 static void
751 save_param(int k, char *buffer, int name, int type2)
752 {
753     param *head, *p;
754 
755     p = TMALLOC(param, 1);
756     NO_SPACE(p);
757 
758     p->type2 = strdup(buffer + type2);
759     NO_SPACE(p->type2);
760     buffer[type2] = '\0';
761     (void)trim_blanks(p->type2);
762 
763     p->name = strdup(buffer + name);
764     NO_SPACE(p->name);
765     buffer[name] = '\0';
766     (void)trim_blanks(p->name);
767 
768     p->type = strdup(buffer);
769     NO_SPACE(p->type);
770     (void)trim_blanks(p->type);
771 
772     if (k == LEX_PARAM)
773 	head = lex_param;
774     else
775 	head = parse_param;
776 
777     if (head != NULL)
778     {
779 	while (head->next)
780 	    head = head->next;
781 	head->next = p;
782     }
783     else
784     {
785 	if (k == LEX_PARAM)
786 	    lex_param = p;
787 	else
788 	    parse_param = p;
789     }
790     p->next = NULL;
791 }
792 
793 /*
794  * Keep a linked list of parameters.  This may be multi-line, if the trailing
795  * right-curly bracket is absent.
796  */
797 static void
798 copy_param(int k)
799 {
800     int c;
801     int name, type2;
802     int curly = 0;
803     char *buf = 0;
804     int i = -1;
805     size_t buf_size = 0;
806     int st_lineno = lineno;
807     char *comma;
808 
809     do
810     {
811 	int state = curly;
812 	c = next_inline();
813 	switch (c)
814 	{
815 	case EOF:
816 	    unexpected_EOF();
817 	    break;
818 	case L_CURL:
819 	    if (curly == 1)
820 	    {
821 		goto oops;
822 	    }
823 	    curly = 1;
824 	    st_lineno = lineno;
825 	    break;
826 	case R_CURL:
827 	    if (curly != 1)
828 	    {
829 		goto oops;
830 	    }
831 	    curly = 2;
832 	    break;
833 	case '\n':
834 	    if (curly == 0)
835 	    {
836 		goto oops;
837 	    }
838 	    break;
839 	case '%':
840 	    if ((curly == 1) && (cptr == line))
841 	    {
842 		lineno = st_lineno;
843 		missing_brace();
844 	    }
845 	    /* FALLTHRU */
846 	case '"':
847 	case '\'':
848 	    goto oops;
849 	default:
850 	    if (curly == 0 && !isspace(UCH(c)))
851 	    {
852 		goto oops;
853 	    }
854 	    break;
855 	}
856 	if (buf == 0)
857 	{
858 	    buf_size = (size_t) linesize;
859 	    buf = TMALLOC(char, buf_size);
860 	}
861 	else if (c == '\n')
862 	{
863 	    get_line();
864 	    if (line == NULL)
865 		unexpected_EOF();
866 	    --cptr;
867 	    buf_size += (size_t) linesize;
868 	    buf = TREALLOC(char, buf, buf_size);
869 	}
870 	NO_SPACE(buf);
871 	if (curly)
872 	{
873 	    if ((state == 2) && (c == L_CURL))
874 	    {
875 		buf[++i] = ',';
876 	    }
877 	    else if ((state == 2) && isspace(UCH(c)))
878 	    {
879 		;
880 	    }
881 	    else if ((c != L_CURL) && (c != R_CURL))
882 	    {
883 		buf[++i] = (char)c;
884 	    }
885 	}
886 	cptr++;
887     }
888     while (curly < 2 || more_curly());
889 
890     if (i == 0)
891     {
892 	if (curly == 1)
893 	{
894 	    lineno = st_lineno;
895 	    missing_brace();
896 	}
897 	goto oops;
898     }
899 
900     buf[i--] = '\0';
901     (void)trim_blanks(buf);
902 
903     comma = buf - 1;
904     do
905     {
906 	char *parms = (comma + 1);
907 	comma = strchr(parms, ',');
908 	if (comma != 0)
909 	    *comma = '\0';
910 
911 	(void)trim_blanks(parms);
912 	i = (int)strlen(parms) - 1;
913 	if (i < 0)
914 	{
915 	    goto oops;
916 	}
917 
918 	if (parms[i] == ']')
919 	{
920 	    int level = 1;
921 	    while (i >= 0 && level > 0 && parms[i] != '[')
922 	    {
923 		if (parms[i] == ']')
924 		    ++level;
925 		else if (parms[i] == '[')
926 		    --level;
927 		i--;
928 	    }
929 	    if (i <= 0)
930 		unexpected_EOF();
931 	    type2 = i--;
932 	}
933 	else
934 	{
935 	    type2 = i + 1;
936 	}
937 
938 	while (i > 0 && (isalnum(UCH(parms[i])) || UCH(parms[i]) == '_'))
939 	    i--;
940 
941 	if (!isspace(UCH(parms[i])) && parms[i] != '*')
942 	    goto oops;
943 
944 	name = i + 1;
945 
946 	save_param(k, parms, name, type2);
947     }
948     while (comma != 0);
949     FREE(buf);
950     return;
951 
952   oops:
953     FREE(buf);
954     syntax_error(lineno, line, cptr);
955 }
956 
957 static int
958 hexval(int c)
959 {
960     if (c >= '0' && c <= '9')
961 	return (c - '0');
962     if (c >= 'A' && c <= 'F')
963 	return (c - 'A' + 10);
964     if (c >= 'a' && c <= 'f')
965 	return (c - 'a' + 10);
966     return (-1);
967 }
968 
969 static bucket *
970 get_literal(void)
971 {
972     int c, quote;
973     int i;
974     int n;
975     char *s;
976     bucket *bp;
977     int s_lineno = lineno;
978     char *s_line = dup_line();
979     char *s_cptr = s_line + (cptr - line);
980 
981     quote = *cptr++;
982     cinc = 0;
983     for (;;)
984     {
985 	c = *cptr++;
986 	if (c == quote)
987 	    break;
988 	if (c == '\n')
989 	    unterminated_string(s_lineno, s_line, s_cptr);
990 	if (c == '\\')
991 	{
992 	    char *c_cptr = cptr - 1;
993 
994 	    c = *cptr++;
995 	    switch (c)
996 	    {
997 	    case '\n':
998 		get_line();
999 		if (line == NULL)
1000 		    unterminated_string(s_lineno, s_line, s_cptr);
1001 		continue;
1002 
1003 	    case '0':
1004 	    case '1':
1005 	    case '2':
1006 	    case '3':
1007 	    case '4':
1008 	    case '5':
1009 	    case '6':
1010 	    case '7':
1011 		n = c - '0';
1012 		c = *cptr;
1013 		if (IS_OCTAL(c))
1014 		{
1015 		    n = (n << 3) + (c - '0');
1016 		    c = *++cptr;
1017 		    if (IS_OCTAL(c))
1018 		    {
1019 			n = (n << 3) + (c - '0');
1020 			++cptr;
1021 		    }
1022 		}
1023 		if (n > MAXCHAR)
1024 		    illegal_character(c_cptr);
1025 		c = n;
1026 		break;
1027 
1028 	    case 'x':
1029 		c = *cptr++;
1030 		n = hexval(c);
1031 		if (n < 0 || n >= 16)
1032 		    illegal_character(c_cptr);
1033 		for (;;)
1034 		{
1035 		    c = *cptr;
1036 		    i = hexval(c);
1037 		    if (i < 0 || i >= 16)
1038 			break;
1039 		    ++cptr;
1040 		    n = (n << 4) + i;
1041 		    if (n > MAXCHAR)
1042 			illegal_character(c_cptr);
1043 		}
1044 		c = n;
1045 		break;
1046 
1047 	    case 'a':
1048 		c = 7;
1049 		break;
1050 	    case 'b':
1051 		c = '\b';
1052 		break;
1053 	    case 'f':
1054 		c = '\f';
1055 		break;
1056 	    case 'n':
1057 		c = '\n';
1058 		break;
1059 	    case 'r':
1060 		c = '\r';
1061 		break;
1062 	    case 't':
1063 		c = '\t';
1064 		break;
1065 	    case 'v':
1066 		c = '\v';
1067 		break;
1068 	    }
1069 	}
1070 	cachec(c);
1071     }
1072     FREE(s_line);
1073 
1074     n = cinc;
1075     s = TMALLOC(char, n);
1076     NO_SPACE(s);
1077 
1078     for (i = 0; i < n; ++i)
1079 	s[i] = cache[i];
1080 
1081     cinc = 0;
1082     if (n == 1)
1083 	cachec('\'');
1084     else
1085 	cachec('"');
1086 
1087     for (i = 0; i < n; ++i)
1088     {
1089 	c = UCH(s[i]);
1090 	if (c == '\\' || c == cache[0])
1091 	{
1092 	    cachec('\\');
1093 	    cachec(c);
1094 	}
1095 	else if (isprint(c))
1096 	    cachec(c);
1097 	else
1098 	{
1099 	    cachec('\\');
1100 	    switch (c)
1101 	    {
1102 	    case 7:
1103 		cachec('a');
1104 		break;
1105 	    case '\b':
1106 		cachec('b');
1107 		break;
1108 	    case '\f':
1109 		cachec('f');
1110 		break;
1111 	    case '\n':
1112 		cachec('n');
1113 		break;
1114 	    case '\r':
1115 		cachec('r');
1116 		break;
1117 	    case '\t':
1118 		cachec('t');
1119 		break;
1120 	    case '\v':
1121 		cachec('v');
1122 		break;
1123 	    default:
1124 		cachec(((c >> 6) & 7) + '0');
1125 		cachec(((c >> 3) & 7) + '0');
1126 		cachec((c & 7) + '0');
1127 		break;
1128 	    }
1129 	}
1130     }
1131 
1132     if (n == 1)
1133 	cachec('\'');
1134     else
1135 	cachec('"');
1136 
1137     cachec(NUL);
1138     bp = lookup(cache);
1139     bp->class = TERM;
1140     if (n == 1 && bp->value == UNDEFINED)
1141 	bp->value = UCH(*s);
1142     FREE(s);
1143 
1144     return (bp);
1145 }
1146 
1147 static int
1148 is_reserved(char *name)
1149 {
1150     char *s;
1151 
1152     if (strcmp(name, ".") == 0 ||
1153 	strcmp(name, "$accept") == 0 ||
1154 	strcmp(name, "$end") == 0)
1155 	return (1);
1156 
1157     if (name[0] == '$' && name[1] == '$' && isdigit(UCH(name[2])))
1158     {
1159 	s = name + 3;
1160 	while (isdigit(UCH(*s)))
1161 	    ++s;
1162 	if (*s == NUL)
1163 	    return (1);
1164     }
1165 
1166     return (0);
1167 }
1168 
1169 static bucket *
1170 get_name(void)
1171 {
1172     int c;
1173 
1174     cinc = 0;
1175     for (c = *cptr; IS_IDENT(c); c = *++cptr)
1176 	cachec(c);
1177     cachec(NUL);
1178 
1179     if (is_reserved(cache))
1180 	used_reserved(cache);
1181 
1182     return (lookup(cache));
1183 }
1184 
1185 static Value_t
1186 get_number(void)
1187 {
1188     int c;
1189     Value_t n;
1190 
1191     n = 0;
1192     for (c = *cptr; isdigit(c); c = *++cptr)
1193 	n = (Value_t)(10 * n + (c - '0'));
1194 
1195     return (n);
1196 }
1197 
1198 static char *
1199 cache_tag(char *tag, size_t len)
1200 {
1201     int i;
1202     char *s;
1203 
1204     for (i = 0; i < ntags; ++i)
1205     {
1206 	if (strncmp(tag, tag_table[i], len) == 0 &&
1207 	    tag_table[i][len] == NUL)
1208 	    return (tag_table[i]);
1209     }
1210 
1211     if (ntags >= tagmax)
1212     {
1213 	tagmax += 16;
1214 	tag_table =
1215 	    (tag_table
1216 	     ? TREALLOC(char *, tag_table, tagmax)
1217 	     : TMALLOC(char *, tagmax));
1218 	NO_SPACE(tag_table);
1219     }
1220 
1221     s = TMALLOC(char, len + 1);
1222     NO_SPACE(s);
1223 
1224     strncpy(s, tag, len);
1225     s[len] = 0;
1226     tag_table[ntags++] = s;
1227     return s;
1228 }
1229 
1230 static char *
1231 get_tag(void)
1232 {
1233     int c;
1234     int t_lineno = lineno;
1235     char *t_line = dup_line();
1236     char *t_cptr = t_line + (cptr - line);
1237 
1238     ++cptr;
1239     c = nextc();
1240     if (c == EOF)
1241 	unexpected_EOF();
1242     if (!isalpha(c) && c != '_' && c != '$')
1243 	illegal_tag(t_lineno, t_line, t_cptr);
1244 
1245     cinc = 0;
1246     do
1247     {
1248 	cachec(c);
1249 	c = *++cptr;
1250     }
1251     while (IS_IDENT(c));
1252     cachec(NUL);
1253 
1254     c = nextc();
1255     if (c == EOF)
1256 	unexpected_EOF();
1257     if (c != '>')
1258 	illegal_tag(t_lineno, t_line, t_cptr);
1259     ++cptr;
1260 
1261     FREE(t_line);
1262     havetags = 1;
1263     return cache_tag(cache, (size_t) cinc);
1264 }
1265 
1266 #if defined(YYBTYACC)
1267 static char *
1268 scan_id(void)
1269 {
1270     char *b = cptr;
1271 
1272     while (isalnum(*cptr) || *cptr == '_' || *cptr == '$')
1273 	cptr++;
1274     return cache_tag(b, (size_t) (cptr - b));
1275 }
1276 #endif
1277 
1278 static void
1279 declare_tokens(int assoc)
1280 {
1281     int c;
1282     bucket *bp;
1283     Value_t value;
1284     char *tag = 0;
1285 
1286     if (assoc != TOKEN)
1287 	++prec;
1288 
1289     c = nextc();
1290     if (c == EOF)
1291 	unexpected_EOF();
1292     if (c == '<')
1293     {
1294 	tag = get_tag();
1295 	c = nextc();
1296 	if (c == EOF)
1297 	    unexpected_EOF();
1298     }
1299 
1300     for (;;)
1301     {
1302 	if (isalpha(c) || c == '_' || c == '.' || c == '$')
1303 	    bp = get_name();
1304 	else if (c == '\'' || c == '"')
1305 	    bp = get_literal();
1306 	else
1307 	    return;
1308 
1309 	if (bp == goal)
1310 	    tokenized_start(bp->name);
1311 	bp->class = TERM;
1312 
1313 	if (tag)
1314 	{
1315 	    if (bp->tag && tag != bp->tag)
1316 		retyped_warning(bp->name);
1317 	    bp->tag = tag;
1318 	}
1319 
1320 	if (assoc != TOKEN)
1321 	{
1322 	    if (bp->prec && prec != bp->prec)
1323 		reprec_warning(bp->name);
1324 	    bp->assoc = (Assoc_t)assoc;
1325 	    bp->prec = prec;
1326 	}
1327 
1328 	c = nextc();
1329 	if (c == EOF)
1330 	    unexpected_EOF();
1331 
1332 	value = UNDEFINED;
1333 	if (isdigit(c))
1334 	{
1335 	    value = get_number();
1336 	    if (bp->value != UNDEFINED && value != bp->value)
1337 		revalued_warning(bp->name);
1338 	    bp->value = value;
1339 	    c = nextc();
1340 	    if (c == EOF)
1341 		unexpected_EOF();
1342 	}
1343     }
1344 }
1345 
1346 /*
1347  * %expect requires special handling
1348  * as it really isn't part of the yacc
1349  * grammar only a flag for yacc proper.
1350  */
1351 static void
1352 declare_expect(int assoc)
1353 {
1354     int c;
1355 
1356     if (assoc != EXPECT && assoc != EXPECT_RR)
1357 	++prec;
1358 
1359     /*
1360      * Stay away from nextc - doesn't
1361      * detect EOL and will read to EOF.
1362      */
1363     c = *++cptr;
1364     if (c == EOF)
1365 	unexpected_EOF();
1366 
1367     for (;;)
1368     {
1369 	if (isdigit(c))
1370 	{
1371 	    if (assoc == EXPECT)
1372 		SRexpect = get_number();
1373 	    else
1374 		RRexpect = get_number();
1375 	    break;
1376 	}
1377 	/*
1378 	 * Looking for number before EOL.
1379 	 * Spaces, tabs, and numbers are ok,
1380 	 * words, punc., etc. are syntax errors.
1381 	 */
1382 	else if (c == '\n' || isalpha(c) || !isspace(c))
1383 	{
1384 	    syntax_error(lineno, line, cptr);
1385 	}
1386 	else
1387 	{
1388 	    c = *++cptr;
1389 	    if (c == EOF)
1390 		unexpected_EOF();
1391 	}
1392     }
1393 }
1394 
1395 #if defined(YYBTYACC)
1396 static void
1397 declare_argtypes(bucket *bp)
1398 {
1399     char *tags[MAXARGS];
1400     int args = 0, c;
1401 
1402     if (bp->args >= 0)
1403 	retyped_warning(bp->name);
1404     cptr++;			/* skip open paren */
1405     for (;;)
1406     {
1407 	c = nextc();
1408 	if (c == EOF)
1409 	    unexpected_EOF();
1410 	if (c != '<')
1411 	    syntax_error(lineno, line, cptr);
1412 	tags[args++] = get_tag();
1413 	c = nextc();
1414 	if (c == R_PAREN)
1415 	    break;
1416 	if (c == EOF)
1417 	    unexpected_EOF();
1418     }
1419     cptr++;			/* skip close paren */
1420     bp->args = args;
1421     bp->argnames = TMALLOC(char *, args);
1422     NO_SPACE(bp->argnames);
1423     bp->argtags = CALLOC(sizeof(char *), args + 1);
1424     NO_SPACE(bp->argtags);
1425     while (--args >= 0)
1426     {
1427 	bp->argtags[args] = tags[args];
1428 	bp->argnames[args] = NULL;
1429     }
1430 }
1431 #endif
1432 
1433 static void
1434 declare_types(void)
1435 {
1436     int c;
1437     bucket *bp = NULL;
1438     char *tag = NULL;
1439 
1440     c = nextc();
1441     if (c == EOF)
1442 	unexpected_EOF();
1443     if (c == '<')
1444 	tag = get_tag();
1445 
1446     for (;;)
1447     {
1448 	c = nextc();
1449 	if (c == EOF)
1450 	    unexpected_EOF();
1451 	if (isalpha(c) || c == '_' || c == '.' || c == '$')
1452 	{
1453 	    bp = get_name();
1454 #if defined(YYBTYACC)
1455 	    if (nextc() == L_PAREN)
1456 		declare_argtypes(bp);
1457 	    else
1458 		bp->args = 0;
1459 #endif
1460 	}
1461 	else if (c == '\'' || c == '"')
1462 	{
1463 	    bp = get_literal();
1464 #if defined(YYBTYACC)
1465 	    bp->args = 0;
1466 #endif
1467 	}
1468 	else
1469 	    return;
1470 
1471 	if (tag)
1472 	{
1473 	    if (bp->tag && tag != bp->tag)
1474 		retyped_warning(bp->name);
1475 	    bp->tag = tag;
1476 	}
1477     }
1478 }
1479 
1480 static void
1481 declare_start(void)
1482 {
1483     int c;
1484     bucket *bp;
1485 
1486     c = nextc();
1487     if (c == EOF)
1488 	unexpected_EOF();
1489     if (!isalpha(c) && c != '_' && c != '.' && c != '$')
1490 	syntax_error(lineno, line, cptr);
1491     bp = get_name();
1492     if (bp->class == TERM)
1493 	terminal_start(bp->name);
1494     if (goal && goal != bp)
1495 	restarted_warning();
1496     goal = bp;
1497 }
1498 
1499 static void
1500 read_declarations(void)
1501 {
1502     int c, k;
1503 
1504     cache_size = CACHE_SIZE;
1505     cache = TMALLOC(char, cache_size);
1506     NO_SPACE(cache);
1507 
1508     for (;;)
1509     {
1510 	c = nextc();
1511 	if (c == EOF)
1512 	    unexpected_EOF();
1513 	if (c != '%')
1514 	    syntax_error(lineno, line, cptr);
1515 	switch (k = keyword())
1516 	{
1517 	case MARK:
1518 	    return;
1519 
1520 	case IDENT:
1521 	    copy_ident();
1522 	    break;
1523 
1524 	case TEXT:
1525 	    copy_text();
1526 	    break;
1527 
1528 	case UNION:
1529 	    copy_union();
1530 	    break;
1531 
1532 	case TOKEN:
1533 	case LEFT:
1534 	case RIGHT:
1535 	case NONASSOC:
1536 	    declare_tokens(k);
1537 	    break;
1538 
1539 	case EXPECT:
1540 	case EXPECT_RR:
1541 	    declare_expect(k);
1542 	    break;
1543 
1544 	case TYPE:
1545 	    declare_types();
1546 	    break;
1547 
1548 	case START:
1549 	    declare_start();
1550 	    break;
1551 
1552 	case PURE_PARSER:
1553 	    pure_parser = 1;
1554 	    break;
1555 
1556 	case PARSE_PARAM:
1557 	case LEX_PARAM:
1558 	    copy_param(k);
1559 	    break;
1560 
1561 	case TOKEN_TABLE:
1562 	    token_table = 1;
1563 	    break;
1564 
1565 #if defined(YYBTYACC)
1566 	case LOCATIONS:
1567 	    locations = 1;
1568 	    break;
1569 
1570 	case DESTRUCTOR:
1571 	    destructor = 1;
1572 	    copy_destructor();
1573 	    break;
1574 #endif
1575 
1576 	case POSIX_YACC:
1577 	    /* noop for bison compatibility. byacc is already designed to be posix
1578 	     * yacc compatible. */
1579 	    break;
1580 	}
1581     }
1582 }
1583 
1584 static void
1585 initialize_grammar(void)
1586 {
1587     nitems = 4;
1588     maxitems = 300;
1589 
1590     pitem = TMALLOC(bucket *, maxitems);
1591     NO_SPACE(pitem);
1592 
1593     pitem[0] = 0;
1594     pitem[1] = 0;
1595     pitem[2] = 0;
1596     pitem[3] = 0;
1597 
1598     nrules = 3;
1599     maxrules = 100;
1600 
1601     plhs = TMALLOC(bucket *, maxrules);
1602     NO_SPACE(plhs);
1603 
1604     plhs[0] = 0;
1605     plhs[1] = 0;
1606     plhs[2] = 0;
1607 
1608     rprec = TMALLOC(Value_t, maxrules);
1609     NO_SPACE(rprec);
1610 
1611     rprec[0] = 0;
1612     rprec[1] = 0;
1613     rprec[2] = 0;
1614 
1615     rassoc = TMALLOC(Assoc_t, maxrules);
1616     NO_SPACE(rassoc);
1617 
1618     rassoc[0] = TOKEN;
1619     rassoc[1] = TOKEN;
1620     rassoc[2] = TOKEN;
1621 }
1622 
1623 static void
1624 expand_items(void)
1625 {
1626     maxitems += 300;
1627     pitem = TREALLOC(bucket *, pitem, maxitems);
1628     NO_SPACE(pitem);
1629 }
1630 
1631 static void
1632 expand_rules(void)
1633 {
1634     maxrules += 100;
1635 
1636     plhs = TREALLOC(bucket *, plhs, maxrules);
1637     NO_SPACE(plhs);
1638 
1639     rprec = TREALLOC(Value_t, rprec, maxrules);
1640     NO_SPACE(rprec);
1641 
1642     rassoc = TREALLOC(Assoc_t, rassoc, maxrules);
1643     NO_SPACE(rassoc);
1644 }
1645 
1646 /* set immediately prior to where copy_args() could be called, and incremented by
1647    the various routines that will rescan the argument list as appropriate */
1648 static int rescan_lineno;
1649 #if defined(YYBTYACC)
1650 
1651 static char *
1652 copy_args(int *alen)
1653 {
1654     struct mstring *s = msnew();
1655     int depth = 0, len = 1;
1656     char c, quote = 0;
1657     int a_lineno = lineno;
1658     char *a_line = dup_line();
1659     char *a_cptr = a_line + (cptr - line - 1);
1660 
1661     while ((c = *cptr++) != R_PAREN || depth || quote)
1662     {
1663 	if (c == ',' && !quote && !depth)
1664 	{
1665 	    len++;
1666 	    mputc(s, 0);
1667 	    continue;
1668 	}
1669 	mputc(s, c);
1670 	if (c == '\n')
1671 	{
1672 	    get_line();
1673 	    if (!line)
1674 	    {
1675 		if (quote)
1676 		    unterminated_string(a_lineno, a_line, a_cptr);
1677 		else
1678 		    unterminated_arglist(a_lineno, a_line, a_cptr);
1679 	    }
1680 	}
1681 	else if (quote)
1682 	{
1683 	    if (c == quote)
1684 		quote = 0;
1685 	    else if (c == '\\')
1686 	    {
1687 		if (*cptr != '\n')
1688 		    mputc(s, *cptr++);
1689 	    }
1690 	}
1691 	else
1692 	{
1693 	    if (c == L_PAREN)
1694 		depth++;
1695 	    else if (c == R_PAREN)
1696 		depth--;
1697 	    else if (c == '\"' || c == '\'')
1698 		quote = c;
1699 	}
1700     }
1701     if (alen)
1702 	*alen = len;
1703     FREE(a_line);
1704     return msdone(s);
1705 }
1706 
1707 static char *
1708 parse_id(char *p, char **save)
1709 {
1710     char *b;
1711 
1712     while (isspace(*p))
1713 	if (*p++ == '\n')
1714 	    rescan_lineno++;
1715     if (!isalpha(*p) && *p != '_')
1716 	return NULL;
1717     b = p;
1718     while (isalnum(*p) || *p == '_' || *p == '$')
1719 	p++;
1720     if (save)
1721     {
1722 	*save = cache_tag(b, (size_t) (p - b));
1723     }
1724     return p;
1725 }
1726 
1727 static char *
1728 parse_int(char *p, int *save)
1729 {
1730     int neg = 0, val = 0;
1731 
1732     while (isspace(*p))
1733 	if (*p++ == '\n')
1734 	    rescan_lineno++;
1735     if (*p == '-')
1736     {
1737 	neg = 1;
1738 	p++;
1739     }
1740     if (!isdigit(*p))
1741 	return NULL;
1742     while (isdigit(*p))
1743 	val = val * 10 + *p++ - '0';
1744     if (neg)
1745 	val = -val;
1746     if (save)
1747 	*save = val;
1748     return p;
1749 }
1750 
1751 static void
1752 parse_arginfo(bucket *a, char *args, int argslen)
1753 {
1754     char *p = args, *tmp;
1755     int i, redec = 0;
1756 
1757     if (a->args >= 0)
1758     {
1759 	if (a->args != argslen)
1760 	    arg_number_disagree_warning(rescan_lineno, a->name);
1761 	redec = 1;
1762     }
1763     else
1764     {
1765 	if ((a->args = argslen) == 0)
1766 	    return;
1767 	a->argnames = TMALLOC(char *, argslen);
1768 	NO_SPACE(a->argnames);
1769 	a->argtags = TMALLOC(char *, argslen);
1770 	NO_SPACE(a->argtags);
1771     }
1772     if (!args)
1773 	return;
1774     for (i = 0; i < argslen; i++)
1775     {
1776 	while (isspace(*p))
1777 	    if (*p++ == '\n')
1778 		rescan_lineno++;
1779 	if (*p++ != '$')
1780 	    bad_formals();
1781 	while (isspace(*p))
1782 	    if (*p++ == '\n')
1783 		rescan_lineno++;
1784 	if (*p == '<')
1785 	{
1786 	    havetags = 1;
1787 	    if (!(p = parse_id(p + 1, &tmp)))
1788 		bad_formals();
1789 	    while (isspace(*p))
1790 		if (*p++ == '\n')
1791 		    rescan_lineno++;
1792 	    if (*p++ != '>')
1793 		bad_formals();
1794 	    if (redec)
1795 	    {
1796 		if (a->argtags[i] != tmp)
1797 		    arg_type_disagree_warning(rescan_lineno, i + 1, a->name);
1798 	    }
1799 	    else
1800 		a->argtags[i] = tmp;
1801 	}
1802 	else if (!redec)
1803 	    a->argtags[i] = NULL;
1804 	if (!(p = parse_id(p, &a->argnames[i])))
1805 	    bad_formals();
1806 	while (isspace(*p))
1807 	    if (*p++ == '\n')
1808 		rescan_lineno++;
1809 	if (*p++)
1810 	    bad_formals();
1811     }
1812     free(args);
1813 }
1814 
1815 static char *
1816 compile_arg(char **theptr, char *yyvaltag)
1817 {
1818     char *p = *theptr;
1819     struct mstring *c = msnew();
1820     int i, j, n;
1821     Value_t *offsets = NULL, maxoffset;
1822     bucket **rhs;
1823 
1824     maxoffset = 0;
1825     n = 0;
1826     for (i = nitems - 1; pitem[i]; --i)
1827     {
1828 	n++;
1829 	if (pitem[i]->class != ARGUMENT)
1830 	    maxoffset++;
1831     }
1832     if (maxoffset > 0)
1833     {
1834 	offsets = TMALLOC(Value_t, maxoffset + 1);
1835 	NO_SPACE(offsets);
1836 
1837 	for (j = 0, i++; i < nitems; i++)
1838 	    if (pitem[i]->class != ARGUMENT)
1839 		offsets[++j] = (Value_t)(i - nitems + 1);
1840     }
1841     rhs = pitem + nitems - 1;
1842 
1843     if (yyvaltag)
1844 	msprintf(c, "yyval.%s = ", yyvaltag);
1845     else
1846 	msprintf(c, "yyval = ");
1847     while (*p)
1848     {
1849 	if (*p == '$')
1850 	{
1851 	    char *tag = NULL;
1852 	    if (*++p == '<')
1853 		if (!(p = parse_id(++p, &tag)) || *p++ != '>')
1854 		    illegal_tag(rescan_lineno, NULL, NULL);
1855 	    if (isdigit(*p) || *p == '-')
1856 	    {
1857 		int val;
1858 		if (!(p = parse_int(p, &val)))
1859 		    dollar_error(rescan_lineno, NULL, NULL);
1860 		if (val <= 0)
1861 		    i = val - n;
1862 		else if (val > maxoffset)
1863 		{
1864 		    dollar_warning(rescan_lineno, val);
1865 		    i = val - maxoffset;
1866 		}
1867 		else if (maxoffset > 0)
1868 		{
1869 		    i = offsets[val];
1870 		    if (!tag && !(tag = rhs[i]->tag) && havetags)
1871 			untyped_rhs(val, rhs[i]->name);
1872 		}
1873 		msprintf(c, "yystack.l_mark[%d]", i);
1874 		if (tag)
1875 		    msprintf(c, ".%s", tag);
1876 		else if (havetags)
1877 		    unknown_rhs(val);
1878 	    }
1879 	    else if (isalpha(*p) || *p == '_')
1880 	    {
1881 		char *arg;
1882 		if (!(p = parse_id(p, &arg)))
1883 		    dollar_error(rescan_lineno, NULL, NULL);
1884 		for (i = plhs[nrules]->args - 1; i >= 0; i--)
1885 		    if (arg == plhs[nrules]->argnames[i])
1886 			break;
1887 		if (i < 0)
1888 		    unknown_arg_warning(rescan_lineno, "$", arg, NULL, NULL);
1889 		else if (!tag)
1890 		    tag = plhs[nrules]->argtags[i];
1891 		msprintf(c, "yystack.l_mark[%d]",
1892 			 i - plhs[nrules]->args + 1 - n);
1893 		if (tag)
1894 		    msprintf(c, ".%s", tag);
1895 		else if (havetags)
1896 		    untyped_arg_warning(rescan_lineno, "$", arg);
1897 	    }
1898 	    else
1899 		dollar_error(rescan_lineno, NULL, NULL);
1900 	}
1901 	else if (*p == '@')
1902 	{
1903 	    at_error(rescan_lineno, NULL, NULL);
1904 	}
1905 	else
1906 	{
1907 	    if (*p == '\n')
1908 		rescan_lineno++;
1909 	    mputc(c, *p++);
1910 	}
1911     }
1912     *theptr = p;
1913     if (maxoffset > 0)
1914 	FREE(offsets);
1915     return msdone(c);
1916 }
1917 
1918 static int
1919 can_elide_arg(char **theptr, char *yyvaltag)
1920 {
1921     char *p = *theptr;
1922     int rv = 0;
1923     int i, j, n = 0;
1924     Value_t *offsets = NULL, maxoffset = 0;
1925     bucket **rhs;
1926     char *tag = 0;
1927 
1928     if (*p++ != '$')
1929 	return 0;
1930     if (*p == '<')
1931     {
1932 	if (!(p = parse_id(++p, &tag)) || *p++ != '>')
1933 	    return 0;
1934     }
1935     for (i = nitems - 1; pitem[i]; --i)
1936     {
1937 	n++;
1938 	if (pitem[i]->class != ARGUMENT)
1939 	    maxoffset++;
1940     }
1941     if (maxoffset > 0)
1942     {
1943 	offsets = TMALLOC(Value_t, maxoffset + 1);
1944 	NO_SPACE(offsets);
1945 
1946 	for (j = 0, i++; i < nitems; i++)
1947 	    if (pitem[i]->class != ARGUMENT)
1948 		offsets[++j] = (Value_t)(i - nitems + 1);
1949     }
1950     rhs = pitem + nitems - 1;
1951 
1952     if (isdigit(*p) || *p == '-')
1953     {
1954 	int val;
1955 	if (!(p = parse_int(p, &val)))
1956 	    rv = 0;
1957 	else
1958 	{
1959 	    if (val <= 0)
1960 		rv = 1 - val + n;
1961 	    else if (val > maxoffset)
1962 		rv = 0;
1963 	    else
1964 	    {
1965 		i = offsets[val];
1966 		rv = 1 - i;
1967 		if (!tag)
1968 		    tag = rhs[i]->tag;
1969 	    }
1970 	}
1971     }
1972     else if (isalpha(*p) || *p == '_')
1973     {
1974 	char *arg;
1975 	if (!(p = parse_id(p, &arg)))
1976 	    return 0;
1977 	for (i = plhs[nrules]->args - 1; i >= 0; i--)
1978 	    if (arg == plhs[nrules]->argnames[i])
1979 		break;
1980 	if (i >= 0)
1981 	{
1982 	    if (!tag)
1983 		tag = plhs[nrules]->argtags[i];
1984 	    rv = plhs[nrules]->args + n - i;
1985 	}
1986     }
1987     if (tag && yyvaltag)
1988     {
1989 	if (strcmp(tag, yyvaltag))
1990 	    rv = 0;
1991     }
1992     else if (tag || yyvaltag)
1993 	rv = 0;
1994     if (maxoffset > 0)
1995 	FREE(offsets);
1996     if (*p || rv <= 0)
1997 	return 0;
1998     *theptr = p + 1;
1999     return rv;
2000 }
2001 
2002 #define ARG_CACHE_SIZE	1024
2003 static struct arg_cache
2004 {
2005     struct arg_cache *next;
2006     char *code;
2007     int rule;
2008 }
2009  *arg_cache[ARG_CACHE_SIZE];
2010 
2011 static int
2012 lookup_arg_cache(char *code)
2013 {
2014     struct arg_cache *entry;
2015 
2016     entry = arg_cache[strnshash(code) % ARG_CACHE_SIZE];
2017     while (entry)
2018     {
2019 	if (!strnscmp(entry->code, code))
2020 	    return entry->rule;
2021 	entry = entry->next;
2022     }
2023     return -1;
2024 }
2025 
2026 static void
2027 insert_arg_cache(char *code, int rule)
2028 {
2029     struct arg_cache *entry = NEW(struct arg_cache);
2030     int i;
2031 
2032     NO_SPACE(entry);
2033     i = strnshash(code) % ARG_CACHE_SIZE;
2034     entry->code = code;
2035     entry->rule = rule;
2036     entry->next = arg_cache[i];
2037     arg_cache[i] = entry;
2038 }
2039 
2040 static void
2041 clean_arg_cache(void)
2042 {
2043     struct arg_cache *e, *t;
2044     int i;
2045 
2046     for (i = 0; i < ARG_CACHE_SIZE; i++)
2047     {
2048 	for (e = arg_cache[i]; (t = e); e = e->next, FREE(t))
2049 	    free(e->code);
2050 	arg_cache[i] = NULL;
2051     }
2052 }
2053 #endif /* defined(YYBTYACC) */
2054 
2055 static void
2056 advance_to_start(void)
2057 {
2058     int c;
2059     bucket *bp;
2060     char *s_cptr;
2061     int s_lineno;
2062 #if defined(YYBTYACC)
2063     char *args = NULL;
2064     int argslen = 0;
2065 #endif
2066 
2067     for (;;)
2068     {
2069 	c = nextc();
2070 	if (c != '%')
2071 	    break;
2072 	s_cptr = cptr;
2073 	switch (keyword())
2074 	{
2075 	case MARK:
2076 	    no_grammar();
2077 
2078 	case TEXT:
2079 	    copy_text();
2080 	    break;
2081 
2082 	case START:
2083 	    declare_start();
2084 	    break;
2085 
2086 	default:
2087 	    syntax_error(lineno, line, s_cptr);
2088 	}
2089     }
2090 
2091     c = nextc();
2092     if (!isalpha(c) && c != '_' && c != '.' && c != '_')
2093 	syntax_error(lineno, line, cptr);
2094     bp = get_name();
2095     if (goal == 0)
2096     {
2097 	if (bp->class == TERM)
2098 	    terminal_start(bp->name);
2099 	goal = bp;
2100     }
2101 
2102     s_lineno = lineno;
2103     c = nextc();
2104     if (c == EOF)
2105 	unexpected_EOF();
2106     rescan_lineno = lineno;	/* line# for possible inherited args rescan */
2107 #if defined(YYBTYACC)
2108     if (c == L_PAREN)
2109     {
2110 	++cptr;
2111 	args = copy_args(&argslen);
2112 	NO_SPACE(args);
2113 	c = nextc();
2114     }
2115 #endif
2116     if (c != ':')
2117 	syntax_error(lineno, line, cptr);
2118     start_rule(bp, s_lineno);
2119 #if defined(YYBTYACC)
2120     parse_arginfo(bp, args, argslen);
2121 #endif
2122     ++cptr;
2123 }
2124 
2125 static void
2126 start_rule(bucket *bp, int s_lineno)
2127 {
2128     if (bp->class == TERM)
2129 	terminal_lhs(s_lineno);
2130     bp->class = NONTERM;
2131     if (!bp->index)
2132 	bp->index = nrules;
2133     if (nrules >= maxrules)
2134 	expand_rules();
2135     plhs[nrules] = bp;
2136     rprec[nrules] = UNDEFINED;
2137     rassoc[nrules] = TOKEN;
2138 }
2139 
2140 static void
2141 end_rule(void)
2142 {
2143     int i;
2144 
2145     if (!last_was_action && plhs[nrules]->tag)
2146     {
2147 	if (pitem[nitems - 1])
2148 	{
2149 	    for (i = nitems - 1; (i > 0) && pitem[i]; --i)
2150 		continue;
2151 	    if (pitem[i + 1] == 0 || pitem[i + 1]->tag != plhs[nrules]->tag)
2152 		default_action_warning(plhs[nrules]->name);
2153 	}
2154 	else
2155 	    default_action_warning(plhs[nrules]->name);
2156     }
2157 
2158     last_was_action = 0;
2159     if (nitems >= maxitems)
2160 	expand_items();
2161     pitem[nitems] = 0;
2162     ++nitems;
2163     ++nrules;
2164 }
2165 
2166 static void
2167 insert_empty_rule(void)
2168 {
2169     bucket *bp, **bpp;
2170 
2171     assert(cache);
2172     assert(cache_size >= CACHE_SIZE);
2173     sprintf(cache, "$$%d", ++gensym);
2174     bp = make_bucket(cache);
2175     last_symbol->next = bp;
2176     last_symbol = bp;
2177     bp->tag = plhs[nrules]->tag;
2178     bp->class = ACTION;
2179 #if defined(YYBTYACC)
2180     bp->args = 0;
2181 #endif
2182 
2183     nitems = (Value_t)(nitems + 2);
2184     if (nitems > maxitems)
2185 	expand_items();
2186     bpp = pitem + nitems - 1;
2187     *bpp-- = bp;
2188     while ((bpp[0] = bpp[-1]) != 0)
2189 	--bpp;
2190 
2191     if (++nrules >= maxrules)
2192 	expand_rules();
2193     plhs[nrules] = plhs[nrules - 1];
2194     plhs[nrules - 1] = bp;
2195     rprec[nrules] = rprec[nrules - 1];
2196     rprec[nrules - 1] = 0;
2197     rassoc[nrules] = rassoc[nrules - 1];
2198     rassoc[nrules - 1] = TOKEN;
2199 }
2200 
2201 #if defined(YYBTYACC)
2202 static char *
2203 insert_arg_rule(char *arg, char *tag)
2204 {
2205     int line_number = rescan_lineno;
2206     char *code = compile_arg(&arg, tag);
2207     int rule = lookup_arg_cache(code);
2208     FILE *f = action_file;
2209 
2210     if (rule < 0)
2211     {
2212 	rule = nrules;
2213 	insert_arg_cache(code, rule);
2214 	trialaction = 1;	/* arg rules always run in trial mode */
2215 	fprintf(f, "case %d:\n", rule - 2);
2216 	if (!lflag)
2217 	    fprintf(f, line_format, line_number, input_file_name);
2218 	fprintf(f, "%s;\n", code);
2219 	fprintf(f, "break;\n");
2220 	insert_empty_rule();
2221 	plhs[rule]->tag = cache_tag(tag, strlen(tag));
2222 	plhs[rule]->class = ARGUMENT;
2223     }
2224     else
2225     {
2226 	if (++nitems > maxitems)
2227 	    expand_items();
2228 	pitem[nitems - 1] = plhs[rule];
2229 	free(code);
2230     }
2231     return arg + 1;
2232 }
2233 #endif
2234 
2235 static void
2236 add_symbol(void)
2237 {
2238     int c;
2239     bucket *bp;
2240     int s_lineno = lineno;
2241 #if defined(YYBTYACC)
2242     char *args = NULL;
2243     int argslen = 0;
2244 #endif
2245 
2246     c = *cptr;
2247     if (c == '\'' || c == '"')
2248 	bp = get_literal();
2249     else
2250 	bp = get_name();
2251 
2252     c = nextc();
2253     rescan_lineno = lineno;	/* line# for possible inherited args rescan */
2254 #if defined(YYBTYACC)
2255     if (c == L_PAREN)
2256     {
2257 	++cptr;
2258 	args = copy_args(&argslen);
2259 	NO_SPACE(args);
2260 	c = nextc();
2261     }
2262 #endif
2263     if (c == ':')
2264     {
2265 	end_rule();
2266 	start_rule(bp, s_lineno);
2267 #if defined(YYBTYACC)
2268 	parse_arginfo(bp, args, argslen);
2269 #endif
2270 	++cptr;
2271 	return;
2272     }
2273 
2274     if (last_was_action)
2275 	insert_empty_rule();
2276     last_was_action = 0;
2277 
2278 #if defined(YYBTYACC)
2279     if (bp->args < 0)
2280 	bp->args = argslen;
2281     if (argslen == 0 && bp->args > 0 && pitem[nitems - 1] == NULL)
2282     {
2283 	int i;
2284 	if (plhs[nrules]->args != bp->args)
2285 	    wrong_number_args_warning("default ", bp->name);
2286 	for (i = bp->args - 1; i >= 0; i--)
2287 	    if (plhs[nrules]->argtags[i] != bp->argtags[i])
2288 		wrong_type_for_arg_warning(i + 1, bp->name);
2289     }
2290     else if (bp->args != argslen)
2291 	wrong_number_args_warning("", bp->name);
2292     if (args != 0)
2293     {
2294 	char *ap = args;
2295 	int i = 0;
2296 	int elide_cnt = can_elide_arg(&ap, bp->argtags[0]);
2297 
2298 	if (elide_cnt > argslen)
2299 	    elide_cnt = 0;
2300 	if (elide_cnt)
2301 	{
2302 	    for (i = 1; i < elide_cnt; i++)
2303 		if (can_elide_arg(&ap, bp->argtags[i]) != elide_cnt - i)
2304 		{
2305 		    elide_cnt = 0;
2306 		    break;
2307 		}
2308 	}
2309 	if (elide_cnt)
2310 	{
2311 	    assert(i == elide_cnt);
2312 	}
2313 	else
2314 	{
2315 	    ap = args;
2316 	    i = 0;
2317 	}
2318 	for (; i < argslen; i++)
2319 	    ap = insert_arg_rule(ap, bp->argtags[i]);
2320 	free(args);
2321     }
2322 #endif /* defined(YYBTYACC) */
2323 
2324     if (++nitems > maxitems)
2325 	expand_items();
2326     pitem[nitems - 1] = bp;
2327 }
2328 
2329 static void
2330 copy_action(void)
2331 {
2332     int c;
2333     int i, j, n;
2334     int depth;
2335 #if defined(YYBTYACC)
2336     int haveyyval = 0;
2337 #endif
2338     char *tag;
2339     FILE *f = action_file;
2340     int a_lineno = lineno;
2341     char *a_line = dup_line();
2342     char *a_cptr = a_line + (cptr - line);
2343     Value_t *offsets = NULL, maxoffset;
2344     bucket **rhs;
2345 
2346     if (last_was_action)
2347 	insert_empty_rule();
2348     last_was_action = 1;
2349 #if defined(YYBTYACC)
2350     trialaction = (*cptr == L_BRAC);
2351 #endif
2352 
2353     fprintf(f, "case %d:\n", nrules - 2);
2354 #if defined(YYBTYACC)
2355     if (backtrack)
2356     {
2357 	if (!trialaction)
2358 	    fprintf(f, "  if (!yytrial)\n");
2359     }
2360 #endif
2361     if (!lflag)
2362 	fprintf(f, line_format, lineno, input_file_name);
2363     if (*cptr == '=')
2364 	++cptr;
2365 
2366     /* avoid putting curly-braces in first column, to ease editing */
2367     if (*after_blanks(cptr) == L_CURL)
2368     {
2369 	putc('\t', f);
2370 	cptr = after_blanks(cptr);
2371     }
2372 
2373     maxoffset = 0;
2374     n = 0;
2375     for (i = nitems - 1; pitem[i]; --i)
2376     {
2377 	++n;
2378 	if (pitem[i]->class != ARGUMENT)
2379 	    maxoffset++;
2380     }
2381     if (maxoffset > 0)
2382     {
2383 	offsets = TMALLOC(Value_t, maxoffset + 1);
2384 	NO_SPACE(offsets);
2385 
2386 	for (j = 0, i++; i < nitems; i++)
2387 	{
2388 	    if (pitem[i]->class != ARGUMENT)
2389 	    {
2390 		offsets[++j] = (Value_t)(i - nitems + 1);
2391 	    }
2392 	}
2393     }
2394     rhs = pitem + nitems - 1;
2395 
2396     depth = 0;
2397   loop:
2398     c = *cptr;
2399     if (c == '$')
2400     {
2401 	if (cptr[1] == '<')
2402 	{
2403 	    int d_lineno = lineno;
2404 	    char *d_line = dup_line();
2405 	    char *d_cptr = d_line + (cptr - line);
2406 
2407 	    ++cptr;
2408 	    tag = get_tag();
2409 	    c = *cptr;
2410 	    if (c == '$')
2411 	    {
2412 		fprintf(f, "yyval.%s", tag);
2413 		++cptr;
2414 		FREE(d_line);
2415 		goto loop;
2416 	    }
2417 	    else if (isdigit(c))
2418 	    {
2419 		i = get_number();
2420 		if (i == 0)
2421 		    fprintf(f, "yystack.l_mark[%d].%s", -n, tag);
2422 		else if (i > maxoffset)
2423 		{
2424 		    dollar_warning(d_lineno, i);
2425 		    fprintf(f, "yystack.l_mark[%d].%s", i - maxoffset, tag);
2426 		}
2427 		else if (offsets)
2428 		    fprintf(f, "yystack.l_mark[%d].%s", offsets[i], tag);
2429 		FREE(d_line);
2430 		goto loop;
2431 	    }
2432 	    else if (c == '-' && isdigit(UCH(cptr[1])))
2433 	    {
2434 		++cptr;
2435 		i = -get_number() - n;
2436 		fprintf(f, "yystack.l_mark[%d].%s", i, tag);
2437 		FREE(d_line);
2438 		goto loop;
2439 	    }
2440 #if defined(YYBTYACC)
2441 	    else if (isalpha(c) || c == '_')
2442 	    {
2443 		char *arg = scan_id();
2444 		for (i = plhs[nrules]->args - 1; i >= 0; i--)
2445 		    if (arg == plhs[nrules]->argnames[i])
2446 			break;
2447 		if (i < 0)
2448 		    unknown_arg_warning(d_lineno, "$", arg, d_line, d_cptr);
2449 		fprintf(f, "yystack.l_mark[%d].%s",
2450 			i - plhs[nrules]->args + 1 - n, tag);
2451 		FREE(d_line);
2452 		goto loop;
2453 	    }
2454 #endif
2455 	    else
2456 		dollar_error(d_lineno, d_line, d_cptr);
2457 	}
2458 	else if (cptr[1] == '$')
2459 	{
2460 	    if (havetags)
2461 	    {
2462 		tag = plhs[nrules]->tag;
2463 		if (tag == 0)
2464 		    untyped_lhs();
2465 		fprintf(f, "yyval.%s", tag);
2466 	    }
2467 	    else
2468 		fprintf(f, "yyval");
2469 	    cptr += 2;
2470 #if defined(YYBTYACC)
2471 	    haveyyval = 1;
2472 #endif
2473 	    goto loop;
2474 	}
2475 	else if (isdigit(UCH(cptr[1])))
2476 	{
2477 	    ++cptr;
2478 	    i = get_number();
2479 	    if (havetags && offsets)
2480 	    {
2481 		if (i <= 0 || i > maxoffset)
2482 		    unknown_rhs(i);
2483 		tag = rhs[offsets[i]]->tag;
2484 		if (tag == 0)
2485 		    untyped_rhs(i, rhs[offsets[i]]->name);
2486 		fprintf(f, "yystack.l_mark[%d].%s", offsets[i], tag);
2487 	    }
2488 	    else
2489 	    {
2490 		if (i == 0)
2491 		    fprintf(f, "yystack.l_mark[%d]", -n);
2492 		else if (i > maxoffset)
2493 		{
2494 		    dollar_warning(lineno, i);
2495 		    fprintf(f, "yystack.l_mark[%d]", i - maxoffset);
2496 		}
2497 		else if (offsets)
2498 		    fprintf(f, "yystack.l_mark[%d]", offsets[i]);
2499 	    }
2500 	    goto loop;
2501 	}
2502 	else if (cptr[1] == '-')
2503 	{
2504 	    cptr += 2;
2505 	    i = get_number();
2506 	    if (havetags)
2507 		unknown_rhs(-i);
2508 	    fprintf(f, "yystack.l_mark[%d]", -i - n);
2509 	    goto loop;
2510 	}
2511 #if defined(YYBTYACC)
2512 	else if (isalpha(cptr[1]) || cptr[1] == '_')
2513 	{
2514 	    char *arg;
2515 	    ++cptr;
2516 	    arg = scan_id();
2517 	    for (i = plhs[nrules]->args - 1; i >= 0; i--)
2518 		if (arg == plhs[nrules]->argnames[i])
2519 		    break;
2520 	    if (i < 0)
2521 		unknown_arg_warning(lineno, "$", arg, line, cptr);
2522 	    tag = (i < 0 ? NULL : plhs[nrules]->argtags[i]);
2523 	    fprintf(f, "yystack.l_mark[%d]", i - plhs[nrules]->args + 1 - n);
2524 	    if (tag)
2525 		fprintf(f, ".%s", tag);
2526 	    else if (havetags)
2527 		untyped_arg_warning(lineno, "$", arg);
2528 	    goto loop;
2529 	}
2530 #endif
2531     }
2532 #if defined(YYBTYACC)
2533     if (c == '@')
2534     {
2535 	if (!locations)
2536 	{
2537 	    int l_lineno = lineno;
2538 	    char *l_line = dup_line();
2539 	    char *l_cptr = l_line + (cptr - line);
2540 	    syntax_error(l_lineno, l_line, l_cptr);
2541 	}
2542 	if (cptr[1] == '$')
2543 	{
2544 	    fprintf(f, "yyloc");
2545 	    cptr += 2;
2546 	    goto loop;
2547 	}
2548 	else if (isdigit(UCH(cptr[1])))
2549 	{
2550 	    ++cptr;
2551 	    i = get_number();
2552 	    if (i == 0)
2553 		fprintf(f, "yystack.p_mark[%d]", -n);
2554 	    else if (i > maxoffset)
2555 	    {
2556 		at_warning(lineno, i);
2557 		fprintf(f, "yystack.p_mark[%d]", i - maxoffset);
2558 	    }
2559 	    else if (offsets)
2560 		fprintf(f, "yystack.p_mark[%d]", offsets[i]);
2561 	    goto loop;
2562 	}
2563 	else if (cptr[1] == '-')
2564 	{
2565 	    cptr += 2;
2566 	    i = get_number();
2567 	    fprintf(f, "yystack.p_mark[%d]", -i - n);
2568 	    goto loop;
2569 	}
2570     }
2571 #endif
2572     if (isalpha(c) || c == '_' || c == '$')
2573     {
2574 	do
2575 	{
2576 	    putc(c, f);
2577 	    c = *++cptr;
2578 	}
2579 	while (isalnum(c) || c == '_' || c == '$');
2580 	goto loop;
2581     }
2582     ++cptr;
2583 #if defined(YYBTYACC)
2584     if (backtrack)
2585     {
2586 	if (trialaction && c == L_BRAC && depth == 0)
2587 	{
2588 	    ++depth;
2589 	    putc(L_CURL, f);
2590 	    goto loop;
2591 	}
2592 	if (trialaction && c == R_BRAC && depth == 1)
2593 	{
2594 	    --depth;
2595 	    putc(R_CURL, f);
2596 	    c = nextc();
2597 	    if (c == L_BRAC && !haveyyval)
2598 	    {
2599 		goto loop;
2600 	    }
2601 	    if (c == L_CURL && !haveyyval)
2602 	    {
2603 		fprintf(f, "  if (!yytrial)\n");
2604 		if (!lflag)
2605 		    fprintf(f, line_format, lineno, input_file_name);
2606 		trialaction = 0;
2607 		goto loop;
2608 	    }
2609 	    fprintf(f, "\nbreak;\n");
2610 	    FREE(a_line);
2611 	    if (maxoffset > 0)
2612 		FREE(offsets);
2613 	    return;
2614 	}
2615     }
2616 #endif
2617     putc(c, f);
2618     switch (c)
2619     {
2620     case '\n':
2621 	get_line();
2622 	if (line)
2623 	    goto loop;
2624 	unterminated_action(a_lineno, a_line, a_cptr);
2625 
2626     case ';':
2627 	if (depth > 0)
2628 	    goto loop;
2629 	fprintf(f, "\nbreak;\n");
2630 	FREE(a_line);
2631 	if (maxoffset > 0)
2632 	    FREE(offsets);
2633 	return;
2634 
2635 #if defined(YYBTYACC)
2636     case L_BRAC:
2637 	if (backtrack)
2638 	    ++depth;
2639 	goto loop;
2640 
2641     case R_BRAC:
2642 	if (backtrack)
2643 	    --depth;
2644 	goto loop;
2645 #endif
2646 
2647     case L_CURL:
2648 	++depth;
2649 	goto loop;
2650 
2651     case R_CURL:
2652 	if (--depth > 0)
2653 	    goto loop;
2654 #if defined(YYBTYACC)
2655 	if (backtrack)
2656 	{
2657 	    c = nextc();
2658 	    if (c == L_BRAC && !haveyyval)
2659 	    {
2660 		trialaction = 1;
2661 		goto loop;
2662 	    }
2663 	    if (c == L_CURL && !haveyyval)
2664 	    {
2665 		fprintf(f, "  if (!yytrial)\n");
2666 		if (!lflag)
2667 		    fprintf(f, line_format, lineno, input_file_name);
2668 		goto loop;
2669 	    }
2670 	}
2671 #endif
2672 	fprintf(f, "\nbreak;\n");
2673 	FREE(a_line);
2674 	if (maxoffset > 0)
2675 	    FREE(offsets);
2676 	return;
2677 
2678     case '\'':
2679     case '"':
2680 	{
2681 	    char *s = copy_string(c);
2682 	    fputs(s, f);
2683 	    free(s);
2684 	}
2685 	goto loop;
2686 
2687     case '/':
2688 	{
2689 	    char *s = copy_comment();
2690 	    fputs(s, f);
2691 	    free(s);
2692 	}
2693 	goto loop;
2694 
2695     default:
2696 	goto loop;
2697     }
2698 }
2699 
2700 #if defined(YYBTYACC)
2701 static void
2702 copy_destructor(void)
2703 {
2704     int c;
2705     int depth;
2706     char *tag;
2707     bucket *bp;
2708     struct mstring *destructor_text = msnew();
2709     char *code_text;
2710     int a_lineno;
2711     char *a_line;
2712     char *a_cptr;
2713 
2714     if (!lflag)
2715 	msprintf(destructor_text, line_format, lineno, input_file_name);
2716 
2717     cptr = after_blanks(cptr);
2718     if (*cptr == L_CURL)
2719 	/* avoid putting curly-braces in first column, to ease editing */
2720 	mputc(destructor_text, '\t');
2721     else
2722 	syntax_error(lineno, line, cptr);
2723 
2724     a_lineno = lineno;
2725     a_line = dup_line();
2726     a_cptr = a_line + (cptr - line);
2727 
2728     depth = 0;
2729   loop:
2730     c = *cptr;
2731     if (c == '$')
2732     {
2733 	if (cptr[1] == '<')
2734 	{
2735 	    int d_lineno = lineno;
2736 	    char *d_line = dup_line();
2737 	    char *d_cptr = d_line + (cptr - line);
2738 
2739 	    ++cptr;
2740 	    tag = get_tag();
2741 	    c = *cptr;
2742 	    if (c == '$')
2743 	    {
2744 		msprintf(destructor_text, "(*val).%s", tag);
2745 		++cptr;
2746 		FREE(d_line);
2747 		goto loop;
2748 	    }
2749 	    else
2750 		dollar_error(d_lineno, d_line, d_cptr);
2751 	}
2752 	else if (cptr[1] == '$')
2753 	{
2754 	    /* process '$$' later; replacement is context dependent */
2755 	    msprintf(destructor_text, "$$");
2756 	    cptr += 2;
2757 	    goto loop;
2758 	}
2759     }
2760     if (c == '@' && cptr[1] == '$')
2761     {
2762 	if (!locations)
2763 	{
2764 	    int l_lineno = lineno;
2765 	    char *l_line = dup_line();
2766 	    char *l_cptr = l_line + (cptr - line);
2767 	    syntax_error(l_lineno, l_line, l_cptr);
2768 	}
2769 	msprintf(destructor_text, "(*loc)");
2770 	cptr += 2;
2771 	goto loop;
2772     }
2773     if (isalpha(c) || c == '_' || c == '$')
2774     {
2775 	do
2776 	{
2777 	    mputc(destructor_text, c);
2778 	    c = *++cptr;
2779 	}
2780 	while (isalnum(c) || c == '_' || c == '$');
2781 	goto loop;
2782     }
2783     ++cptr;
2784     mputc(destructor_text, c);
2785     switch (c)
2786     {
2787     case '\n':
2788 	get_line();
2789 	if (line)
2790 	    goto loop;
2791 	unterminated_action(a_lineno, a_line, a_cptr);
2792 
2793     case L_CURL:
2794 	++depth;
2795 	goto loop;
2796 
2797     case R_CURL:
2798 	if (--depth > 0)
2799 	    goto loop;
2800 	goto process_symbols;
2801 
2802     case '\'':
2803     case '"':
2804 	{
2805 	    char *s = copy_string(c);
2806 	    msprintf(destructor_text, "%s", s);
2807 	    free(s);
2808 	}
2809 	goto loop;
2810 
2811     case '/':
2812 	{
2813 	    char *s = copy_comment();
2814 	    msprintf(destructor_text, "%s", s);
2815 	    free(s);
2816 	}
2817 	goto loop;
2818 
2819     default:
2820 	goto loop;
2821     }
2822   process_symbols:
2823     code_text = msdone(destructor_text);
2824     for (;;)
2825     {
2826 	c = nextc();
2827 	if (c == EOF)
2828 	    unexpected_EOF();
2829 	if (c == '<')
2830 	{
2831 	    if (cptr[1] == '>')
2832 	    {			/* "no semantic type" default destructor */
2833 		cptr += 2;
2834 		if ((bp = default_destructor[UNTYPED_DEFAULT]) == NULL)
2835 		{
2836 		    static char untyped_default[] = "<>";
2837 		    bp = make_bucket("untyped default");
2838 		    bp->tag = untyped_default;
2839 		    default_destructor[UNTYPED_DEFAULT] = bp;
2840 		}
2841 		if (bp->destructor != NULL)
2842 		    destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2843 		else
2844 		    /* replace "$$" with "(*val)" in destructor code */
2845 		    bp->destructor = process_destructor_XX(code_text, NULL);
2846 	    }
2847 	    else if (cptr[1] == '*' && cptr[2] == '>')
2848 	    {			/* "no per-symbol or per-type" default destructor */
2849 		cptr += 3;
2850 		if ((bp = default_destructor[TYPED_DEFAULT]) == NULL)
2851 		{
2852 		    static char typed_default[] = "<*>";
2853 		    bp = make_bucket("typed default");
2854 		    bp->tag = typed_default;
2855 		    default_destructor[TYPED_DEFAULT] = bp;
2856 		}
2857 		if (bp->destructor != NULL)
2858 		    destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2859 		else
2860 		{
2861 		    /* postpone re-processing destructor $$s until end of grammar spec */
2862 		    bp->destructor = TMALLOC(char, strlen(code_text) + 1);
2863 		    NO_SPACE(bp->destructor);
2864 		    strcpy(bp->destructor, code_text);
2865 		}
2866 	    }
2867 	    else
2868 	    {			/* "semantic type" default destructor */
2869 		tag = get_tag();
2870 		bp = lookup_type_destructor(tag);
2871 		if (bp->destructor != NULL)
2872 		    destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2873 		else
2874 		    /* replace "$$" with "(*val).tag" in destructor code */
2875 		    bp->destructor = process_destructor_XX(code_text, tag);
2876 	    }
2877 	}
2878 	else if (isalpha(c) || c == '_' || c == '.' || c == '$')
2879 	{			/* "symbol" destructor */
2880 	    bp = get_name();
2881 	    if (bp->destructor != NULL)
2882 		destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2883 	    else
2884 	    {
2885 		/* postpone re-processing destructor $$s until end of grammar spec */
2886 		bp->destructor = TMALLOC(char, strlen(code_text) + 1);
2887 		NO_SPACE(bp->destructor);
2888 		strcpy(bp->destructor, code_text);
2889 	    }
2890 	}
2891 	else
2892 	    break;
2893     }
2894     free(a_line);
2895     free(code_text);
2896 }
2897 
2898 static char *
2899 process_destructor_XX(char *code, char *tag)
2900 {
2901     int c;
2902     int quote;
2903     int depth;
2904     struct mstring *new_code = msnew();
2905     char *codeptr = code;
2906 
2907     depth = 0;
2908   loop:			/* step thru code */
2909     c = *codeptr;
2910     if (c == '$' && codeptr[1] == '$')
2911     {
2912 	codeptr += 2;
2913 	if (tag == NULL)
2914 	    msprintf(new_code, "(*val)");
2915 	else
2916 	    msprintf(new_code, "(*val).%s", tag);
2917 	goto loop;
2918     }
2919     if (isalpha(c) || c == '_' || c == '$')
2920     {
2921 	do
2922 	{
2923 	    mputc(new_code, c);
2924 	    c = *++codeptr;
2925 	}
2926 	while (isalnum(c) || c == '_' || c == '$');
2927 	goto loop;
2928     }
2929     ++codeptr;
2930     mputc(new_code, c);
2931     switch (c)
2932     {
2933     case L_CURL:
2934 	++depth;
2935 	goto loop;
2936 
2937     case R_CURL:
2938 	if (--depth > 0)
2939 	    goto loop;
2940 	return msdone(new_code);
2941 
2942     case '\'':
2943     case '"':
2944 	quote = c;
2945 	for (;;)
2946 	{
2947 	    c = *codeptr++;
2948 	    mputc(new_code, c);
2949 	    if (c == quote)
2950 		goto loop;
2951 	    if (c == '\\')
2952 	    {
2953 		c = *codeptr++;
2954 		mputc(new_code, c);
2955 	    }
2956 	}
2957 
2958     case '/':
2959 	c = *codeptr;
2960 	if (c == '*')
2961 	{
2962 	    mputc(new_code, c);
2963 	    ++codeptr;
2964 	    for (;;)
2965 	    {
2966 		c = *codeptr++;
2967 		mputc(new_code, c);
2968 		if (c == '*' && *codeptr == '/')
2969 		{
2970 		    mputc(new_code, '/');
2971 		    ++codeptr;
2972 		    goto loop;
2973 		}
2974 	    }
2975 	}
2976 	goto loop;
2977 
2978     default:
2979 	goto loop;
2980     }
2981 }
2982 #endif /* defined(YYBTYACC) */
2983 
2984 static int
2985 mark_symbol(void)
2986 {
2987     int c;
2988     bucket *bp = NULL;
2989 
2990     c = cptr[1];
2991     if (c == '%' || c == '\\')
2992     {
2993 	cptr += 2;
2994 	return (1);
2995     }
2996 
2997     if (c == '=')
2998 	cptr += 2;
2999     else if ((c == 'p' || c == 'P') &&
3000 	     ((c = cptr[2]) == 'r' || c == 'R') &&
3001 	     ((c = cptr[3]) == 'e' || c == 'E') &&
3002 	     ((c = cptr[4]) == 'c' || c == 'C') &&
3003 	     ((c = cptr[5], !IS_IDENT(c))))
3004 	cptr += 5;
3005     else
3006 	syntax_error(lineno, line, cptr);
3007 
3008     c = nextc();
3009     if (isalpha(c) || c == '_' || c == '.' || c == '$')
3010 	bp = get_name();
3011     else if (c == '\'' || c == '"')
3012 	bp = get_literal();
3013     else
3014     {
3015 	syntax_error(lineno, line, cptr);
3016 	/*NOTREACHED */
3017     }
3018 
3019     if (rprec[nrules] != UNDEFINED && bp->prec != rprec[nrules])
3020 	prec_redeclared();
3021 
3022     rprec[nrules] = bp->prec;
3023     rassoc[nrules] = bp->assoc;
3024     return (0);
3025 }
3026 
3027 static void
3028 read_grammar(void)
3029 {
3030     int c;
3031 
3032     initialize_grammar();
3033     advance_to_start();
3034 
3035     for (;;)
3036     {
3037 	c = nextc();
3038 	if (c == EOF)
3039 	    break;
3040 	if (isalpha(c)
3041 	    || c == '_'
3042 	    || c == '.'
3043 	    || c == '$'
3044 	    || c == '\''
3045 	    || c == '"')
3046 	    add_symbol();
3047 #if defined(YYBTYACC)
3048 	else if (c == L_CURL || c == '=' || (backtrack && c == L_BRAC))
3049 #else
3050 	else if (c == L_CURL || c == '=')
3051 #endif
3052 	    copy_action();
3053 	else if (c == '|')
3054 	{
3055 	    end_rule();
3056 	    start_rule(plhs[nrules - 1], 0);
3057 	    ++cptr;
3058 	}
3059 	else if (c == '%')
3060 	{
3061 	    if (mark_symbol())
3062 		break;
3063 	}
3064 	else
3065 	    syntax_error(lineno, line, cptr);
3066     }
3067     end_rule();
3068 #if defined(YYBTYACC)
3069     if (goal->args > 0)
3070 	start_requires_args(goal->name);
3071 #endif
3072 }
3073 
3074 static void
3075 free_tags(void)
3076 {
3077     int i;
3078 
3079     if (tag_table == 0)
3080 	return;
3081 
3082     for (i = 0; i < ntags; ++i)
3083     {
3084 	assert(tag_table[i]);
3085 	FREE(tag_table[i]);
3086     }
3087     FREE(tag_table);
3088 }
3089 
3090 static void
3091 pack_names(void)
3092 {
3093     bucket *bp;
3094     char *p, *s, *t;
3095 
3096     name_pool_size = 13;	/* 13 == sizeof("$end") + sizeof("$accept") */
3097     for (bp = first_symbol; bp; bp = bp->next)
3098 	name_pool_size += strlen(bp->name) + 1;
3099 
3100     name_pool = TMALLOC(char, name_pool_size);
3101     NO_SPACE(name_pool);
3102 
3103     strcpy(name_pool, "$accept");
3104     strcpy(name_pool + 8, "$end");
3105     t = name_pool + 13;
3106     for (bp = first_symbol; bp; bp = bp->next)
3107     {
3108 	p = t;
3109 	s = bp->name;
3110 	while ((*t++ = *s++) != 0)
3111 	    continue;
3112 	FREE(bp->name);
3113 	bp->name = p;
3114     }
3115 }
3116 
3117 static void
3118 check_symbols(void)
3119 {
3120     bucket *bp;
3121 
3122     if (goal->class == UNKNOWN)
3123 	undefined_goal(goal->name);
3124 
3125     for (bp = first_symbol; bp; bp = bp->next)
3126     {
3127 	if (bp->class == UNKNOWN)
3128 	{
3129 	    undefined_symbol_warning(bp->name);
3130 	    bp->class = TERM;
3131 	}
3132     }
3133 }
3134 
3135 static void
3136 protect_string(char *src, char **des)
3137 {
3138     unsigned len;
3139     char *s;
3140     char *d;
3141 
3142     *des = src;
3143     if (src)
3144     {
3145 	len = 1;
3146 	s = src;
3147 	while (*s)
3148 	{
3149 	    if ('\\' == *s || '"' == *s)
3150 		len++;
3151 	    s++;
3152 	    len++;
3153 	}
3154 
3155 	*des = d = TMALLOC(char, len);
3156 	NO_SPACE(d);
3157 
3158 	s = src;
3159 	while (*s)
3160 	{
3161 	    if ('\\' == *s || '"' == *s)
3162 		*d++ = '\\';
3163 	    *d++ = *s++;
3164 	}
3165 	*d = '\0';
3166     }
3167 }
3168 
3169 static void
3170 pack_symbols(void)
3171 {
3172     bucket *bp;
3173     bucket **v;
3174     Value_t i, j, k, n;
3175 #if defined(YYBTYACC)
3176     Value_t max_tok_pval;
3177 #endif
3178 
3179     nsyms = 2;
3180     ntokens = 1;
3181     for (bp = first_symbol; bp; bp = bp->next)
3182     {
3183 	++nsyms;
3184 	if (bp->class == TERM)
3185 	    ++ntokens;
3186     }
3187     start_symbol = (Value_t)ntokens;
3188     nvars = (Value_t)(nsyms - ntokens);
3189 
3190     symbol_name = TMALLOC(char *, nsyms);
3191     NO_SPACE(symbol_name);
3192 
3193     symbol_value = TMALLOC(Value_t, nsyms);
3194     NO_SPACE(symbol_value);
3195 
3196     symbol_prec = TMALLOC(Value_t, nsyms);
3197     NO_SPACE(symbol_prec);
3198 
3199     symbol_assoc = TMALLOC(char, nsyms);
3200     NO_SPACE(symbol_assoc);
3201 
3202 #if defined(YYBTYACC)
3203     symbol_pval = TMALLOC(Value_t, nsyms);
3204     NO_SPACE(symbol_pval);
3205 
3206     if (destructor)
3207     {
3208 	symbol_destructor = CALLOC(sizeof(char *), nsyms);
3209 	NO_SPACE(symbol_destructor);
3210 
3211 	symbol_type_tag = CALLOC(sizeof(char *), nsyms);
3212 	NO_SPACE(symbol_type_tag);
3213     }
3214 #endif
3215 
3216     v = TMALLOC(bucket *, nsyms);
3217     NO_SPACE(v);
3218 
3219     v[0] = 0;
3220     v[start_symbol] = 0;
3221 
3222     i = 1;
3223     j = (Value_t)(start_symbol + 1);
3224     for (bp = first_symbol; bp; bp = bp->next)
3225     {
3226 	if (bp->class == TERM)
3227 	    v[i++] = bp;
3228 	else
3229 	    v[j++] = bp;
3230     }
3231     assert(i == ntokens && j == nsyms);
3232 
3233     for (i = 1; i < ntokens; ++i)
3234 	v[i]->index = i;
3235 
3236     goal->index = (Index_t)(start_symbol + 1);
3237     k = (Value_t)(start_symbol + 2);
3238     while (++i < nsyms)
3239 	if (v[i] != goal)
3240 	{
3241 	    v[i]->index = k;
3242 	    ++k;
3243 	}
3244 
3245     goal->value = 0;
3246     k = 1;
3247     for (i = (Value_t)(start_symbol + 1); i < nsyms; ++i)
3248     {
3249 	if (v[i] != goal)
3250 	{
3251 	    v[i]->value = k;
3252 	    ++k;
3253 	}
3254     }
3255 
3256     k = 0;
3257     for (i = 1; i < ntokens; ++i)
3258     {
3259 	n = v[i]->value;
3260 	if (n > 256)
3261 	{
3262 	    for (j = k++; j > 0 && symbol_value[j - 1] > n; --j)
3263 		symbol_value[j] = symbol_value[j - 1];
3264 	    symbol_value[j] = n;
3265 	}
3266     }
3267 
3268     assert(v[1] != 0);
3269 
3270     if (v[1]->value == UNDEFINED)
3271 	v[1]->value = 256;
3272 
3273     j = 0;
3274     n = 257;
3275     for (i = 2; i < ntokens; ++i)
3276     {
3277 	if (v[i]->value == UNDEFINED)
3278 	{
3279 	    while (j < k && n == symbol_value[j])
3280 	    {
3281 		while (++j < k && n == symbol_value[j])
3282 		    continue;
3283 		++n;
3284 	    }
3285 	    v[i]->value = n;
3286 	    ++n;
3287 	}
3288     }
3289 
3290     symbol_name[0] = name_pool + 8;
3291     symbol_value[0] = 0;
3292     symbol_prec[0] = 0;
3293     symbol_assoc[0] = TOKEN;
3294 #if defined(YYBTYACC)
3295     symbol_pval[0] = 0;
3296     max_tok_pval = 0;
3297 #endif
3298     for (i = 1; i < ntokens; ++i)
3299     {
3300 	symbol_name[i] = v[i]->name;
3301 	symbol_value[i] = v[i]->value;
3302 	symbol_prec[i] = v[i]->prec;
3303 	symbol_assoc[i] = v[i]->assoc;
3304 #if defined(YYBTYACC)
3305 	symbol_pval[i] = v[i]->value;
3306 	if (symbol_pval[i] > max_tok_pval)
3307 	    max_tok_pval = symbol_pval[i];
3308 	if (destructor)
3309 	{
3310 	    symbol_destructor[i] = v[i]->destructor;
3311 	    symbol_type_tag[i] = v[i]->tag;
3312 	}
3313 #endif
3314     }
3315     symbol_name[start_symbol] = name_pool;
3316     symbol_value[start_symbol] = -1;
3317     symbol_prec[start_symbol] = 0;
3318     symbol_assoc[start_symbol] = TOKEN;
3319 #if defined(YYBTYACC)
3320     symbol_pval[start_symbol] = (Value_t)(max_tok_pval + 1);
3321 #endif
3322     for (++i; i < nsyms; ++i)
3323     {
3324 	k = v[i]->index;
3325 	symbol_name[k] = v[i]->name;
3326 	symbol_value[k] = v[i]->value;
3327 	symbol_prec[k] = v[i]->prec;
3328 	symbol_assoc[k] = v[i]->assoc;
3329 #if defined(YYBTYACC)
3330 	symbol_pval[k] = (Value_t)((max_tok_pval + 1) + v[i]->value + 1);
3331 	if (destructor)
3332 	{
3333 	    symbol_destructor[k] = v[i]->destructor;
3334 	    symbol_type_tag[k] = v[i]->tag;
3335 	}
3336 #endif
3337     }
3338 
3339     if (gflag)
3340     {
3341 	symbol_pname = TMALLOC(char *, nsyms);
3342 	NO_SPACE(symbol_pname);
3343 
3344 	for (i = 0; i < nsyms; ++i)
3345 	    protect_string(symbol_name[i], &(symbol_pname[i]));
3346     }
3347 
3348     FREE(v);
3349 }
3350 
3351 static void
3352 pack_grammar(void)
3353 {
3354     int i;
3355     Value_t j;
3356     Assoc_t assoc;
3357     Value_t prec2;
3358 
3359     ritem = TMALLOC(Value_t, nitems);
3360     NO_SPACE(ritem);
3361 
3362     rlhs = TMALLOC(Value_t, nrules);
3363     NO_SPACE(rlhs);
3364 
3365     rrhs = TMALLOC(Value_t, nrules + 1);
3366     NO_SPACE(rrhs);
3367 
3368     rprec = TREALLOC(Value_t, rprec, nrules);
3369     NO_SPACE(rprec);
3370 
3371     rassoc = TREALLOC(Assoc_t, rassoc, nrules);
3372     NO_SPACE(rassoc);
3373 
3374     ritem[0] = -1;
3375     ritem[1] = goal->index;
3376     ritem[2] = 0;
3377     ritem[3] = -2;
3378     rlhs[0] = 0;
3379     rlhs[1] = 0;
3380     rlhs[2] = start_symbol;
3381     rrhs[0] = 0;
3382     rrhs[1] = 0;
3383     rrhs[2] = 1;
3384 
3385     j = 4;
3386     for (i = 3; i < nrules; ++i)
3387     {
3388 #if defined(YYBTYACC)
3389 	if (plhs[i]->args > 0)
3390 	{
3391 	    if (plhs[i]->argnames)
3392 	    {
3393 		FREE(plhs[i]->argnames);
3394 		plhs[i]->argnames = NULL;
3395 	    }
3396 	    if (plhs[i]->argtags)
3397 	    {
3398 		FREE(plhs[i]->argtags);
3399 		plhs[i]->argtags = NULL;
3400 	    }
3401 	}
3402 #endif /* defined(YYBTYACC) */
3403 	rlhs[i] = plhs[i]->index;
3404 	rrhs[i] = j;
3405 	assoc = TOKEN;
3406 	prec2 = 0;
3407 	while (pitem[j])
3408 	{
3409 	    ritem[j] = pitem[j]->index;
3410 	    if (pitem[j]->class == TERM)
3411 	    {
3412 		prec2 = pitem[j]->prec;
3413 		assoc = pitem[j]->assoc;
3414 	    }
3415 	    ++j;
3416 	}
3417 	ritem[j] = (Value_t)-i;
3418 	++j;
3419 	if (rprec[i] == UNDEFINED)
3420 	{
3421 	    rprec[i] = prec2;
3422 	    rassoc[i] = assoc;
3423 	}
3424     }
3425     rrhs[i] = j;
3426 
3427     FREE(plhs);
3428     FREE(pitem);
3429 #if defined(YYBTYACC)
3430     clean_arg_cache();
3431 #endif
3432 }
3433 
3434 static void
3435 print_grammar(void)
3436 {
3437     int i, k;
3438     size_t j, spacing = 0;
3439     FILE *f = verbose_file;
3440 
3441     if (!vflag)
3442 	return;
3443 
3444     k = 1;
3445     for (i = 2; i < nrules; ++i)
3446     {
3447 	if (rlhs[i] != rlhs[i - 1])
3448 	{
3449 	    if (i != 2)
3450 		fprintf(f, "\n");
3451 	    fprintf(f, "%4d  %s :", i - 2, symbol_name[rlhs[i]]);
3452 	    spacing = strlen(symbol_name[rlhs[i]]) + 1;
3453 	}
3454 	else
3455 	{
3456 	    fprintf(f, "%4d  ", i - 2);
3457 	    j = spacing;
3458 	    while (j-- != 0)
3459 		putc(' ', f);
3460 	    putc('|', f);
3461 	}
3462 
3463 	while (ritem[k] >= 0)
3464 	{
3465 	    fprintf(f, " %s", symbol_name[ritem[k]]);
3466 	    ++k;
3467 	}
3468 	++k;
3469 	putc('\n', f);
3470     }
3471 }
3472 
3473 #if defined(YYBTYACC)
3474 static void
3475 finalize_destructors(void)
3476 {
3477     int i;
3478     bucket *bp;
3479     char *tag;
3480 
3481     for (i = 2; i < nsyms; ++i)
3482     {
3483 	tag = symbol_type_tag[i];
3484 	if (symbol_destructor[i] == NULL)
3485 	{
3486 	    if (tag == NULL)
3487 	    {			/* use <> destructor, if there is one */
3488 		if ((bp = default_destructor[UNTYPED_DEFAULT]) != NULL)
3489 		{
3490 		    symbol_destructor[i] = TMALLOC(char,
3491 						   strlen(bp->destructor) + 1);
3492 		    NO_SPACE(symbol_destructor[i]);
3493 		    strcpy(symbol_destructor[i], bp->destructor);
3494 		}
3495 	    }
3496 	    else
3497 	    {			/* use type destructor for this tag, if there is one */
3498 		bp = lookup_type_destructor(tag);
3499 		if (bp->destructor != NULL)
3500 		{
3501 		    symbol_destructor[i] = TMALLOC(char,
3502 						   strlen(bp->destructor) + 1);
3503 		    NO_SPACE(symbol_destructor[i]);
3504 		    strcpy(symbol_destructor[i], bp->destructor);
3505 		}
3506 		else
3507 		{		/* use <*> destructor, if there is one */
3508 		    if ((bp = default_destructor[TYPED_DEFAULT]) != NULL)
3509 			/* replace "$$" with "(*val).tag" in destructor code */
3510 			symbol_destructor[i]
3511 			    = process_destructor_XX(bp->destructor, tag);
3512 		}
3513 	    }
3514 	}
3515 	else
3516 	{			/* replace "$$" with "(*val)[.tag]" in destructor code */
3517 	    symbol_destructor[i]
3518 		= process_destructor_XX(symbol_destructor[i], tag);
3519 	}
3520     }
3521     /* 'symbol_type_tag[]' elements are freed by 'free_tags()' */
3522     DO_FREE(symbol_type_tag);	/* no longer needed */
3523     if ((bp = default_destructor[UNTYPED_DEFAULT]) != NULL)
3524     {
3525 	FREE(bp->name);
3526 	/* 'bp->tag' is a static value, don't free */
3527 	FREE(bp->destructor);
3528 	FREE(bp);
3529     }
3530     if ((bp = default_destructor[TYPED_DEFAULT]) != NULL)
3531     {
3532 	FREE(bp->name);
3533 	/* 'bp->tag' is a static value, don't free */
3534 	FREE(bp->destructor);
3535 	FREE(bp);
3536     }
3537     if ((bp = default_destructor[TYPE_SPECIFIED]) != NULL)
3538     {
3539 	bucket *p;
3540 	for (; bp; bp = p)
3541 	{
3542 	    p = bp->link;
3543 	    FREE(bp->name);
3544 	    /* 'bp->tag' freed by 'free_tags()' */
3545 	    FREE(bp->destructor);
3546 	    FREE(bp);
3547 	}
3548     }
3549 }
3550 #endif /* defined(YYBTYACC) */
3551 
3552 void
3553 reader(void)
3554 {
3555     write_section(code_file, banner);
3556     create_symbol_table();
3557     read_declarations();
3558     read_grammar();
3559     free_symbol_table();
3560     pack_names();
3561     check_symbols();
3562     pack_symbols();
3563     pack_grammar();
3564     free_symbols();
3565     print_grammar();
3566 #if defined(YYBTYACC)
3567     if (destructor)
3568 	finalize_destructors();
3569 #endif
3570     free_tags();
3571 }
3572 
3573 #ifdef NO_LEAKS
3574 static param *
3575 free_declarations(param *list)
3576 {
3577     while (list != 0)
3578     {
3579 	param *next = list->next;
3580 	free(list->type);
3581 	free(list->name);
3582 	free(list->type2);
3583 	free(list);
3584 	list = next;
3585     }
3586     return list;
3587 }
3588 
3589 void
3590 reader_leaks(void)
3591 {
3592     lex_param = free_declarations(lex_param);
3593     parse_param = free_declarations(parse_param);
3594 
3595     DO_FREE(line);
3596     DO_FREE(rrhs);
3597     DO_FREE(rlhs);
3598     DO_FREE(rprec);
3599     DO_FREE(ritem);
3600     DO_FREE(rassoc);
3601     DO_FREE(cache);
3602     DO_FREE(name_pool);
3603     DO_FREE(symbol_name);
3604     DO_FREE(symbol_prec);
3605     DO_FREE(symbol_assoc);
3606     DO_FREE(symbol_value);
3607 #if defined(YYBTYACC)
3608     DO_FREE(symbol_pval);
3609     DO_FREE(symbol_destructor);
3610     DO_FREE(symbol_type_tag);
3611 #endif
3612 }
3613 #endif
3614