![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / bison|
Return to output.c CVS log | Up to [Research Unix] / researchv10dc / cmd / bison |
1.1 ! root 1: /* Output the generated parsing program for bison, ! 2: Copyright (C) 1984, 1986 Bob Corbett and Free Software Foundation, Inc. ! 3: ! 4: BISON is distributed in the hope that it will be useful, but WITHOUT ANY ! 5: WARRANTY. No author or distributor accepts responsibility to anyone ! 6: for the consequences of using it or for whether it serves any ! 7: particular purpose or works at all, unless he says so in writing. ! 8: Refer to the BISON General Public License for full details. ! 9: ! 10: Everyone is granted permission to copy, modify and redistribute BISON, ! 11: but only under the conditions described in the BISON General Public ! 12: License. A copy of this license is supposed to have been given to you ! 13: along with BISON so you can know your rights and responsibilities. It ! 14: should be in a file named COPYING. Among other things, the copyright ! 15: notice and this notice must be preserved on all copies. ! 16: ! 17: In other words, you are welcome to use, share and improve this program. ! 18: You are forbidden to forbid anyone else to use, share and improve ! 19: what you give them. Help stamp out software-hoarding! */ ! 20: ! 21: /* functions to output parsing data to various files. Entries are: ! 22: ! 23: output_headers () ! 24: ! 25: Output constant strings to the beginning of certain files. ! 26: ! 27: output_trailers() ! 28: ! 29: Output constant strings to the ends of certain files. ! 30: ! 31: output () ! 32: ! 33: Output the parsing tables and the parser code to ftable. ! 34: ! 35: The parser tables consist of: (starred ones needed only for the semantic parser) ! 36: ! 37: yytranslate = vector mapping yylex's token numbers into bison's token numbers. ! 38: ! 39: yytname = vector of string-names indexed by bison token number ! 40: ! 41: yyrline = vector of line-numbers of all rules. For yydebug printouts. ! 42: ! 43: * yyrhs = vector of items of all rules. ! 44: This is exactly what ritems contains. ! 45: ! 46: * yyprhs[r] = index in yyrhs of first item for rule r. ! 47: ! 48: yyr1[r] = symbol number of symbol that rule r derives. ! 49: ! 50: yyr2[r] = number of symbols composing right hand side of rule r. ! 51: ! 52: * yystos[s] = the symbol number of the symbol that leads to state s. ! 53: ! 54: yydefact[s] = default rule to reduce with in state s, ! 55: when yytable doesn't specify something else to do. ! 56: Zero means the default is an error. ! 57: ! 58: yydefgoto[i] = default state to go to after a reduction of a rule that ! 59: generates variable ntokens + i, except when yytable ! 60: specifies something else to do. ! 61: ! 62: yypact[s] = index in yytable of the portion describing state s. ! 63: The lookahed token's type is used to index that portion ! 64: to find out what to do. ! 65: ! 66: If the value in yytable is positive, ! 67: we shift the token and go to that state. ! 68: ! 69: If the value is negative, it is minus a rule number to reduce by. ! 70: ! 71: If the value is zero, the default action from yydefact[s] is used. ! 72: ! 73: yypgoto[i] = the index in yytable of the portion describing ! 74: what to do after reducing a rule that derives variable i + ntokens. ! 75: This portion is indexed by the parser state number ! 76: as of before the text for this nonterminal was read. ! 77: The value from yytable is the state to go to. ! 78: ! 79: yytable = a vector filled with portions for different uses, ! 80: found via yypact and yypgoto. ! 81: ! 82: yycheck = a vector indexed in parallel with yytable. ! 83: It indicates, in a roundabout way, the bounds of the ! 84: portion you are trying to examine. ! 85: ! 86: Suppose that the portion of yytable starts at index p ! 87: and the index to be examined within the portion is i. ! 88: Then if yycheck[p+i] != i, i is outside the bounds ! 89: of what is actually allocated, and the default ! 90: (from yydefact or yydefgoto) should be used. ! 91: Otherwise, yytable[p+i] should be used. ! 92: ! 93: YYFINAL = the state number of the termination state. ! 94: YYFLAG = most negative short int. Used to flag ?? ! 95: YYNTBASE = ntokens. ! 96: ! 97: */ ! 98: ! 99: #include <stdio.h> ! 100: #include "machine.h" ! 101: #include "new.h" ! 102: #include "files.h" ! 103: #include "gram.h" ! 104: #include "state.h" ! 105: ! 106: #define MAXTABLE 32767 ! 107: ! 108: ! 109: extern char **tags; ! 110: extern int tokensetsize; ! 111: extern int final_state; ! 112: extern core **state_table; ! 113: extern shifts **shift_table; ! 114: extern errs **err_table; ! 115: extern reductions **reduction_table; ! 116: extern short *accessing_symbol; ! 117: extern unsigned *LA; ! 118: extern short *LAruleno; ! 119: extern short *lookaheads; ! 120: extern char *consistent; ! 121: extern short *goto_map; ! 122: extern short *from_state; ! 123: extern short *to_state; ! 124: ! 125: ! 126: static int nvectors; ! 127: static int nentries; ! 128: static short **froms; ! 129: static short **tos; ! 130: static short *tally; ! 131: static short *width; ! 132: static short *actrow; ! 133: static short *state_count; ! 134: static short *order; ! 135: static short *base; ! 136: static short *pos; ! 137: static short *table; ! 138: static short *check; ! 139: static int lowzero; ! 140: static int high; ! 141: ! 142: ! 143: ! 144: #define GUARDSTR "\n#include \"%s\"\nextern int yyerror;\n\ ! 145: extern int yycost;\nextern char * yymsg;\nextern YYSTYPE yyval;\n\n\ ! 146: yyguard(n, yyvsp, yylsp)\nregister int n;\nregister YYSTYPE *yyvsp;\n\ ! 147: register YYLTYPE *yylsp;\n\ ! 148: {\n yyerror = 0;\nyycost = 0;\n yymsg = 0;\nswitch (n)\n {" ! 149: ! 150: #define ACTSTR "\n#include \"%s\"\nextern YYSTYPE yyval;\ ! 151: \nextern int yychar;\ ! 152: yyaction(n, yyvsp, yylsp)\nregister int n;\nregister YYSTYPE *yyvsp;\n\ ! 153: register YYLTYPE *yylsp;\n{\n switch (n)\n{" ! 154: ! 155: #define ACTSTR_SIMPLE "\n switch (yyn) {\n" ! 156: ! 157: ! 158: ! 159: output_headers() ! 160: { ! 161: if (semantic_parser) ! 162: fprintf(fguard, GUARDSTR, attrsfile); ! 163: fprintf(faction, (semantic_parser ? ACTSTR : ACTSTR_SIMPLE), attrsfile); ! 164: /* if (semantic_parser) JF moved this below ! 165: fprintf(ftable, "#include \"%s\"\n", attrsfile); ! 166: fprintf(ftable, "#include <stdio.h>\n\n"); */ ! 167: } ! 168: ! 169: output_trailers() ! 170: { ! 171: if (semantic_parser) ! 172: { ! 173: fprintf(fguard, "\n }\n}\n"); ! 174: fprintf(faction, "\n }\n}\n"); ! 175: } ! 176: else ! 177: fprintf(faction, "\n}\n"); ! 178: } ! 179: ! 180: ! 181: output() ! 182: { ! 183: int c; ! 184: ! 185: /* output_token_defines(ftable); /* JF put out token defines FIRST */ ! 186: if (!semantic_parser) /* JF Put out other stuff */ ! 187: { ! 188: rewind(fattrs); ! 189: while ((c=getc(fattrs))!=EOF) ! 190: putc(c,ftable); ! 191: } ! 192: ! 193: if (semantic_parser) ! 194: fprintf(ftable, "#include \"%s\"\n", attrsfile); ! 195: fprintf(ftable, "#include <stdio.h>\n\n"); ! 196: ! 197: /* Make "const" do nothing if not in ANSI C. */ ! 198: fprintf (ftable, "#ifndef __STDC__\n#define const\n#endif\n\n"); ! 199: ! 200: free_itemsets(); ! 201: output_defines(); ! 202: output_token_translations(); ! 203: if (semantic_parser) ! 204: output_gram(); ! 205: FREE(ritem); ! 206: if (semantic_parser) ! 207: output_stos(); ! 208: output_rule_data(); ! 209: output_actions(); ! 210: output_parser(); ! 211: output_program(); ! 212: } ! 213: ! 214: output_token_translations() ! 215: { ! 216: register int i, j; ! 217: /* register short *sp; JF unused */ ! 218: ! 219: if (translations) ! 220: { ! 221: fprintf(ftable, ! 222: "\n#define YYTRANSLATE(x) ((unsigned)(x) <= %d ? yytranslate[x] : %d)\n", ! 223: max_user_token_number, nsyms); ! 224: ! 225: if (ntokens < 127) /* play it very safe; check maximum element value. */ ! 226: fprintf(ftable, "\nstatic const char yytranslate[] = { 0"); ! 227: else ! 228: fprintf(ftable, "\nstatic const short yytranslate[] = { 0"); ! 229: ! 230: j = 10; ! 231: for (i = 1; i <= max_user_token_number; i++) ! 232: { ! 233: putc(',', ftable); ! 234: ! 235: if (j >= 10) ! 236: { ! 237: putc('\n', ftable); ! 238: j = 1; ! 239: } ! 240: else ! 241: { ! 242: j++; ! 243: } ! 244: ! 245: fprintf(ftable, "%6d", token_translations[i]); ! 246: } ! 247: ! 248: fprintf(ftable, "\n};\n"); ! 249: } ! 250: else ! 251: { ! 252: fprintf(ftable, "\n#define YYTRANSLATE(x) (x)\n"); ! 253: } ! 254: } ! 255: ! 256: ! 257: ! 258: output_gram() ! 259: { ! 260: register int i; ! 261: register int j; ! 262: register short *sp; ! 263: ! 264: fprintf(ftable, "\nstatic const short yyprhs[] = { 0"); ! 265: ! 266: j = 10; ! 267: for (i = 1; i <= nrules; i++) ! 268: { ! 269: putc(',', ftable); ! 270: ! 271: if (j >= 10) ! 272: { ! 273: putc('\n', ftable); ! 274: j = 1; ! 275: } ! 276: else ! 277: { ! 278: j++; ! 279: } ! 280: ! 281: fprintf(ftable, "%6d", rrhs[i]); ! 282: } ! 283: ! 284: fprintf(ftable, "\n};\n\nstatic const short yyrhs[] = {%6d", ritem[0]); ! 285: ! 286: j = 10; ! 287: for (sp = ritem + 1; *sp; sp++) ! 288: { ! 289: putc(',', ftable); ! 290: ! 291: if (j >= 10) ! 292: { ! 293: putc('\n', ftable); ! 294: j = 1; ! 295: } ! 296: else ! 297: { ! 298: j++; ! 299: } ! 300: ! 301: if (*sp > 0) ! 302: fprintf(ftable, "%6d", *sp); ! 303: else ! 304: fprintf(ftable, " 0"); ! 305: } ! 306: ! 307: fprintf(ftable, "\n};\n"); ! 308: } ! 309: ! 310: ! 311: ! 312: output_stos() ! 313: { ! 314: register int i; ! 315: register int j; ! 316: ! 317: fprintf(ftable, "\nstatic const short yystos[] = { 0"); ! 318: ! 319: j = 10; ! 320: for (i = 1; i < nstates; i++) ! 321: { ! 322: putc(',', ftable); ! 323: ! 324: if (j >= 10) ! 325: { ! 326: putc('\n', ftable); ! 327: j = 1; ! 328: } ! 329: else ! 330: { ! 331: j++; ! 332: } ! 333: ! 334: fprintf(ftable, "%6d", accessing_symbol[i]); ! 335: } ! 336: ! 337: fprintf(ftable, "\n};\n"); ! 338: } ! 339: ! 340: ! 341: ! 342: output_rule_data() ! 343: { ! 344: register int i; ! 345: register int j; ! 346: ! 347: fprintf(ftable, "\nstatic const short yyrline[] = { 0"); ! 348: ! 349: j = 10; ! 350: for (i = 1; i <= nrules; i++) ! 351: { ! 352: putc(',', ftable); ! 353: ! 354: if (j >= 10) ! 355: { ! 356: putc('\n', ftable); ! 357: j = 1; ! 358: } ! 359: else ! 360: { ! 361: j++; ! 362: } ! 363: ! 364: fprintf(ftable, "%6d", rline[i]); ! 365: } ! 366: ! 367: /* Output the table of token names. */ ! 368: ! 369: fprintf(ftable, "\n};\n\nstatic const char * const yytname[] = { 0"); ! 370: ! 371: j = 10; ! 372: for (i = 1; i <= ntokens; i++) ! 373: { ! 374: register char *p; ! 375: putc(',', ftable); ! 376: ! 377: if (j >= 10) ! 378: { ! 379: putc('\n', ftable); ! 380: j = 1; ! 381: } ! 382: else ! 383: { ! 384: j++; ! 385: } ! 386: ! 387: putc ('\"', ftable); ! 388: ! 389: for (p = tags[i]; *p; p++) ! 390: if (*p == '"' || *p == '\\') ! 391: fprintf(ftable, "\\%c", *p); ! 392: else if (*p == '\n') ! 393: fprintf(ftable, "\\n"); ! 394: else if (*p == '\t') ! 395: fprintf(ftable, "\\t"); ! 396: else if (*p == '\b') ! 397: fprintf(ftable, "\\b"); ! 398: else if (*p < 040 || *p >= 0177) ! 399: fprintf(ftable, "\\%03o", *p); ! 400: else ! 401: putc(*p, ftable); ! 402: ! 403: putc ('\"', ftable); ! 404: } ! 405: ! 406: fprintf(ftable, "\n};\n\nstatic const short yyr1[] = { 0"); ! 407: ! 408: j = 10; ! 409: for (i = 1; i <= nrules; i++) ! 410: { ! 411: putc(',', ftable); ! 412: ! 413: if (j >= 10) ! 414: { ! 415: putc('\n', ftable); ! 416: j = 1; ! 417: } ! 418: else ! 419: { ! 420: j++; ! 421: } ! 422: ! 423: fprintf(ftable, "%6d", rlhs[i]); ! 424: } ! 425: ! 426: FREE(rlhs + 1); ! 427: ! 428: fprintf(ftable, "\n};\n\nstatic const short yyr2[] = { 0"); ! 429: ! 430: j = 10; ! 431: for (i = 1; i < nrules; i++) ! 432: { ! 433: putc(',', ftable); ! 434: ! 435: if (j >= 10) ! 436: { ! 437: putc('\n', ftable); ! 438: j = 1; ! 439: } ! 440: else ! 441: { ! 442: j++; ! 443: } ! 444: ! 445: fprintf(ftable, "%6d", rrhs[i + 1] - rrhs[i] - 1); ! 446: } ! 447: ! 448: putc(',', ftable); ! 449: if (j >= 10) ! 450: putc('\n', ftable); ! 451: ! 452: fprintf(ftable, "%6d\n};\n", nitems - rrhs[nrules] - 1); ! 453: FREE(rrhs + 1); ! 454: } ! 455: ! 456: ! 457: ! 458: output_defines() ! 459: { ! 460: fprintf(ftable, "\n\n#define\tYYFINAL\t\t%d\n", final_state); ! 461: fprintf(ftable, "#define\tYYFLAG\t\t%d\n", MINSHORT); ! 462: fprintf(ftable, "#define\tYYNTBASE\t%d\n", ntokens); ! 463: } ! 464: ! 465: ! 466: ! 467: /* compute and output yydefact, yydefgoto, yypact, yypgoto, yytable and yycheck. */ ! 468: ! 469: output_actions() ! 470: { ! 471: nvectors = nstates + nvars; ! 472: ! 473: froms = NEW2(nvectors, short *); ! 474: tos = NEW2(nvectors, short *); ! 475: tally = NEW2(nvectors, short); ! 476: width = NEW2(nvectors, short); ! 477: ! 478: token_actions(); ! 479: free_shifts(); ! 480: free_reductions(); ! 481: FREE(lookaheads); ! 482: FREE(LA); ! 483: FREE(LAruleno); ! 484: FREE(accessing_symbol); ! 485: ! 486: goto_actions(); ! 487: FREE(goto_map + ntokens); ! 488: FREE(from_state); ! 489: FREE(to_state); ! 490: ! 491: sort_actions(); ! 492: pack_table(); ! 493: output_base(); ! 494: output_table(); ! 495: output_check(); ! 496: } ! 497: ! 498: ! 499: ! 500: /* figure out the actions for the specified state, indexed by lookahead token type. ! 501: ! 502: The yydefact table is output now. The detailed info ! 503: is saved for putting into yytable later. */ ! 504: ! 505: token_actions() ! 506: { ! 507: register int i; ! 508: register int j; ! 509: register int k; ! 510: ! 511: actrow = NEW2(ntokens, short); ! 512: ! 513: k = action_row(0); ! 514: fprintf(ftable, "\nstatic const short yydefact[] = {%6d", k); ! 515: save_row(0); ! 516: ! 517: j = 10; ! 518: for (i = 1; i < nstates; i++) ! 519: { ! 520: putc(',', ftable); ! 521: ! 522: if (j >= 10) ! 523: { ! 524: putc('\n', ftable); ! 525: j = 1; ! 526: } ! 527: else ! 528: { ! 529: j++; ! 530: } ! 531: ! 532: k = action_row(i); ! 533: fprintf(ftable, "%6d", k); ! 534: save_row(i); ! 535: } ! 536: ! 537: fprintf(ftable, "\n};\n"); ! 538: FREE(actrow); ! 539: } ! 540: ! 541: ! 542: ! 543: /* Decide what to do for each type of token if seen as the lookahead token in specified state. ! 544: The value returned is used as the default action (yydefact) for the state. ! 545: In addition, actrow is filled with what to do for each kind of token, ! 546: index by symbol number, with zero meaning do the default action. ! 547: The value MINSHORT, a very negative number, means this situation ! 548: is an error. The parser recognizes this value specially. ! 549: ! 550: This is where conflicts are resolved. The loop over lookahead rules ! 551: considered lower-numbered rules last, and the last rule considered that likes ! 552: a token gets to handle it. */ ! 553: ! 554: int ! 555: action_row(state) ! 556: int state; ! 557: { ! 558: register int i; ! 559: register int j; ! 560: register int k; ! 561: register int m; ! 562: register int n; ! 563: register int count; ! 564: register int default_rule; ! 565: register int nreds; ! 566: register int max; ! 567: register int rule; ! 568: register int shift_state; ! 569: register int symbol; ! 570: register unsigned mask; ! 571: register unsigned *wordp; ! 572: register reductions *redp; ! 573: register shifts *shiftp; ! 574: register errs *errp; ! 575: int nodefault = 0; /* set nonzero to inhibit having any default reduction */ ! 576: ! 577: for (i = 0; i < ntokens; i++) ! 578: actrow[i] = 0; ! 579: ! 580: default_rule = 0; ! 581: nreds = 0; ! 582: redp = reduction_table[state]; ! 583: ! 584: if (redp) ! 585: { ! 586: nreds = redp->nreds; ! 587: ! 588: if (nreds >= 1) ! 589: { ! 590: /* loop over all the rules available here which require lookahead */ ! 591: m = lookaheads[state]; ! 592: n = lookaheads[state + 1]; ! 593: ! 594: for (i = n - 1; i >= m; i--) ! 595: { ! 596: rule = - LAruleno[i]; ! 597: wordp = LA + i * tokensetsize; ! 598: mask = 1; ! 599: ! 600: /* and find each token which the rule finds acceptable to come next */ ! 601: for (j = 0; j < ntokens; j++) ! 602: { ! 603: /* and record this rule as the rule to use if that token follows. */ ! 604: if (mask & *wordp) ! 605: actrow[j] = rule; ! 606: ! 607: mask <<= 1; ! 608: if (mask == 0) ! 609: { ! 610: mask = 1; ! 611: wordp++; ! 612: } ! 613: } ! 614: } ! 615: } ! 616: } ! 617: ! 618: shiftp = shift_table[state]; ! 619: ! 620: /* now see which tokens are allowed for shifts in this state. ! 621: For them, record the shift as the thing to do. So shift is preferred to reduce. */ ! 622: ! 623: if (shiftp) ! 624: { ! 625: k = shiftp->nshifts; ! 626: ! 627: for (i = 0; i < k; i++) ! 628: { ! 629: shift_state = shiftp->shifts[i]; ! 630: if (! shift_state) continue; ! 631: ! 632: symbol = accessing_symbol[shift_state]; ! 633: ! 634: if (ISVAR(symbol)) ! 635: break; ! 636: ! 637: actrow[symbol] = shift_state; ! 638: ! 639: /* do not use any default reduction if there is a shift for error */ ! 640: ! 641: if (symbol == error_token_number) nodefault = 1; ! 642: } ! 643: } ! 644: ! 645: errp = err_table[state]; ! 646: ! 647: /* See which tokens are an explicit error in this state ! 648: (due to %nonassoc). For them, record MINSHORT as the action. */ ! 649: ! 650: if (errp) ! 651: { ! 652: k = errp->nerrs; ! 653: ! 654: for (i = 0; i < k; i++) ! 655: { ! 656: symbol = errp->errs[i]; ! 657: actrow[symbol] = MINSHORT; ! 658: } ! 659: } ! 660: ! 661: /* now find the most common reduction and make it the default action for this state. */ ! 662: ! 663: if (nreds >= 1 && ! nodefault) ! 664: { ! 665: if (consistent[state]) ! 666: default_rule = redp->rules[0]; ! 667: else ! 668: { ! 669: max = 0; ! 670: for (i = m; i < n; i++) ! 671: { ! 672: count = 0; ! 673: rule = - LAruleno[i]; ! 674: ! 675: for (j = 0; j < ntokens; j++) ! 676: { ! 677: if (actrow[j] == rule) ! 678: count++; ! 679: } ! 680: ! 681: if (count > max) ! 682: { ! 683: max = count; ! 684: default_rule = rule; ! 685: } ! 686: } ! 687: ! 688: /* actions which match the default are replaced with zero, ! 689: which means "use the default" */ ! 690: ! 691: if (max > 0) ! 692: { ! 693: for (j = 0; j < ntokens; j++) ! 694: { ! 695: if (actrow[j] == default_rule) ! 696: actrow[j] = 0; ! 697: } ! 698: ! 699: default_rule = - default_rule; ! 700: } ! 701: } ! 702: } ! 703: ! 704: /* If have no default rule, the default is an error. ! 705: So replace any action which says "error" with "use default". */ ! 706: ! 707: if (default_rule == 0) ! 708: for (j = 0; j < ntokens; j++) ! 709: { ! 710: if (actrow[j] == MINSHORT) ! 711: actrow[j] = 0; ! 712: } ! 713: ! 714: return (default_rule); ! 715: } ! 716: ! 717: ! 718: ! 719: save_row(state) ! 720: int state; ! 721: { ! 722: register int i; ! 723: register int count; ! 724: register short *sp; ! 725: register short *sp1; ! 726: register short *sp2; ! 727: ! 728: count = 0; ! 729: for (i = 0; i < ntokens; i++) ! 730: { ! 731: if (actrow[i] != 0) ! 732: count++; ! 733: } ! 734: ! 735: if (count == 0) ! 736: return; ! 737: ! 738: froms[state] = sp1 = sp = NEW2(count, short); ! 739: tos[state] = sp2 = NEW2(count, short); ! 740: ! 741: for (i = 0; i < ntokens; i++) ! 742: { ! 743: if (actrow[i] != 0) ! 744: { ! 745: *sp1++ = i; ! 746: *sp2++ = actrow[i]; ! 747: } ! 748: } ! 749: ! 750: tally[state] = count; ! 751: width[state] = sp1[-1] - sp[0] + 1; ! 752: } ! 753: ! 754: ! 755: ! 756: /* figure out what to do after reducing with each rule, ! 757: depending on the saved state from before the beginning ! 758: of parsing the data that matched this rule. ! 759: ! 760: The yydefgoto table is output now. The detailed info ! 761: is saved for putting into yytable later. */ ! 762: ! 763: goto_actions() ! 764: { ! 765: register int i; ! 766: register int j; ! 767: register int k; ! 768: ! 769: state_count = NEW2(nstates, short); ! 770: ! 771: k = default_goto(ntokens); ! 772: fprintf(ftable, "\nstatic const short yydefgoto[] = {%6d", k); ! 773: save_column(ntokens, k); ! 774: ! 775: j = 10; ! 776: for (i = ntokens + 1; i < nsyms; i++) ! 777: { ! 778: putc(',', ftable); ! 779: ! 780: if (j >= 10) ! 781: { ! 782: putc('\n', ftable); ! 783: j = 1; ! 784: } ! 785: else ! 786: { ! 787: j++; ! 788: } ! 789: ! 790: k = default_goto(i); ! 791: fprintf(ftable, "%6d", k); ! 792: save_column(i, k); ! 793: } ! 794: ! 795: fprintf(ftable, "\n};\n"); ! 796: FREE(state_count); ! 797: } ! 798: ! 799: ! 800: ! 801: int ! 802: default_goto(symbol) ! 803: int symbol; ! 804: { ! 805: register int i; ! 806: register int m; ! 807: register int n; ! 808: register int default_state; ! 809: register int max; ! 810: ! 811: m = goto_map[symbol]; ! 812: n = goto_map[symbol + 1]; ! 813: ! 814: if (m == n) ! 815: return (-1); ! 816: ! 817: for (i = 0; i < nstates; i++) ! 818: state_count[i] = 0; ! 819: ! 820: for (i = m; i < n; i++) ! 821: state_count[to_state[i]]++; ! 822: ! 823: max = 0; ! 824: default_state = -1; ! 825: ! 826: for (i = 0; i < nstates; i++) ! 827: { ! 828: if (state_count[i] > max) ! 829: { ! 830: max = state_count[i]; ! 831: default_state = i; ! 832: } ! 833: } ! 834: ! 835: return (default_state); ! 836: } ! 837: ! 838: ! 839: ! 840: save_column(symbol, default_state) ! 841: int symbol; ! 842: int default_state; ! 843: { ! 844: register int i; ! 845: register int m; ! 846: register int n; ! 847: register short *sp; ! 848: register short *sp1; ! 849: register short *sp2; ! 850: register int count; ! 851: register int symno; ! 852: ! 853: m = goto_map[symbol]; ! 854: n = goto_map[symbol + 1]; ! 855: ! 856: count = 0; ! 857: for (i = m; i < n; i++) ! 858: { ! 859: if (to_state[i] != default_state) ! 860: count++; ! 861: } ! 862: ! 863: if (count == 0) ! 864: return; ! 865: ! 866: symno = symbol - ntokens + nstates; ! 867: ! 868: froms[symno] = sp1 = sp = NEW2(count, short); ! 869: tos[symno] = sp2 = NEW2(count, short); ! 870: ! 871: for (i = m; i < n; i++) ! 872: { ! 873: if (to_state[i] != default_state) ! 874: { ! 875: *sp1++ = from_state[i]; ! 876: *sp2++ = to_state[i]; ! 877: } ! 878: } ! 879: ! 880: tally[symno] = count; ! 881: width[symno] = sp1[-1] - sp[0] + 1; ! 882: } ! 883: ! 884: ! 885: ! 886: /* the next few functions decide how to pack ! 887: the actions and gotos information into yytable. */ ! 888: ! 889: sort_actions() ! 890: { ! 891: register int i; ! 892: register int j; ! 893: register int k; ! 894: register int t; ! 895: register int w; ! 896: ! 897: order = NEW2(nvectors, short); ! 898: nentries = 0; ! 899: ! 900: for (i = 0; i < nvectors; i++) ! 901: { ! 902: if (tally[i] > 0) ! 903: { ! 904: t = tally[i]; ! 905: w = width[i]; ! 906: j = nentries - 1; ! 907: ! 908: while (j >= 0 && (width[order[j]] < w)) ! 909: j--; ! 910: ! 911: while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t)) ! 912: j--; ! 913: ! 914: for (k = nentries - 1; k > j; k--) ! 915: order[k + 1] = order[k]; ! 916: ! 917: order[j + 1] = i; ! 918: nentries++; ! 919: } ! 920: } ! 921: } ! 922: ! 923: ! 924: ! 925: pack_table() ! 926: { ! 927: register int i; ! 928: register int place; ! 929: register int state; ! 930: ! 931: base = NEW2(nvectors, short); ! 932: pos = NEW2(nentries, short); ! 933: table = NEW2(MAXTABLE, short); ! 934: check = NEW2(MAXTABLE, short); ! 935: ! 936: lowzero = 0; ! 937: high = 0; ! 938: ! 939: for (i = 0; i < nvectors; i++) ! 940: base[i] = MINSHORT; ! 941: ! 942: for (i = 0; i < MAXTABLE; i++) ! 943: check[i] = -1; ! 944: ! 945: for (i = 0; i < nentries; i++) ! 946: { ! 947: state = matching_state(i); ! 948: ! 949: if (state < 0) ! 950: place = pack_vector(i); ! 951: else ! 952: place = base[state]; ! 953: ! 954: pos[i] = place; ! 955: base[order[i]] = place; ! 956: } ! 957: ! 958: for (i = 0; i < nvectors; i++) ! 959: { ! 960: FREE(froms[i]); ! 961: FREE(tos[i]); ! 962: } ! 963: ! 964: FREE(froms); ! 965: FREE(tos); ! 966: FREE(pos); ! 967: } ! 968: ! 969: ! 970: ! 971: int ! 972: matching_state(vector) ! 973: int vector; ! 974: { ! 975: register int i; ! 976: register int j; ! 977: register int k; ! 978: register int t; ! 979: register int w; ! 980: register int match; ! 981: register int prev; ! 982: ! 983: i = order[vector]; ! 984: if (i >= nstates) ! 985: return (-1); ! 986: ! 987: t = tally[i]; ! 988: w = width[i]; ! 989: ! 990: for (prev = vector - 1; prev >= 0; prev--) ! 991: { ! 992: j = order[prev]; ! 993: if (width[j] != w || tally[j] != t) ! 994: return (-1); ! 995: ! 996: match = 1; ! 997: for (k = 0; match && k < t; k++) ! 998: { ! 999: if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k]) ! 1000: match = 0; ! 1001: } ! 1002: ! 1003: if (match) ! 1004: return (j); ! 1005: } ! 1006: ! 1007: return (-1); ! 1008: } ! 1009: ! 1010: ! 1011: ! 1012: int ! 1013: pack_vector(vector) ! 1014: int vector; ! 1015: { ! 1016: register int i; ! 1017: register int j; ! 1018: register int k; ! 1019: register int t; ! 1020: register int loc; ! 1021: register int ok; ! 1022: register short *from; ! 1023: register short *to; ! 1024: ! 1025: i = order[vector]; ! 1026: t = tally[i]; ! 1027: ! 1028: if (t == 0) ! 1029: berror("pack_vector"); ! 1030: ! 1031: from = froms[i]; ! 1032: to = tos[i]; ! 1033: ! 1034: for (j = lowzero - from[0]; j < MAXTABLE; j++) ! 1035: { ! 1036: ok = 1; ! 1037: ! 1038: for (k = 0; ok && k < t; k++) ! 1039: { ! 1040: loc = j + from[k]; ! 1041: if (loc > MAXTABLE) ! 1042: fatals("maximum table size (%d) exceeded",MAXTABLE); ! 1043: ! 1044: if (table[loc] != 0) ! 1045: ok = 0; ! 1046: } ! 1047: ! 1048: for (k = 0; ok && k < vector; k++) ! 1049: { ! 1050: if (pos[k] == j) ! 1051: ok = 0; ! 1052: } ! 1053: ! 1054: if (ok) ! 1055: { ! 1056: for (k = 0; k < t; k++) ! 1057: { ! 1058: loc = j + from[k]; ! 1059: table[loc] = to[k]; ! 1060: check[loc] = from[k]; ! 1061: } ! 1062: ! 1063: while (table[lowzero] != 0) ! 1064: lowzero++; ! 1065: ! 1066: if (loc > high) ! 1067: high = loc; ! 1068: ! 1069: return (j); ! 1070: } ! 1071: } ! 1072: ! 1073: berror("pack_vector"); ! 1074: return 0; /* JF keep lint happy */ ! 1075: } ! 1076: ! 1077: ! 1078: ! 1079: /* the following functions output yytable, yycheck ! 1080: and the vectors whose elements index the portion starts */ ! 1081: ! 1082: output_base() ! 1083: { ! 1084: register int i; ! 1085: register int j; ! 1086: ! 1087: fprintf(ftable, "\nstatic const short yypact[] = {%6d", base[0]); ! 1088: ! 1089: j = 10; ! 1090: for (i = 1; i < nstates; i++) ! 1091: { ! 1092: putc(',', ftable); ! 1093: ! 1094: if (j >= 10) ! 1095: { ! 1096: putc('\n', ftable); ! 1097: j = 1; ! 1098: } ! 1099: else ! 1100: { ! 1101: j++; ! 1102: } ! 1103: ! 1104: fprintf(ftable, "%6d", base[i]); ! 1105: } ! 1106: ! 1107: fprintf(ftable, "\n};\n\nstatic const short yypgoto[] = {%6d", base[nstates]); ! 1108: ! 1109: j = 10; ! 1110: for (i = nstates + 1; i < nvectors; i++) ! 1111: { ! 1112: putc(',', ftable); ! 1113: ! 1114: if (j >= 10) ! 1115: { ! 1116: putc('\n', ftable); ! 1117: j = 1; ! 1118: } ! 1119: else ! 1120: { ! 1121: j++; ! 1122: } ! 1123: ! 1124: fprintf(ftable, "%6d", base[i]); ! 1125: } ! 1126: ! 1127: fprintf(ftable, "\n};\n"); ! 1128: FREE(base); ! 1129: } ! 1130: ! 1131: ! 1132: ! 1133: output_table() ! 1134: { ! 1135: register int i; ! 1136: register int j; ! 1137: ! 1138: fprintf(ftable, "\n\n#define\tYYLAST\t\t%d\n\n", high); ! 1139: fprintf(ftable, "\nstatic const short yytable[] = {%6d", table[0]); ! 1140: ! 1141: j = 10; ! 1142: for (i = 1; i <= high; i++) ! 1143: { ! 1144: putc(',', ftable); ! 1145: ! 1146: if (j >= 10) ! 1147: { ! 1148: putc('\n', ftable); ! 1149: j = 1; ! 1150: } ! 1151: else ! 1152: { ! 1153: j++; ! 1154: } ! 1155: ! 1156: fprintf(ftable, "%6d", table[i]); ! 1157: } ! 1158: ! 1159: fprintf(ftable, "\n};\n"); ! 1160: FREE(table); ! 1161: } ! 1162: ! 1163: ! 1164: ! 1165: output_check() ! 1166: { ! 1167: register int i; ! 1168: register int j; ! 1169: ! 1170: fprintf(ftable, "\nstatic const short yycheck[] = {%6d", check[0]); ! 1171: ! 1172: j = 10; ! 1173: for (i = 1; i <= high; i++) ! 1174: { ! 1175: putc(',', ftable); ! 1176: ! 1177: if (j >= 10) ! 1178: { ! 1179: putc('\n', ftable); ! 1180: j = 1; ! 1181: } ! 1182: else ! 1183: { ! 1184: j++; ! 1185: } ! 1186: ! 1187: fprintf(ftable, "%6d", check[i]); ! 1188: } ! 1189: ! 1190: fprintf(ftable, "\n};\n"); ! 1191: FREE(check); ! 1192: } ! 1193: ! 1194: ! 1195: ! 1196: /* copy the parser code into the ftable file at the end. */ ! 1197: ! 1198: output_parser() ! 1199: { ! 1200: register int c; ! 1201: #ifdef DONTDEF ! 1202: FILE *fpars; ! 1203: #else ! 1204: #define fpars fparser ! 1205: #endif ! 1206: ! 1207: if (pure_parser) ! 1208: fprintf(ftable, "#define YYIMPURE 1\n\n"); ! 1209: else ! 1210: fprintf(ftable, "#define YYPURE 1\n\n"); ! 1211: ! 1212: #ifdef DONTDEF /* JF no longer needed 'cuz open_extra_files changes the ! 1213: currently open parser from bison.simple to bison.hairy */ ! 1214: if (semantic_parser) ! 1215: fpars = fparser; ! 1216: else fpars = fparser1; ! 1217: #endif ! 1218: ! 1219: c = getc(fpars); ! 1220: while (c != EOF) ! 1221: { ! 1222: if (c == '$') { ! 1223: #ifdef DONTDEF ! 1224: fprintf(ftable, "#include \"%s\"\n", actfile); ! 1225: #else ! 1226: /* JF don't #include the action file. Stuff it right in. */ ! 1227: rewind(faction); ! 1228: for(c=getc(faction);c!=EOF;c=getc(faction)) ! 1229: putc(c,ftable); ! 1230: #endif ! 1231: } else ! 1232: putc(c, ftable); ! 1233: c = getc(fpars); ! 1234: } ! 1235: } ! 1236: ! 1237: ! 1238: ! 1239: output_program() ! 1240: { ! 1241: register int c; ! 1242: extern int lineno; ! 1243: ! 1244: fprintf(ftable, "#line %d \"%s\"\n", lineno, infile); ! 1245: ! 1246: c = getc(finput); ! 1247: while (c != EOF) ! 1248: { ! 1249: putc(c, ftable); ! 1250: c = getc(finput); ! 1251: } ! 1252: } ! 1253: ! 1254: ! 1255: ! 1256: free_itemsets() ! 1257: { ! 1258: register core *cp,*cptmp; ! 1259: ! 1260: FREE(state_table); ! 1261: ! 1262: for (cp = first_state; cp; cp = cptmp) { ! 1263: cptmp=cp->next; ! 1264: FREE(cp); ! 1265: } ! 1266: } ! 1267: ! 1268: ! 1269: ! 1270: free_shifts() ! 1271: { ! 1272: register shifts *sp,*sptmp;/* JF derefrenced freed ptr */ ! 1273: ! 1274: FREE(shift_table); ! 1275: ! 1276: for (sp = first_shift; sp; sp = sptmp) { ! 1277: sptmp=sp->next; ! 1278: FREE(sp); ! 1279: } ! 1280: } ! 1281: ! 1282: ! 1283: ! 1284: free_reductions() ! 1285: { ! 1286: register reductions *rp,*rptmp;/* JF fixed freed ptr */ ! 1287: ! 1288: FREE(reduction_table); ! 1289: ! 1290: for (rp = first_reduction; rp; rp = rptmp) { ! 1291: rptmp=rp->next; ! 1292: FREE(rp); ! 1293: } ! 1294: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.