?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
periodic: Remove obsolete daily/status-named and weekly/clean-kvmdb
[dragonfly.git] / contrib / byacc / reader.c
blobebf40d2a6d147f42da0f6f4d069bcee75c0853da
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
DragonFly BSD