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