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