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