test/calc2.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    calc2_parse
  17 #endif /* yyparse */
  18
  19 #ifndef yylex
  20 #define yylex      calc2_lex
  21 #endif /* yylex */
  22
  23 #ifndef yyerror
  24 #define yyerror    calc2_error
  25 #endif /* yyerror */
  26
  27 #ifndef yychar
  28 #define yychar     calc2_char
  29 #endif /* yychar */
  30
  31 #ifndef yyval
  32 #define yyval      calc2_val
  33 #endif /* yyval */
  34
  35 #ifndef yylval
  36 #define yylval     calc2_lval
  37 #endif /* yylval */
  38
  39 #ifndef yydebug
  40 #define yydebug    calc2_debug
  41 #endif /* yydebug */
  42
  43 #ifndef yynerrs
  44 #define yynerrs    calc2_nerrs
  45 #endif /* yynerrs */
  46
  47 #ifndef yyerrflag
  48 #define yyerrflag  calc2_errflag
  49 #endif /* yyerrflag */
  50
  51 #ifndef yylhs
  52 #define yylhs      calc2_lhs
  53 #endif /* yylhs */
  54
  55 #ifndef yylen
  56 #define yylen      calc2_len
  57 #endif /* yylen */
  58
  59 #ifndef yydefred
  60 #define yydefred   calc2_defred
  61 #endif /* yydefred */
  62
  63 #ifndef yydgoto
  64 #define yydgoto    calc2_dgoto
  65 #endif /* yydgoto */
  66
  67 #ifndef yysindex
  68 #define yysindex   calc2_sindex
  69 #endif /* yysindex */
  70
  71 #ifndef yyrindex
  72 #define yyrindex   calc2_rindex
  73 #endif /* yyrindex */
  74
  75 #ifndef yygindex
  76 #define yygindex   calc2_gindex
  77 #endif /* yygindex */
  78
  79 #ifndef yytable
  80 #define yytable    calc2_table
  81 #endif /* yytable */
  82
  83 #ifndef yycheck
  84 #define yycheck    calc2_check
  85 #endif /* yycheck */
  86
  87 #ifndef yyname
  88 #define yyname     calc2_name
  89 #endif /* yyname */
  90
  91 #ifndef yyrule
  92 #define yyrule     calc2_rule
  93 #endif /* yyrule */
  94 #define YYPREFIX "calc2_"
  95
  96 #define YYPURE 0
  97
  98 #line 7 "calc2.y"
  99 # include <stdio.h>
 100 # include <ctype.h>
 101
 102 #line 103 "calc2.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(void *YYLEX_PARAM)
 123 # define YYLEX yylex(YYLEX_PARAM)
 124 #else
 125 # define YYLEX_DECL() yylex(int * base)
 126 # define YYLEX yylex(base)
 127 #endif
 128
 129 extern int YYPARSE_DECL();
 130 extern int YYLEX_DECL();
 131
 132 #define DIGIT 257
 133 #define LETTER 258
 134 #define UMINUS 259
 135 #define YYERRCODE 256
 136 static const short calc2_lhs[] = {                       -1,
 137     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 138     2,    2,    2,    2,    2,    2,    3,    3,
 139 };
 140 static const short calc2_len[] = {                        2,
 141     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 142     3,    3,    3,    2,    1,    1,    1,    2,
 143 };
 144 static const short calc2_defred[] = {                     1,
 145     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 146     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 147     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 148    10,   11,
 149 };
 150 static const short calc2_dgoto[] = {                      1,
 151     7,    8,    9,
 152 };
 153 static const short calc2_sindex[] = {                     0,
 154   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 155   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 156   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 157     0,    0,
 158 };
 159 static const short calc2_rindex[] = {                     0,
 160     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 161     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 162     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 163     0,    0,
 164 };
 165 static const short calc2_gindex[] = {                     0,
 166     0,   65,    0,
 167 };
 168 #define YYTABLESIZE 220
 169 static const short calc2_table[] = {                      6,
 170    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 171    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 172     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 173     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 174     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 175     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 176     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 177    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 178    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 179     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 180     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 181     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 182     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 183     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 184     0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
 185     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 186     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 187     0,    0,    0,    0,    0,    0,    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,    2,    3,    4,    3,   12,
 192 };
 193 static const short calc2_check[] = {                     40,
 194    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 195    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 196    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 197    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 198    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 199    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 200    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 201     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 202    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 203    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 204    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 205    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 206    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 207    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 208    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
 209    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 210    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 211    -1,   -1,   -1,   -1,   -1,   -1,   -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,  256,  257,  258,  257,  258,
 216 };
 217 #define YYFINAL 1
 218 #ifndef YYDEBUG
 219 #define YYDEBUG 0
 220 #endif
 221 #define YYMAXTOKEN 259
 222 #if YYDEBUG
 223 static const char *yyname[] = {
 224
 225 "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,
 226 0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
 227 0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 228 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,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,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,0,0,0,
 232 0,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
 233 };
 234 static const char *yyrule[] = {
 235 "$accept : list",
 236 "list :",
 237 "list : list stat '\\n'",
 238 "list : list error '\\n'",
 239 "stat : expr",
 240 "stat : LETTER '=' expr",
 241 "expr : '(' expr ')'",
 242 "expr : expr '+' expr",
 243 "expr : expr '-' expr",
 244 "expr : expr '*' expr",
 245 "expr : expr '/' expr",
 246 "expr : expr '%' expr",
 247 "expr : expr '&' expr",
 248 "expr : expr '|' expr",
 249 "expr : '-' expr",
 250 "expr : LETTER",
 251 "expr : number",
 252 "number : DIGIT",
 253 "number : number DIGIT",
 254
 255 };
 256 #endif
 257 /* define the initial stack-sizes */
 258 #ifdef YYSTACKSIZE
 259 #undef YYMAXDEPTH
 260 #define YYMAXDEPTH  YYSTACKSIZE
 261 #else
 262 #ifdef YYMAXDEPTH
 263 #define YYSTACKSIZE YYMAXDEPTH
 264 #else
 265 #define YYSTACKSIZE 500
 266 #define YYMAXDEPTH  500
 267 #endif
 268 #endif
 269
 270 #define YYINITSTACKSIZE 500
 271
 272 int      yydebug;
 273 int      yynerrs;
 274
 275 typedef struct {
 276     unsigned stacksize;
 277     short    *s_base;
 278     short    *s_mark;
 279     short    *s_last;
 280     YYSTYPE  *l_base;
 281     YYSTYPE  *l_mark;
 282 } YYSTACKDATA;
 283 int      yyerrflag;
 284 int      yychar;
 285 YYSTYPE  yyval;
 286 YYSTYPE  yylval;
 287
 288 /* variables for the parser stack */
 289 static YYSTACKDATA yystack;
 290 #line 65 "calc2.y"
 291  /* start of programs */
 292
 293 int
 294 main (void)
 295 {
 296     int regs[26];
 297     int base = 10;
 298
 299     while(!feof(stdin)) {
 300         yyparse(regs, &base);
 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(int *base)
 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') % (*base);
 331         return ( DIGIT );
 332     }
 333     return( c );
 334 }
 335 #line 336 "calc2.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 27 "calc2.y"
 547         {  yyerrok ; }
 548 break;
 549 case 4:
 550 #line 31 "calc2.y"
 551         {  printf("%d\n",yystack.l_mark[0]);}
 552 break;
 553 case 5:
 554 #line 33 "calc2.y"
 555         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 556 break;
 557 case 6:
 558 #line 37 "calc2.y"
 559         {  yyval = yystack.l_mark[-1]; }
 560 break;
 561 case 7:
 562 #line 39 "calc2.y"
 563         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 564 break;
 565 case 8:
 566 #line 41 "calc2.y"
 567         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 568 break;
 569 case 9:
 570 #line 43 "calc2.y"
 571         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 572 break;
 573 case 10:
 574 #line 45 "calc2.y"
 575         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 576 break;
 577 case 11:
 578 #line 47 "calc2.y"
 579         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 580 break;
 581 case 12:
 582 #line 49 "calc2.y"
 583         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 584 break;
 585 case 13:
 586 #line 51 "calc2.y"
 587         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 588 break;
 589 case 14:
 590 #line 53 "calc2.y"
 591         {  yyval = - yystack.l_mark[0]; }
 592 break;
 593 case 15:
 594 #line 55 "calc2.y"
 595         {  yyval = regs[yystack.l_mark[0]]; }
 596 break;
 597 case 17:
 598 #line 60 "calc2.y"
 599         {  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
 600 break;
 601 case 18:
 602 #line 62 "calc2.y"
 603         {  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
 604 break;
 605 #line 606 "calc2.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 }