![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bi-parser.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to bi-parser.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 ! root 1: ! 2: /* A Bison parser, made from bi-parser.y */ ! 3: ! 4: #define DEFOP 258 ! 5: #define STRING 259 ! 6: ! 7: #line 21 "bi-parser.y" ! 8: ! 9: ! 10: #include <stdio.h> ! 11: #include "hconfig.h" ! 12: #include "bi-defs.h" ! 13: ! 14: extern char yytext[]; ! 15: extern int yyleng; ! 16: ! 17: ! 18: /* Chain of all defs built by the parser. */ ! 19: struct def *defs; ! 20: int ndefs; ! 21: ! 22: static struct node *makenode (); ! 23: static struct variation *makevar (); ! 24: static struct def *makedef (); ! 25: ! 26: void yyerror (); ! 27: ! 28: ! 29: #line 43 "bi-parser.y" ! 30: typedef union ! 31: { ! 32: char *string; ! 33: struct def *def; ! 34: struct variation *variation; ! 35: struct node *node; ! 36: } YYSTYPE; ! 37: ! 38: #ifndef YYLTYPE ! 39: typedef ! 40: struct yyltype ! 41: { ! 42: int timestamp; ! 43: int first_line; ! 44: int first_column; ! 45: int last_line; ! 46: int last_column; ! 47: char *text; ! 48: } ! 49: yyltype; ! 50: ! 51: #define YYLTYPE yyltype ! 52: #endif ! 53: ! 54: #include <stdio.h> ! 55: ! 56: #ifndef __STDC__ ! 57: #define const ! 58: #endif ! 59: ! 60: ! 61: ! 62: #define YYFINAL 39 ! 63: #define YYFLAG -32768 ! 64: #define YYNTBASE 8 ! 65: ! 66: #define YYTRANSLATE(x) ((unsigned)(x) <= 259 ? yytranslate[x] : 17) ! 67: ! 68: static const char yytranslate[] = { 0, ! 69: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 70: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 71: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 72: 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, ! 73: 7, 2, 2, 6, 2, 2, 2, 2, 2, 2, ! 74: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 75: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 76: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 77: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 78: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 79: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 80: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 81: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 82: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 83: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 84: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 85: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 86: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 87: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 88: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 89: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 90: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 91: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 92: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 93: 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 94: 2, 2, 2, 2, 2, 1, 2, 3, 4 ! 95: }; ! 96: ! 97: static const short yyrline[] = { 0, ! 98: 59, 64, 66, 70, 75, 77, 81, 84, 86, 88, ! 99: 92, 94, 97, 100, 104, 107, 111 ! 100: }; ! 101: ! 102: static const char * const yytname[] = { 0, ! 103: "error","$illegal.","DEFOP","STRING","'('","','","')'","top" ! 104: }; ! 105: ! 106: static const short yyr1[] = { 0, ! 107: 8, 9, 9, 10, 11, 11, 12, 12, 12, 12, ! 108: 13, 13, 14, 14, 15, 15, 16 ! 109: }; ! 110: ! 111: static const short yyr2[] = { 0, ! 112: 1, 1, 2, 10, 1, 3, 3, 5, 7, 9, ! 113: 0, 1, 3, 0, 1, 3, 1 ! 114: }; ! 115: ! 116: static const short yydefact[] = { 0, ! 117: 0, 1, 2, 0, 3, 0, 11, 12, 0, 0, ! 118: 0, 11, 0, 5, 0, 0, 0, 14, 7, 6, ! 119: 4, 0, 0, 17, 0, 15, 14, 8, 13, 0, ! 120: 0, 16, 14, 9, 0, 10, 0, 0, 0 ! 121: }; ! 122: ! 123: static const short yydefgoto[] = { 37, ! 124: 2, 3, 13, 14, 9, 23, 25, 26 ! 125: }; ! 126: ! 127: static const short yypact[] = { 2, ! 128: 6, 2,-32768, 8,-32768, 7, 10,-32768, 9, 11, ! 129: 12, 10, -5,-32768, -3, 12, 13, 14,-32768,-32768, ! 130: -32768, 17, 1,-32768, 15, 18, 14,-32768,-32768, 17, ! 131: 3,-32768, 14,-32768, 16,-32768, 25, 26,-32768 ! 132: }; ! 133: ! 134: static const short yypgoto[] = {-32768, ! 135: -32768, 27,-32768, 19, 20, -27, -12,-32768 ! 136: }; ! 137: ! 138: ! 139: #define YYLAST 35 ! 140: ! 141: ! 142: static const short yytable[] = { 31, ! 143: 16, 17, 18, 19, 1, 35, 27, 28, 33, 34, ! 144: 4, 6, 7, 8, 10, 11, 12, 32, 22, 21, ! 145: 24, 29, 36, 30, 38, 39, 0, 0, 5, 0, ! 146: 0, 15, 0, 0, 20 ! 147: }; ! 148: ! 149: static const short yycheck[] = { 27, ! 150: 6, 7, 6, 7, 3, 33, 6, 7, 6, 7, ! 151: 5, 4, 6, 4, 6, 5, 5, 30, 5, 7, ! 152: 4, 7, 7, 6, 0, 0, -1, -1, 2, -1, ! 153: -1, 12, -1, -1, 16 ! 154: }; ! 155: #define YYPURE 1 ! 156: ! 157: /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ ! 158: #line 3 "bison.simple" ! 159: ! 160: /* Skeleton output parser for bison, ! 161: Copyright (C) 1984 Bob Corbett and Richard Stallman ! 162: ! 163: This program is free software; you can redistribute it and/or modify ! 164: it under the terms of the GNU General Public License as published by ! 165: the Free Software Foundation; either version 1, or (at your option) ! 166: any later version. ! 167: ! 168: This program is distributed in the hope that it will be useful, ! 169: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 170: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 171: GNU General Public License for more details. ! 172: ! 173: You should have received a copy of the GNU General Public License ! 174: along with this program; if not, write to the Free Software ! 175: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 176: ! 177: ! 178: #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) ! 179: #include <alloca.h> ! 180: #endif ! 181: ! 182: /* This is the parser code that is written into each bison parser ! 183: when the %semantic_parser declaration is not specified in the grammar. ! 184: It was written by Richard Stallman by simplifying the hairy parser ! 185: used when %semantic_parser is specified. */ ! 186: ! 187: /* Note: there must be only one dollar sign in this file. ! 188: It is replaced by the list of actions, each action ! 189: as one case of the switch. */ ! 190: ! 191: #define yyerrok (yyerrstatus = 0) ! 192: #define yyclearin (yychar = YYEMPTY) ! 193: #define YYEMPTY -2 ! 194: #define YYEOF 0 ! 195: #define YYFAIL goto yyerrlab; ! 196: #define YYACCEPT return(0) ! 197: #define YYABORT return(1) ! 198: #define YYERROR goto yyerrlab ! 199: ! 200: #define YYTERROR 1 ! 201: #define YYERRCODE 256 ! 202: ! 203: #ifndef YYIMPURE ! 204: #define YYLEX yylex() ! 205: #endif ! 206: ! 207: #ifndef YYPURE ! 208: #define YYLEX yylex(&yylval, &yylloc) ! 209: #endif ! 210: ! 211: /* If nonreentrant, generate the variables here */ ! 212: ! 213: #ifndef YYIMPURE ! 214: ! 215: int yychar; /* the lookahead symbol */ ! 216: YYSTYPE yylval; /* the semantic value of the */ ! 217: /* lookahead symbol */ ! 218: ! 219: YYLTYPE yylloc; /* location data for the lookahead */ ! 220: /* symbol */ ! 221: ! 222: int yynerrs; /* number of parse errors so far */ ! 223: #endif /* YYIMPURE */ ! 224: ! 225: #if YYDEBUG != 0 ! 226: int yydebug; /* nonzero means print parse trace */ ! 227: /* Since this is uninitialized, it does not stop multiple parsers ! 228: from coexisting. */ ! 229: #endif ! 230: ! 231: /* YYMAXDEPTH indicates the initial size of the parser's stacks */ ! 232: ! 233: #ifndef YYMAXDEPTH ! 234: #define YYMAXDEPTH 200 ! 235: #endif ! 236: ! 237: /* YYMAXLIMIT is the maximum size the stacks can grow to ! 238: (effective only if the built-in stack extension method is used). */ ! 239: ! 240: #ifndef YYMAXLIMIT ! 241: #define YYMAXLIMIT 10000 ! 242: #endif ! 243: ! 244: ! 245: #line 90 "bison.simple" ! 246: int ! 247: yyparse() ! 248: { ! 249: register int yystate; ! 250: register int yyn; ! 251: register short *yyssp; ! 252: register YYSTYPE *yyvsp; ! 253: YYLTYPE *yylsp; ! 254: int yyerrstatus; /* number of tokens to shift before error messages enabled */ ! 255: int yychar1; /* lookahead token as an internal (translated) token number */ ! 256: ! 257: short yyssa[YYMAXDEPTH]; /* the state stack */ ! 258: YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */ ! 259: YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */ ! 260: ! 261: short *yyss = yyssa; /* refer to the stacks thru separate pointers */ ! 262: YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ ! 263: YYLTYPE *yyls = yylsa; ! 264: ! 265: int yymaxdepth = YYMAXDEPTH; ! 266: ! 267: #ifndef YYPURE ! 268: int yychar; ! 269: YYSTYPE yylval; ! 270: YYLTYPE yylloc; ! 271: int yynerrs; ! 272: #endif ! 273: ! 274: YYSTYPE yyval; /* the variable used to return */ ! 275: /* semantic values from the action */ ! 276: /* routines */ ! 277: ! 278: int yylen; ! 279: ! 280: #if YYDEBUG != 0 ! 281: if (yydebug) ! 282: fprintf(stderr, "Starting parse\n"); ! 283: #endif ! 284: ! 285: yystate = 0; ! 286: yyerrstatus = 0; ! 287: yynerrs = 0; ! 288: yychar = YYEMPTY; /* Cause a token to be read. */ ! 289: ! 290: /* Initialize stack pointers. ! 291: Waste one element of value and location stack ! 292: so that they stay on the same level as the state stack. */ ! 293: ! 294: yyssp = yyss - 1; ! 295: yyvsp = yyvs; ! 296: yylsp = yyls; ! 297: ! 298: /* Push a new state, which is found in yystate . */ ! 299: /* In all cases, when you get here, the value and location stacks ! 300: have just been pushed. so pushing a state here evens the stacks. */ ! 301: yynewstate: ! 302: ! 303: *++yyssp = yystate; ! 304: ! 305: if (yyssp >= yyss + yymaxdepth - 1) ! 306: { ! 307: /* Give user a chance to reallocate the stack */ ! 308: /* Use copies of these so that the &'s don't force the real ones into memory. */ ! 309: YYSTYPE *yyvs1 = yyvs; ! 310: YYLTYPE *yyls1 = yyls; ! 311: short *yyss1 = yyss; ! 312: ! 313: /* Get the current used size of the three stacks, in elements. */ ! 314: int size = yyssp - yyss + 1; ! 315: ! 316: #ifdef yyoverflow ! 317: /* Each stack pointer address is followed by the size of ! 318: the data in use in that stack, in bytes. */ ! 319: yyoverflow("parser stack overflow", ! 320: &yyss1, size * sizeof (*yyssp), ! 321: &yyvs1, size * sizeof (*yyvsp), ! 322: &yyls1, size * sizeof (*yylsp), ! 323: &yymaxdepth); ! 324: ! 325: yyss = yyss1; yyvs = yyvs1; yyls = yyls1; ! 326: #else /* no yyoverflow */ ! 327: /* Extend the stack our own way. */ ! 328: if (yymaxdepth >= YYMAXLIMIT) ! 329: yyerror("parser stack overflow"); ! 330: yymaxdepth *= 2; ! 331: if (yymaxdepth > YYMAXLIMIT) ! 332: yymaxdepth = YYMAXLIMIT; ! 333: yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp)); ! 334: bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp)); ! 335: yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp)); ! 336: bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp)); ! 337: #ifdef YYLSP_NEEDED ! 338: yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp)); ! 339: bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp)); ! 340: #endif ! 341: #endif /* no yyoverflow */ ! 342: ! 343: yyssp = yyss + size - 1; ! 344: yyvsp = yyvs + size - 1; ! 345: #ifdef YYLSP_NEEDED ! 346: yylsp = yyls + size - 1; ! 347: #endif ! 348: ! 349: #if YYDEBUG != 0 ! 350: if (yydebug) ! 351: fprintf(stderr, "Stack size increased to %d\n", yymaxdepth); ! 352: #endif ! 353: ! 354: if (yyssp >= yyss + yymaxdepth - 1) ! 355: YYABORT; ! 356: } ! 357: ! 358: #if YYDEBUG != 0 ! 359: if (yydebug) ! 360: fprintf(stderr, "Entering state %d\n", yystate); ! 361: #endif ! 362: ! 363: /* Do appropriate processing given the current state. */ ! 364: /* Read a lookahead token if we need one and don't already have one. */ ! 365: yyresume: ! 366: ! 367: /* First try to decide what to do without reference to lookahead token. */ ! 368: ! 369: yyn = yypact[yystate]; ! 370: if (yyn == YYFLAG) ! 371: goto yydefault; ! 372: ! 373: /* Not known => get a lookahead token if don't already have one. */ ! 374: ! 375: /* yychar is either YYEMPTY or YYEOF ! 376: or a valid token in external form. */ ! 377: ! 378: if (yychar == YYEMPTY) ! 379: { ! 380: #if YYDEBUG != 0 ! 381: if (yydebug) ! 382: fprintf(stderr, "Reading a token: "); ! 383: #endif ! 384: yychar = YYLEX; ! 385: } ! 386: ! 387: /* Convert token to internal form (in yychar1) for indexing tables with */ ! 388: ! 389: if (yychar <= 0) /* This means end of input. */ ! 390: { ! 391: yychar1 = 0; ! 392: yychar = YYEOF; /* Don't call YYLEX any more */ ! 393: ! 394: #if YYDEBUG != 0 ! 395: if (yydebug) ! 396: fprintf(stderr, "Now at end of input.\n"); ! 397: #endif ! 398: } ! 399: else ! 400: { ! 401: yychar1 = YYTRANSLATE(yychar); ! 402: ! 403: #if YYDEBUG != 0 ! 404: if (yydebug) ! 405: fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]); ! 406: #endif ! 407: } ! 408: ! 409: yyn += yychar1; ! 410: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) ! 411: goto yydefault; ! 412: ! 413: yyn = yytable[yyn]; ! 414: ! 415: /* yyn is what to do for this token type in this state. ! 416: Negative => reduce, -yyn is rule number. ! 417: Positive => shift, yyn is new state. ! 418: New state is final state => don't bother to shift, ! 419: just return success. ! 420: 0, or most negative number => error. */ ! 421: ! 422: if (yyn < 0) ! 423: { ! 424: if (yyn == YYFLAG) ! 425: goto yyerrlab; ! 426: yyn = -yyn; ! 427: goto yyreduce; ! 428: } ! 429: else if (yyn == 0) ! 430: goto yyerrlab; ! 431: ! 432: if (yyn == YYFINAL) ! 433: YYACCEPT; ! 434: ! 435: /* Shift the lookahead token. */ ! 436: ! 437: #if YYDEBUG != 0 ! 438: if (yydebug) ! 439: fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); ! 440: #endif ! 441: ! 442: /* Discard the token being shifted unless it is eof. */ ! 443: if (yychar != YYEOF) ! 444: yychar = YYEMPTY; ! 445: ! 446: *++yyvsp = yylval; ! 447: #ifdef YYLSP_NEEDED ! 448: *++yylsp = yylloc; ! 449: #endif ! 450: ! 451: /* count tokens shifted since error; after three, turn off error status. */ ! 452: if (yyerrstatus) yyerrstatus--; ! 453: ! 454: yystate = yyn; ! 455: goto yynewstate; ! 456: ! 457: /* Do the default action for the current state. */ ! 458: yydefault: ! 459: ! 460: yyn = yydefact[yystate]; ! 461: if (yyn == 0) ! 462: goto yyerrlab; ! 463: ! 464: /* Do a reduction. yyn is the number of a rule to reduce with. */ ! 465: yyreduce: ! 466: yylen = yyr2[yyn]; ! 467: yyval = yyvsp[1-yylen]; /* implement default value of the action */ ! 468: ! 469: #if YYDEBUG != 0 ! 470: if (yydebug) ! 471: { ! 472: if (yylen == 1) ! 473: fprintf (stderr, "Reducing 1 value via line %d, ", ! 474: yyrline[yyn]); ! 475: else ! 476: fprintf (stderr, "Reducing %d values via line %d, ", ! 477: yylen, yyrline[yyn]); ! 478: } ! 479: #endif ! 480: ! 481: ! 482: switch (yyn) { ! 483: ! 484: case 1: ! 485: #line 61 "bi-parser.y" ! 486: { defs = yyvsp[0].def; ; ! 487: break;} ! 488: case 3: ! 489: #line 67 "bi-parser.y" ! 490: { yyvsp[0].def->next = yyvsp[-1].def; yyval.def = yyvsp[0].def; ; ! 491: break;} ! 492: case 4: ! 493: #line 72 "bi-parser.y" ! 494: { yyval.def = makedef (yyvsp[-7].string, yyvsp[-5].string, yyvsp[-2].variation); ; ! 495: break;} ! 496: case 6: ! 497: #line 78 "bi-parser.y" ! 498: { yyvsp[0].variation->next = yyvsp[-2].variation; yyval.variation = yyvsp[0].variation; ; ! 499: break;} ! 500: case 7: ! 501: #line 83 "bi-parser.y" ! 502: { yyval.variation = makevar (yyvsp[-1].string, (struct node *) NULL, (struct node *) NULL, (struct node *) NULL); ; ! 503: break;} ! 504: case 8: ! 505: #line 85 "bi-parser.y" ! 506: { yyval.variation = makevar (yyvsp[-3].string, yyvsp[-1].node, (struct node *) NULL, (struct node *) NULL); ; ! 507: break;} ! 508: case 9: ! 509: #line 87 "bi-parser.y" ! 510: { yyval.variation = makevar (yyvsp[-5].string, yyvsp[-3].node, yyvsp[-1].node, (struct node *) NULL); ; ! 511: break;} ! 512: case 10: ! 513: #line 89 "bi-parser.y" ! 514: { yyval.variation = makevar (yyvsp[-7].string, yyvsp[-5].node, yyvsp[-3].node, yyvsp[-1].node); ; ! 515: break;} ! 516: case 11: ! 517: #line 93 "bi-parser.y" ! 518: { yyval.string = ""; ; ! 519: break;} ! 520: case 12: ! 521: #line 94 "bi-parser.y" ! 522: { yyval.string = yyvsp[0].string; ; ! 523: break;} ! 524: case 13: ! 525: #line 99 "bi-parser.y" ! 526: { yyval.node = yyvsp[-1].node; ; ! 527: break;} ! 528: case 14: ! 529: #line 101 "bi-parser.y" ! 530: { yyval.node = NULL; ; ! 531: break;} ! 532: case 16: ! 533: #line 108 "bi-parser.y" ! 534: { yyvsp[-2].node->next = yyvsp[0].node; yyval.node = yyvsp[-2].node; ; ! 535: break;} ! 536: case 17: ! 537: #line 113 "bi-parser.y" ! 538: { yyval.node = makenode (yyvsp[0].string); ; ! 539: break;} ! 540: } ! 541: /* the action file gets copied in in place of this dollarsign */ ! 542: #line 327 "bison.simple" ! 543: ! 544: yyvsp -= yylen; ! 545: yyssp -= yylen; ! 546: #ifdef YYLSP_NEEDED ! 547: yylsp -= yylen; ! 548: #endif ! 549: ! 550: #if YYDEBUG != 0 ! 551: if (yydebug) ! 552: { ! 553: short *ssp1 = yyss - 1; ! 554: fprintf (stderr, "state stack now"); ! 555: while (ssp1 != yyssp) ! 556: fprintf (stderr, " %d", *++ssp1); ! 557: fprintf (stderr, "\n"); ! 558: } ! 559: #endif ! 560: ! 561: *++yyvsp = yyval; ! 562: ! 563: #ifdef YYLSP_NEEDED ! 564: yylsp++; ! 565: if (yylen == 0) ! 566: { ! 567: yylsp->first_line = yylloc.first_line; ! 568: yylsp->first_column = yylloc.first_column; ! 569: yylsp->last_line = (yylsp-1)->last_line; ! 570: yylsp->last_column = (yylsp-1)->last_column; ! 571: yylsp->text = 0; ! 572: } ! 573: else ! 574: { ! 575: yylsp->last_line = (yylsp+yylen-1)->last_line; ! 576: yylsp->last_column = (yylsp+yylen-1)->last_column; ! 577: } ! 578: #endif ! 579: ! 580: /* Now "shift" the result of the reduction. ! 581: Determine what state that goes to, ! 582: based on the state we popped back to ! 583: and the rule number reduced by. */ ! 584: ! 585: yyn = yyr1[yyn]; ! 586: ! 587: yystate = yypgoto[yyn - YYNTBASE] + *yyssp; ! 588: if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) ! 589: yystate = yytable[yystate]; ! 590: else ! 591: yystate = yydefgoto[yyn - YYNTBASE]; ! 592: ! 593: goto yynewstate; ! 594: ! 595: yyerrlab: /* here on detecting error */ ! 596: ! 597: if (! yyerrstatus) ! 598: /* If not already recovering from an error, report this error. */ ! 599: { ! 600: ++yynerrs; ! 601: yyerror("parse error"); ! 602: } ! 603: ! 604: if (yyerrstatus == 3) ! 605: { ! 606: /* if just tried and failed to reuse lookahead token after an error, discard it. */ ! 607: ! 608: /* return failure if at end of input */ ! 609: if (yychar == YYEOF) ! 610: YYABORT; ! 611: ! 612: #if YYDEBUG != 0 ! 613: if (yydebug) ! 614: fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); ! 615: #endif ! 616: ! 617: yychar = YYEMPTY; ! 618: } ! 619: ! 620: /* Else will try to reuse lookahead token ! 621: after shifting the error token. */ ! 622: ! 623: yyerrstatus = 3; /* Each real token shifted decrements this */ ! 624: ! 625: goto yyerrhandle; ! 626: ! 627: yyerrdefault: /* current state does not do anything special for the error token. */ ! 628: ! 629: #if 0 ! 630: /* This is wrong; only states that explicitly want error tokens ! 631: should shift them. */ ! 632: yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ ! 633: if (yyn) goto yydefault; ! 634: #endif ! 635: ! 636: yyerrpop: /* pop the current state because it cannot handle the error token */ ! 637: ! 638: if (yyssp == yyss) YYABORT; ! 639: yyvsp--; ! 640: yystate = *--yyssp; ! 641: #ifdef YYLSP_NEEDED ! 642: yylsp--; ! 643: #endif ! 644: ! 645: #if YYDEBUG != 0 ! 646: if (yydebug) ! 647: { ! 648: short *ssp1 = yyss - 1; ! 649: fprintf (stderr, "Error: state stack now"); ! 650: while (ssp1 != yyssp) ! 651: fprintf (stderr, " %d", *++ssp1); ! 652: fprintf (stderr, "\n"); ! 653: } ! 654: #endif ! 655: ! 656: yyerrhandle: ! 657: ! 658: yyn = yypact[yystate]; ! 659: if (yyn == YYFLAG) ! 660: goto yyerrdefault; ! 661: ! 662: yyn += YYTERROR; ! 663: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) ! 664: goto yyerrdefault; ! 665: ! 666: yyn = yytable[yyn]; ! 667: if (yyn < 0) ! 668: { ! 669: if (yyn == YYFLAG) ! 670: goto yyerrpop; ! 671: yyn = -yyn; ! 672: goto yyreduce; ! 673: } ! 674: else if (yyn == 0) ! 675: goto yyerrpop; ! 676: ! 677: if (yyn == YYFINAL) ! 678: YYACCEPT; ! 679: ! 680: #if YYDEBUG != 0 ! 681: if (yydebug) ! 682: fprintf(stderr, "Shifting error token, "); ! 683: #endif ! 684: ! 685: *++yyvsp = yylval; ! 686: #ifdef YYLSP_NEEDED ! 687: *++yylsp = yylloc; ! 688: #endif ! 689: ! 690: yystate = yyn; ! 691: goto yynewstate; ! 692: } ! 693: #line 116 "bi-parser.y" ! 694: ! 695: ! 696: static struct node * ! 697: makenode (s) ! 698: char *s; ! 699: { ! 700: struct node *n; ! 701: ! 702: n = (struct node *) malloc (sizeof (struct node)); ! 703: n->text = s; ! 704: n->next = NULL; ! 705: return n; ! 706: } ! 707: ! 708: static struct variation * ! 709: makevar (name, inputs, outputs, literals) ! 710: char *name; ! 711: struct node *inputs, *outputs, *literals; ! 712: { ! 713: struct variation *v; ! 714: ! 715: v = (struct variation *) malloc (sizeof (struct variation)); ! 716: v->name = name; ! 717: v->code = ndefs++; ! 718: v->inputs = inputs; ! 719: v->outputs = outputs; ! 720: v->literals = literals; ! 721: v->next = NULL; ! 722: return v; ! 723: } ! 724: ! 725: static struct def * ! 726: makedef (name, template, vars) ! 727: char *name, *template; ! 728: struct variation *vars; ! 729: { ! 730: struct def *d; ! 731: ! 732: d = (struct def *) malloc (sizeof (struct def)); ! 733: d->basename = name; ! 734: d->template = template; ! 735: d->variations = vars; ! 736: d->next = NULL; ! 737: return d; ! 738: } ! 739: ! 740: void ! 741: yyerror (s) ! 742: char *s; ! 743: { ! 744: fprintf (stderr, "syntax error in input\n"); ! 745: exit (FATAL_EXIT_CODE); ! 746: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.