1 /* $Id: output.c,v 1.74 2014/10/05 23:21:09 tom Exp $ */ 2 3 #include "defs.h" 4 5 #define StaticOrR (rflag ? "" : "static ") 6 #define CountLine(fp) (!rflag || ((fp) == code_file)) 7 8 #if defined(YYBTYACC) 9 #define PER_STATE 3 10 #else 11 #define PER_STATE 2 12 #endif 13 14 static int nvectors; 15 static int nentries; 16 static Value_t **froms; 17 static Value_t **tos; 18 #if defined(YYBTYACC) 19 static Value_t *conflicts = NULL; 20 static Value_t nconflicts = 0; 21 #endif 22 static Value_t *tally; 23 static Value_t *width; 24 static Value_t *state_count; 25 static Value_t *order; 26 static Value_t *base; 27 static Value_t *pos; 28 static int maxtable; 29 static Value_t *table; 30 static Value_t *check; 31 static int lowzero; 32 static long high; 33 34 static void 35 putc_code(FILE * fp, int c) 36 { 37 if ((c == '\n') && (fp == code_file)) 38 ++outline; 39 putc(c, fp); 40 } 41 42 static void 43 putl_code(FILE * fp, const char *s) 44 { 45 if (fp == code_file) 46 ++outline; 47 fputs(s, fp); 48 } 49 50 static void 51 puts_code(FILE * fp, const char *s) 52 { 53 fputs(s, fp); 54 } 55 56 static void 57 puts_param_types(FILE * fp, param * list, int more) 58 { 59 param *p; 60 61 if (list != 0) 62 { 63 for (p = list; p; p = p->next) 64 { 65 size_t len_type = strlen(p->type); 66 fprintf(fp, "%s%s%s%s%s", p->type, 67 (((len_type != 0) && (p->type[len_type - 1] == '*')) 68 ? "" 69 : " "), 70 p->name, p->type2, 71 ((more || p->next) ? ", " : "")); 72 } 73 } 74 else 75 { 76 if (!more) 77 fprintf(fp, "void"); 78 } 79 } 80 81 static void 82 puts_param_names(FILE * fp, param * list, int more) 83 { 84 param *p; 85 86 for (p = list; p; p = p->next) 87 { 88 fprintf(fp, "%s%s", p->name, 89 ((more || p->next) ? ", " : "")); 90 } 91 } 92 93 static void 94 write_code_lineno(FILE * fp) 95 { 96 if (!lflag && (fp == code_file)) 97 { 98 ++outline; 99 fprintf(fp, line_format, outline + 1, code_file_name); 100 } 101 } 102 103 static void 104 write_input_lineno(void) 105 { 106 if (!lflag) 107 { 108 ++outline; 109 fprintf(code_file, line_format, lineno, input_file_name); 110 } 111 } 112 113 static void 114 define_prefixed(FILE * fp, const char *name) 115 { 116 int bump_line = CountLine(fp); 117 if (bump_line) 118 ++outline; 119 fprintf(fp, "\n"); 120 121 if (bump_line) 122 ++outline; 123 fprintf(fp, "#ifndef %s\n", name); 124 125 if (bump_line) 126 ++outline; 127 fprintf(fp, "#define %-10s %s%s\n", name, symbol_prefix, name + 2); 128 129 if (bump_line) 130 ++outline; 131 fprintf(fp, "#endif /* %s */\n", name); 132 } 133 134 static void 135 output_prefix(FILE * fp) 136 { 137 if (symbol_prefix == NULL) 138 { 139 symbol_prefix = "yy"; 140 } 141 else 142 { 143 define_prefixed(fp, "yyparse"); 144 define_prefixed(fp, "yylex"); 145 define_prefixed(fp, "yyerror"); 146 define_prefixed(fp, "yychar"); 147 define_prefixed(fp, "yyval"); 148 define_prefixed(fp, "yylval"); 149 define_prefixed(fp, "yydebug"); 150 define_prefixed(fp, "yynerrs"); 151 define_prefixed(fp, "yyerrflag"); 152 define_prefixed(fp, "yylhs"); 153 define_prefixed(fp, "yylen"); 154 define_prefixed(fp, "yydefred"); 155 #if defined(YYBTYACC) 156 define_prefixed(fp, "yystos"); 157 #endif 158 define_prefixed(fp, "yydgoto"); 159 define_prefixed(fp, "yysindex"); 160 define_prefixed(fp, "yyrindex"); 161 define_prefixed(fp, "yygindex"); 162 define_prefixed(fp, "yytable"); 163 define_prefixed(fp, "yycheck"); 164 define_prefixed(fp, "yyname"); 165 define_prefixed(fp, "yyrule"); 166 #if defined(YYBTYACC) 167 if (locations) 168 { 169 define_prefixed(fp, "yyloc"); 170 define_prefixed(fp, "yylloc"); 171 } 172 putc_code(fp, '\n'); 173 putl_code(fp, "#if YYBTYACC\n"); 174 175 define_prefixed(fp, "yycindex"); 176 define_prefixed(fp, "yyctable"); 177 178 putc_code(fp, '\n'); 179 putl_code(fp, "#endif /* YYBTYACC */\n"); 180 putc_code(fp, '\n'); 181 #endif 182 } 183 if (CountLine(fp)) 184 ++outline; 185 fprintf(fp, "#define YYPREFIX \"%s\"\n", symbol_prefix); 186 } 187 188 static void 189 output_newline(void) 190 { 191 if (!rflag) 192 ++outline; 193 putc('\n', output_file); 194 } 195 196 static void 197 output_line(const char *value) 198 { 199 fputs(value, output_file); 200 output_newline(); 201 } 202 203 static void 204 output_int(int value) 205 { 206 fprintf(output_file, "%5d,", value); 207 } 208 209 static void 210 start_int_table(const char *name, int value) 211 { 212 int need = 34 - (int)(strlen(symbol_prefix) + strlen(name)); 213 214 if (need < 6) 215 need = 6; 216 fprintf(output_file, 217 "%sconst YYINT %s%s[] = {%*d,", 218 StaticOrR, symbol_prefix, name, need, value); 219 } 220 221 static void 222 start_str_table(const char *name) 223 { 224 fprintf(output_file, 225 "%sconst char *const %s%s[] = {", 226 StaticOrR, symbol_prefix, name); 227 output_newline(); 228 } 229 230 static void 231 end_table(void) 232 { 233 output_newline(); 234 output_line("};"); 235 } 236 237 static void 238 output_YYINT_typedef(FILE * fp) 239 { 240 /* generate the type used to index the various parser tables */ 241 if (CountLine(fp)) 242 ++outline; 243 fprintf(fp, "typedef %s YYINT;\n", CONCAT1("", YYINT)); 244 } 245 246 static void 247 output_rule_data(void) 248 { 249 int i; 250 int j; 251 252 output_YYINT_typedef(output_file); 253 254 start_int_table("lhs", symbol_value[start_symbol]); 255 256 j = 10; 257 for (i = 3; i < nrules; i++) 258 { 259 if (j >= 10) 260 { 261 output_newline(); 262 j = 1; 263 } 264 else 265 ++j; 266 267 output_int(symbol_value[rlhs[i]]); 268 } 269 end_table(); 270 271 start_int_table("len", 2); 272 273 j = 10; 274 for (i = 3; i < nrules; i++) 275 { 276 if (j >= 10) 277 { 278 output_newline(); 279 j = 1; 280 } 281 else 282 j++; 283 284 output_int(rrhs[i + 1] - rrhs[i] - 1); 285 } 286 end_table(); 287 } 288 289 static void 290 output_yydefred(void) 291 { 292 int i, j; 293 294 start_int_table("defred", (defred[0] ? defred[0] - 2 : 0)); 295 296 j = 10; 297 for (i = 1; i < nstates; i++) 298 { 299 if (j < 10) 300 ++j; 301 else 302 { 303 output_newline(); 304 j = 1; 305 } 306 307 output_int((defred[i] ? defred[i] - 2 : 0)); 308 } 309 310 end_table(); 311 } 312 313 #if defined(YYBTYACC) 314 static void 315 output_accessing_symbols(void) 316 { 317 int i, j; 318 int *translate; 319 320 if (nstates != 0) 321 { 322 translate = TMALLOC(int, nstates); 323 NO_SPACE(translate); 324 325 for (i = 0; i < nstates; ++i) 326 { 327 int gsymb = accessing_symbol[i]; 328 329 translate[i] = symbol_pval[gsymb]; 330 } 331 332 /* yystos[] may be unused, depending on compile-time defines */ 333 start_int_table("stos", translate[0]); 334 335 j = 10; 336 for (i = 1; i < nstates; ++i) 337 { 338 if (j < 10) 339 ++j; 340 else 341 { 342 output_newline(); 343 j = 1; 344 } 345 346 output_int(translate[i]); 347 } 348 349 end_table(); 350 FREE(translate); 351 } 352 } 353 354 static Value_t 355 find_conflict_base(int cbase) 356 { 357 int i, j; 358 359 for (i = 0; i < cbase; i++) 360 { 361 for (j = 0; j + cbase < nconflicts; j++) 362 { 363 if (conflicts[i + j] != conflicts[cbase + j]) 364 break; 365 } 366 if (j + cbase >= nconflicts) 367 break; 368 } 369 return (Value_t) i; 370 } 371 #endif 372 373 static void 374 token_actions(void) 375 { 376 int i, j; 377 Value_t shiftcount, reducecount; 378 #if defined(YYBTYACC) 379 Value_t conflictcount = 0; 380 Value_t csym = -1; 381 Value_t cbase = 0; 382 #endif 383 int max, min; 384 Value_t *actionrow, *r, *s; 385 action *p; 386 387 actionrow = NEW2(PER_STATE * ntokens, Value_t); 388 for (i = 0; i < nstates; ++i) 389 { 390 if (parser[i]) 391 { 392 for (j = 0; j < PER_STATE * ntokens; ++j) 393 actionrow[j] = 0; 394 395 shiftcount = 0; 396 reducecount = 0; 397 #if defined(YYBTYACC) 398 if (backtrack) 399 { 400 conflictcount = 0; 401 csym = -1; 402 cbase = nconflicts; 403 } 404 #endif 405 for (p = parser[i]; p; p = p->next) 406 { 407 #if defined(YYBTYACC) 408 if (backtrack) 409 { 410 if (csym != -1 && csym != p->symbol) 411 { 412 conflictcount++; 413 conflicts[nconflicts++] = -1; 414 j = find_conflict_base(cbase); 415 actionrow[csym + 2 * ntokens] = (Value_t) (j + 1); 416 if (j == cbase) 417 { 418 cbase = nconflicts; 419 } 420 else 421 { 422 if (conflicts[cbase] == -1) 423 cbase++; 424 nconflicts = cbase; 425 } 426 csym = -1; 427 } 428 } 429 #endif 430 if (p->suppressed == 0) 431 { 432 if (p->action_code == SHIFT) 433 { 434 ++shiftcount; 435 actionrow[p->symbol] = p->number; 436 } 437 else if (p->action_code == REDUCE && p->number != defred[i]) 438 { 439 ++reducecount; 440 actionrow[p->symbol + ntokens] = p->number; 441 } 442 } 443 #if defined(YYBTYACC) 444 else if (backtrack && p->suppressed == 1) 445 { 446 csym = p->symbol; 447 if (p->action_code == SHIFT) 448 { 449 conflicts[nconflicts++] = p->number; 450 } 451 else if (p->action_code == REDUCE && p->number != defred[i]) 452 { 453 if (cbase == nconflicts) 454 { 455 if (cbase) 456 cbase--; 457 else 458 conflicts[nconflicts++] = -1; 459 } 460 conflicts[nconflicts++] = (Value_t) (p->number - 2); 461 } 462 } 463 #endif 464 } 465 #if defined(YYBTYACC) 466 if (backtrack && csym != -1) 467 { 468 conflictcount++; 469 conflicts[nconflicts++] = -1; 470 j = find_conflict_base(cbase); 471 actionrow[csym + 2 * ntokens] = (Value_t) (j + 1); 472 if (j == cbase) 473 { 474 cbase = nconflicts; 475 } 476 else 477 { 478 if (conflicts[cbase] == -1) 479 cbase++; 480 nconflicts = cbase; 481 } 482 } 483 #endif 484 485 tally[i] = shiftcount; 486 tally[nstates + i] = reducecount; 487 #if defined(YYBTYACC) 488 if (backtrack) 489 tally[2 * nstates + i] = conflictcount; 490 #endif 491 width[i] = 0; 492 width[nstates + i] = 0; 493 #if defined(YYBTYACC) 494 if (backtrack) 495 width[2 * nstates + i] = 0; 496 #endif 497 if (shiftcount > 0) 498 { 499 froms[i] = r = NEW2(shiftcount, Value_t); 500 tos[i] = s = NEW2(shiftcount, Value_t); 501 min = MAXYYINT; 502 max = 0; 503 for (j = 0; j < ntokens; ++j) 504 { 505 if (actionrow[j]) 506 { 507 if (min > symbol_value[j]) 508 min = symbol_value[j]; 509 if (max < symbol_value[j]) 510 max = symbol_value[j]; 511 *r++ = symbol_value[j]; 512 *s++ = actionrow[j]; 513 } 514 } 515 width[i] = (Value_t) (max - min + 1); 516 } 517 if (reducecount > 0) 518 { 519 froms[nstates + i] = r = NEW2(reducecount, Value_t); 520 tos[nstates + i] = s = NEW2(reducecount, Value_t); 521 min = MAXYYINT; 522 max = 0; 523 for (j = 0; j < ntokens; ++j) 524 { 525 if (actionrow[ntokens + j]) 526 { 527 if (min > symbol_value[j]) 528 min = symbol_value[j]; 529 if (max < symbol_value[j]) 530 max = symbol_value[j]; 531 *r++ = symbol_value[j]; 532 *s++ = (Value_t) (actionrow[ntokens + j] - 2); 533 } 534 } 535 width[nstates + i] = (Value_t) (max - min + 1); 536 } 537 #if defined(YYBTYACC) 538 if (backtrack && conflictcount > 0) 539 { 540 froms[2 * nstates + i] = r = NEW2(conflictcount, Value_t); 541 tos[2 * nstates + i] = s = NEW2(conflictcount, Value_t); 542 min = MAXYYINT; 543 max = 0; 544 for (j = 0; j < ntokens; ++j) 545 { 546 if (actionrow[2 * ntokens + j]) 547 { 548 if (min > symbol_value[j]) 549 min = symbol_value[j]; 550 if (max < symbol_value[j]) 551 max = symbol_value[j]; 552 *r++ = symbol_value[j]; 553 *s++ = (Value_t) (actionrow[2 * ntokens + j] - 1); 554 } 555 } 556 width[2 * nstates + i] = (Value_t) (max - min + 1); 557 } 558 #endif 559 } 560 } 561 FREE(actionrow); 562 } 563 564 static int 565 default_goto(int symbol) 566 { 567 int i; 568 int m; 569 int n; 570 int default_state; 571 int max; 572 573 m = goto_map[symbol]; 574 n = goto_map[symbol + 1]; 575 576 if (m == n) 577 return (0); 578 579 for (i = 0; i < nstates; i++) 580 state_count[i] = 0; 581 582 for (i = m; i < n; i++) 583 state_count[to_state[i]]++; 584 585 max = 0; 586 default_state = 0; 587 for (i = 0; i < nstates; i++) 588 { 589 if (state_count[i] > max) 590 { 591 max = state_count[i]; 592 default_state = i; 593 } 594 } 595 596 return (default_state); 597 } 598 599 static void 600 save_column(int symbol, int default_state) 601 { 602 int i; 603 int m; 604 int n; 605 Value_t *sp; 606 Value_t *sp1; 607 Value_t *sp2; 608 Value_t count; 609 int symno; 610 611 m = goto_map[symbol]; 612 n = goto_map[symbol + 1]; 613 614 count = 0; 615 for (i = m; i < n; i++) 616 { 617 if (to_state[i] != default_state) 618 ++count; 619 } 620 if (count == 0) 621 return; 622 623 symno = symbol_value[symbol] + PER_STATE * nstates; 624 625 froms[symno] = sp1 = sp = NEW2(count, Value_t); 626 tos[symno] = sp2 = NEW2(count, Value_t); 627 628 for (i = m; i < n; i++) 629 { 630 if (to_state[i] != default_state) 631 { 632 *sp1++ = from_state[i]; 633 *sp2++ = to_state[i]; 634 } 635 } 636 637 tally[symno] = count; 638 width[symno] = (Value_t) (sp1[-1] - sp[0] + 1); 639 } 640 641 static void 642 goto_actions(void) 643 { 644 int i, j, k; 645 646 state_count = NEW2(nstates, Value_t); 647 648 k = default_goto(start_symbol + 1); 649 start_int_table("dgoto", k); 650 save_column(start_symbol + 1, k); 651 652 j = 10; 653 for (i = start_symbol + 2; i < nsyms; i++) 654 { 655 if (j >= 10) 656 { 657 output_newline(); 658 j = 1; 659 } 660 else 661 ++j; 662 663 k = default_goto(i); 664 output_int(k); 665 save_column(i, k); 666 } 667 668 end_table(); 669 FREE(state_count); 670 } 671 672 static void 673 sort_actions(void) 674 { 675 Value_t i; 676 int j; 677 int k; 678 int t; 679 int w; 680 681 order = NEW2(nvectors, Value_t); 682 nentries = 0; 683 684 for (i = 0; i < nvectors; i++) 685 { 686 if (tally[i] > 0) 687 { 688 t = tally[i]; 689 w = width[i]; 690 j = nentries - 1; 691 692 while (j >= 0 && (width[order[j]] < w)) 693 j--; 694 695 while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t)) 696 j--; 697 698 for (k = nentries - 1; k > j; k--) 699 order[k + 1] = order[k]; 700 701 order[j + 1] = i; 702 nentries++; 703 } 704 } 705 } 706 707 /* The function matching_vector determines if the vector specified by */ 708 /* the input parameter matches a previously considered vector. The */ 709 /* test at the start of the function checks if the vector represents */ 710 /* a row of shifts over terminal symbols or a row of reductions, or a */ 711 /* column of shifts over a nonterminal symbol. Berkeley Yacc does not */ 712 /* check if a column of shifts over a nonterminal symbols matches a */ 713 /* previously considered vector. Because of the nature of LR parsing */ 714 /* tables, no two columns can match. Therefore, the only possible */ 715 /* match would be between a row and a column. Such matches are */ 716 /* unlikely. Therefore, to save time, no attempt is made to see if a */ 717 /* column matches a previously considered vector. */ 718 /* */ 719 /* Matching_vector is poorly designed. The test could easily be made */ 720 /* faster. Also, it depends on the vectors being in a specific */ 721 /* order. */ 722 #if defined(YYBTYACC) 723 /* */ 724 /* Not really any point in checking for matching conflicts -- it is */ 725 /* extremely unlikely to occur, and conflicts are (hopefully) rare. */ 726 #endif 727 728 static int 729 matching_vector(int vector) 730 { 731 int i; 732 int j; 733 int k; 734 int t; 735 int w; 736 int match; 737 int prev; 738 739 i = order[vector]; 740 if (i >= 2 * nstates) 741 return (-1); 742 743 t = tally[i]; 744 w = width[i]; 745 746 for (prev = vector - 1; prev >= 0; prev--) 747 { 748 j = order[prev]; 749 if (width[j] != w || tally[j] != t) 750 return (-1); 751 752 match = 1; 753 for (k = 0; match && k < t; k++) 754 { 755 if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k]) 756 match = 0; 757 } 758 759 if (match) 760 return (j); 761 } 762 763 return (-1); 764 } 765 766 static int 767 pack_vector(int vector) 768 { 769 int i, j, k, l; 770 int t; 771 int loc; 772 int ok; 773 Value_t *from; 774 Value_t *to; 775 int newmax; 776 777 i = order[vector]; 778 t = tally[i]; 779 assert(t); 780 781 from = froms[i]; 782 to = tos[i]; 783 784 j = lowzero - from[0]; 785 for (k = 1; k < t; ++k) 786 if (lowzero - from[k] > j) 787 j = lowzero - from[k]; 788 for (;; ++j) 789 { 790 if (j == 0) 791 continue; 792 ok = 1; 793 for (k = 0; ok && k < t; k++) 794 { 795 loc = j + from[k]; 796 if (loc >= maxtable - 1) 797 { 798 if (loc >= MAXTABLE - 1) 799 fatal("maximum table size exceeded"); 800 801 newmax = maxtable; 802 do 803 { 804 newmax += 200; 805 } 806 while (newmax <= loc); 807 808 table = TREALLOC(Value_t, table, newmax); 809 NO_SPACE(table); 810 811 check = TREALLOC(Value_t, check, newmax); 812 NO_SPACE(check); 813 814 for (l = maxtable; l < newmax; ++l) 815 { 816 table[l] = 0; 817 check[l] = -1; 818 } 819 maxtable = newmax; 820 } 821 822 if (check[loc] != -1) 823 ok = 0; 824 } 825 for (k = 0; ok && k < vector; k++) 826 { 827 if (pos[k] == j) 828 ok = 0; 829 } 830 if (ok) 831 { 832 for (k = 0; k < t; k++) 833 { 834 loc = j + from[k]; 835 table[loc] = to[k]; 836 check[loc] = from[k]; 837 if (loc > high) 838 high = loc; 839 } 840 841 while (check[lowzero] != -1) 842 ++lowzero; 843 844 return (j); 845 } 846 } 847 } 848 849 static void 850 pack_table(void) 851 { 852 int i; 853 Value_t place; 854 int state; 855 856 base = NEW2(nvectors, Value_t); 857 pos = NEW2(nentries, Value_t); 858 859 maxtable = 1000; 860 table = NEW2(maxtable, Value_t); 861 check = NEW2(maxtable, Value_t); 862 863 lowzero = 0; 864 high = 0; 865 866 for (i = 0; i < maxtable; i++) 867 check[i] = -1; 868 869 for (i = 0; i < nentries; i++) 870 { 871 state = matching_vector(i); 872 873 if (state < 0) 874 place = (Value_t) pack_vector(i); 875 else 876 place = base[state]; 877 878 pos[i] = place; 879 base[order[i]] = place; 880 } 881 882 for (i = 0; i < nvectors; i++) 883 { 884 if (froms[i]) 885 FREE(froms[i]); 886 if (tos[i]) 887 FREE(tos[i]); 888 } 889 890 DO_FREE(froms); 891 DO_FREE(tos); 892 DO_FREE(tally); 893 DO_FREE(width); 894 DO_FREE(pos); 895 } 896 897 static void 898 output_base(void) 899 { 900 int i, j; 901 902 start_int_table("sindex", base[0]); 903 904 j = 10; 905 for (i = 1; i < nstates; i++) 906 { 907 if (j >= 10) 908 { 909 output_newline(); 910 j = 1; 911 } 912 else 913 ++j; 914 915 output_int(base[i]); 916 } 917 918 end_table(); 919 920 start_int_table("rindex", base[nstates]); 921 922 j = 10; 923 for (i = nstates + 1; i < 2 * nstates; i++) 924 { 925 if (j >= 10) 926 { 927 output_newline(); 928 j = 1; 929 } 930 else 931 ++j; 932 933 output_int(base[i]); 934 } 935 936 end_table(); 937 938 #if defined(YYBTYACC) 939 output_line("#if YYBTYACC"); 940 start_int_table("cindex", base[2 * nstates]); 941 942 j = 10; 943 for (i = 2 * nstates + 1; i < 3 * nstates; i++) 944 { 945 if (j >= 10) 946 { 947 output_newline(); 948 j = 1; 949 } 950 else 951 ++j; 952 953 output_int(base[i]); 954 } 955 956 end_table(); 957 output_line("#endif"); 958 #endif 959 960 start_int_table("gindex", base[PER_STATE * nstates]); 961 962 j = 10; 963 for (i = PER_STATE * nstates + 1; i < nvectors - 1; i++) 964 { 965 if (j >= 10) 966 { 967 output_newline(); 968 j = 1; 969 } 970 else 971 ++j; 972 973 output_int(base[i]); 974 } 975 976 end_table(); 977 FREE(base); 978 } 979 980 static void 981 output_table(void) 982 { 983 int i; 984 int j; 985 986 if (high >= MAXYYINT) 987 { 988 fprintf(stderr, "YYTABLESIZE: %ld\n", high); 989 fprintf(stderr, "Table is longer than %d elements.\n", MAXYYINT); 990 done(1); 991 } 992 993 ++outline; 994 fprintf(code_file, "#define YYTABLESIZE %ld\n", high); 995 start_int_table("table", table[0]); 996 997 j = 10; 998 for (i = 1; i <= high; i++) 999 { 1000 if (j >= 10) 1001 { 1002 output_newline(); 1003 j = 1; 1004 } 1005 else 1006 ++j; 1007 1008 output_int(table[i]); 1009 } 1010 1011 end_table(); 1012 FREE(table); 1013 } 1014 1015 static void 1016 output_check(void) 1017 { 1018 int i; 1019 int j; 1020 1021 start_int_table("check", check[0]); 1022 1023 j = 10; 1024 for (i = 1; i <= high; i++) 1025 { 1026 if (j >= 10) 1027 { 1028 output_newline(); 1029 j = 1; 1030 } 1031 else 1032 ++j; 1033 1034 output_int(check[i]); 1035 } 1036 1037 end_table(); 1038 FREE(check); 1039 } 1040 1041 #if defined(YYBTYACC) 1042 static void 1043 output_ctable(void) 1044 { 1045 int i; 1046 int j; 1047 int limit = (conflicts != 0) ? nconflicts : 0; 1048 1049 if (limit < high) 1050 limit = (int)high; 1051 1052 output_line("#if YYBTYACC"); 1053 start_int_table("ctable", conflicts ? conflicts[0] : -1); 1054 1055 j = 10; 1056 for (i = 1; i < limit; i++) 1057 { 1058 if (j >= 10) 1059 { 1060 output_newline(); 1061 j = 1; 1062 } 1063 else 1064 ++j; 1065 1066 output_int((conflicts != 0 && i < nconflicts) ? conflicts[i] : -1); 1067 } 1068 1069 if (conflicts) 1070 FREE(conflicts); 1071 1072 end_table(); 1073 output_line("#endif"); 1074 } 1075 #endif 1076 1077 static void 1078 output_actions(void) 1079 { 1080 nvectors = PER_STATE * nstates + nvars; 1081 1082 froms = NEW2(nvectors, Value_t *); 1083 tos = NEW2(nvectors, Value_t *); 1084 tally = NEW2(nvectors, Value_t); 1085 width = NEW2(nvectors, Value_t); 1086 1087 #if defined(YYBTYACC) 1088 if (backtrack && (SRtotal + RRtotal) != 0) 1089 conflicts = NEW2(4 * (SRtotal + RRtotal), Value_t); 1090 #endif 1091 1092 token_actions(); 1093 FREE(lookaheads); 1094 FREE(LA); 1095 FREE(LAruleno); 1096 FREE(accessing_symbol); 1097 1098 goto_actions(); 1099 FREE(goto_base); 1100 FREE(from_state); 1101 FREE(to_state); 1102 1103 sort_actions(); 1104 pack_table(); 1105 output_base(); 1106 output_table(); 1107 output_check(); 1108 #if defined(YYBTYACC) 1109 output_ctable(); 1110 #endif 1111 } 1112 1113 static int 1114 is_C_identifier(char *name) 1115 { 1116 char *s; 1117 int c; 1118 1119 s = name; 1120 c = *s; 1121 if (c == '"') 1122 { 1123 c = *++s; 1124 if (!isalpha(c) && c != '_' && c != '$') 1125 return (0); 1126 while ((c = *++s) != '"') 1127 { 1128 if (!isalnum(c) && c != '_' && c != '$') 1129 return (0); 1130 } 1131 return (1); 1132 } 1133 1134 if (!isalpha(c) && c != '_' && c != '$') 1135 return (0); 1136 while ((c = *++s) != 0) 1137 { 1138 if (!isalnum(c) && c != '_' && c != '$') 1139 return (0); 1140 } 1141 return (1); 1142 } 1143 1144 #if USE_HEADER_GUARDS 1145 static void 1146 start_defines_file(void) 1147 { 1148 fprintf(defines_file, "#ifndef _%s_defines_h_\n", symbol_prefix); 1149 fprintf(defines_file, "#define _%s_defines_h_\n\n", symbol_prefix); 1150 } 1151 1152 static void 1153 end_defines_file(void) 1154 { 1155 fprintf(defines_file, "\n#endif /* _%s_defines_h_ */\n", symbol_prefix); 1156 } 1157 #else 1158 #define start_defines_file() /* nothing */ 1159 #define end_defines_file() /* nothing */ 1160 #endif 1161 1162 static void 1163 output_defines(FILE * fp) 1164 { 1165 int c, i; 1166 char *s; 1167 1168 for (i = 2; i < ntokens; ++i) 1169 { 1170 s = symbol_name[i]; 1171 if (is_C_identifier(s) && (!sflag || *s != '"')) 1172 { 1173 fprintf(fp, "#define "); 1174 c = *s; 1175 if (c == '"') 1176 { 1177 while ((c = *++s) != '"') 1178 { 1179 putc(c, fp); 1180 } 1181 } 1182 else 1183 { 1184 do 1185 { 1186 putc(c, fp); 1187 } 1188 while ((c = *++s) != 0); 1189 } 1190 if (fp == code_file) 1191 ++outline; 1192 fprintf(fp, " %d\n", symbol_value[i]); 1193 } 1194 } 1195 1196 if (fp == code_file) 1197 ++outline; 1198 if (fp != defines_file || iflag) 1199 fprintf(fp, "#define YYERRCODE %d\n", symbol_value[1]); 1200 1201 if (fp == defines_file || (iflag && !dflag)) 1202 { 1203 if (unionized) 1204 { 1205 if (union_file != 0) 1206 { 1207 rewind(union_file); 1208 while ((c = getc(union_file)) != EOF) 1209 putc_code(fp, c); 1210 } 1211 fprintf(fp, "extern YYSTYPE %slval;\n", symbol_prefix); 1212 } 1213 } 1214 } 1215 1216 static void 1217 output_stored_text(FILE * fp) 1218 { 1219 int c; 1220 FILE *in; 1221 1222 rewind(text_file); 1223 if (text_file == NULL) 1224 open_error("text_file"); 1225 in = text_file; 1226 if ((c = getc(in)) == EOF) 1227 return; 1228 putc_code(fp, c); 1229 while ((c = getc(in)) != EOF) 1230 { 1231 putc_code(fp, c); 1232 } 1233 write_code_lineno(fp); 1234 } 1235 1236 static void 1237 output_debug(void) 1238 { 1239 int i, j, k, max, maxtok; 1240 const char **symnam; 1241 const char *s; 1242 1243 ++outline; 1244 fprintf(code_file, "#define YYFINAL %d\n", final_state); 1245 1246 putl_code(code_file, "#ifndef YYDEBUG\n"); 1247 ++outline; 1248 fprintf(code_file, "#define YYDEBUG %d\n", tflag); 1249 putl_code(code_file, "#endif\n"); 1250 1251 if (rflag) 1252 { 1253 fprintf(output_file, "#ifndef YYDEBUG\n"); 1254 fprintf(output_file, "#define YYDEBUG %d\n", tflag); 1255 fprintf(output_file, "#endif\n"); 1256 } 1257 1258 maxtok = 0; 1259 for (i = 0; i < ntokens; ++i) 1260 if (symbol_value[i] > maxtok) 1261 maxtok = symbol_value[i]; 1262 1263 /* symbol_value[$accept] = -1 */ 1264 /* symbol_value[<goal>] = 0 */ 1265 /* remaining non-terminals start at 1 */ 1266 max = maxtok; 1267 for (i = ntokens; i < nsyms; ++i) 1268 if (((maxtok + 1) + (symbol_value[i] + 1)) > max) 1269 max = (maxtok + 1) + (symbol_value[i] + 1); 1270 1271 ++outline; 1272 fprintf(code_file, "#define YYMAXTOKEN %d\n", maxtok); 1273 1274 ++outline; 1275 fprintf(code_file, "#define YYUNDFTOKEN %d\n", max + 1); 1276 1277 ++outline; 1278 fprintf(code_file, "#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? " 1279 "YYUNDFTOKEN : (a))\n"); 1280 1281 symnam = TMALLOC(const char *, max + 2); 1282 NO_SPACE(symnam); 1283 1284 /* Note that it is not necessary to initialize the element */ 1285 /* symnam[max]. */ 1286 #if defined(YYBTYACC) 1287 for (i = 0; i < max; ++i) 1288 symnam[i] = 0; 1289 for (i = nsyms - 1; i >= 0; --i) 1290 symnam[symbol_pval[i]] = symbol_name[i]; 1291 symnam[max + 1] = "illegal-symbol"; 1292 #else 1293 for (i = 0; i <= max; ++i) 1294 symnam[i] = 0; 1295 for (i = ntokens - 1; i >= 2; --i) 1296 symnam[symbol_value[i]] = symbol_name[i]; 1297 symnam[0] = "end-of-file"; 1298 symnam[max + 1] = "illegal-symbol"; 1299 #endif 1300 1301 /* 1302 * bison's yytname[] array is roughly the same as byacc's yyname[] array. 1303 * The difference is that byacc does not predefine "$undefined". 1304 * 1305 * If the grammar declares "%token-table", define symbol "yytname" so 1306 * an application such as ntpd can build. 1307 */ 1308 if (token_table) 1309 { 1310 output_line("#undef yytname"); 1311 output_line("#define yytname yyname"); 1312 } 1313 else 1314 { 1315 output_line("#if YYDEBUG"); 1316 } 1317 1318 start_str_table("name"); 1319 j = 80; 1320 for (i = 0; i <= max + 1; ++i) 1321 { 1322 if ((s = symnam[i]) != 0) 1323 { 1324 if (s[0] == '"') 1325 { 1326 k = 7; 1327 while (*++s != '"') 1328 { 1329 ++k; 1330 if (*s == '\\') 1331 { 1332 k += 2; 1333 if (*++s == '\\') 1334 ++k; 1335 } 1336 } 1337 j += k; 1338 if (j > 80) 1339 { 1340 output_newline(); 1341 j = k; 1342 } 1343 fprintf(output_file, "\"\\\""); 1344 s = symnam[i]; 1345 while (*++s != '"') 1346 { 1347 if (*s == '\\') 1348 { 1349 fprintf(output_file, "\\\\"); 1350 if (*++s == '\\') 1351 fprintf(output_file, "\\\\"); 1352 else 1353 putc(*s, output_file); 1354 } 1355 else 1356 putc(*s, output_file); 1357 } 1358 fprintf(output_file, "\\\"\","); 1359 } 1360 else if (s[0] == '\'') 1361 { 1362 if (s[1] == '"') 1363 { 1364 j += 7; 1365 if (j > 80) 1366 { 1367 output_newline(); 1368 j = 7; 1369 } 1370 fprintf(output_file, "\"'\\\"'\","); 1371 } 1372 else 1373 { 1374 k = 5; 1375 while (*++s != '\'') 1376 { 1377 ++k; 1378 if (*s == '\\') 1379 { 1380 k += 2; 1381 if (*++s == '\\') 1382 ++k; 1383 } 1384 } 1385 j += k; 1386 if (j > 80) 1387 { 1388 output_newline(); 1389 j = k; 1390 } 1391 fprintf(output_file, "\"'"); 1392 s = symnam[i]; 1393 while (*++s != '\'') 1394 { 1395 if (*s == '\\') 1396 { 1397 fprintf(output_file, "\\\\"); 1398 if (*++s == '\\') 1399 fprintf(output_file, "\\\\"); 1400 else 1401 putc(*s, output_file); 1402 } 1403 else 1404 putc(*s, output_file); 1405 } 1406 fprintf(output_file, "'\","); 1407 } 1408 } 1409 else 1410 { 1411 k = (int)strlen(s) + 3; 1412 j += k; 1413 if (j > 80) 1414 { 1415 output_newline(); 1416 j = k; 1417 } 1418 putc('"', output_file); 1419 do 1420 { 1421 putc(*s, output_file); 1422 } 1423 while (*++s); 1424 fprintf(output_file, "\","); 1425 } 1426 } 1427 else 1428 { 1429 j += 2; 1430 if (j > 80) 1431 { 1432 output_newline(); 1433 j = 2; 1434 } 1435 fprintf(output_file, "0,"); 1436 } 1437 } 1438 end_table(); 1439 FREE(symnam); 1440 1441 if (token_table) 1442 output_line("#if YYDEBUG"); 1443 start_str_table("rule"); 1444 for (i = 2; i < nrules; ++i) 1445 { 1446 fprintf(output_file, "\"%s :", symbol_name[rlhs[i]]); 1447 for (j = rrhs[i]; ritem[j] > 0; ++j) 1448 { 1449 s = symbol_name[ritem[j]]; 1450 if (s[0] == '"') 1451 { 1452 fprintf(output_file, " \\\""); 1453 while (*++s != '"') 1454 { 1455 if (*s == '\\') 1456 { 1457 if (s[1] == '\\') 1458 fprintf(output_file, "\\\\\\\\"); 1459 else 1460 fprintf(output_file, "\\\\%c", s[1]); 1461 ++s; 1462 } 1463 else 1464 putc(*s, output_file); 1465 } 1466 fprintf(output_file, "\\\""); 1467 } 1468 else if (s[0] == '\'') 1469 { 1470 if (s[1] == '"') 1471 fprintf(output_file, " '\\\"'"); 1472 else if (s[1] == '\\') 1473 { 1474 if (s[2] == '\\') 1475 fprintf(output_file, " '\\\\\\\\"); 1476 else 1477 fprintf(output_file, " '\\\\%c", s[2]); 1478 s += 2; 1479 while (*++s != '\'') 1480 putc(*s, output_file); 1481 putc('\'', output_file); 1482 } 1483 else 1484 fprintf(output_file, " '%c'", s[1]); 1485 } 1486 else 1487 fprintf(output_file, " %s", s); 1488 } 1489 fprintf(output_file, "\","); 1490 output_newline(); 1491 } 1492 1493 end_table(); 1494 output_line("#endif"); 1495 } 1496 1497 #if defined(YYBTYACC) 1498 static void 1499 output_backtracking_parser(FILE * fp) 1500 { 1501 putl_code(fp, "#undef YYBTYACC\n"); 1502 #if defined(YYBTYACC) 1503 if (backtrack) 1504 { 1505 putl_code(fp, "#define YYBTYACC 1\n"); 1506 putl_code(fp, 1507 "#define YYDEBUGSTR (yytrial ? YYPREFIX \"debug(trial)\" : YYPREFIX \"debug\")\n"); 1508 } 1509 else 1510 #endif 1511 { 1512 putl_code(fp, "#define YYBTYACC 0\n"); 1513 putl_code(fp, "#define YYDEBUGSTR YYPREFIX \"debug\"\n"); 1514 } 1515 } 1516 #endif 1517 1518 static void 1519 output_pure_parser(FILE * fp) 1520 { 1521 putc_code(fp, '\n'); 1522 1523 if (fp == code_file) 1524 ++outline; 1525 fprintf(fp, "#define YYPURE %d\n", pure_parser); 1526 putc_code(fp, '\n'); 1527 } 1528 1529 static void 1530 output_stype(FILE * fp) 1531 { 1532 if (!unionized && ntags == 0) 1533 { 1534 putc_code(fp, '\n'); 1535 putl_code(fp, "#if " 1536 "! defined(YYSTYPE) && " 1537 "! defined(YYSTYPE_IS_DECLARED)\n"); 1538 putl_code(fp, "/* Default: YYSTYPE is the semantic value type. */\n"); 1539 putl_code(fp, "typedef int YYSTYPE;\n"); 1540 putl_code(fp, "# define YYSTYPE_IS_DECLARED 1\n"); 1541 putl_code(fp, "#endif\n"); 1542 } 1543 } 1544 1545 #if defined(YYBTYACC) 1546 static void 1547 output_ltype(FILE * fp) 1548 { 1549 putc_code(fp, '\n'); 1550 putl_code(fp, "#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED\n"); 1551 putl_code(fp, "/* Default: YYLTYPE is the text position type. */\n"); 1552 putl_code(fp, "typedef struct YYLTYPE\n"); 1553 putl_code(fp, "{\n"); 1554 putl_code(fp, " int first_line;\n"); 1555 putl_code(fp, " int first_column;\n"); 1556 putl_code(fp, " int last_line;\n"); 1557 putl_code(fp, " int last_column;\n"); 1558 putl_code(fp, "} YYLTYPE;\n"); 1559 putl_code(fp, "#define YYLTYPE_IS_DECLARED 1\n"); 1560 putl_code(fp, "#endif\n"); 1561 } 1562 #endif 1563 1564 static void 1565 output_trailing_text(void) 1566 { 1567 int c, last; 1568 FILE *in; 1569 1570 if (line == 0) 1571 return; 1572 1573 in = input_file; 1574 c = *cptr; 1575 if (c == '\n') 1576 { 1577 ++lineno; 1578 if ((c = getc(in)) == EOF) 1579 return; 1580 write_input_lineno(); 1581 putc_code(code_file, c); 1582 last = c; 1583 } 1584 else 1585 { 1586 write_input_lineno(); 1587 do 1588 { 1589 putc_code(code_file, c); 1590 } 1591 while ((c = *++cptr) != '\n'); 1592 putc_code(code_file, c); 1593 last = '\n'; 1594 } 1595 1596 while ((c = getc(in)) != EOF) 1597 { 1598 putc_code(code_file, c); 1599 last = c; 1600 } 1601 1602 if (last != '\n') 1603 { 1604 putc_code(code_file, '\n'); 1605 } 1606 write_code_lineno(code_file); 1607 } 1608 1609 static void 1610 output_semantic_actions(void) 1611 { 1612 int c, last; 1613 1614 rewind(action_file); 1615 if ((c = getc(action_file)) == EOF) 1616 return; 1617 1618 last = c; 1619 putc_code(code_file, c); 1620 while ((c = getc(action_file)) != EOF) 1621 { 1622 putc_code(code_file, c); 1623 last = c; 1624 } 1625 1626 if (last != '\n') 1627 { 1628 putc_code(code_file, '\n'); 1629 } 1630 1631 write_code_lineno(code_file); 1632 } 1633 1634 static void 1635 output_parse_decl(FILE * fp) 1636 { 1637 putc_code(fp, '\n'); 1638 putl_code(fp, "/* compatibility with bison */\n"); 1639 putl_code(fp, "#ifdef YYPARSE_PARAM\n"); 1640 putl_code(fp, "/* compatibility with FreeBSD */\n"); 1641 putl_code(fp, "# ifdef YYPARSE_PARAM_TYPE\n"); 1642 putl_code(fp, 1643 "# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)\n"); 1644 putl_code(fp, "# else\n"); 1645 putl_code(fp, "# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)\n"); 1646 putl_code(fp, "# endif\n"); 1647 putl_code(fp, "#else\n"); 1648 1649 puts_code(fp, "# define YYPARSE_DECL() yyparse("); 1650 puts_param_types(fp, parse_param, 0); 1651 putl_code(fp, ")\n"); 1652 1653 putl_code(fp, "#endif\n"); 1654 } 1655 1656 static void 1657 output_lex_decl(FILE * fp) 1658 { 1659 putc_code(fp, '\n'); 1660 putl_code(fp, "/* Parameters sent to lex. */\n"); 1661 putl_code(fp, "#ifdef YYLEX_PARAM\n"); 1662 if (pure_parser) 1663 { 1664 putl_code(fp, "# ifdef YYLEX_PARAM_TYPE\n"); 1665 #if defined(YYBTYACC) 1666 if (locations) 1667 { 1668 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval," 1669 " YYLTYPE *yylloc," 1670 " YYLEX_PARAM_TYPE YYLEX_PARAM)\n"); 1671 } 1672 else 1673 #endif 1674 { 1675 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval," 1676 " YYLEX_PARAM_TYPE YYLEX_PARAM)\n"); 1677 } 1678 putl_code(fp, "# else\n"); 1679 #if defined(YYBTYACC) 1680 if (locations) 1681 { 1682 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval," 1683 " YYLTYPE *yylloc," 1684 " void * YYLEX_PARAM)\n"); 1685 } 1686 else 1687 #endif 1688 { 1689 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval," 1690 " void * YYLEX_PARAM)\n"); 1691 } 1692 putl_code(fp, "# endif\n"); 1693 #if defined(YYBTYACC) 1694 if (locations) 1695 putl_code(fp, 1696 "# define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)\n"); 1697 else 1698 #endif 1699 putl_code(fp, "# define YYLEX yylex(&yylval, YYLEX_PARAM)\n"); 1700 } 1701 else 1702 { 1703 putl_code(fp, "# define YYLEX_DECL() yylex(void *YYLEX_PARAM)\n"); 1704 putl_code(fp, "# define YYLEX yylex(YYLEX_PARAM)\n"); 1705 } 1706 putl_code(fp, "#else\n"); 1707 if (pure_parser && lex_param) 1708 { 1709 #if defined(YYBTYACC) 1710 if (locations) 1711 puts_code(fp, 1712 "# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLTYPE *yylloc, "); 1713 else 1714 #endif 1715 puts_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval, "); 1716 puts_param_types(fp, lex_param, 0); 1717 putl_code(fp, ")\n"); 1718 1719 #if defined(YYBTYACC) 1720 if (locations) 1721 puts_code(fp, "# define YYLEX yylex(&yylval, &yylloc, "); 1722 else 1723 #endif 1724 puts_code(fp, "# define YYLEX yylex(&yylval, "); 1725 puts_param_names(fp, lex_param, 0); 1726 putl_code(fp, ")\n"); 1727 } 1728 else if (pure_parser) 1729 { 1730 #if defined(YYBTYACC) 1731 if (locations) 1732 { 1733 putl_code(fp, 1734 "# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLTYPE *yylloc)\n"); 1735 putl_code(fp, "# define YYLEX yylex(&yylval, &yylloc)\n"); 1736 } 1737 else 1738 #endif 1739 { 1740 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval)\n"); 1741 putl_code(fp, "# define YYLEX yylex(&yylval)\n"); 1742 } 1743 } 1744 else if (lex_param) 1745 { 1746 puts_code(fp, "# define YYLEX_DECL() yylex("); 1747 puts_param_types(fp, lex_param, 0); 1748 putl_code(fp, ")\n"); 1749 1750 puts_code(fp, "# define YYLEX yylex("); 1751 puts_param_names(fp, lex_param, 0); 1752 putl_code(fp, ")\n"); 1753 } 1754 else 1755 { 1756 putl_code(fp, "# define YYLEX_DECL() yylex(void)\n"); 1757 putl_code(fp, "# define YYLEX yylex()\n"); 1758 } 1759 putl_code(fp, "#endif\n"); 1760 } 1761 1762 static void 1763 output_error_decl(FILE * fp) 1764 { 1765 putc_code(fp, '\n'); 1766 putl_code(fp, "/* Parameters sent to yyerror. */\n"); 1767 putl_code(fp, "#ifndef YYERROR_DECL\n"); 1768 puts_code(fp, "#define YYERROR_DECL() yyerror("); 1769 #if defined(YYBTYACC) 1770 if (locations) 1771 puts_code(fp, "YYLTYPE loc, "); 1772 #endif 1773 puts_param_types(fp, parse_param, 1); 1774 putl_code(fp, "const char *s)\n"); 1775 putl_code(fp, "#endif\n"); 1776 1777 putl_code(fp, "#ifndef YYERROR_CALL\n"); 1778 1779 puts_code(fp, "#define YYERROR_CALL(msg) yyerror("); 1780 #if defined(YYBTYACC) 1781 if (locations) 1782 puts_code(fp, "yylloc, "); 1783 #endif 1784 puts_param_names(fp, parse_param, 1); 1785 putl_code(fp, "msg)\n"); 1786 1787 putl_code(fp, "#endif\n"); 1788 } 1789 1790 #if defined(YYBTYACC) 1791 static void 1792 output_yydestruct_decl(FILE * fp) 1793 { 1794 putc_code(fp, '\n'); 1795 putl_code(fp, "#ifndef YYDESTRUCT_DECL\n"); 1796 1797 puts_code(fp, 1798 "#define YYDESTRUCT_DECL() " 1799 "yydestruct(const char *msg, int psymb, YYSTYPE *val"); 1800 #if defined(YYBTYACC) 1801 if (locations) 1802 puts_code(fp, ", YYLTYPE *loc"); 1803 #endif 1804 if (parse_param) 1805 { 1806 puts_code(fp, ", "); 1807 puts_param_types(fp, parse_param, 0); 1808 } 1809 putl_code(fp, ")\n"); 1810 1811 putl_code(fp, "#endif\n"); 1812 1813 putl_code(fp, "#ifndef YYDESTRUCT_CALL\n"); 1814 1815 puts_code(fp, "#define YYDESTRUCT_CALL(msg, psymb, val"); 1816 #if defined(YYBTYACC) 1817 if (locations) 1818 puts_code(fp, ", loc"); 1819 #endif 1820 puts_code(fp, ") yydestruct(msg, psymb, val"); 1821 #if defined(YYBTYACC) 1822 if (locations) 1823 puts_code(fp, ", loc"); 1824 #endif 1825 if (parse_param) 1826 { 1827 puts_code(fp, ", "); 1828 puts_param_names(fp, parse_param, 0); 1829 } 1830 putl_code(fp, ")\n"); 1831 1832 putl_code(fp, "#endif\n"); 1833 } 1834 1835 static void 1836 output_yydestruct_impl(void) 1837 { 1838 int i; 1839 char *s, *destructor_code; 1840 1841 putc_code(code_file, '\n'); 1842 putl_code(code_file, "/* Release memory associated with symbol. */\n"); 1843 putl_code(code_file, "#if ! defined YYDESTRUCT_IS_DECLARED\n"); 1844 putl_code(code_file, "static void\n"); 1845 putl_code(code_file, "YYDESTRUCT_DECL()\n"); 1846 putl_code(code_file, "{\n"); 1847 putl_code(code_file, " switch (psymb)\n"); 1848 putl_code(code_file, " {\n"); 1849 for (i = 2; i < nsyms; ++i) 1850 { 1851 if ((destructor_code = symbol_destructor[i]) != NULL) 1852 { 1853 ++outline; 1854 fprintf(code_file, "\tcase %d:\n", symbol_pval[i]); 1855 /* comprehend the number of lines in the destructor code */ 1856 for (s = destructor_code; (s = strchr(s, '\n')) != NULL; s++) 1857 ++outline; 1858 puts_code(code_file, destructor_code); 1859 putc_code(code_file, '\n'); 1860 putl_code(code_file, "\tbreak;\n"); 1861 write_code_lineno(code_file); 1862 FREE(destructor_code); 1863 } 1864 } 1865 putl_code(code_file, " }\n"); 1866 putl_code(code_file, "}\n"); 1867 putl_code(code_file, "#define YYDESTRUCT_IS_DECLARED 1\n"); 1868 putl_code(code_file, "#endif\n"); 1869 1870 DO_FREE(symbol_destructor); 1871 } 1872 #endif 1873 1874 static void 1875 free_itemsets(void) 1876 { 1877 core *cp, *next; 1878 1879 FREE(state_table); 1880 for (cp = first_state; cp; cp = next) 1881 { 1882 next = cp->next; 1883 FREE(cp); 1884 } 1885 } 1886 1887 static void 1888 free_shifts(void) 1889 { 1890 shifts *sp, *next; 1891 1892 FREE(shift_table); 1893 for (sp = first_shift; sp; sp = next) 1894 { 1895 next = sp->next; 1896 FREE(sp); 1897 } 1898 } 1899 1900 static void 1901 free_reductions(void) 1902 { 1903 reductions *rp, *next; 1904 1905 FREE(reduction_table); 1906 for (rp = first_reduction; rp; rp = next) 1907 { 1908 next = rp->next; 1909 FREE(rp); 1910 } 1911 } 1912 1913 static void 1914 output_externs(FILE * fp, const char *const section[]) 1915 { 1916 int i; 1917 const char *s; 1918 1919 for (i = 0; (s = section[i]) != 0; ++i) 1920 { 1921 /* prefix non-blank lines that don't start with 1922 C pre-processor directives with 'extern ' */ 1923 if (*s && (*s != '#')) 1924 fputs("extern\t", fp); 1925 if (fp == code_file) 1926 ++outline; 1927 fprintf(fp, "%s\n", s); 1928 } 1929 } 1930 1931 void 1932 output(void) 1933 { 1934 FILE *fp; 1935 1936 free_itemsets(); 1937 free_shifts(); 1938 free_reductions(); 1939 1940 #if defined(YYBTYACC) 1941 output_backtracking_parser(output_file); 1942 if (rflag) 1943 output_backtracking_parser(code_file); 1944 #endif 1945 1946 if (iflag) 1947 { 1948 write_code_lineno(code_file); 1949 ++outline; 1950 fprintf(code_file, "#include \"%s\"\n", externs_file_name); 1951 fp = externs_file; 1952 } 1953 else 1954 fp = code_file; 1955 1956 output_prefix(fp); 1957 output_pure_parser(fp); 1958 output_stored_text(fp); 1959 output_stype(fp); 1960 #if defined(YYBTYACC) 1961 if (locations) 1962 output_ltype(fp); 1963 #endif 1964 output_parse_decl(fp); 1965 output_lex_decl(fp); 1966 output_error_decl(fp); 1967 #if defined(YYBTYACC) 1968 if (destructor) 1969 output_yydestruct_decl(fp); 1970 #endif 1971 if (iflag || !rflag) 1972 { 1973 write_section(fp, xdecls); 1974 } 1975 1976 if (iflag) 1977 { 1978 output_externs(externs_file, global_vars); 1979 if (!pure_parser) 1980 output_externs(externs_file, impure_vars); 1981 } 1982 1983 if (iflag) 1984 { 1985 if (dflag) 1986 { 1987 ++outline; 1988 fprintf(code_file, "#include \"%s\"\n", defines_file_name); 1989 } 1990 else 1991 output_defines(externs_file); 1992 } 1993 else 1994 { 1995 putc_code(code_file, '\n'); 1996 output_defines(code_file); 1997 } 1998 1999 if (dflag) 2000 { 2001 start_defines_file(); 2002 output_defines(defines_file); 2003 end_defines_file(); 2004 } 2005 2006 output_rule_data(); 2007 output_yydefred(); 2008 #if defined(YYBTYACC) 2009 output_accessing_symbols(); 2010 #endif 2011 output_actions(); 2012 free_parser(); 2013 output_debug(); 2014 if (rflag) 2015 { 2016 write_section(code_file, xdecls); 2017 output_YYINT_typedef(code_file); 2018 write_section(code_file, tables); 2019 } 2020 write_section(code_file, global_vars); 2021 if (!pure_parser) 2022 { 2023 write_section(code_file, impure_vars); 2024 } 2025 write_section(code_file, hdr_defs); 2026 if (!pure_parser) 2027 { 2028 write_section(code_file, hdr_vars); 2029 } 2030 output_trailing_text(); 2031 #if defined(YYBTYACC) 2032 if (destructor) 2033 output_yydestruct_impl(); 2034 #endif 2035 write_section(code_file, body_1); 2036 if (pure_parser) 2037 { 2038 write_section(code_file, body_vars); 2039 } 2040 write_section(code_file, body_2); 2041 output_semantic_actions(); 2042 write_section(code_file, trailer); 2043 } 2044 2045 #ifdef NO_LEAKS 2046 void 2047 output_leaks(void) 2048 { 2049 DO_FREE(tally); 2050 DO_FREE(width); 2051 DO_FREE(order); 2052 } 2053 #endif 2054