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