test/calc.tab.c

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