test/pure_calc.tab.c

   1 #ifndef lint
   2 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
   3 #endif
   4
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8
   9 #define YYEMPTY        (-1)
  10 #define yyclearin      (yychar = YYEMPTY)
  11 #define yyerrok        (yyerrflag = 0)
  12 #define YYRECOVERING() (yyerrflag != 0)
  13
  14
  15 #ifndef yyparse
  16 #define yyparse    calc_parse
  17 #endif /* yyparse */
  18
  19 #ifndef yylex
  20 #define yylex      calc_lex
  21 #endif /* yylex */
  22
  23 #ifndef yyerror
  24 #define yyerror    calc_error
  25 #endif /* yyerror */
  26
  27 #ifndef yychar
  28 #define yychar     calc_char
  29 #endif /* yychar */
  30
  31 #ifndef yyval
  32 #define yyval      calc_val
  33 #endif /* yyval */
  34
  35 #ifndef yylval
  36 #define yylval     calc_lval
  37 #endif /* yylval */
  38
  39 #ifndef yydebug
  40 #define yydebug    calc_debug
  41 #endif /* yydebug */
  42
  43 #ifndef yynerrs
  44 #define yynerrs    calc_nerrs
  45 #endif /* yynerrs */
  46
  47 #ifndef yyerrflag
  48 #define yyerrflag  calc_errflag
  49 #endif /* yyerrflag */
  50
  51 #ifndef yylhs
  52 #define yylhs      calc_lhs
  53 #endif /* yylhs */
  54
  55 #ifndef yylen
  56 #define yylen      calc_len
  57 #endif /* yylen */
  58
  59 #ifndef yydefred
  60 #define yydefred   calc_defred
  61 #endif /* yydefred */
  62
  63 #ifndef yydgoto
  64 #define yydgoto    calc_dgoto
  65 #endif /* yydgoto */
  66
  67 #ifndef yysindex
  68 #define yysindex   calc_sindex
  69 #endif /* yysindex */
  70
  71 #ifndef yyrindex
  72 #define yyrindex   calc_rindex
  73 #endif /* yyrindex */
  74
  75 #ifndef yygindex
  76 #define yygindex   calc_gindex
  77 #endif /* yygindex */
  78
  79 #ifndef yytable
  80 #define yytable    calc_table
  81 #endif /* yytable */
  82
  83 #ifndef yycheck
  84 #define yycheck    calc_check
  85 #endif /* yycheck */
  86
  87 #ifndef yyname
  88 #define yyname     calc_name
  89 #endif /* yyname */
  90
  91 #ifndef yyrule
  92 #define yyrule     calc_rule
  93 #endif /* yyrule */
  94 #define YYPREFIX "calc_"
  95
  96 #define YYPURE 1
  97
  98 #line 2 "pure_calc.y"
  99 # include <stdio.h>
 100 # include <ctype.h>
 101
 102 int regs[26];
 103 int base;
 104
 105 #line 106 "pure_calc.tab.c"
 106
 107 #ifndef YYSTYPE
 108 typedef int YYSTYPE;
 109 #endif
 110
 111 /* compatibility with bison */
 112 #ifdef YYPARSE_PARAM
 113 /* compatibility with FreeBSD */
 114 # ifdef YYPARSE_PARAM_TYPE
 115 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 116 # else
 117 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 118 # endif
 119 #else
 120 # define YYPARSE_DECL() yyparse(void)
 121 #endif
 122
 123 /* Parameters sent to lex. */
 124 #ifdef YYLEX_PARAM
 125 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void *YYLEX_PARAM)
 126 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 127 #else
 128 # define YYLEX_DECL() yylex(YYSTYPE *yylval)
 129 # define YYLEX yylex(&yylval)
 130 #endif
 131
 132 /* Parameters sent to yyerror. */
 133 #define YYERROR_DECL() yyerror(const char *s)
 134 #define YYERROR_CALL(msg) yyerror(msg)
 135
 136 extern int YYPARSE_DECL();
 137 extern int YYLEX_DECL();
 138
 139 #define DIGIT 257
 140 #define LETTER 258
 141 #define UMINUS 259
 142 #define YYERRCODE 256
 143 static const short calc_lhs[] = {                        -1,
 144     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 145     2,    2,    2,    2,    2,    2,    3,    3,
 146 };
 147 static const short calc_len[] = {                         2,
 148     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 149     3,    3,    3,    2,    1,    1,    1,    2,
 150 };
 151 static const short calc_defred[] = {                      1,
 152     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 153     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 154     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 155    10,   11,
 156 };
 157 static const short calc_dgoto[] = {                       1,
 158     7,    8,    9,
 159 };
 160 static const short calc_sindex[] = {                      0,
 161   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 162   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 163   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 164     0,    0,
 165 };
 166 static const short calc_rindex[] = {                      0,
 167     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 168     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 169     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 170     0,    0,
 171 };
 172 static const short calc_gindex[] = {                      0,
 173     0,   65,    0,
 174 };
 175 #define YYTABLESIZE 220
 176 static const short calc_table[] = {                       6,
 177    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 178    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 179     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 180     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 181     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 182     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 183     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 184    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 185    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 186     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 187     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 188     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 189     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 190     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 191     0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
 192     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 193     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 194     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 195     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 196     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 197     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 198     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 199 };
 200 static const short calc_check[] = {                      40,
 201    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 202    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 203    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 204    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 205    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 206    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 207    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 208     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 209    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 210    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 211    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 212    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 213    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 214    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 215    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
 216    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 217    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 218    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 219    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 220    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 221    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 222    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 223 };
 224 #define YYFINAL 1
 225 #ifndef YYDEBUG
 226 #define YYDEBUG 0
 227 #endif
 228 #define YYMAXTOKEN 259
 229 #if YYDEBUG
 230 static const char *yyname[] = {
 231
 232 "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 233 0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
 234 0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 235 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
 236 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 237 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 238 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 239 0,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
 240 };
 241 static const char *yyrule[] = {
 242 "$accept : list",
 243 "list :",
 244 "list : list stat '\\n'",
 245 "list : list error '\\n'",
 246 "stat : expr",
 247 "stat : LETTER '=' expr",
 248 "expr : '(' expr ')'",
 249 "expr : expr '+' expr",
 250 "expr : expr '-' expr",
 251 "expr : expr '*' expr",
 252 "expr : expr '/' expr",
 253 "expr : expr '%' expr",
 254 "expr : expr '&' expr",
 255 "expr : expr '|' expr",
 256 "expr : '-' expr",
 257 "expr : LETTER",
 258 "expr : number",
 259 "number : DIGIT",
 260 "number : number DIGIT",
 261
 262 };
 263 #endif
 264 /* define the initial stack-sizes */
 265 #ifdef YYSTACKSIZE
 266 #undef YYMAXDEPTH
 267 #define YYMAXDEPTH  YYSTACKSIZE
 268 #else
 269 #ifdef YYMAXDEPTH
 270 #define YYSTACKSIZE YYMAXDEPTH
 271 #else
 272 #define YYSTACKSIZE 500
 273 #define YYMAXDEPTH  500
 274 #endif
 275 #endif
 276
 277 #define YYINITSTACKSIZE 500
 278
 279 int      yydebug;
 280 int      yynerrs;
 281
 282 typedef struct {
 283     unsigned stacksize;
 284     short    *s_base;
 285     short    *s_mark;
 286     short    *s_last;
 287     YYSTYPE  *l_base;
 288     YYSTYPE  *l_mark;
 289 } YYSTACKDATA;
 290 #line 63 "pure_calc.y"
 291  /* start of programs */
 292
 293 int
 294 main (void)
 295 {
 296     while(!feof(stdin)) {
 297         yyparse();
 298     }
 299     return 0;
 300 }
 301
 302 static void
 303 yyerror(const char *s)
 304 {
 305     fprintf(stderr, "%s\n", s);
 306 }
 307
 308 int
 309 yylex(YYSTYPE *value)
 310 {
 311         /* lexical analysis routine */
 312         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 313         /* return DIGIT for a digit, yylval = 0 through 9 */
 314         /* all other characters are returned immediately */
 315
 316     int c;
 317
 318     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 319
 320     /* c is now nonblank */
 321
 322     if( islower( c )) {
 323         *value = c - 'a';
 324         return ( LETTER );
 325     }
 326     if( isdigit( c )) {
 327         *value = c - '0';
 328         return ( DIGIT );
 329     }
 330     return( c );
 331 }
 332 #line 333 "pure_calc.tab.c"
 333
 334 #if YYDEBUG
 335 #include <stdio.h>              /* needed for printf */
 336 #endif
 337
 338 #include <stdlib.h>     /* needed for malloc, etc */
 339 #include <string.h>     /* needed for memset */
 340
 341 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 342 static int yygrowstack(YYSTACKDATA *data)
 343 {
 344     int i;
 345     unsigned newsize;
 346     short *newss;
 347     YYSTYPE *newvs;
 348
 349     if ((newsize = data->stacksize) == 0)
 350         newsize = YYINITSTACKSIZE;
 351     else if (newsize >= YYMAXDEPTH)
 352         return -1;
 353     else if ((newsize *= 2) > YYMAXDEPTH)
 354         newsize = YYMAXDEPTH;
 355
 356     i = data->s_mark - data->s_base;
 357     newss = (data->s_base != 0)
 358           ? (short *)realloc(data->s_base, newsize * sizeof(*newss))
 359           : (short *)malloc(newsize * sizeof(*newss));
 360     if (newss == 0)
 361         return -1;
 362
 363     data->s_base = newss;
 364     data->s_mark = newss + i;
 365
 366     newvs = (data->l_base != 0)
 367           ? (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs))
 368           : (YYSTYPE *)malloc(newsize * sizeof(*newvs));
 369     if (newvs == 0)
 370         return -1;
 371
 372     data->l_base = newvs;
 373     data->l_mark = newvs + i;
 374
 375     data->stacksize = newsize;
 376     data->s_last = data->s_base + newsize - 1;
 377     return 0;
 378 }
 379
 380 #if YYPURE || defined(YY_NO_LEAKS)
 381 static void yyfreestack(YYSTACKDATA *data)
 382 {
 383     free(data->s_base);
 384     free(data->l_base);
 385     memset(data, 0, sizeof(*data));
 386 }
 387 #else
 388 #define yyfreestack(data) /* nothing */
 389 #endif
 390
 391 #define YYABORT  goto yyabort
 392 #define YYREJECT goto yyabort
 393 #define YYACCEPT goto yyaccept
 394 #define YYERROR  goto yyerrlab
 395
 396 int
 397 YYPARSE_DECL()
 398 {
 399     int      yyerrflag;
 400     int      yychar;
 401     YYSTYPE  yyval;
 402     YYSTYPE  yylval;
 403
 404     /* variables for the parser stack */
 405     YYSTACKDATA yystack;
 406     int yym, yyn, yystate;
 407 #if YYDEBUG
 408     const char *yys;
 409
 410     if ((yys = getenv("YYDEBUG")) != 0)
 411     {
 412         yyn = *yys;
 413         if (yyn >= '0' && yyn <= '9')
 414             yydebug = yyn - '0';
 415     }
 416 #endif
 417
 418     yynerrs = 0;
 419     yyerrflag = 0;
 420     yychar = YYEMPTY;
 421     yystate = 0;
 422
 423 #if YYPURE
 424     memset(&yystack, 0, sizeof(yystack));
 425 #endif
 426
 427     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 428     yystack.s_mark = yystack.s_base;
 429     yystack.l_mark = yystack.l_base;
 430     yystate = 0;
 431     *yystack.s_mark = 0;
 432
 433 yyloop:
 434     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 435     if (yychar < 0)
 436     {
 437         if ((yychar = YYLEX) < 0) yychar = 0;
 438 #if YYDEBUG
 439         if (yydebug)
 440         {
 441             yys = 0;
 442             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 443             if (!yys) yys = "illegal-symbol";
 444             printf("%sdebug: state %d, reading %d (%s)\n",
 445                     YYPREFIX, yystate, yychar, yys);
 446         }
 447 #endif
 448     }
 449     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 450             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 451     {
 452 #if YYDEBUG
 453         if (yydebug)
 454             printf("%sdebug: state %d, shifting to state %d\n",
 455                     YYPREFIX, yystate, yytable[yyn]);
 456 #endif
 457         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 458         {
 459             goto yyoverflow;
 460         }
 461         yystate = yytable[yyn];
 462         *++yystack.s_mark = yytable[yyn];
 463         *++yystack.l_mark = yylval;
 464         yychar = YYEMPTY;
 465         if (yyerrflag > 0)  --yyerrflag;
 466         goto yyloop;
 467     }
 468     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 469             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 470     {
 471         yyn = yytable[yyn];
 472         goto yyreduce;
 473     }
 474     if (yyerrflag) goto yyinrecovery;
 475
 476     yyerror("syntax error");
 477
 478     goto yyerrlab;
 479
 480 yyerrlab:
 481     ++yynerrs;
 482
 483 yyinrecovery:
 484     if (yyerrflag < 3)
 485     {
 486         yyerrflag = 3;
 487         for (;;)
 488         {
 489             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 490                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 491             {
 492 #if YYDEBUG
 493                 if (yydebug)
 494                     printf("%sdebug: state %d, error recovery shifting\
 495  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 496 #endif
 497                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 498                 {
 499                     goto yyoverflow;
 500                 }
 501                 yystate = yytable[yyn];
 502                 *++yystack.s_mark = yytable[yyn];
 503                 *++yystack.l_mark = yylval;
 504                 goto yyloop;
 505             }
 506             else
 507             {
 508 #if YYDEBUG
 509                 if (yydebug)
 510                     printf("%sdebug: error recovery discarding state %d\n",
 511                             YYPREFIX, *yystack.s_mark);
 512 #endif
 513                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 514                 --yystack.s_mark;
 515                 --yystack.l_mark;
 516             }
 517         }
 518     }
 519     else
 520     {
 521         if (yychar == 0) goto yyabort;
 522 #if YYDEBUG
 523         if (yydebug)
 524         {
 525             yys = 0;
 526             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 527             if (!yys) yys = "illegal-symbol";
 528             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 529                     YYPREFIX, yystate, yychar, yys);
 530         }
 531 #endif
 532         yychar = YYEMPTY;
 533         goto yyloop;
 534     }
 535
 536 yyreduce:
 537 #if YYDEBUG
 538     if (yydebug)
 539         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 540                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 541 #endif
 542     yym = yylen[yyn];
 543     if (yym)
 544         yyval = yystack.l_mark[1-yym];
 545     else
 546         memset(&yyval, 0, sizeof yyval);
 547     switch (yyn)
 548     {
 549 case 3:
 550 #line 25 "pure_calc.y"
 551         {  yyerrok ; }
 552 break;
 553 case 4:
 554 #line 29 "pure_calc.y"
 555         {  printf("%d\n",yystack.l_mark[0]);}
 556 break;
 557 case 5:
 558 #line 31 "pure_calc.y"
 559         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 560 break;
 561 case 6:
 562 #line 35 "pure_calc.y"
 563         {  yyval = yystack.l_mark[-1]; }
 564 break;
 565 case 7:
 566 #line 37 "pure_calc.y"
 567         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 568 break;
 569 case 8:
 570 #line 39 "pure_calc.y"
 571         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 572 break;
 573 case 9:
 574 #line 41 "pure_calc.y"
 575         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 576 break;
 577 case 10:
 578 #line 43 "pure_calc.y"
 579         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 580 break;
 581 case 11:
 582 #line 45 "pure_calc.y"
 583         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 584 break;
 585 case 12:
 586 #line 47 "pure_calc.y"
 587         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 588 break;
 589 case 13:
 590 #line 49 "pure_calc.y"
 591         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 592 break;
 593 case 14:
 594 #line 51 "pure_calc.y"
 595         {  yyval = - yystack.l_mark[0]; }
 596 break;
 597 case 15:
 598 #line 53 "pure_calc.y"
 599         {  yyval = regs[yystack.l_mark[0]]; }
 600 break;
 601 case 17:
 602 #line 58 "pure_calc.y"
 603         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 604 break;
 605 case 18:
 606 #line 60 "pure_calc.y"
 607         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 608 break;
 609 #line 610 "pure_calc.tab.c"
 610     }
 611     yystack.s_mark -= yym;
 612     yystate = *yystack.s_mark;
 613     yystack.l_mark -= yym;
 614     yym = yylhs[yyn];
 615     if (yystate == 0 && yym == 0)
 616     {
 617 #if YYDEBUG
 618         if (yydebug)
 619             printf("%sdebug: after reduction, shifting from state 0 to\
 620  state %d\n", YYPREFIX, YYFINAL);
 621 #endif
 622         yystate = YYFINAL;
 623         *++yystack.s_mark = YYFINAL;
 624         *++yystack.l_mark = yyval;
 625         if (yychar < 0)
 626         {
 627             if ((yychar = YYLEX) < 0) yychar = 0;
 628 #if YYDEBUG
 629             if (yydebug)
 630             {
 631                 yys = 0;
 632                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 633                 if (!yys) yys = "illegal-symbol";
 634                 printf("%sdebug: state %d, reading %d (%s)\n",
 635                         YYPREFIX, YYFINAL, yychar, yys);
 636             }
 637 #endif
 638         }
 639         if (yychar == 0) goto yyaccept;
 640         goto yyloop;
 641     }
 642     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 643             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 644         yystate = yytable[yyn];
 645     else
 646         yystate = yydgoto[yym];
 647 #if YYDEBUG
 648     if (yydebug)
 649         printf("%sdebug: after reduction, shifting from state %d \
 650 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 651 #endif
 652     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 653     {
 654         goto yyoverflow;
 655     }
 656     *++yystack.s_mark = (short) yystate;
 657     *++yystack.l_mark = yyval;
 658     goto yyloop;
 659
 660 yyoverflow:
 661     yyerror("yacc stack overflow");
 662
 663 yyabort:
 664     yyfreestack(&yystack);
 665     return (1);
 666
 667 yyaccept:
 668     yyfreestack(&yystack);
 669     return (0);
 670 }