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