00001
00002
00003
00004
00005 #define YYBISON 1
00006
00007 #define yyparse kdeprint_foomatic2parse
00008 #define yylex kdeprint_foomatic2lex
00009 #define yyerror kdeprint_foomatic2error
00010 #define yylval kdeprint_foomatic2lval
00011 #define yychar kdeprint_foomatic2char
00012 #define yydebug kdeprint_foomatic2debug
00013 #define yynerrs kdeprint_foomatic2nerrs
00014 #define VAR 257
00015 #define STRING 258
00016 #define NUMBER 259
00017 #define UNDEF 260
00018 #define POSTPIPE 261
00019 #define QUOTED 262
00020
00021 #line 1 "./fooparser.y"
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #define YYSTYPE QVariant
00043 #define YYPARSE_PARAM fooloader
00044 #ifndef YYDEBUG
00045 #define YYDEBUG 1
00046 #endif
00047
00048 #include <stdlib.h>
00049 #include <qvariant.h>
00050 #include "foomatic2loader.h"
00051
00052 void yyerror(const char*) {}
00053 int yylex();
00054 #ifndef YYSTYPE
00055 #define YYSTYPE int
00056 #endif
00057 #include <stdio.h>
00058
00059 #ifndef __cplusplus
00060 #ifndef __STDC__
00061 #define const
00062 #endif
00063 #endif
00064
00065
00066
00067 #define YYFINAL 36
00068 #define YYFLAG -32768
00069 #define YYNTBASE 17
00070
00071 #define YYTRANSLATE(x) ((unsigned)(x) <= 262 ? yytranslate[x] : 23)
00072
00073 static const char yytranslate[] = { 0,
00074 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00075 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00076 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00077 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00078 2, 2, 2, 13, 2, 2, 2, 2, 2, 2,
00079 2, 2, 2, 2, 2, 2, 2, 2, 12, 2,
00080 9, 14, 2, 2, 2, 2, 2, 2, 2, 2,
00081 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00082 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00083 15, 2, 16, 2, 2, 2, 2, 2, 2, 2,
00084 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00085 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00086 2, 2, 10, 2, 11, 2, 2, 2, 2, 2,
00087 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00088 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00089 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00090 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00091 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00092 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00093 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00094 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00095 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00096 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00097 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00098 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00099 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
00100 7, 8
00101 };
00102
00103 #if YYDEBUG != 0
00104 static const short yyprhs[] = { 0,
00105 0, 2, 5, 12, 17, 19, 23, 28, 30, 34,
00106 36, 38, 40, 44, 48, 51
00107 };
00108
00109 static const short yyrhs[] = { 18,
00110 0, 17, 18, 0, 3, 9, 10, 19, 11, 12,
00111 0, 7, 9, 8, 12, 0, 20, 0, 19, 13,
00112 20, 0, 4, 9, 14, 22, 0, 22, 0, 21,
00113 13, 22, 0, 6, 0, 4, 0, 5, 0, 15,
00114 21, 16, 0, 10, 19, 11, 0, 15, 16, 0,
00115 10, 11, 0
00116 };
00117
00118 #endif
00119
00120 #if YYDEBUG != 0
00121 static const short yyrline[] = { 0,
00122 42, 43, 46, 47, 50, 51, 54, 57, 58, 61,
00123 62, 63, 64, 65, 66, 67
00124 };
00125 #endif
00126
00127
00128 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
00129
00130 static const char * const yytname[] = { "$","error","$undefined.","VAR","STRING",
00131 "NUMBER","UNDEF","POSTPIPE","QUOTED","'='","'{'","'}'","';'","','","'>'","'['",
00132 "']'","foo","foodata","fieldlist","assignment","valuelist","value", NULL
00133 };
00134 #endif
00135
00136 static const short yyr1[] = { 0,
00137 17, 17, 18, 18, 19, 19, 20, 21, 21, 22,
00138 22, 22, 22, 22, 22, 22
00139 };
00140
00141 static const short yyr2[] = { 0,
00142 1, 2, 6, 4, 1, 3, 4, 1, 3, 1,
00143 1, 1, 3, 3, 2, 2
00144 };
00145
00146 static const short yydefact[] = { 0,
00147 0, 0, 0, 1, 0, 0, 2, 0, 0, 0,
00148 0, 5, 4, 0, 0, 0, 0, 3, 6, 11,
00149 12, 10, 0, 0, 7, 16, 0, 15, 0, 8,
00150 14, 0, 13, 9, 0, 0
00151 };
00152
00153 static const short yydefgoto[] = { 3,
00154 4, 11, 12, 29, 25
00155 };
00156
00157 static const short yypact[] = { 15,
00158 11, 20, 10,-32768, -2, 18,-32768, 27, 7, 23,
00159 14,-32768,-32768, 19, 22, 27, -1,-32768,-32768,-32768,
00160 -32768,-32768, 12, -4,-32768,-32768, 17,-32768, 8,-32768,
00161 -32768, -1,-32768,-32768, 35,-32768
00162 };
00163
00164 static const short yypgoto[] = {-32768,
00165 33, 16, 21,-32768, -17
00166 };
00167
00168
00169 #define YYLAST 39
00170
00171
00172 static const short yytable[] = { 20,
00173 21, 22, 20, 21, 22, 23, 30, 8, 23, 35,
00174 24, 28, 1, 24, 34, 10, 2, 1, 13, 5,
00175 32, 2, 26, 33, 15, 9, 16, 31, 6, 16,
00176 10, 14, 17, 18, 36, 7, 19, 0, 27
00177 };
00178
00179 static const short yycheck[] = { 4,
00180 5, 6, 4, 5, 6, 10, 24, 10, 10, 0,
00181 15, 16, 3, 15, 32, 4, 7, 3, 12, 9,
00182 13, 7, 11, 16, 11, 8, 13, 11, 9, 13,
00183 4, 9, 14, 12, 0, 3, 16, -1, 23
00184 };
00185
00186 #line 3 "/usr/lib/bison.simple"
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217 #ifndef YYSTACK_USE_ALLOCA
00218 #ifdef alloca
00219 #define YYSTACK_USE_ALLOCA
00220 #else
00221 #ifdef __GNUC__
00222 #define YYSTACK_USE_ALLOCA
00223 #define alloca __builtin_alloca
00224 #else
00225 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
00226 #define YYSTACK_USE_ALLOCA
00227 #include <alloca.h>
00228 #else
00229
00230
00231
00232 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
00233 #if 0
00234
00235 #include <malloc.h>
00236 #endif
00237 #else
00238 #if defined(_AIX)
00239
00240
00241
00242 #pragma alloca
00243 #define YYSTACK_USE_ALLOCA
00244 #else
00245 #if 0
00246 #ifdef __hpux
00247
00248 #define YYSTACK_USE_ALLOCA
00249 #define alloca __builtin_alloca
00250 #endif
00251 #endif
00252 #endif
00253 #endif
00254 #endif
00255 #endif
00256 #endif
00257 #endif
00258
00259 #ifdef YYSTACK_USE_ALLOCA
00260 #define YYSTACK_ALLOC alloca
00261 #else
00262 #define YYSTACK_ALLOC malloc
00263 #endif
00264
00265
00266
00267
00268
00269 #define yyerrok (yyerrstatus = 0)
00270 #define yyclearin (yychar = YYEMPTY)
00271 #define YYEMPTY -2
00272 #define YYEOF 0
00273 #define YYACCEPT goto yyacceptlab
00274 #define YYABORT goto yyabortlab
00275 #define YYERROR goto yyerrlab1
00276
00277
00278
00279
00280 #define YYFAIL goto yyerrlab
00281 #define YYRECOVERING() (!!yyerrstatus)
00282 #define YYBACKUP(token, value) \
00283 do \
00284 if (yychar == YYEMPTY && yylen == 1) \
00285 { yychar = (token), yylval = (value); \
00286 yychar1 = YYTRANSLATE (yychar); \
00287 YYPOPSTACK; \
00288 goto yybackup; \
00289 } \
00290 else \
00291 { yyerror ("syntax error: cannot back up"); YYERROR; } \
00292 while (0)
00293
00294 #define YYTERROR 1
00295 #define YYERRCODE 256
00296
00297 #ifndef YYPURE
00298 #define YYLEX yylex()
00299 #endif
00300
00301 #ifdef YYPURE
00302 #ifdef YYLSP_NEEDED
00303 #ifdef YYLEX_PARAM
00304 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
00305 #else
00306 #define YYLEX yylex(&yylval, &yylloc)
00307 #endif
00308 #else
00309 #ifdef YYLEX_PARAM
00310 #define YYLEX yylex(&yylval, YYLEX_PARAM)
00311 #else
00312 #define YYLEX yylex(&yylval)
00313 #endif
00314 #endif
00315 #endif
00316
00317
00318
00319 #ifndef YYPURE
00320
00321 int yychar;
00322 YYSTYPE yylval;
00323
00324
00325 #ifdef YYLSP_NEEDED
00326 YYLTYPE yylloc;
00327
00328 #endif
00329
00330 int yynerrs;
00331 #endif
00332
00333 #if YYDEBUG != 0
00334 int yydebug;
00335
00336
00337 #endif
00338
00339
00340
00341 #ifndef YYINITDEPTH
00342 #define YYINITDEPTH 200
00343 #endif
00344
00345
00346
00347
00348 #if YYMAXDEPTH == 0
00349 #undef YYMAXDEPTH
00350 #endif
00351
00352 #ifndef YYMAXDEPTH
00353 #define YYMAXDEPTH 10000
00354 #endif
00355
00356
00357
00358
00359
00360
00361 #if __GNUC__ > 1
00362 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
00363 #else
00364 #ifndef __cplusplus
00365
00366
00367
00368 static void
00369 __yy_memcpy (to, from, count)
00370 char *to;
00371 char *from;
00372 unsigned int count;
00373 {
00374 register char *f = from;
00375 register char *t = to;
00376 register int i = count;
00377
00378 while (i-- > 0)
00379 *t++ = *f++;
00380 }
00381
00382 #else
00383
00384
00385
00386 static void
00387 __yy_memcpy (char *to, char *from, unsigned int count)
00388 {
00389 register char *t = to;
00390 register char *f = from;
00391 register int i = count;
00392
00393 while (i-- > 0)
00394 *t++ = *f++;
00395 }
00396
00397 #endif
00398 #endif
00399
00400 #line 217 "/usr/lib/bison.simple"
00401
00402
00403
00404
00405
00406
00407
00408 #ifdef YYPARSE_PARAM
00409 #ifdef __cplusplus
00410 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
00411 #define YYPARSE_PARAM_DECL
00412 #else
00413 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
00414 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
00415 #endif
00416 #else
00417 #define YYPARSE_PARAM_ARG
00418 #define YYPARSE_PARAM_DECL
00419 #endif
00420
00421
00422 #ifdef __GNUC__
00423 #ifdef YYPARSE_PARAM
00424 int yyparse (void *);
00425 #else
00426 int yyparse (void);
00427 #endif
00428 #endif
00429
00430 int
00431 yyparse(YYPARSE_PARAM_ARG)
00432 YYPARSE_PARAM_DECL
00433 {
00434 register int yystate;
00435 register int yyn;
00436 register short *yyssp;
00437 register YYSTYPE *yyvsp;
00438 int yyerrstatus;
00439 int yychar1 = 0;
00440
00441 short yyssa[YYINITDEPTH];
00442 YYSTYPE yyvsa[YYINITDEPTH];
00443
00444 short *yyss = yyssa;
00445 YYSTYPE *yyvs = yyvsa;
00446
00447 #ifdef YYLSP_NEEDED
00448 YYLTYPE yylsa[YYINITDEPTH];
00449 YYLTYPE *yyls = yylsa;
00450 YYLTYPE *yylsp;
00451
00452 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
00453 #else
00454 #define YYPOPSTACK (yyvsp--, yyssp--)
00455 #endif
00456
00457 int yystacksize = YYINITDEPTH;
00458 int yyfree_stacks = 0;
00459
00460 #ifdef YYPURE
00461 int yychar;
00462 YYSTYPE yylval;
00463 int yynerrs;
00464 #ifdef YYLSP_NEEDED
00465 YYLTYPE yylloc;
00466 #endif
00467 #endif
00468
00469 YYSTYPE yyval;
00470
00471
00472
00473 int yylen;
00474
00475 #if YYDEBUG != 0
00476 if (yydebug)
00477 fprintf(stderr, "Starting parse\n");
00478 #endif
00479
00480 yystate = 0;
00481 yyerrstatus = 0;
00482 yynerrs = 0;
00483 yychar = YYEMPTY;
00484
00485
00486
00487
00488
00489
00490 yyssp = yyss - 1;
00491 yyvsp = yyvs;
00492 #ifdef YYLSP_NEEDED
00493 yylsp = yyls;
00494 #endif
00495
00496
00497
00498
00499 yynewstate:
00500
00501 *++yyssp = yystate;
00502
00503 if (yyssp >= yyss + yystacksize - 1)
00504 {
00505
00506
00507 YYSTYPE *yyvs1 = yyvs;
00508 short *yyss1 = yyss;
00509 #ifdef YYLSP_NEEDED
00510 YYLTYPE *yyls1 = yyls;
00511 #endif
00512
00513
00514 int size = yyssp - yyss + 1;
00515
00516 #ifdef yyoverflow
00517
00518
00519 #ifdef YYLSP_NEEDED
00520
00521
00522 yyoverflow("parser stack overflow",
00523 &yyss1, size * sizeof (*yyssp),
00524 &yyvs1, size * sizeof (*yyvsp),
00525 &yyls1, size * sizeof (*yylsp),
00526 &yystacksize);
00527 #else
00528 yyoverflow("parser stack overflow",
00529 &yyss1, size * sizeof (*yyssp),
00530 &yyvs1, size * sizeof (*yyvsp),
00531 &yystacksize);
00532 #endif
00533
00534 yyss = yyss1; yyvs = yyvs1;
00535 #ifdef YYLSP_NEEDED
00536 yyls = yyls1;
00537 #endif
00538 #else
00539
00540 if (yystacksize >= YYMAXDEPTH)
00541 {
00542 yyerror("parser stack overflow");
00543 if (yyfree_stacks)
00544 {
00545 free (yyss);
00546 free (yyvs);
00547 #ifdef YYLSP_NEEDED
00548 free (yyls);
00549 #endif
00550 }
00551 return 2;
00552 }
00553 yystacksize *= 2;
00554 if (yystacksize > YYMAXDEPTH)
00555 yystacksize = YYMAXDEPTH;
00556 #ifndef YYSTACK_USE_ALLOCA
00557 yyfree_stacks = 1;
00558 #endif
00559 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
00560 __yy_memcpy ((char *)yyss, (char *)yyss1,
00561 size * (unsigned int) sizeof (*yyssp));
00562 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
00563 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
00564 size * (unsigned int) sizeof (*yyvsp));
00565 #ifdef YYLSP_NEEDED
00566 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
00567 __yy_memcpy ((char *)yyls, (char *)yyls1,
00568 size * (unsigned int) sizeof (*yylsp));
00569 #endif
00570 #endif
00571
00572 yyssp = yyss + size - 1;
00573 yyvsp = yyvs + size - 1;
00574 #ifdef YYLSP_NEEDED
00575 yylsp = yyls + size - 1;
00576 #endif
00577
00578 #if YYDEBUG != 0
00579 if (yydebug)
00580 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
00581 #endif
00582
00583 if (yyssp >= yyss + yystacksize - 1)
00584 YYABORT;
00585 }
00586
00587 #if YYDEBUG != 0
00588 if (yydebug)
00589 fprintf(stderr, "Entering state %d\n", yystate);
00590 #endif
00591
00592 goto yybackup;
00593 yybackup:
00594
00595
00596
00597
00598
00599
00600
00601 yyn = yypact[yystate];
00602 if (yyn == YYFLAG)
00603 goto yydefault;
00604
00605
00606
00607
00608
00609
00610 if (yychar == YYEMPTY)
00611 {
00612 #if YYDEBUG != 0
00613 if (yydebug)
00614 fprintf(stderr, "Reading a token: ");
00615 #endif
00616 yychar = YYLEX;
00617 }
00618
00619
00620
00621 if (yychar <= 0)
00622 {
00623 yychar1 = 0;
00624 yychar = YYEOF;
00625
00626 #if YYDEBUG != 0
00627 if (yydebug)
00628 fprintf(stderr, "Now at end of input.\n");
00629 #endif
00630 }
00631 else
00632 {
00633 yychar1 = YYTRANSLATE(yychar);
00634
00635 #if YYDEBUG != 0
00636 if (yydebug)
00637 {
00638 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
00639
00640
00641 #ifdef YYPRINT
00642 YYPRINT (stderr, yychar, yylval);
00643 #endif
00644 fprintf (stderr, ")\n");
00645 }
00646 #endif
00647 }
00648
00649 yyn += yychar1;
00650 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
00651 goto yydefault;
00652
00653 yyn = yytable[yyn];
00654
00655
00656
00657
00658
00659
00660
00661
00662 if (yyn < 0)
00663 {
00664 if (yyn == YYFLAG)
00665 goto yyerrlab;
00666 yyn = -yyn;
00667 goto yyreduce;
00668 }
00669 else if (yyn == 0)
00670 goto yyerrlab;
00671
00672 if (yyn == YYFINAL)
00673 YYACCEPT;
00674
00675
00676
00677 #if YYDEBUG != 0
00678 if (yydebug)
00679 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
00680 #endif
00681
00682
00683 if (yychar != YYEOF)
00684 yychar = YYEMPTY;
00685
00686 *++yyvsp = yylval;
00687 #ifdef YYLSP_NEEDED
00688 *++yylsp = yylloc;
00689 #endif
00690
00691
00692 if (yyerrstatus) yyerrstatus--;
00693
00694 yystate = yyn;
00695 goto yynewstate;
00696
00697
00698 yydefault:
00699
00700 yyn = yydefact[yystate];
00701 if (yyn == 0)
00702 goto yyerrlab;
00703
00704
00705 yyreduce:
00706 yylen = yyr2[yyn];
00707 if (yylen > 0)
00708 yyval = yyvsp[1-yylen];
00709
00710 #if YYDEBUG != 0
00711 if (yydebug)
00712 {
00713 int i;
00714
00715 fprintf (stderr, "Reducing via rule %d (line %d), ",
00716 yyn, yyrline[yyn]);
00717
00718
00719 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
00720 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
00721 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
00722 }
00723 #endif
00724
00725
00726 switch (yyn) {
00727
00728 case 3:
00729 #line 46 "./fooparser.y"
00730 { static_cast<Foomatic2Loader*>(fooloader)->m_foodata.insert("VAR",yyvsp[-2]); ;
00731 break;}
00732 case 4:
00733 #line 47 "./fooparser.y"
00734 { static_cast<Foomatic2Loader*>(fooloader)->m_foodata.insert("POSTPIPE",yyvsp[-1]); ;
00735 break;}
00736 case 5:
00737 #line 50 "./fooparser.y"
00738 { yyval = yyvsp[0]; ;
00739 break;}
00740 case 6:
00741 #line 51 "./fooparser.y"
00742 { QMap<QString,QVariant>::ConstIterator it = yyvsp[0].mapBegin(); yyvsp[-2].asMap().insert(it.key(), it.data()); yyval = yyvsp[-2]; ;
00743 break;}
00744 case 7:
00745 #line 54 "./fooparser.y"
00746 { yyval.asMap().insert(yyvsp[-3].toString(), yyvsp[0]); ;
00747 break;}
00748 case 8:
00749 #line 57 "./fooparser.y"
00750 { yyval.asList().append(yyvsp[0]); ;
00751 break;}
00752 case 9:
00753 #line 58 "./fooparser.y"
00754 { yyvsp[-2].asList().append(yyvsp[0]); yyval = yyvsp[-2]; ;
00755 break;}
00756 case 10:
00757 #line 61 "./fooparser.y"
00758 { yyval = QVariant(); ;
00759 break;}
00760 case 11:
00761 #line 62 "./fooparser.y"
00762 { yyval = yyvsp[0]; ;
00763 break;}
00764 case 12:
00765 #line 63 "./fooparser.y"
00766 { yyval = yyvsp[0]; ;
00767 break;}
00768 case 13:
00769 #line 64 "./fooparser.y"
00770 { yyval = yyvsp[-1]; ;
00771 break;}
00772 case 14:
00773 #line 65 "./fooparser.y"
00774 { yyval = yyvsp[-1]; ;
00775 break;}
00776 case 15:
00777 #line 66 "./fooparser.y"
00778 { yyval = QVariant(); ;
00779 break;}
00780 case 16:
00781 #line 67 "./fooparser.y"
00782 { yyval = QVariant(); ;
00783 break;}
00784 }
00785
00786 #line 543 "/usr/lib/bison.simple"
00787
00788 yyvsp -= yylen;
00789 yyssp -= yylen;
00790 #ifdef YYLSP_NEEDED
00791 yylsp -= yylen;
00792 #endif
00793
00794 #if YYDEBUG != 0
00795 if (yydebug)
00796 {
00797 short *ssp1 = yyss - 1;
00798 fprintf (stderr, "state stack now");
00799 while (ssp1 != yyssp)
00800 fprintf (stderr, " %d", *++ssp1);
00801 fprintf (stderr, "\n");
00802 }
00803 #endif
00804
00805 *++yyvsp = yyval;
00806
00807 #ifdef YYLSP_NEEDED
00808 yylsp++;
00809 if (yylen == 0)
00810 {
00811 yylsp->first_line = yylloc.first_line;
00812 yylsp->first_column = yylloc.first_column;
00813 yylsp->last_line = (yylsp-1)->last_line;
00814 yylsp->last_column = (yylsp-1)->last_column;
00815 yylsp->text = 0;
00816 }
00817 else
00818 {
00819 yylsp->last_line = (yylsp+yylen-1)->last_line;
00820 yylsp->last_column = (yylsp+yylen-1)->last_column;
00821 }
00822 #endif
00823
00824
00825
00826
00827
00828
00829 yyn = yyr1[yyn];
00830
00831 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
00832 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
00833 yystate = yytable[yystate];
00834 else
00835 yystate = yydefgoto[yyn - YYNTBASE];
00836
00837 goto yynewstate;
00838
00839 yyerrlab:
00840
00841 if (! yyerrstatus)
00842
00843 {
00844 ++yynerrs;
00845
00846 #ifdef YYERROR_VERBOSE
00847 yyn = yypact[yystate];
00848
00849 if (yyn > YYFLAG && yyn < YYLAST)
00850 {
00851 int size = 0;
00852 char *msg;
00853 int x, count;
00854
00855 count = 0;
00856
00857 for (x = (yyn < 0 ? -yyn : 0);
00858 x < (sizeof(yytname) / sizeof(char *)); x++)
00859 if (yycheck[x + yyn] == x)
00860 size += strlen(yytname[x]) + 15, count++;
00861 msg = (char *) malloc(size + 15);
00862 if (msg != 0)
00863 {
00864 strcpy(msg, "parse error");
00865
00866 if (count < 5)
00867 {
00868 count = 0;
00869 for (x = (yyn < 0 ? -yyn : 0);
00870 x < (sizeof(yytname) / sizeof(char *)); x++)
00871 if (yycheck[x + yyn] == x)
00872 {
00873 strcat(msg, count == 0 ? ", expecting `" : " or `");
00874 strcat(msg, yytname[x]);
00875 strcat(msg, "'");
00876 count++;
00877 }
00878 }
00879 yyerror(msg);
00880 free(msg);
00881 }
00882 else
00883 yyerror ("parse error; also virtual memory exceeded");
00884 }
00885 else
00886 #endif
00887 yyerror("parse error");
00888 }
00889
00890 goto yyerrlab1;
00891 yyerrlab1:
00892
00893 if (yyerrstatus == 3)
00894 {
00895
00896
00897
00898 if (yychar == YYEOF)
00899 YYABORT;
00900
00901 #if YYDEBUG != 0
00902 if (yydebug)
00903 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
00904 #endif
00905
00906 yychar = YYEMPTY;
00907 }
00908
00909
00910
00911
00912 yyerrstatus = 3;
00913
00914 goto yyerrhandle;
00915
00916 yyerrdefault:
00917
00918 #if 0
00919
00920
00921 yyn = yydefact[yystate];
00922 if (yyn) goto yydefault;
00923 #endif
00924
00925 yyerrpop:
00926
00927 if (yyssp == yyss) YYABORT;
00928 yyvsp--;
00929 yystate = *--yyssp;
00930 #ifdef YYLSP_NEEDED
00931 yylsp--;
00932 #endif
00933
00934 #if YYDEBUG != 0
00935 if (yydebug)
00936 {
00937 short *ssp1 = yyss - 1;
00938 fprintf (stderr, "Error: state stack now");
00939 while (ssp1 != yyssp)
00940 fprintf (stderr, " %d", *++ssp1);
00941 fprintf (stderr, "\n");
00942 }
00943 #endif
00944
00945 yyerrhandle:
00946
00947 yyn = yypact[yystate];
00948 if (yyn == YYFLAG)
00949 goto yyerrdefault;
00950
00951 yyn += YYTERROR;
00952 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
00953 goto yyerrdefault;
00954
00955 yyn = yytable[yyn];
00956 if (yyn < 0)
00957 {
00958 if (yyn == YYFLAG)
00959 goto yyerrpop;
00960 yyn = -yyn;
00961 goto yyreduce;
00962 }
00963 else if (yyn == 0)
00964 goto yyerrpop;
00965
00966 if (yyn == YYFINAL)
00967 YYACCEPT;
00968
00969 #if YYDEBUG != 0
00970 if (yydebug)
00971 fprintf(stderr, "Shifting error token, ");
00972 #endif
00973
00974 *++yyvsp = yylval;
00975 #ifdef YYLSP_NEEDED
00976 *++yylsp = yylloc;
00977 #endif
00978
00979 yystate = yyn;
00980 goto yynewstate;
00981
00982 yyacceptlab:
00983
00984 if (yyfree_stacks)
00985 {
00986 free (yyss);
00987 free (yyvs);
00988 #ifdef YYLSP_NEEDED
00989 free (yyls);
00990 #endif
00991 }
00992 return 0;
00993
00994 yyabortlab:
00995
00996 if (yyfree_stacks)
00997 {
00998 free (yyss);
00999 free (yyvs);
01000 #ifdef YYLSP_NEEDED
01001 free (yyls);
01002 #endif
01003 }
01004 return 1;
01005 }
01006 #line 70 "./fooparser.y"
01007