reader.c revision 1.7
1 /* $NetBSD: reader.c,v 1.7 2011/09/10 21:29:04 christos Exp $ */ 2 /* Id: reader.c,v 1.33 2011/09/06 22:56:53 tom Exp */ 3 4 #include "defs.h" 5 6 #include <sys/cdefs.h> 7 __RCSID("$NetBSD: reader.c,v 1.7 2011/09/10 21:29:04 christos Exp $"); 8 9 /* The line size must be a positive integer. One hundred was chosen */ 10 /* because few lines in Yacc input grammars exceed 100 characters. */ 11 /* Note that if a line exceeds LINESIZE characters, the line buffer */ 12 /* will be expanded to accomodate it. */ 13 14 #define LINESIZE 100 15 16 #define L_CURL '{' 17 #define R_CURL '}' 18 19 static void start_rule(bucket *bp, int s_lineno); 20 21 static char *cache; 22 static int cinc, cache_size; 23 24 int ntags; 25 static int tagmax; 26 static char **tag_table; 27 28 static char saw_eof; 29 char unionized; 30 char *cptr, *line; 31 static int linesize; 32 33 static bucket *goal; 34 static Value_t prec; 35 static int gensym; 36 static char last_was_action; 37 38 static int maxitems; 39 static bucket **pitem; 40 41 static int maxrules; 42 static bucket **plhs; 43 44 static size_t name_pool_size; 45 static char *name_pool; 46 47 char line_format[] = "#line %d \"%s\"\n"; 48 49 param *lex_param; 50 param *parse_param; 51 52 static void 53 cachec(int c) 54 { 55 assert(cinc >= 0); 56 if (cinc >= cache_size) 57 { 58 cache_size += 256; 59 cache = REALLOC(cache, cache_size); 60 NO_SPACE(cache); 61 } 62 cache[cinc] = (char)c; 63 ++cinc; 64 } 65 66 static void 67 get_line(void) 68 { 69 FILE *f = input_file; 70 int c; 71 int i; 72 73 if (saw_eof || (c = getc(f)) == EOF) 74 { 75 if (line) 76 { 77 FREE(line); 78 line = 0; 79 } 80 cptr = 0; 81 saw_eof = 1; 82 return; 83 } 84 85 if (line == 0 || linesize != (LINESIZE + 1)) 86 { 87 if (line) 88 FREE(line); 89 linesize = LINESIZE + 1; 90 line = MALLOC(linesize); 91 NO_SPACE(line); 92 } 93 94 i = 0; 95 ++lineno; 96 for (;;) 97 { 98 line[i] = (char)c; 99 if (c == '\n') 100 { 101 cptr = line; 102 return; 103 } 104 if (++i >= linesize) 105 { 106 linesize += LINESIZE; 107 line = REALLOC(line, linesize); 108 NO_SPACE(line); 109 } 110 c = getc(f); 111 if (c == EOF) 112 { 113 line[i] = '\n'; 114 saw_eof = 1; 115 cptr = line; 116 return; 117 } 118 } 119 } 120 121 static char * 122 dup_line(void) 123 { 124 char *p, *s, *t; 125 126 if (line == 0) 127 return (0); 128 s = line; 129 while (*s != '\n') 130 ++s; 131 p = MALLOC(s - line + 1); 132 NO_SPACE(p); 133 134 s = line; 135 t = p; 136 while ((*t++ = *s++) != '\n') 137 continue; 138 return (p); 139 } 140 141 static void 142 skip_comment(void) 143 { 144 char *s; 145 146 int st_lineno = lineno; 147 char *st_line = dup_line(); 148 char *st_cptr = st_line + (cptr - line); 149 150 s = cptr + 2; 151 for (;;) 152 { 153 if (*s == '*' && s[1] == '/') 154 { 155 cptr = s + 2; 156 FREE(st_line); 157 return; 158 } 159 if (*s == '\n') 160 { 161 get_line(); 162 if (line == 0) 163 unterminated_comment(st_lineno, st_line, st_cptr); 164 s = cptr; 165 } 166 else 167 ++s; 168 } 169 } 170 171 static int 172 nextc(void) 173 { 174 char *s; 175 176 if (line == 0) 177 { 178 get_line(); 179 if (line == 0) 180 return (EOF); 181 } 182 183 s = cptr; 184 for (;;) 185 { 186 switch (*s) 187 { 188 case '\n': 189 get_line(); 190 if (line == 0) 191 return (EOF); 192 s = cptr; 193 break; 194 195 case ' ': 196 case '\t': 197 case '\f': 198 case '\r': 199 case '\v': 200 case ',': 201 case ';': 202 ++s; 203 break; 204 205 case '\\': 206 cptr = s; 207 return ('%'); 208 209 case '/': 210 if (s[1] == '*') 211 { 212 cptr = s; 213 skip_comment(); 214 s = cptr; 215 break; 216 } 217 else if (s[1] == '/') 218 { 219 get_line(); 220 if (line == 0) 221 return (EOF); 222 s = cptr; 223 break; 224 } 225 /* FALLTHRU */ 226 227 default: 228 cptr = s; 229 return (*s); 230 } 231 } 232 } 233 234 /* 235 * Compare keyword to cached token, treating '_' and '-' the same. Some 236 * grammars rely upon this misfeature. 237 */ 238 static int 239 matchec(const char *name) 240 { 241 const char *p = cache; 242 const char *q = name; 243 int code = 0; /* assume mismatch */ 244 245 while (*p != '\0' && *q != '\0') 246 { 247 char a = *p++; 248 char b = *q++; 249 if (a == '_') 250 a = '-'; 251 if (b == '_') 252 b = '-'; 253 if (a != b) 254 break; 255 if (*p == '\0' && *q == '\0') 256 { 257 code = 1; 258 break; 259 } 260 } 261 return code; 262 } 263 264 static int 265 keyword(void) 266 { 267 int c; 268 char *t_cptr = cptr; 269 270 c = *++cptr; 271 if (isalpha(c)) 272 { 273 cinc = 0; 274 for (;;) 275 { 276 if (isalpha(c)) 277 { 278 if (isupper(c)) 279 c = tolower(c); 280 cachec(c); 281 } 282 else if (isdigit(c) 283 || c == '-' 284 || c == '_' 285 || c == '.' 286 || c == '$') 287 { 288 cachec(c); 289 } 290 else 291 { 292 break; 293 } 294 c = *++cptr; 295 } 296 cachec(NUL); 297 298 if (matchec("token") || matchec("term")) 299 return (TOKEN); 300 if (matchec("type")) 301 return (TYPE); 302 if (matchec("left")) 303 return (LEFT); 304 if (matchec("right")) 305 return (RIGHT); 306 if (matchec("nonassoc") || matchec("binary")) 307 return (NONASSOC); 308 if (matchec("start")) 309 return (START); 310 if (matchec("union")) 311 return (UNION); 312 if (matchec("ident")) 313 return (IDENT); 314 if (matchec("expect")) 315 return (EXPECT); 316 if (matchec("expect-rr")) 317 return (EXPECT_RR); 318 if (matchec("pure-parser")) 319 return (PURE_PARSER); 320 if (matchec("parse-param")) 321 return (PARSE_PARAM); 322 if (matchec("lex-param")) 323 return (LEX_PARAM); 324 if (matchec("yacc")) 325 return (POSIX_YACC); 326 } 327 else 328 { 329 ++cptr; 330 if (c == L_CURL) 331 return (TEXT); 332 if (c == '%' || c == '\\') 333 return (MARK); 334 if (c == '<') 335 return (LEFT); 336 if (c == '>') 337 return (RIGHT); 338 if (c == '0') 339 return (TOKEN); 340 if (c == '2') 341 return (NONASSOC); 342 } 343 syntax_error(lineno, line, t_cptr); 344 /*NOTREACHED */ 345 } 346 347 348 static void 349 copy_ident(void) 350 { 351 int c; 352 FILE *f = output_file; 353 354 c = nextc(); 355 if (c == EOF) 356 unexpected_EOF(); 357 if (c != '"') 358 syntax_error(lineno, line, cptr); 359 ++outline; 360 fprintf(f, "#ident \""); 361 for (;;) 362 { 363 c = *++cptr; 364 if (c == '\n') 365 { 366 fprintf(f, "\"\n"); 367 return; 368 } 369 putc(c, f); 370 if (c == '"') 371 { 372 putc('\n', f); 373 ++cptr; 374 return; 375 } 376 } 377 } 378 379 static void 380 copy_text(void) 381 { 382 int c; 383 int quote; 384 FILE *f = text_file; 385 int need_newline = 0; 386 int t_lineno = lineno; 387 char *t_line = dup_line(); 388 char *t_cptr = t_line + (cptr - line - 2); 389 390 if (*cptr == '\n') 391 { 392 get_line(); 393 if (line == 0) 394 unterminated_text(t_lineno, t_line, t_cptr); 395 } 396 if (!lflag) 397 fprintf(f, line_format, lineno, input_file_name); 398 399 loop: 400 c = *cptr++; 401 switch (c) 402 { 403 case '\n': 404 next_line: 405 putc('\n', f); 406 need_newline = 0; 407 get_line(); 408 if (line) 409 goto loop; 410 unterminated_text(t_lineno, t_line, t_cptr); 411 412 case '\'': 413 case '"': 414 { 415 int s_lineno = lineno; 416 char *s_line = dup_line(); 417 char *s_cptr = s_line + (cptr - line - 1); 418 419 quote = c; 420 putc(c, f); 421 for (;;) 422 { 423 c = *cptr++; 424 putc(c, f); 425 if (c == quote) 426 { 427 need_newline = 1; 428 FREE(s_line); 429 goto loop; 430 } 431 if (c == '\n') 432 unterminated_string(s_lineno, s_line, s_cptr); 433 if (c == '\\') 434 { 435 c = *cptr++; 436 putc(c, f); 437 if (c == '\n') 438 { 439 get_line(); 440 if (line == 0) 441 unterminated_string(s_lineno, s_line, s_cptr); 442 } 443 } 444 } 445 } 446 447 case '/': 448 putc(c, f); 449 need_newline = 1; 450 c = *cptr; 451 if (c == '/') 452 { 453 putc('*', f); 454 while ((c = *++cptr) != '\n') 455 { 456 if (c == '*' && cptr[1] == '/') 457 fprintf(f, "* "); 458 else 459 putc(c, f); 460 } 461 fprintf(f, "*/"); 462 goto next_line; 463 } 464 if (c == '*') 465 { 466 int c_lineno = lineno; 467 char *c_line = dup_line(); 468 char *c_cptr = c_line + (cptr - line - 1); 469 470 putc('*', f); 471 ++cptr; 472 for (;;) 473 { 474 c = *cptr++; 475 putc(c, f); 476 if (c == '*' && *cptr == '/') 477 { 478 putc('/', f); 479 ++cptr; 480 FREE(c_line); 481 goto loop; 482 } 483 if (c == '\n') 484 { 485 get_line(); 486 if (line == 0) 487 unterminated_comment(c_lineno, c_line, c_cptr); 488 } 489 } 490 } 491 need_newline = 1; 492 goto loop; 493 494 case '%': 495 case '\\': 496 if (*cptr == R_CURL) 497 { 498 if (need_newline) 499 putc('\n', f); 500 ++cptr; 501 FREE(t_line); 502 return; 503 } 504 /* FALLTHRU */ 505 506 default: 507 putc(c, f); 508 need_newline = 1; 509 goto loop; 510 } 511 } 512 513 static void 514 puts_both(const char *s) 515 { 516 fputs(s, text_file); 517 if (dflag) 518 fputs(s, union_file); 519 } 520 521 static void 522 putc_both(int c) 523 { 524 putc(c, text_file); 525 if (dflag) 526 putc(c, union_file); 527 } 528 529 static void 530 copy_union(void) 531 { 532 int c; 533 int quote; 534 int depth; 535 int u_lineno = lineno; 536 char *u_line = dup_line(); 537 char *u_cptr = u_line + (cptr - line - 6); 538 539 if (unionized) 540 over_unionized(cptr - 6); 541 unionized = 1; 542 543 if (!lflag) 544 fprintf(text_file, line_format, lineno, input_file_name); 545 546 puts_both("#ifdef YYSTYPE\n"); 547 puts_both("#undef YYSTYPE_IS_DECLARED\n"); 548 puts_both("#define YYSTYPE_IS_DECLARED 1\n"); 549 puts_both("#endif\n"); 550 puts_both("#ifndef YYSTYPE_IS_DECLARED\n"); 551 puts_both("#define YYSTYPE_IS_DECLARED 1\n"); 552 puts_both("typedef union"); 553 554 depth = 0; 555 loop: 556 c = *cptr++; 557 putc_both(c); 558 switch (c) 559 { 560 case '\n': 561 next_line: 562 get_line(); 563 if (line == 0) 564 unterminated_union(u_lineno, u_line, u_cptr); 565 goto loop; 566 567 case L_CURL: 568 ++depth; 569 goto loop; 570 571 case R_CURL: 572 if (--depth == 0) 573 { 574 puts_both(" YYSTYPE;\n"); 575 puts_both("#endif /* !YYSTYPE_IS_DECLARED */\n"); 576 FREE(u_line); 577 return; 578 } 579 goto loop; 580 581 case '\'': 582 case '"': 583 { 584 int s_lineno = lineno; 585 char *s_line = dup_line(); 586 char *s_cptr = s_line + (cptr - line - 1); 587 588 quote = c; 589 for (;;) 590 { 591 c = *cptr++; 592 putc_both(c); 593 if (c == quote) 594 { 595 FREE(s_line); 596 goto loop; 597 } 598 if (c == '\n') 599 unterminated_string(s_lineno, s_line, s_cptr); 600 if (c == '\\') 601 { 602 c = *cptr++; 603 putc_both(c); 604 if (c == '\n') 605 { 606 get_line(); 607 if (line == 0) 608 unterminated_string(s_lineno, s_line, s_cptr); 609 } 610 } 611 } 612 } 613 614 case '/': 615 c = *cptr; 616 if (c == '/') 617 { 618 putc_both('*'); 619 while ((c = *++cptr) != '\n') 620 { 621 if (c == '*' && cptr[1] == '/') 622 { 623 puts_both("* "); 624 } 625 else 626 { 627 putc_both(c); 628 } 629 } 630 puts_both("*/\n"); 631 goto next_line; 632 } 633 if (c == '*') 634 { 635 int c_lineno = lineno; 636 char *c_line = dup_line(); 637 char *c_cptr = c_line + (cptr - line - 1); 638 639 putc_both('*'); 640 ++cptr; 641 for (;;) 642 { 643 c = *cptr++; 644 putc_both(c); 645 if (c == '*' && *cptr == '/') 646 { 647 putc_both('/'); 648 ++cptr; 649 FREE(c_line); 650 goto loop; 651 } 652 if (c == '\n') 653 { 654 get_line(); 655 if (line == 0) 656 unterminated_comment(c_lineno, c_line, c_cptr); 657 } 658 } 659 } 660 goto loop; 661 662 default: 663 goto loop; 664 } 665 } 666 667 /* 668 * Keep a linked list of parameters 669 */ 670 static void 671 copy_param(int k) 672 { 673 char *buf; 674 int c; 675 param *head, *p; 676 int i; 677 int name, type2; 678 679 c = nextc(); 680 if (c == EOF) 681 unexpected_EOF(); 682 if (c != '{') 683 goto out; 684 cptr++; 685 686 c = nextc(); 687 if (c == EOF) 688 unexpected_EOF(); 689 if (c == '}') 690 goto out; 691 692 buf = MALLOC(linesize); 693 NO_SPACE(buf); 694 695 for (i = 0; (c = *cptr++) != '}'; i++) 696 { 697 if (c == '\0') 698 missing_brace(); 699 if (c == EOF) 700 unexpected_EOF(); 701 buf[i] = (char)c; 702 } 703 704 if (i == 0) 705 goto out; 706 707 buf[i--] = '\0'; 708 while (i >= 0 && isspace(UCH(buf[i]))) 709 buf[i--] = '\0'; 710 711 if (buf[i] == ']') 712 { 713 int level = 1; 714 while (i >= 0 && level > 0 && buf[i] != '[') 715 { 716 if (buf[i] == ']') 717 ++level; 718 else if (buf[i] == '[') 719 --level; 720 i--; 721 } 722 if (i <= 0) 723 unexpected_EOF(); 724 type2 = i--; 725 } 726 else 727 { 728 type2 = i + 1; 729 } 730 731 while (i >= 0 && (isalnum(UCH(buf[i])) || 732 UCH(buf[i]) == '_')) 733 i--; 734 735 if (!isspace(UCH(buf[i])) && buf[i] != '*') 736 goto out; 737 738 name = i + 1; 739 740 p = MALLOC(sizeof(*p)); 741 NO_SPACE(p); 742 743 p->type2 = strdup(buf + type2); 744 NO_SPACE(p->type2); 745 746 buf[type2] = '\0'; 747 748 p->name = strdup(buf + name); 749 NO_SPACE(p->name); 750 751 buf[name] = '\0'; 752 p->type = buf; 753 754 if (k == LEX_PARAM) 755 head = lex_param; 756 else 757 head = parse_param; 758 759 if (head != NULL) 760 { 761 while (head->next) 762 head = head->next; 763 head->next = p; 764 } 765 else 766 { 767 if (k == LEX_PARAM) 768 lex_param = p; 769 else 770 parse_param = p; 771 } 772 p->next = NULL; 773 return; 774 775 out: 776 syntax_error(lineno, line, cptr); 777 } 778 779 static int 780 hexval(int c) 781 { 782 if (c >= '0' && c <= '9') 783 return (c - '0'); 784 if (c >= 'A' && c <= 'F') 785 return (c - 'A' + 10); 786 if (c >= 'a' && c <= 'f') 787 return (c - 'a' + 10); 788 return (-1); 789 } 790 791 static bucket * 792 get_literal(void) 793 { 794 int c, quote; 795 int i; 796 int n; 797 char *s; 798 bucket *bp; 799 int s_lineno = lineno; 800 char *s_line = dup_line(); 801 char *s_cptr = s_line + (cptr - line); 802 803 quote = *cptr++; 804 cinc = 0; 805 for (;;) 806 { 807 c = *cptr++; 808 if (c == quote) 809 break; 810 if (c == '\n') 811 unterminated_string(s_lineno, s_line, s_cptr); 812 if (c == '\\') 813 { 814 char *c_cptr = cptr - 1; 815 816 c = *cptr++; 817 switch (c) 818 { 819 case '\n': 820 get_line(); 821 if (line == 0) 822 unterminated_string(s_lineno, s_line, s_cptr); 823 continue; 824 825 case '0': 826 case '1': 827 case '2': 828 case '3': 829 case '4': 830 case '5': 831 case '6': 832 case '7': 833 n = c - '0'; 834 c = *cptr; 835 if (IS_OCTAL(c)) 836 { 837 n = (n << 3) + (c - '0'); 838 c = *++cptr; 839 if (IS_OCTAL(c)) 840 { 841 n = (n << 3) + (c - '0'); 842 ++cptr; 843 } 844 } 845 if (n > MAXCHAR) 846 illegal_character(c_cptr); 847 c = n; 848 break; 849 850 case 'x': 851 c = *cptr++; 852 n = hexval(c); 853 if (n < 0 || n >= 16) 854 illegal_character(c_cptr); 855 for (;;) 856 { 857 c = *cptr; 858 i = hexval(c); 859 if (i < 0 || i >= 16) 860 break; 861 ++cptr; 862 n = (n << 4) + i; 863 if (n > MAXCHAR) 864 illegal_character(c_cptr); 865 } 866 c = n; 867 break; 868 869 case 'a': 870 c = 7; 871 break; 872 case 'b': 873 c = '\b'; 874 break; 875 case 'f': 876 c = '\f'; 877 break; 878 case 'n': 879 c = '\n'; 880 break; 881 case 'r': 882 c = '\r'; 883 break; 884 case 't': 885 c = '\t'; 886 break; 887 case 'v': 888 c = '\v'; 889 break; 890 } 891 } 892 cachec(c); 893 } 894 FREE(s_line); 895 896 n = cinc; 897 s = MALLOC(n); 898 NO_SPACE(s); 899 900 for (i = 0; i < n; ++i) 901 s[i] = cache[i]; 902 903 cinc = 0; 904 if (n == 1) 905 cachec('\''); 906 else 907 cachec('"'); 908 909 for (i = 0; i < n; ++i) 910 { 911 c = UCH(s[i]); 912 if (c == '\\' || c == cache[0]) 913 { 914 cachec('\\'); 915 cachec(c); 916 } 917 else if (isprint(c)) 918 cachec(c); 919 else 920 { 921 cachec('\\'); 922 switch (c) 923 { 924 case 7: 925 cachec('a'); 926 break; 927 case '\b': 928 cachec('b'); 929 break; 930 case '\f': 931 cachec('f'); 932 break; 933 case '\n': 934 cachec('n'); 935 break; 936 case '\r': 937 cachec('r'); 938 break; 939 case '\t': 940 cachec('t'); 941 break; 942 case '\v': 943 cachec('v'); 944 break; 945 default: 946 cachec(((c >> 6) & 7) + '0'); 947 cachec(((c >> 3) & 7) + '0'); 948 cachec((c & 7) + '0'); 949 break; 950 } 951 } 952 } 953 954 if (n == 1) 955 cachec('\''); 956 else 957 cachec('"'); 958 959 cachec(NUL); 960 bp = lookup(cache); 961 bp->class = TERM; 962 if (n == 1 && bp->value == UNDEFINED) 963 bp->value = UCH(*s); 964 FREE(s); 965 966 return (bp); 967 } 968 969 static int 970 is_reserved(char *name) 971 { 972 char *s; 973 974 if (strcmp(name, ".") == 0 || 975 strcmp(name, "$accept") == 0 || 976 strcmp(name, "$end") == 0) 977 return (1); 978 979 if (name[0] == '$' && name[1] == '$' && isdigit(UCH(name[2]))) 980 { 981 s = name + 3; 982 while (isdigit(UCH(*s))) 983 ++s; 984 if (*s == NUL) 985 return (1); 986 } 987 988 return (0); 989 } 990 991 static bucket * 992 get_name(void) 993 { 994 int c; 995 996 cinc = 0; 997 for (c = *cptr; IS_IDENT(c); c = *++cptr) 998 cachec(c); 999 cachec(NUL); 1000 1001 if (is_reserved(cache)) 1002 used_reserved(cache); 1003 1004 return (lookup(cache)); 1005 } 1006 1007 static Value_t 1008 get_number(void) 1009 { 1010 int c; 1011 Value_t n; 1012 1013 n = 0; 1014 for (c = *cptr; isdigit(c); c = *++cptr) 1015 n = (Value_t) (10 * n + (c - '0')); 1016 1017 return (n); 1018 } 1019 1020 static char * 1021 get_tag(void) 1022 { 1023 int c; 1024 int i; 1025 char *s; 1026 int t_lineno = lineno; 1027 char *t_line = dup_line(); 1028 char *t_cptr = t_line + (cptr - line); 1029 1030 ++cptr; 1031 c = nextc(); 1032 if (c == EOF) 1033 unexpected_EOF(); 1034 if (!isalpha(c) && c != '_' && c != '$') 1035 illegal_tag(t_lineno, t_line, t_cptr); 1036 1037 cinc = 0; 1038 do 1039 { 1040 cachec(c); 1041 c = *++cptr; 1042 } 1043 while (IS_IDENT(c)); 1044 cachec(NUL); 1045 1046 c = nextc(); 1047 if (c == EOF) 1048 unexpected_EOF(); 1049 if (c != '>') 1050 illegal_tag(t_lineno, t_line, t_cptr); 1051 ++cptr; 1052 1053 for (i = 0; i < ntags; ++i) 1054 { 1055 if (strcmp(cache, tag_table[i]) == 0) 1056 { 1057 FREE(t_line); 1058 return (tag_table[i]); 1059 } 1060 } 1061 1062 if (ntags >= tagmax) 1063 { 1064 tagmax += 16; 1065 tag_table = (char **) 1066 (tag_table 1067 ? REALLOC(tag_table, (unsigned)tagmax * sizeof(char *)) 1068 : MALLOC((unsigned)tagmax * sizeof(char *))); 1069 NO_SPACE(tag_table); 1070 } 1071 1072 s = MALLOC(cinc); 1073 NO_SPACE(s); 1074 1075 strcpy(s, cache); 1076 tag_table[ntags] = s; 1077 ++ntags; 1078 FREE(t_line); 1079 return (s); 1080 } 1081 1082 static void 1083 declare_tokens(int assoc) 1084 { 1085 int c; 1086 bucket *bp; 1087 Value_t value; 1088 char *tag = 0; 1089 1090 if (assoc != TOKEN) 1091 ++prec; 1092 1093 c = nextc(); 1094 if (c == EOF) 1095 unexpected_EOF(); 1096 if (c == '<') 1097 { 1098 tag = get_tag(); 1099 c = nextc(); 1100 if (c == EOF) 1101 unexpected_EOF(); 1102 } 1103 1104 for (;;) 1105 { 1106 if (isalpha(c) || c == '_' || c == '.' || c == '$') 1107 bp = get_name(); 1108 else if (c == '\'' || c == '"') 1109 bp = get_literal(); 1110 else 1111 return; 1112 1113 if (bp == goal) 1114 tokenized_start(bp->name); 1115 bp->class = TERM; 1116 1117 if (tag) 1118 { 1119 if (bp->tag && tag != bp->tag) 1120 retyped_warning(bp->name); 1121 bp->tag = tag; 1122 } 1123 1124 if (assoc != TOKEN) 1125 { 1126 if (bp->prec && prec != bp->prec) 1127 reprec_warning(bp->name); 1128 bp->assoc = (Assoc_t) assoc; 1129 bp->prec = prec; 1130 } 1131 1132 c = nextc(); 1133 if (c == EOF) 1134 unexpected_EOF(); 1135 1136 if (isdigit(c)) 1137 { 1138 value = get_number(); 1139 if (bp->value != UNDEFINED && value != bp->value) 1140 revalued_warning(bp->name); 1141 bp->value = value; 1142 c = nextc(); 1143 if (c == EOF) 1144 unexpected_EOF(); 1145 } 1146 } 1147 } 1148 1149 /* 1150 * %expect requires special handling 1151 * as it really isn't part of the yacc 1152 * grammar only a flag for yacc proper. 1153 */ 1154 static void 1155 declare_expect(int assoc) 1156 { 1157 int c; 1158 1159 if (assoc != EXPECT && assoc != EXPECT_RR) 1160 ++prec; 1161 1162 /* 1163 * Stay away from nextc - doesn't 1164 * detect EOL and will read to EOF. 1165 */ 1166 c = *++cptr; 1167 if (c == EOF) 1168 unexpected_EOF(); 1169 1170 for (;;) 1171 { 1172 if (isdigit(c)) 1173 { 1174 if (assoc == EXPECT) 1175 SRexpect = get_number(); 1176 else 1177 RRexpect = get_number(); 1178 break; 1179 } 1180 /* 1181 * Looking for number before EOL. 1182 * Spaces, tabs, and numbers are ok, 1183 * words, punc., etc. are syntax errors. 1184 */ 1185 else if (c == '\n' || isalpha(c) || !isspace(c)) 1186 { 1187 syntax_error(lineno, line, cptr); 1188 } 1189 else 1190 { 1191 c = *++cptr; 1192 if (c == EOF) 1193 unexpected_EOF(); 1194 } 1195 } 1196 } 1197 1198 static void 1199 declare_types(void) 1200 { 1201 int c; 1202 bucket *bp; 1203 char *tag; 1204 1205 c = nextc(); 1206 if (c == EOF) 1207 unexpected_EOF(); 1208 if (c != '<') 1209 syntax_error(lineno, line, cptr); 1210 tag = get_tag(); 1211 1212 for (;;) 1213 { 1214 c = nextc(); 1215 if (isalpha(c) || c == '_' || c == '.' || c == '$') 1216 bp = get_name(); 1217 else if (c == '\'' || c == '"') 1218 bp = get_literal(); 1219 else 1220 return; 1221 1222 if (bp->tag && tag != bp->tag) 1223 retyped_warning(bp->name); 1224 bp->tag = tag; 1225 } 1226 } 1227 1228 static void 1229 declare_start(void) 1230 { 1231 int c; 1232 bucket *bp; 1233 1234 c = nextc(); 1235 if (c == EOF) 1236 unexpected_EOF(); 1237 if (!isalpha(c) && c != '_' && c != '.' && c != '$') 1238 syntax_error(lineno, line, cptr); 1239 bp = get_name(); 1240 if (bp->class == TERM) 1241 terminal_start(bp->name); 1242 if (goal && goal != bp) 1243 restarted_warning(); 1244 goal = bp; 1245 } 1246 1247 static void 1248 read_declarations(void) 1249 { 1250 int c, k; 1251 1252 cache_size = 256; 1253 cache = MALLOC(cache_size); 1254 NO_SPACE(cache); 1255 1256 for (;;) 1257 { 1258 c = nextc(); 1259 if (c == EOF) 1260 unexpected_EOF(); 1261 if (c != '%') 1262 syntax_error(lineno, line, cptr); 1263 switch (k = keyword()) 1264 { 1265 case MARK: 1266 return; 1267 1268 case IDENT: 1269 copy_ident(); 1270 break; 1271 1272 case TEXT: 1273 copy_text(); 1274 break; 1275 1276 case UNION: 1277 copy_union(); 1278 break; 1279 1280 case TOKEN: 1281 case LEFT: 1282 case RIGHT: 1283 case NONASSOC: 1284 declare_tokens(k); 1285 break; 1286 1287 case EXPECT: 1288 case EXPECT_RR: 1289 declare_expect(k); 1290 break; 1291 1292 case TYPE: 1293 declare_types(); 1294 break; 1295 1296 case START: 1297 declare_start(); 1298 break; 1299 1300 case PURE_PARSER: 1301 pure_parser = 1; 1302 break; 1303 1304 case PARSE_PARAM: 1305 case LEX_PARAM: 1306 copy_param(k); 1307 break; 1308 1309 case POSIX_YACC: 1310 /* noop for bison compatibility. byacc is already designed to be posix 1311 * yacc compatible. */ 1312 break; 1313 } 1314 } 1315 } 1316 1317 static void 1318 initialize_grammar(void) 1319 { 1320 nitems = 4; 1321 maxitems = 300; 1322 1323 pitem = (bucket **)MALLOC((unsigned)maxitems * sizeof(bucket *)); 1324 NO_SPACE(pitem); 1325 1326 pitem[0] = 0; 1327 pitem[1] = 0; 1328 pitem[2] = 0; 1329 pitem[3] = 0; 1330 1331 nrules = 3; 1332 maxrules = 100; 1333 1334 plhs = (bucket **)MALLOC((unsigned)maxrules * sizeof(bucket *)); 1335 NO_SPACE(plhs); 1336 1337 plhs[0] = 0; 1338 plhs[1] = 0; 1339 plhs[2] = 0; 1340 1341 rprec = (short *)MALLOC((unsigned)maxrules * sizeof(short)); 1342 NO_SPACE(rprec); 1343 1344 rprec[0] = 0; 1345 rprec[1] = 0; 1346 rprec[2] = 0; 1347 1348 rassoc = (char *)MALLOC((unsigned)maxrules * sizeof(char)); 1349 NO_SPACE(rassoc); 1350 1351 rassoc[0] = TOKEN; 1352 rassoc[1] = TOKEN; 1353 rassoc[2] = TOKEN; 1354 } 1355 1356 static void 1357 expand_items(void) 1358 { 1359 maxitems += 300; 1360 pitem = (bucket **)REALLOC(pitem, (unsigned)maxitems * sizeof(bucket *)); 1361 NO_SPACE(pitem); 1362 } 1363 1364 static void 1365 expand_rules(void) 1366 { 1367 maxrules += 100; 1368 1369 plhs = (bucket **)REALLOC(plhs, (unsigned)maxrules * sizeof(bucket *)); 1370 NO_SPACE(plhs); 1371 1372 rprec = (short *)REALLOC(rprec, (unsigned)maxrules * sizeof(short)); 1373 NO_SPACE(rprec); 1374 1375 rassoc = (char *)REALLOC(rassoc, (unsigned)maxrules * sizeof(char)); 1376 NO_SPACE(rassoc); 1377 } 1378 1379 static void 1380 advance_to_start(void) 1381 { 1382 int c; 1383 bucket *bp; 1384 char *s_cptr; 1385 int s_lineno; 1386 1387 for (;;) 1388 { 1389 c = nextc(); 1390 if (c != '%') 1391 break; 1392 s_cptr = cptr; 1393 switch (keyword()) 1394 { 1395 case MARK: 1396 no_grammar(); 1397 1398 case TEXT: 1399 copy_text(); 1400 break; 1401 1402 case START: 1403 declare_start(); 1404 break; 1405 1406 default: 1407 syntax_error(lineno, line, s_cptr); 1408 } 1409 } 1410 1411 c = nextc(); 1412 if (!isalpha(c) && c != '_' && c != '.' && c != '_') 1413 syntax_error(lineno, line, cptr); 1414 bp = get_name(); 1415 if (goal == 0) 1416 { 1417 if (bp->class == TERM) 1418 terminal_start(bp->name); 1419 goal = bp; 1420 } 1421 1422 s_lineno = lineno; 1423 c = nextc(); 1424 if (c == EOF) 1425 unexpected_EOF(); 1426 if (c != ':') 1427 syntax_error(lineno, line, cptr); 1428 start_rule(bp, s_lineno); 1429 ++cptr; 1430 } 1431 1432 static void 1433 start_rule(bucket *bp, int s_lineno) 1434 { 1435 if (bp->class == TERM) 1436 terminal_lhs(s_lineno); 1437 bp->class = NONTERM; 1438 if (nrules >= maxrules) 1439 expand_rules(); 1440 plhs[nrules] = bp; 1441 rprec[nrules] = UNDEFINED; 1442 rassoc[nrules] = TOKEN; 1443 } 1444 1445 static void 1446 end_rule(void) 1447 { 1448 int i; 1449 1450 if (!last_was_action && plhs[nrules]->tag) 1451 { 1452 if (pitem[nitems - 1]) 1453 { 1454 for (i = nitems - 1; (i > 0) && pitem[i]; --i) 1455 continue; 1456 if (pitem[i + 1] == 0 || pitem[i + 1]->tag != plhs[nrules]->tag) 1457 default_action_warning(); 1458 } 1459 else 1460 { 1461 default_action_warning(); 1462 } 1463 } 1464 1465 last_was_action = 0; 1466 if (nitems >= maxitems) 1467 expand_items(); 1468 pitem[nitems] = 0; 1469 ++nitems; 1470 ++nrules; 1471 } 1472 1473 static void 1474 insert_empty_rule(void) 1475 { 1476 bucket *bp, **bpp; 1477 1478 assert(cache); 1479 sprintf(cache, "$$%d", ++gensym); 1480 bp = make_bucket(cache); 1481 last_symbol->next = bp; 1482 last_symbol = bp; 1483 bp->tag = plhs[nrules]->tag; 1484 bp->class = NONTERM; 1485 1486 if ((nitems += 2) > maxitems) 1487 expand_items(); 1488 bpp = pitem + nitems - 1; 1489 *bpp-- = bp; 1490 while ((bpp[0] = bpp[-1]) != 0) 1491 --bpp; 1492 1493 if (++nrules >= maxrules) 1494 expand_rules(); 1495 plhs[nrules] = plhs[nrules - 1]; 1496 plhs[nrules - 1] = bp; 1497 rprec[nrules] = rprec[nrules - 1]; 1498 rprec[nrules - 1] = 0; 1499 rassoc[nrules] = rassoc[nrules - 1]; 1500 rassoc[nrules - 1] = TOKEN; 1501 } 1502 1503 static void 1504 add_symbol(void) 1505 { 1506 int c; 1507 bucket *bp; 1508 int s_lineno = lineno; 1509 1510 c = *cptr; 1511 if (c == '\'' || c == '"') 1512 bp = get_literal(); 1513 else 1514 bp = get_name(); 1515 1516 c = nextc(); 1517 if (c == ':') 1518 { 1519 end_rule(); 1520 start_rule(bp, s_lineno); 1521 ++cptr; 1522 return; 1523 } 1524 1525 if (last_was_action) 1526 insert_empty_rule(); 1527 last_was_action = 0; 1528 1529 if (++nitems > maxitems) 1530 expand_items(); 1531 pitem[nitems - 1] = bp; 1532 } 1533 1534 static char * 1535 after_blanks(char *s) 1536 { 1537 while (*s != '\0' && isspace(UCH(*s))) 1538 ++s; 1539 return s; 1540 } 1541 1542 static void 1543 copy_action(void) 1544 { 1545 int c; 1546 int i, n; 1547 int depth; 1548 int quote; 1549 char *tag; 1550 FILE *f = action_file; 1551 int a_lineno = lineno; 1552 char *a_line = dup_line(); 1553 char *a_cptr = a_line + (cptr - line); 1554 1555 if (last_was_action) 1556 insert_empty_rule(); 1557 last_was_action = 1; 1558 1559 fprintf(f, "case %d:\n", nrules - 2); 1560 if (!lflag) 1561 fprintf(f, line_format, lineno, input_file_name); 1562 if (*cptr == '=') 1563 ++cptr; 1564 1565 /* avoid putting curly-braces in first column, to ease editing */ 1566 if (*after_blanks(cptr) == L_CURL) 1567 { 1568 putc('\t', f); 1569 cptr = after_blanks(cptr); 1570 } 1571 1572 n = 0; 1573 for (i = nitems - 1; pitem[i]; --i) 1574 ++n; 1575 1576 depth = 0; 1577 loop: 1578 c = *cptr; 1579 if (c == '$') 1580 { 1581 if (cptr[1] == '<') 1582 { 1583 int d_lineno = lineno; 1584 char *d_line = dup_line(); 1585 char *d_cptr = d_line + (cptr - line); 1586 1587 ++cptr; 1588 tag = get_tag(); 1589 c = *cptr; 1590 if (c == '$') 1591 { 1592 fprintf(f, "yyval.%s", tag); 1593 ++cptr; 1594 FREE(d_line); 1595 goto loop; 1596 } 1597 else if (isdigit(c)) 1598 { 1599 i = get_number(); 1600 if (i > n) 1601 dollar_warning(d_lineno, i); 1602 fprintf(f, "yystack.l_mark[%d].%s", i - n, tag); 1603 FREE(d_line); 1604 goto loop; 1605 } 1606 else if (c == '-' && isdigit(UCH(cptr[1]))) 1607 { 1608 ++cptr; 1609 i = -get_number() - n; 1610 fprintf(f, "yystack.l_mark[%d].%s", i, tag); 1611 FREE(d_line); 1612 goto loop; 1613 } 1614 else 1615 dollar_error(d_lineno, d_line, d_cptr); 1616 } 1617 else if (cptr[1] == '$') 1618 { 1619 if (ntags) 1620 { 1621 tag = plhs[nrules]->tag; 1622 if (tag == 0) 1623 untyped_lhs(); 1624 fprintf(f, "yyval.%s", tag); 1625 } 1626 else 1627 fprintf(f, "yyval"); 1628 cptr += 2; 1629 goto loop; 1630 } 1631 else if (isdigit(UCH(cptr[1]))) 1632 { 1633 ++cptr; 1634 i = get_number(); 1635 if (ntags) 1636 { 1637 if (i <= 0 || i > n) 1638 unknown_rhs(i); 1639 tag = pitem[nitems + i - n - 1]->tag; 1640 if (tag == 0) 1641 untyped_rhs(i, pitem[nitems + i - n - 1]->name); 1642 fprintf(f, "yystack.l_mark[%d].%s", i - n, tag); 1643 } 1644 else 1645 { 1646 if (i > n) 1647 dollar_warning(lineno, i); 1648 fprintf(f, "yystack.l_mark[%d]", i - n); 1649 } 1650 goto loop; 1651 } 1652 else if (cptr[1] == '-') 1653 { 1654 cptr += 2; 1655 i = get_number(); 1656 if (ntags) 1657 unknown_rhs(-i); 1658 fprintf(f, "yystack.l_mark[%d]", -i - n); 1659 goto loop; 1660 } 1661 } 1662 if (isalpha(c) || c == '_' || c == '$') 1663 { 1664 do 1665 { 1666 putc(c, f); 1667 c = *++cptr; 1668 } 1669 while (isalnum(c) || c == '_' || c == '$'); 1670 goto loop; 1671 } 1672 putc(c, f); 1673 ++cptr; 1674 switch (c) 1675 { 1676 case '\n': 1677 next_line: 1678 get_line(); 1679 if (line) 1680 goto loop; 1681 unterminated_action(a_lineno, a_line, a_cptr); 1682 1683 case ';': 1684 if (depth > 0) 1685 goto loop; 1686 fprintf(f, "\nbreak;\n"); 1687 free(a_line); 1688 return; 1689 1690 case L_CURL: 1691 ++depth; 1692 goto loop; 1693 1694 case R_CURL: 1695 if (--depth > 0) 1696 goto loop; 1697 fprintf(f, "\nbreak;\n"); 1698 free(a_line); 1699 return; 1700 1701 case '\'': 1702 case '"': 1703 { 1704 int s_lineno = lineno; 1705 char *s_line = dup_line(); 1706 char *s_cptr = s_line + (cptr - line - 1); 1707 1708 quote = c; 1709 for (;;) 1710 { 1711 c = *cptr++; 1712 putc(c, f); 1713 if (c == quote) 1714 { 1715 FREE(s_line); 1716 goto loop; 1717 } 1718 if (c == '\n') 1719 unterminated_string(s_lineno, s_line, s_cptr); 1720 if (c == '\\') 1721 { 1722 c = *cptr++; 1723 putc(c, f); 1724 if (c == '\n') 1725 { 1726 get_line(); 1727 if (line == 0) 1728 unterminated_string(s_lineno, s_line, s_cptr); 1729 } 1730 } 1731 } 1732 } 1733 1734 case '/': 1735 c = *cptr; 1736 if (c == '/') 1737 { 1738 putc('*', f); 1739 while ((c = *++cptr) != '\n') 1740 { 1741 if (c == '*' && cptr[1] == '/') 1742 fprintf(f, "* "); 1743 else 1744 putc(c, f); 1745 } 1746 fprintf(f, "*/\n"); 1747 goto next_line; 1748 } 1749 if (c == '*') 1750 { 1751 int c_lineno = lineno; 1752 char *c_line = dup_line(); 1753 char *c_cptr = c_line + (cptr - line - 1); 1754 1755 putc('*', f); 1756 ++cptr; 1757 for (;;) 1758 { 1759 c = *cptr++; 1760 putc(c, f); 1761 if (c == '*' && *cptr == '/') 1762 { 1763 putc('/', f); 1764 ++cptr; 1765 FREE(c_line); 1766 goto loop; 1767 } 1768 if (c == '\n') 1769 { 1770 get_line(); 1771 if (line == 0) 1772 unterminated_comment(c_lineno, c_line, c_cptr); 1773 } 1774 } 1775 } 1776 goto loop; 1777 1778 default: 1779 goto loop; 1780 } 1781 } 1782 1783 static int 1784 mark_symbol(void) 1785 { 1786 int c; 1787 bucket *bp; 1788 1789 c = cptr[1]; 1790 if (c == '%' || c == '\\') 1791 { 1792 cptr += 2; 1793 return (1); 1794 } 1795 1796 if (c == '=') 1797 cptr += 2; 1798 else if ((c == 'p' || c == 'P') && 1799 ((c = cptr[2]) == 'r' || c == 'R') && 1800 ((c = cptr[3]) == 'e' || c == 'E') && 1801 ((c = cptr[4]) == 'c' || c == 'C') && 1802 ((c = cptr[5], !IS_IDENT(c)))) 1803 cptr += 5; 1804 else 1805 syntax_error(lineno, line, cptr); 1806 1807 c = nextc(); 1808 if (isalpha(c) || c == '_' || c == '.' || c == '$') 1809 bp = get_name(); 1810 else if (c == '\'' || c == '"') 1811 bp = get_literal(); 1812 else 1813 { 1814 syntax_error(lineno, line, cptr); 1815 /*NOTREACHED */ 1816 } 1817 1818 if (rprec[nrules] != UNDEFINED && bp->prec != rprec[nrules]) 1819 prec_redeclared(); 1820 1821 rprec[nrules] = bp->prec; 1822 rassoc[nrules] = bp->assoc; 1823 return (0); 1824 } 1825 1826 static void 1827 read_grammar(void) 1828 { 1829 int c; 1830 1831 initialize_grammar(); 1832 advance_to_start(); 1833 1834 for (;;) 1835 { 1836 c = nextc(); 1837 if (c == EOF) 1838 break; 1839 if (isalpha(c) 1840 || c == '_' 1841 || c == '.' 1842 || c == '$' 1843 || c == '\'' 1844 || c == '"') 1845 add_symbol(); 1846 else if (c == L_CURL || c == '=') 1847 copy_action(); 1848 else if (c == '|') 1849 { 1850 end_rule(); 1851 start_rule(plhs[nrules - 1], 0); 1852 ++cptr; 1853 } 1854 else if (c == '%') 1855 { 1856 if (mark_symbol()) 1857 break; 1858 } 1859 else 1860 syntax_error(lineno, line, cptr); 1861 } 1862 end_rule(); 1863 } 1864 1865 static void 1866 free_tags(void) 1867 { 1868 int i; 1869 1870 if (tag_table == 0) 1871 return; 1872 1873 for (i = 0; i < ntags; ++i) 1874 { 1875 assert(tag_table[i]); 1876 FREE(tag_table[i]); 1877 } 1878 FREE(tag_table); 1879 } 1880 1881 static void 1882 pack_names(void) 1883 { 1884 bucket *bp; 1885 char *p, *s, *t; 1886 1887 name_pool_size = 13; /* 13 == sizeof("$end") + sizeof("$accept") */ 1888 for (bp = first_symbol; bp; bp = bp->next) 1889 name_pool_size += strlen(bp->name) + 1; 1890 1891 name_pool = MALLOC(name_pool_size); 1892 NO_SPACE(name_pool); 1893 1894 strlcpy(name_pool, "$accept", name_pool_size); 1895 strlcpy(name_pool + 8, "$end", name_pool_size - 8); 1896 t = name_pool + 13; 1897 for (bp = first_symbol; bp; bp = bp->next) 1898 { 1899 p = t; 1900 s = bp->name; 1901 while ((*t++ = *s++) != 0) 1902 continue; 1903 FREE(bp->name); 1904 bp->name = p; 1905 } 1906 } 1907 1908 static void 1909 check_symbols(void) 1910 { 1911 bucket *bp; 1912 1913 if (goal->class == UNKNOWN) 1914 undefined_goal(goal->name); 1915 1916 for (bp = first_symbol; bp; bp = bp->next) 1917 { 1918 if (bp->class == UNKNOWN) 1919 { 1920 undefined_symbol_warning(bp->name); 1921 bp->class = TERM; 1922 } 1923 } 1924 } 1925 1926 static void 1927 protect_string(char *src, char **des) 1928 { 1929 unsigned len; 1930 char *s; 1931 char *d; 1932 1933 *des = src; 1934 if (src) 1935 { 1936 len = 1; 1937 s = src; 1938 while (*s) 1939 { 1940 if ('\\' == *s || '"' == *s) 1941 len++; 1942 s++; 1943 len++; 1944 } 1945 1946 *des = d = (char *)MALLOC(len); 1947 NO_SPACE(d); 1948 1949 s = src; 1950 while (*s) 1951 { 1952 if ('\\' == *s || '"' == *s) 1953 *d++ = '\\'; 1954 *d++ = *s++; 1955 } 1956 *d = '\0'; 1957 } 1958 } 1959 1960 static void 1961 pack_symbols(void) 1962 { 1963 bucket *bp; 1964 bucket **v; 1965 Value_t i, j, k, n; 1966 1967 nsyms = 2; 1968 ntokens = 1; 1969 for (bp = first_symbol; bp; bp = bp->next) 1970 { 1971 ++nsyms; 1972 if (bp->class == TERM) 1973 ++ntokens; 1974 } 1975 start_symbol = (Value_t) ntokens; 1976 nvars = nsyms - ntokens; 1977 1978 symbol_name = (char **)MALLOC((unsigned)nsyms * sizeof(char *)); 1979 NO_SPACE(symbol_name); 1980 1981 symbol_value = (short *)MALLOC((unsigned)nsyms * sizeof(short)); 1982 NO_SPACE(symbol_value); 1983 1984 symbol_prec = (short *)MALLOC((unsigned)nsyms * sizeof(short)); 1985 NO_SPACE(symbol_prec); 1986 1987 symbol_assoc = MALLOC(nsyms); 1988 NO_SPACE(symbol_assoc); 1989 1990 v = (bucket **)MALLOC((unsigned)nsyms * sizeof(bucket *)); 1991 NO_SPACE(v); 1992 1993 v[0] = 0; 1994 v[start_symbol] = 0; 1995 1996 i = 1; 1997 j = (Value_t) (start_symbol + 1); 1998 for (bp = first_symbol; bp; bp = bp->next) 1999 { 2000 if (bp->class == TERM) 2001 v[i++] = bp; 2002 else 2003 v[j++] = bp; 2004 } 2005 assert(i == ntokens && j == nsyms); 2006 2007 for (i = 1; i < ntokens; ++i) 2008 v[i]->index = i; 2009 2010 goal->index = (Index_t) (start_symbol + 1); 2011 k = (Value_t) (start_symbol + 2); 2012 while (++i < nsyms) 2013 if (v[i] != goal) 2014 { 2015 v[i]->index = k; 2016 ++k; 2017 } 2018 2019 goal->value = 0; 2020 k = 1; 2021 for (i = (Value_t) (start_symbol + 1); i < nsyms; ++i) 2022 { 2023 if (v[i] != goal) 2024 { 2025 v[i]->value = k; 2026 ++k; 2027 } 2028 } 2029 2030 k = 0; 2031 for (i = 1; i < ntokens; ++i) 2032 { 2033 n = v[i]->value; 2034 if (n > 256) 2035 { 2036 for (j = k++; j > 0 && symbol_value[j - 1] > n; --j) 2037 symbol_value[j] = symbol_value[j - 1]; 2038 symbol_value[j] = n; 2039 } 2040 } 2041 2042 assert(v[1] != 0); 2043 2044 if (v[1]->value == UNDEFINED) 2045 v[1]->value = 256; 2046 2047 j = 0; 2048 n = 257; 2049 for (i = 2; i < ntokens; ++i) 2050 { 2051 if (v[i]->value == UNDEFINED) 2052 { 2053 while (j < k && n == symbol_value[j]) 2054 { 2055 while (++j < k && n == symbol_value[j]) 2056 continue; 2057 ++n; 2058 } 2059 v[i]->value = n; 2060 ++n; 2061 } 2062 } 2063 2064 symbol_name[0] = name_pool + 8; 2065 symbol_value[0] = 0; 2066 symbol_prec[0] = 0; 2067 symbol_assoc[0] = TOKEN; 2068 for (i = 1; i < ntokens; ++i) 2069 { 2070 symbol_name[i] = v[i]->name; 2071 symbol_value[i] = v[i]->value; 2072 symbol_prec[i] = v[i]->prec; 2073 symbol_assoc[i] = v[i]->assoc; 2074 } 2075 symbol_name[start_symbol] = name_pool; 2076 symbol_value[start_symbol] = -1; 2077 symbol_prec[start_symbol] = 0; 2078 symbol_assoc[start_symbol] = TOKEN; 2079 for (++i; i < nsyms; ++i) 2080 { 2081 k = v[i]->index; 2082 symbol_name[k] = v[i]->name; 2083 symbol_value[k] = v[i]->value; 2084 symbol_prec[k] = v[i]->prec; 2085 symbol_assoc[k] = v[i]->assoc; 2086 } 2087 2088 if (gflag) 2089 { 2090 symbol_pname = (char **)MALLOC((unsigned)nsyms * sizeof(char *)); 2091 NO_SPACE(symbol_pname); 2092 2093 for (i = 0; i < nsyms; ++i) 2094 protect_string(symbol_name[i], &(symbol_pname[i])); 2095 } 2096 2097 FREE(v); 2098 } 2099 2100 static void 2101 pack_grammar(void) 2102 { 2103 int i; 2104 Value_t j; 2105 Assoc_t assoc; 2106 Value_t prec2; 2107 2108 ritem = (short *)MALLOC((unsigned)nitems * sizeof(short)); 2109 NO_SPACE(ritem); 2110 2111 rlhs = (short *)MALLOC((unsigned)nrules * sizeof(short)); 2112 NO_SPACE(rlhs); 2113 2114 rrhs = (short *)MALLOC((unsigned)(nrules + 1) * sizeof(short)); 2115 NO_SPACE(rrhs); 2116 2117 rprec = (short *)REALLOC(rprec, (unsigned)nrules * sizeof(short)); 2118 NO_SPACE(rprec); 2119 2120 rassoc = REALLOC(rassoc, nrules); 2121 NO_SPACE(rassoc); 2122 2123 ritem[0] = -1; 2124 ritem[1] = goal->index; 2125 ritem[2] = 0; 2126 ritem[3] = -2; 2127 rlhs[0] = 0; 2128 rlhs[1] = 0; 2129 rlhs[2] = start_symbol; 2130 rrhs[0] = 0; 2131 rrhs[1] = 0; 2132 rrhs[2] = 1; 2133 2134 j = 4; 2135 for (i = 3; i < nrules; ++i) 2136 { 2137 rlhs[i] = plhs[i]->index; 2138 rrhs[i] = j; 2139 assoc = TOKEN; 2140 prec2 = 0; 2141 while (pitem[j]) 2142 { 2143 ritem[j] = pitem[j]->index; 2144 if (pitem[j]->class == TERM) 2145 { 2146 prec2 = pitem[j]->prec; 2147 assoc = pitem[j]->assoc; 2148 } 2149 ++j; 2150 } 2151 ritem[j] = (Value_t) - i; 2152 ++j; 2153 if (rprec[i] == UNDEFINED) 2154 { 2155 rprec[i] = prec2; 2156 rassoc[i] = assoc; 2157 } 2158 } 2159 rrhs[i] = j; 2160 2161 FREE(plhs); 2162 FREE(pitem); 2163 } 2164 2165 static void 2166 print_grammar(void) 2167 { 2168 int i, k; 2169 size_t j, spacing = 0; 2170 FILE *f = verbose_file; 2171 2172 if (!vflag) 2173 return; 2174 2175 k = 1; 2176 for (i = 2; i < nrules; ++i) 2177 { 2178 if (rlhs[i] != rlhs[i - 1]) 2179 { 2180 if (i != 2) 2181 fprintf(f, "\n"); 2182 fprintf(f, "%4d %s :", i - 2, symbol_name[rlhs[i]]); 2183 spacing = strlen(symbol_name[rlhs[i]]) + 1; 2184 } 2185 else 2186 { 2187 fprintf(f, "%4d ", i - 2); 2188 j = spacing; 2189 while (j-- != 0) 2190 putc(' ', f); 2191 putc('|', f); 2192 } 2193 2194 while (ritem[k] >= 0) 2195 { 2196 fprintf(f, " %s", symbol_name[ritem[k]]); 2197 ++k; 2198 } 2199 ++k; 2200 putc('\n', f); 2201 } 2202 } 2203 2204 void 2205 reader(void) 2206 { 2207 write_section(code_file, banner); 2208 create_symbol_table(); 2209 read_declarations(); 2210 read_grammar(); 2211 free_symbol_table(); 2212 free_tags(); 2213 pack_names(); 2214 check_symbols(); 2215 pack_symbols(); 2216 pack_grammar(); 2217 free_symbols(); 2218 print_grammar(); 2219 } 2220 2221 #ifdef NO_LEAKS 2222 static param * 2223 free_declarations(param * list) 2224 { 2225 while (list != 0) 2226 { 2227 param *next = list->next; 2228 free(list->type); 2229 free(list->name); 2230 free(list->type2); 2231 free(list); 2232 list = next; 2233 } 2234 return list; 2235 } 2236 2237 void 2238 reader_leaks(void) 2239 { 2240 lex_param = free_declarations(lex_param); 2241 parse_param = free_declarations(parse_param); 2242 2243 DO_FREE(line); 2244 DO_FREE(rrhs); 2245 DO_FREE(rlhs); 2246 DO_FREE(rprec); 2247 DO_FREE(ritem); 2248 DO_FREE(rassoc); 2249 DO_FREE(cache); 2250 DO_FREE(name_pool); 2251 DO_FREE(symbol_name); 2252 DO_FREE(symbol_prec); 2253 DO_FREE(symbol_assoc); 2254 DO_FREE(symbol_value); 2255 } 2256 #endif 2257
Indexes created Wed Mar 04 15:26:31 UTC 2026