1 /* 2 * Copyright (c) 1989 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Robert Paul Corbett. 7 * 8 * %sccs.include.redist.c% 9 */ 10 11 #ifndef lint 12 static char sccsid[] = "@(#)output.c 5.6 (Berkeley) 01/20/91"; 13 #endif /* not lint */ 14 15 #include "defs.h" 16 17 static int nvectors; 18 static int nentries; 19 static short **froms; 20 static short **tos; 21 static short *tally; 22 static short *width; 23 static short *state_count; 24 static short *order; 25 static short *base; 26 static short *pos; 27 static int maxtable; 28 static short *table; 29 static short *check; 30 static int lowzero; 31 static int high; 32 33 34 output() 35 { 36 free_itemsets(); 37 free_shifts(); 38 free_reductions(); 39 output_stored_text(); 40 output_defines(); 41 output_rule_data(); 42 output_yydefred(); 43 output_actions(); 44 free_parser(); 45 output_debug(); 46 output_stype(); 47 if (rflag) write_section(tables); 48 write_section(header); 49 output_trailing_text(); 50 write_section(body); 51 output_semantic_actions(); 52 write_section(trailer); 53 } 54 55 56 output_rule_data() 57 { 58 register int i; 59 register int j; 60 61 62 fprintf(output_file, "short yylhs[] = {%42d,", 63 symbol_value[start_symbol]); 64 65 j = 10; 66 for (i = 3; i < nrules; i++) 67 { 68 if (j >= 10) 69 { 70 if (!rflag) ++outline; 71 putc('\n', output_file); 72 j = 1; 73 } 74 else 75 ++j; 76 77 fprintf(output_file, "%5d,", symbol_value[rlhs[i]]); 78 } 79 if (!rflag) outline += 2; 80 fprintf(output_file, "\n};\n"); 81 82 fprintf(output_file, "short yylen[] = {%42d,", 2); 83 84 j = 10; 85 for (i = 3; i < nrules; i++) 86 { 87 if (j >= 10) 88 { 89 if (!rflag) ++outline; 90 putc('\n', output_file); 91 j = 1; 92 } 93 else 94 j++; 95 96 fprintf(output_file, "%5d,", rrhs[i + 1] - rrhs[i] - 1); 97 } 98 if (!rflag) outline += 2; 99 fprintf(output_file, "\n};\n"); 100 } 101 102 103 output_yydefred() 104 { 105 register int i, j; 106 107 fprintf(output_file, "short yydefred[] = {%39d,", 108 (defred[0] ? defred[0] - 2 : 0)); 109 110 j = 10; 111 for (i = 1; i < nstates; i++) 112 { 113 if (j < 10) 114 ++j; 115 else 116 { 117 if (!rflag) ++outline; 118 putc('\n', output_file); 119 j = 1; 120 } 121 122 fprintf(output_file, "%5d,", (defred[i] ? defred[i] - 2 : 0)); 123 } 124 125 if (!rflag) outline += 2; 126 fprintf(output_file, "\n};\n"); 127 } 128 129 130 output_actions() 131 { 132 nvectors = 2*nstates + nvars; 133 134 froms = NEW2(nvectors, short *); 135 tos = NEW2(nvectors, short *); 136 tally = NEW2(nvectors, short); 137 width = NEW2(nvectors, short); 138 139 token_actions(); 140 FREE(lookaheads); 141 FREE(LA); 142 FREE(LAruleno); 143 FREE(accessing_symbol); 144 145 goto_actions(); 146 FREE(goto_map + ntokens); 147 FREE(from_state); 148 FREE(to_state); 149 150 sort_actions(); 151 pack_table(); 152 output_base(); 153 output_table(); 154 output_check(); 155 } 156 157 158 token_actions() 159 { 160 register int i, j; 161 register int shiftcount, reducecount; 162 register int max, min; 163 register short *actionrow, *r, *s; 164 register action *p; 165 166 actionrow = NEW2(2*ntokens, short); 167 for (i = 0; i < nstates; ++i) 168 { 169 if (parser[i]) 170 { 171 for (j = 0; j < 2*ntokens; ++j) 172 actionrow[j] = 0; 173 174 shiftcount = 0; 175 reducecount = 0; 176 for (p = parser[i]; p; p = p->next) 177 { 178 if (p->suppressed == 0) 179 { 180 if (p->action_code == SHIFT) 181 { 182 ++shiftcount; 183 actionrow[p->symbol] = p->number; 184 } 185 else if (p->action_code == REDUCE && p->number != defred[i]) 186 { 187 ++reducecount; 188 actionrow[p->symbol + ntokens] = p->number; 189 } 190 } 191 } 192 193 tally[i] = shiftcount; 194 tally[nstates+i] = reducecount; 195 width[i] = 0; 196 width[nstates+i] = 0; 197 if (shiftcount > 0) 198 { 199 froms[i] = r = NEW2(shiftcount, short); 200 tos[i] = s = NEW2(shiftcount, short); 201 min = MAXSHORT; 202 max = 0; 203 for (j = 0; j < ntokens; ++j) 204 { 205 if (actionrow[j]) 206 { 207 if (min > symbol_value[j]) 208 min = symbol_value[j]; 209 if (max < symbol_value[j]) 210 max = symbol_value[j]; 211 *r++ = symbol_value[j]; 212 *s++ = actionrow[j]; 213 } 214 } 215 width[i] = max - min + 1; 216 } 217 if (reducecount > 0) 218 { 219 froms[nstates+i] = r = NEW2(reducecount, short); 220 tos[nstates+i] = s = NEW2(reducecount, short); 221 min = MAXSHORT; 222 max = 0; 223 for (j = 0; j < ntokens; ++j) 224 { 225 if (actionrow[ntokens+j]) 226 { 227 if (min > symbol_value[j]) 228 min = symbol_value[j]; 229 if (max < symbol_value[j]) 230 max = symbol_value[j]; 231 *r++ = symbol_value[j]; 232 *s++ = actionrow[ntokens+j] - 2; 233 } 234 } 235 width[nstates+i] = max - min + 1; 236 } 237 } 238 } 239 FREE(actionrow); 240 } 241 242 goto_actions() 243 { 244 register int i, j, k; 245 246 state_count = NEW2(nstates, short); 247 248 k = default_goto(start_symbol + 1); 249 fprintf(output_file, "short yydgoto[] = {%40d,", k); 250 save_column(start_symbol + 1, k); 251 252 j = 10; 253 for (i = start_symbol + 2; i < nsyms; i++) 254 { 255 if (j >= 10) 256 { 257 if (!rflag) ++outline; 258 putc('\n', output_file); 259 j = 1; 260 } 261 else 262 ++j; 263 264 k = default_goto(i); 265 fprintf(output_file, "%5d,", k); 266 save_column(i, k); 267 } 268 269 if (!rflag) outline += 2; 270 fprintf(output_file, "\n};\n"); 271 FREE(state_count); 272 } 273 274 int 275 default_goto(symbol) 276 int symbol; 277 { 278 register int i; 279 register int m; 280 register int n; 281 register int default_state; 282 register int max; 283 284 m = goto_map[symbol]; 285 n = goto_map[symbol + 1]; 286 287 if (m == n) return (0); 288 289 for (i = 0; i < nstates; i++) 290 state_count[i] = 0; 291 292 for (i = m; i < n; i++) 293 state_count[to_state[i]]++; 294 295 max = 0; 296 default_state = 0; 297 for (i = 0; i < nstates; i++) 298 { 299 if (state_count[i] > max) 300 { 301 max = state_count[i]; 302 default_state = i; 303 } 304 } 305 306 return (default_state); 307 } 308 309 310 311 save_column(symbol, default_state) 312 int symbol; 313 int default_state; 314 { 315 register int i; 316 register int m; 317 register int n; 318 register short *sp; 319 register short *sp1; 320 register short *sp2; 321 register int count; 322 register int symno; 323 324 m = goto_map[symbol]; 325 n = goto_map[symbol + 1]; 326 327 count = 0; 328 for (i = m; i < n; i++) 329 { 330 if (to_state[i] != default_state) 331 ++count; 332 } 333 if (count == 0) return; 334 335 symno = symbol_value[symbol] + 2*nstates; 336 337 froms[symno] = sp1 = sp = NEW2(count, short); 338 tos[symno] = sp2 = NEW2(count, short); 339 340 for (i = m; i < n; i++) 341 { 342 if (to_state[i] != default_state) 343 { 344 *sp1++ = from_state[i]; 345 *sp2++ = to_state[i]; 346 } 347 } 348 349 tally[symno] = count; 350 width[symno] = sp1[-1] - sp[0] + 1; 351 } 352 353 sort_actions() 354 { 355 register int i; 356 register int j; 357 register int k; 358 register int t; 359 register int w; 360 361 order = NEW2(nvectors, short); 362 nentries = 0; 363 364 for (i = 0; i < nvectors; i++) 365 { 366 if (tally[i] > 0) 367 { 368 t = tally[i]; 369 w = width[i]; 370 j = nentries - 1; 371 372 while (j >= 0 && (width[order[j]] < w)) 373 j--; 374 375 while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t)) 376 j--; 377 378 for (k = nentries - 1; k > j; k--) 379 order[k + 1] = order[k]; 380 381 order[j + 1] = i; 382 nentries++; 383 } 384 } 385 } 386 387 388 pack_table() 389 { 390 register int i; 391 register int place; 392 register int state; 393 394 base = NEW2(nvectors, short); 395 pos = NEW2(nentries, short); 396 397 maxtable = 1000; 398 table = NEW2(maxtable, short); 399 check = NEW2(maxtable, short); 400 401 lowzero = 0; 402 high = 0; 403 404 for (i = 0; i < maxtable; i++) 405 check[i] = -1; 406 407 for (i = 0; i < nentries; i++) 408 { 409 state = matching_vector(i); 410 411 if (state < 0) 412 place = pack_vector(i); 413 else 414 place = base[state]; 415 416 pos[i] = place; 417 base[order[i]] = place; 418 } 419 420 for (i = 0; i < nvectors; i++) 421 { 422 if (froms[i]) 423 FREE(froms[i]); 424 if (tos[i]) 425 FREE(tos[i]); 426 } 427 428 FREE(froms); 429 FREE(tos); 430 FREE(pos); 431 } 432 433 434 /* The function matching_vector determines if the vector specified by */ 435 /* the input parameter matches a previously considered vector. The */ 436 /* test at the start of the function checks if the vector represents */ 437 /* a row of shifts over terminal symbols or a row of reductions, or a */ 438 /* column of shifts over a nonterminal symbol. Berkeley Yacc does not */ 439 /* check if a column of shifts over a nonterminal symbols matches a */ 440 /* previously considered vector. Because of the nature of LR parsing */ 441 /* tables, no two columns can match. Therefore, the only possible */ 442 /* match would be between a row and a column. Such matches are */ 443 /* unlikely. Therefore, to save time, no attempt is made to see if a */ 444 /* column matches a previously considered vector. */ 445 /* */ 446 /* Matching_vector is poorly designed. The test could easily be made */ 447 /* faster. Also, it depends on the vectors being in a specific */ 448 /* order. */ 449 450 int 451 matching_vector(vector) 452 int vector; 453 { 454 register int i; 455 register int j; 456 register int k; 457 register int t; 458 register int w; 459 register int match; 460 register int prev; 461 462 i = order[vector]; 463 if (i >= 2*nstates) 464 return (-1); 465 466 t = tally[i]; 467 w = width[i]; 468 469 for (prev = vector - 1; prev >= 0; prev--) 470 { 471 j = order[prev]; 472 if (width[j] != w || tally[j] != t) 473 return (-1); 474 475 match = 1; 476 for (k = 0; match && k < t; k++) 477 { 478 if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k]) 479 match = 0; 480 } 481 482 if (match) 483 return (j); 484 } 485 486 return (-1); 487 } 488 489 490 491 int 492 pack_vector(vector) 493 int vector; 494 { 495 register int i, j, k, l; 496 register int t; 497 register int loc; 498 register int ok; 499 register short *from; 500 register short *to; 501 int newmax; 502 503 i = order[vector]; 504 t = tally[i]; 505 assert(t); 506 507 from = froms[i]; 508 to = tos[i]; 509 510 j = lowzero - from[0]; 511 for (k = 1; k < t; ++k) 512 if (lowzero - from[k] > j) 513 j = lowzero - from[k]; 514 for (;; ++j) 515 { 516 if (j == 0) 517 continue; 518 ok = 1; 519 for (k = 0; ok && k < t; k++) 520 { 521 loc = j + from[k]; 522 if (loc >= maxtable) 523 { 524 if (loc >= MAXTABLE) 525 fatal("maximum table size exceeded"); 526 527 newmax = maxtable; 528 do { newmax += 200; } while (newmax <= loc); 529 table = (short *) REALLOC(table, newmax*sizeof(short)); 530 if (table == 0) no_space(); 531 check = (short *) REALLOC(check, newmax*sizeof(short)); 532 if (check == 0) no_space(); 533 for (l = maxtable; l < newmax; ++l) 534 { 535 table[l] = 0; 536 check[l] = -1; 537 } 538 maxtable = newmax; 539 } 540 541 if (check[loc] != -1) 542 ok = 0; 543 } 544 for (k = 0; ok && k < vector; k++) 545 { 546 if (pos[k] == j) 547 ok = 0; 548 } 549 if (ok) 550 { 551 for (k = 0; k < t; k++) 552 { 553 loc = j + from[k]; 554 table[loc] = to[k]; 555 check[loc] = from[k]; 556 if (loc > high) high = loc; 557 } 558 559 while (check[lowzero] != -1) 560 ++lowzero; 561 562 return (j); 563 } 564 } 565 } 566 567 568 569 output_base() 570 { 571 register int i, j; 572 573 fprintf(output_file, "short yysindex[] = {%39d,", base[0]); 574 575 j = 10; 576 for (i = 1; i < nstates; i++) 577 { 578 if (j >= 10) 579 { 580 if (!rflag) ++outline; 581 putc('\n', output_file); 582 j = 1; 583 } 584 else 585 ++j; 586 587 fprintf(output_file, "%5d,", base[i]); 588 } 589 590 if (!rflag) outline += 2; 591 fprintf(output_file, "\n};\nshort yyrindex[] = {%39d,", 592 base[nstates]); 593 594 j = 10; 595 for (i = nstates + 1; i < 2*nstates; i++) 596 { 597 if (j >= 10) 598 { 599 if (!rflag) ++outline; 600 putc('\n', output_file); 601 j = 1; 602 } 603 else 604 ++j; 605 606 fprintf(output_file, "%5d,", base[i]); 607 } 608 609 if (!rflag) outline += 2; 610 fprintf(output_file, "\n};\nshort yygindex[] = {%39d,", 611 base[2*nstates]); 612 613 j = 10; 614 for (i = 2*nstates + 1; i < nvectors - 1; i++) 615 { 616 if (j >= 10) 617 { 618 if (!rflag) ++outline; 619 putc('\n', output_file); 620 j = 1; 621 } 622 else 623 ++j; 624 625 fprintf(output_file, "%5d,", base[i]); 626 } 627 628 if (!rflag) outline += 2; 629 fprintf(output_file, "\n};\n"); 630 FREE(base); 631 } 632 633 634 635 output_table() 636 { 637 register int i; 638 register int j; 639 640 ++outline; 641 fprintf(code_file, "#define YYTABLESIZE %d\n", high); 642 fprintf(output_file, "short yytable[] = {%40d,", table[0]); 643 644 j = 10; 645 for (i = 1; i <= high; i++) 646 { 647 if (j >= 10) 648 { 649 if (!rflag) ++outline; 650 putc('\n', output_file); 651 j = 1; 652 } 653 else 654 ++j; 655 656 fprintf(output_file, "%5d,", table[i]); 657 } 658 659 if (!rflag) outline += 2; 660 fprintf(output_file, "\n};\n"); 661 FREE(table); 662 } 663 664 665 666 output_check() 667 { 668 register int i; 669 register int j; 670 671 fprintf(output_file, "short yycheck[] = {%40d,", check[0]); 672 673 j = 10; 674 for (i = 1; i <= high; i++) 675 { 676 if (j >= 10) 677 { 678 if (!rflag) ++outline; 679 putc('\n', output_file); 680 j = 1; 681 } 682 else 683 ++j; 684 685 fprintf(output_file, "%5d,", check[i]); 686 } 687 688 if (!rflag) outline += 2; 689 fprintf(output_file, "\n};\n"); 690 FREE(check); 691 } 692 693 694 int 695 is_C_identifier(name) 696 char *name; 697 { 698 register char *s; 699 register int c; 700 701 s = name; 702 c = *s; 703 if (c == '"') 704 { 705 c = *++s; 706 if (!isalpha(c) && c != '_' && c != '$') 707 return (0); 708 while ((c = *++s) != '"') 709 { 710 if (!isalnum(c) && c != '_' && c != '$') 711 return (0); 712 } 713 return (1); 714 } 715 716 if (!isalpha(c) && c != '_' && c != '$') 717 return (0); 718 while (c = *++s) 719 { 720 if (!isalnum(c) && c != '_' && c != '$') 721 return (0); 722 } 723 return (1); 724 } 725 726 727 output_defines() 728 { 729 register int c, i; 730 register char *s; 731 732 for (i = 2; i < ntokens; ++i) 733 { 734 s = symbol_name[i]; 735 if (is_C_identifier(s)) 736 { 737 fprintf(code_file, "#define "); 738 if (dflag) fprintf(defines_file, "#define "); 739 c = *s; 740 if (c == '"') 741 { 742 while ((c = *++s) != '"') 743 { 744 putc(c, code_file); 745 if (dflag) putc(c, defines_file); 746 } 747 } 748 else 749 { 750 do 751 { 752 putc(c, code_file); 753 if (dflag) putc(c, defines_file); 754 } 755 while (c = *++s); 756 } 757 ++outline; 758 fprintf(code_file, " %d\n", symbol_value[i]); 759 if (dflag) fprintf(defines_file, " %d\n", symbol_value[i]); 760 } 761 } 762 763 ++outline; 764 fprintf(code_file, "#define YYERRCODE %d\n", symbol_value[1]); 765 766 if (dflag && unionized) 767 { 768 fclose(union_file); 769 union_file = fopen(union_file_name, "r"); 770 if (union_file == NULL) open_error(union_file_name); 771 while ((c = getc(union_file)) != EOF) 772 putc(c, defines_file); 773 fprintf(defines_file, " YYSTYPE;\nextern YYSTYPE yylval;\n"); 774 } 775 } 776 777 778 output_stored_text() 779 { 780 register int c; 781 register FILE *in, *out; 782 783 fclose(text_file); 784 text_file = fopen(text_file_name, "r"); 785 if (text_file == NULL) 786 open_error(text_file_name); 787 in = text_file; 788 if ((c = getc(in)) == EOF) 789 return; 790 out = code_file; 791 if (c == '\n') 792 ++outline; 793 putc(c, out); 794 while ((c = getc(in)) != EOF) 795 { 796 if (c == '\n') 797 ++outline; 798 putc(c, out); 799 } 800 if (!lflag) 801 fprintf(out, line_format, ++outline + 1, code_file_name); 802 } 803 804 805 output_debug() 806 { 807 register int i, j, k, max; 808 char **symnam, *s; 809 810 ++outline; 811 fprintf(code_file, "#define YYFINAL %d\n", final_state); 812 outline += 3; 813 fprintf(code_file, "#ifndef YYDEBUG\n#define YYDEBUG %d\n#endif\n", 814 tflag); 815 if (rflag) 816 fprintf(output_file, "#ifndef YYDEBUG\n#define YYDEBUG %d\n#endif\n", 817 tflag); 818 819 max = 0; 820 for (i = 2; i < ntokens; ++i) 821 if (symbol_value[i] > max) 822 max = symbol_value[i]; 823 ++outline; 824 fprintf(code_file, "#define YYMAXTOKEN %d\n", max); 825 826 symnam = (char **) MALLOC((max+1)*sizeof(char *)); 827 if (symnam == 0) no_space(); 828 829 /* Note that it is not necessary to initialize the element */ 830 /* symnam[max]. */ 831 for (i = 0; i < max; ++i) 832 symnam[i] = 0; 833 for (i = ntokens - 1; i >= 2; --i) 834 symnam[symbol_value[i]] = symbol_name[i]; 835 symnam[0] = "end-of-file"; 836 837 if (!rflag) ++outline; 838 fprintf(output_file, "#if YYDEBUG\nchar *yyname[] = {"); 839 j = 80; 840 for (i = 0; i <= max; ++i) 841 { 842 if (s = symnam[i]) 843 { 844 if (s[0] == '"') 845 { 846 k = 7; 847 while (*++s != '"') 848 { 849 ++k; 850 if (*s == '\\') 851 { 852 k += 2; 853 if (*++s == '\\') 854 ++k; 855 } 856 } 857 j += k; 858 if (j > 80) 859 { 860 if (!rflag) ++outline; 861 putc('\n', output_file); 862 j = k; 863 } 864 fprintf(output_file, "\"\\\""); 865 s = symnam[i]; 866 while (*++s != '"') 867 { 868 if (*s == '\\') 869 { 870 fprintf(output_file, "\\\\"); 871 if (*++s == '\\') 872 fprintf(output_file, "\\\\"); 873 else 874 putc(*s, output_file); 875 } 876 else 877 putc(*s, output_file); 878 } 879 fprintf(output_file, "\\\"\","); 880 } 881 else if (s[0] == '\'') 882 { 883 if (s[1] == '"') 884 { 885 j += 7; 886 if (j > 80) 887 { 888 if (!rflag) ++outline; 889 putc('\n', output_file); 890 j = 7; 891 } 892 fprintf(output_file, "\"'\\\"'\","); 893 } 894 else 895 { 896 k = 5; 897 while (*++s != '\'') 898 { 899 ++k; 900 if (*s == '\\') 901 { 902 k += 2; 903 if (*++s == '\\') 904 ++k; 905 } 906 } 907 j += k; 908 if (j > 80) 909 { 910 if (!rflag) ++outline; 911 putc('\n', output_file); 912 j = k; 913 } 914 fprintf(output_file, "\"'"); 915 s = symnam[i]; 916 while (*++s != '\'') 917 { 918 if (*s == '\\') 919 { 920 fprintf(output_file, "\\\\"); 921 if (*++s == '\\') 922 fprintf(output_file, "\\\\"); 923 else 924 putc(*s, output_file); 925 } 926 else 927 putc(*s, output_file); 928 } 929 fprintf(output_file, "'\","); 930 } 931 } 932 else 933 { 934 k = strlen(s) + 3; 935 j += k; 936 if (j > 80) 937 { 938 if (!rflag) ++outline; 939 putc('\n', output_file); 940 j = k; 941 } 942 putc('"', output_file); 943 do { putc(*s, output_file); } while (*++s); 944 fprintf(output_file, "\","); 945 } 946 } 947 else 948 { 949 j += 2; 950 if (j > 80) 951 { 952 if (!rflag) ++outline; 953 putc('\n', output_file); 954 j = 2; 955 } 956 fprintf(output_file, "0,"); 957 } 958 } 959 if (!rflag) outline += 2; 960 fprintf(output_file, "\n};\n"); 961 FREE(symnam); 962 963 if (!rflag) ++outline; 964 fprintf(output_file, "char *yyrule[] = {\n"); 965 for (i = 2; i < nrules; ++i) 966 { 967 fprintf(output_file, "\"%s :", symbol_name[rlhs[i]]); 968 for (j = rrhs[i]; ritem[j] > 0; ++j) 969 { 970 s = symbol_name[ritem[j]]; 971 if (s[0] == '"') 972 { 973 fprintf(output_file, " \\\""); 974 while (*++s != '"') 975 { 976 if (*s == '\\') 977 { 978 if (s[1] == '\\') 979 fprintf(output_file, "\\\\\\\\"); 980 else 981 fprintf(output_file, "\\\\%c", s[1]); 982 ++s; 983 } 984 else 985 putc(*s, output_file); 986 } 987 fprintf(output_file, "\\\""); 988 } 989 else if (s[0] == '\'') 990 { 991 if (s[1] == '"') 992 fprintf(output_file, " '\\\"'"); 993 else if (s[1] == '\\') 994 { 995 if (s[2] == '\\') 996 fprintf(output_file, " '\\\\\\\\"); 997 else 998 fprintf(output_file, " '\\\\%c", s[2]); 999 s += 2; 1000 while (*++s != '\'') 1001 putc(*s, output_file); 1002 putc('\'', output_file); 1003 } 1004 else 1005 fprintf(output_file, " '%c'", s[1]); 1006 } 1007 else 1008 fprintf(output_file, " %s", s); 1009 } 1010 if (!rflag) ++outline; 1011 fprintf(output_file, "\",\n"); 1012 } 1013 1014 if (!rflag) outline += 2; 1015 fprintf(output_file, "};\n#endif\n"); 1016 } 1017 1018 1019 output_stype() 1020 { 1021 if (!unionized && ntags == 0) 1022 { 1023 outline += 3; 1024 fprintf(code_file, "#ifndef YYSTYPE\ntypedef int YYSTYPE;\n#endif\n"); 1025 } 1026 } 1027 1028 1029 output_trailing_text() 1030 { 1031 register int c, last; 1032 register FILE *in, *out; 1033 1034 if (line == 0) 1035 return; 1036 1037 in = input_file; 1038 out = code_file; 1039 c = *cptr; 1040 if (c == '\n') 1041 { 1042 ++lineno; 1043 if ((c = getc(in)) == EOF) 1044 return; 1045 if (!lflag) 1046 { 1047 ++outline; 1048 fprintf(out, line_format, lineno, input_file_name); 1049 } 1050 if (c == '\n') 1051 ++outline; 1052 putc(c, out); 1053 last = c; 1054 } 1055 else 1056 { 1057 if (!lflag) 1058 { 1059 ++outline; 1060 fprintf(out, line_format, lineno, input_file_name); 1061 } 1062 do { putc(c, out); } while ((c = *++cptr) != '\n'); 1063 ++outline; 1064 putc('\n', out); 1065 last = '\n'; 1066 } 1067 1068 while ((c = getc(in)) != EOF) 1069 { 1070 if (c == '\n') 1071 ++outline; 1072 putc(c, out); 1073 last = c; 1074 } 1075 1076 if (last != '\n') 1077 { 1078 ++outline; 1079 putc('\n', out); 1080 } 1081 if (!lflag) 1082 fprintf(out, line_format, ++outline + 1, code_file_name); 1083 } 1084 1085 1086 output_semantic_actions() 1087 { 1088 register int c, last; 1089 register FILE *out; 1090 1091 fclose(action_file); 1092 action_file = fopen(action_file_name, "r"); 1093 if (action_file == NULL) 1094 open_error(action_file_name); 1095 1096 if ((c = getc(action_file)) == EOF) 1097 return; 1098 1099 out = code_file; 1100 last = c; 1101 if (c == '\n') 1102 ++outline; 1103 putc(c, out); 1104 while ((c = getc(action_file)) != EOF) 1105 { 1106 if (c == '\n') 1107 ++outline; 1108 putc(c, out); 1109 last = c; 1110 } 1111 1112 if (last != '\n') 1113 { 1114 ++outline; 1115 putc('\n', out); 1116 } 1117 1118 if (!lflag) 1119 fprintf(out, line_format, ++outline + 1, code_file_name); 1120 } 1121 1122 1123 free_itemsets() 1124 { 1125 register core *cp, *next; 1126 1127 FREE(state_table); 1128 for (cp = first_state; cp; cp = next) 1129 { 1130 next = cp->next; 1131 FREE(cp); 1132 } 1133 } 1134 1135 1136 free_shifts() 1137 { 1138 register shifts *sp, *next; 1139 1140 FREE(shift_table); 1141 for (sp = first_shift; sp; sp = next) 1142 { 1143 next = sp->next; 1144 FREE(sp); 1145 } 1146 } 1147 1148 1149 1150 free_reductions() 1151 { 1152 register reductions *rp, *next; 1153 1154 FREE(reduction_table); 1155 for (rp = first_reduction; rp; rp = next) 1156 { 1157 next = rp->next; 1158 FREE(rp); 1159 } 1160 } 1161