test/calc3.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    calc3_parse
  17 #endif /* yyparse */
  18
  19 #ifndef yylex
  20 #define yylex      calc3_lex
  21 #endif /* yylex */
  22
  23 #ifndef yyerror
  24 #define yyerror    calc3_error
  25 #endif /* yyerror */
  26
  27 #ifndef yychar
  28 #define yychar     calc3_char
  29 #endif /* yychar */
  30
  31 #ifndef yyval
  32 #define yyval      calc3_val
  33 #endif /* yyval */
  34
  35 #ifndef yylval
  36 #define yylval     calc3_lval
  37 #endif /* yylval */
  38
  39 #ifndef yydebug
  40 #define yydebug    calc3_debug
  41 #endif /* yydebug */
  42
  43 #ifndef yynerrs
  44 #define yynerrs    calc3_nerrs
  45 #endif /* yynerrs */
  46
  47 #ifndef yyerrflag
  48 #define yyerrflag  calc3_errflag
  49 #endif /* yyerrflag */
  50
  51 #ifndef yylhs
  52 #define yylhs      calc3_lhs
  53 #endif /* yylhs */
  54
  55 #ifndef yylen
  56 #define yylen      calc3_len
  57 #endif /* yylen */
  58
  59 #ifndef yydefred
  60 #define yydefred   calc3_defred
  61 #endif /* yydefred */
  62
  63 #ifndef yydgoto
  64 #define yydgoto    calc3_dgoto
  65 #endif /* yydgoto */
  66
  67 #ifndef yysindex
  68 #define yysindex   calc3_sindex
  69 #endif /* yysindex */
  70
  71 #ifndef yyrindex
  72 #define yyrindex   calc3_rindex
  73 #endif /* yyrindex */
  74
  75 #ifndef yygindex
  76 #define yygindex   calc3_gindex
  77 #endif /* yygindex */
  78
  79 #ifndef yytable
  80 #define yytable    calc3_table
  81 #endif /* yytable */
  82
  83 #ifndef yycheck
  84 #define yycheck    calc3_check
  85 #endif /* yycheck */
  86
  87 #ifndef yyname
  88 #define yyname     calc3_name
  89 #endif /* yyname */
  90
  91 #ifndef yyrule
  92 #define yyrule     calc3_rule
  93 #endif /* yyrule */
  94 #define YYPREFIX "calc3_"
  95
  96 #define YYPURE 1
  97
  98 #line 9 "calc3.y"
  99 # include <stdio.h>
 100 # include <ctype.h>
 101
 102 #line 103 "calc3.tab.c"
 103
 104 #ifndef YYSTYPE
 105 typedef int YYSTYPE;
 106 #endif
 107
 108 /* compatibility with bison */
 109 #ifdef YYPARSE_PARAM
 110 /* compatibility with FreeBSD */
 111 # ifdef YYPARSE_PARAM_TYPE
 112 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 113 # else
 114 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 115 # endif
 116 #else
 117 # define YYPARSE_DECL() yyparse(int  regs[26], int * base)
 118 #endif
 119
 120 /* Parameters sent to lex. */
 121 #ifdef YYLEX_PARAM
 122 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void *YYLEX_PARAM)
 123 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 124 #else
 125 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
 126 # define YYLEX yylex(&yylval, base)
 127 #endif
 128
 129 /* Parameters sent to yyerror. */
 130 #define YYERROR_DECL() yyerror(YYSTYPE *v, const char *s)
 131 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
 132
 133 extern int YYPARSE_DECL();
 134 extern int YYLEX_DECL();
 135
 136 #define DIGIT 257
 137 #define LETTER 258
 138 #define UMINUS 259
 139 #define YYERRCODE 256
 140 static const short calc3_lhs[] = {                       -1,
 141     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 142     2,    2,    2,    2,    2,    2,    3,    3,
 143 };
 144 static const short calc3_len[] = {                        2,
 145     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 146     3,    3,    3,    2,    1,    1,    1,    2,
 147 };
 148 static const short calc3_defred[] = {                     1,
 149     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 150     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 151     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 152    10,   11,
 153 };
 154 static const short calc3_dgoto[] = {                      1,
 155     7,    8,    9,
 156 };
 157 static const short calc3_sindex[] = {                     0,
 158   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 159   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 160   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 161     0,    0,
 162 };
 163 static const short calc3_rindex[] = {                     0,
 164     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 165     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 166     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 167     0,    0,
 168 };
 169 static const short calc3_gindex[] = {                     0,
 170     0,   65,    0,
 171 };
 172 #define YYTABLESIZE 220
 173 static const short calc3_table[] = {                      6,
 174    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 175    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 176     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 177     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 178     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 179     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 180     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 181    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 182    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 183     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 184     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 185     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 186     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 187     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 188     0,    0,    0,    0,    0,   16,    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,    0,    0,    0,    0,    0,
 195     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 196 };
 197 static const short calc3_check[] = {                     40,
 198    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 199    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 200    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 201    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 202    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 203    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 204    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 205     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 206    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 207    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 208    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 209    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 210    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 211    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 212    -1,   -1,   -1,   -1,   -1,  124,   -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,   -1,   -1,   -1,   -1,   -1,
 219    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 220 };
 221 #define YYFINAL 1
 222 #ifndef YYDEBUG
 223 #define YYDEBUG 0
 224 #endif
 225 #define YYMAXTOKEN 259
 226 #if YYDEBUG
 227 static const char *yyname[] = {
 228
 229 "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,
 230 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,
 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,0,0,0,0,0,0,0,0,0,0,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,"DIGIT","LETTER","UMINUS",
 237 };
 238 static const char *yyrule[] = {
 239 "$accept : list",
 240 "list :",
 241 "list : list stat '\\n'",
 242 "list : list error '\\n'",
 243 "stat : expr",
 244 "stat : LETTER '=' expr",
 245 "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 '|' expr",
 253 "expr : '-' expr",
 254 "expr : LETTER",
 255 "expr : number",
 256 "number : DIGIT",
 257 "number : number DIGIT",
 258
 259 };
 260 #endif
 261 /* define the initial stack-sizes */
 262 #ifdef YYSTACKSIZE
 263 #undef YYMAXDEPTH
 264 #define YYMAXDEPTH  YYSTACKSIZE
 265 #else
 266 #ifdef YYMAXDEPTH
 267 #define YYSTACKSIZE YYMAXDEPTH
 268 #else
 269 #define YYSTACKSIZE 500
 270 #define YYMAXDEPTH  500
 271 #endif
 272 #endif
 273
 274 #define YYINITSTACKSIZE 500
 275
 276 int      yydebug;
 277 int      yynerrs;
 278
 279 typedef struct {
 280     unsigned stacksize;
 281     short    *s_base;
 282     short    *s_mark;
 283     short    *s_last;
 284     YYSTYPE  *l_base;
 285     YYSTYPE  *l_mark;
 286 } YYSTACKDATA;
 287 #line 67 "calc3.y"
 288  /* start of programs */
 289
 290 int
 291 main (void)
 292 {
 293     int regs[26];
 294     int base = 10;
 295
 296     while(!feof(stdin)) {
 297         yyparse(regs, &base);
 298     }
 299     return 0;
 300 }
 301
 302 static void
 303 YYERROR_DECL()
 304 {
 305     fprintf(stderr, "%s\n", s);
 306 }
 307
 308 int
 309 YYLEX_DECL()
 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         *yylval = (c - 'a');
 324         return ( LETTER );
 325     }
 326     if( isdigit( c )) {
 327         *yylval = (c - '0') % (*base);
 328         return ( DIGIT );
 329     }
 330     return( c );
 331 }
 332 #line 333 "calc3.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(regs, base, "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 29 "calc3.y"
 551         {  yyerrok ; }
 552 break;
 553 case 4:
 554 #line 33 "calc3.y"
 555         {  printf("%d\n",yystack.l_mark[0]);}
 556 break;
 557 case 5:
 558 #line 35 "calc3.y"
 559         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 560 break;
 561 case 6:
 562 #line 39 "calc3.y"
 563         {  yyval = yystack.l_mark[-1]; }
 564 break;
 565 case 7:
 566 #line 41 "calc3.y"
 567         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 568 break;
 569 case 8:
 570 #line 43 "calc3.y"
 571         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 572 break;
 573 case 9:
 574 #line 45 "calc3.y"
 575         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 576 break;
 577 case 10:
 578 #line 47 "calc3.y"
 579         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 580 break;
 581 case 11:
 582 #line 49 "calc3.y"
 583         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 584 break;
 585 case 12:
 586 #line 51 "calc3.y"
 587         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 588 break;
 589 case 13:
 590 #line 53 "calc3.y"
 591         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 592 break;
 593 case 14:
 594 #line 55 "calc3.y"
 595         {  yyval = - yystack.l_mark[0]; }
 596 break;
 597 case 15:
 598 #line 57 "calc3.y"
 599         {  yyval = regs[yystack.l_mark[0]]; }
 600 break;
 601 case 17:
 602 #line 62 "calc3.y"
 603         {  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
 604 break;
 605 case 18:
 606 #line 64 "calc3.y"
 607         {  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
 608 break;
 609 #line 610 "calc3.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(regs, base, "yacc stack overflow");
 662
 663 yyabort:
 664     yyfreestack(&yystack);
 665     return (1);
 666
 667 yyaccept:
 668     yyfreestack(&yystack);
 669     return (0);
 670 }