test/pure_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 1
  97
  98 #line 2 "pure_calc.y"
  99 # include <stdio.h>
 100 # include <ctype.h>
 101
 102 int regs[26];
 103 int base;
 104
 105 #line 106 "pure_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(YYSTYPE *yylval, void *YYLEX_PARAM)
 126 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 127 #else
 128 # define YYLEX_DECL() yylex(YYSTYPE *yylval)
 129 # define YYLEX yylex(&yylval)
 130 #endif
 131
 132 /* Parameters sent to yyerror. */
 133 #define YYERROR_DECL() yyerror(const char *s)
 134 #define YYERROR_CALL(msg) yyerror(msg)
 135
 136 extern int YYPARSE_DECL();
 137
 138 #define DIGIT 257
 139 #define LETTER 258
 140 #define UMINUS 259
 141 #define YYERRCODE 256
 142 static const short calc_lhs[] = {                        -1,
 143     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 144     2,    2,    2,    2,    2,    2,    3,    3,
 145 };
 146 static const short calc_len[] = {                         2,
 147     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 148     3,    3,    3,    2,    1,    1,    1,    2,
 149 };
 150 static const short calc_defred[] = {                      1,
 151     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 152     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 153     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 154    10,   11,
 155 };
 156 static const short calc_dgoto[] = {                       1,
 157     7,    8,    9,
 158 };
 159 static const short calc_sindex[] = {                      0,
 160   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 161   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 162   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 163     0,    0,
 164 };
 165 static const short calc_rindex[] = {                      0,
 166     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 167     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 168     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 169     0,    0,
 170 };
 171 static const short calc_gindex[] = {                      0,
 172     0,   65,    0,
 173 };
 174 #define YYTABLESIZE 220
 175 static const short calc_table[] = {                       6,
 176    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 177    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 178     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 179     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 180     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 181     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 182     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 183    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 184    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 185     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 186     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 187     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 188     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 189     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 190     0,    0,    0,    0,    0,   16,    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,    0,    0,    0,    0,    0,
 196     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 197     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 198 };
 199 static const short calc_check[] = {                      40,
 200    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 201    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 202    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 203    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 204    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 205    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 206    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 207     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 208    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 209    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 210    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 211    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 212    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 213    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 214    -1,   -1,   -1,   -1,   -1,  124,   -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,   -1,   -1,   -1,   -1,   -1,
 220    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 221    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 222 };
 223 #define YYFINAL 1
 224 #ifndef YYDEBUG
 225 #define YYDEBUG 0
 226 #endif
 227 #define YYMAXTOKEN 259
 228 #if YYDEBUG
 229 static const char *yyname[] = {
 230
 231 "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,
 232 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,
 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,
 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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 237 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 238 0,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
 239 };
 240 static const char *yyrule[] = {
 241 "$accept : list",
 242 "list :",
 243 "list : list stat '\\n'",
 244 "list : list error '\\n'",
 245 "stat : expr",
 246 "stat : LETTER '=' expr",
 247 "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 '&' expr",
 254 "expr : expr '|' expr",
 255 "expr : '-' expr",
 256 "expr : LETTER",
 257 "expr : number",
 258 "number : DIGIT",
 259 "number : number DIGIT",
 260
 261 };
 262 #endif
 263 /* define the initial stack-sizes */
 264 #ifdef YYSTACKSIZE
 265 #undef YYMAXDEPTH
 266 #define YYMAXDEPTH  YYSTACKSIZE
 267 #else
 268 #ifdef YYMAXDEPTH
 269 #define YYSTACKSIZE YYMAXDEPTH
 270 #else
 271 #define YYSTACKSIZE 500
 272 #define YYMAXDEPTH  500
 273 #endif
 274 #endif
 275
 276 #define YYINITSTACKSIZE 500
 277
 278 int      yydebug;
 279 int      yynerrs;
 280
 281 typedef struct {
 282     unsigned stacksize;
 283     short    *s_base;
 284     short    *s_mark;
 285     short    *s_last;
 286     YYSTYPE  *l_base;
 287     YYSTYPE  *l_mark;
 288 } YYSTACKDATA;
 289 #line 63 "pure_calc.y"
 290  /* start of programs */
 291
 292 #ifdef YYBYACC
 293 extern int YYLEX_DECL();
 294 static void YYERROR_DECL();
 295 #endif
 296
 297 int
 298 main (void)
 299 {
 300     while(!feof(stdin)) {
 301         yyparse();
 302     }
 303     return 0;
 304 }
 305
 306 static void
 307 yyerror(const char *s)
 308 {
 309     fprintf(stderr, "%s\n", s);
 310 }
 311
 312 int
 313 yylex(YYSTYPE *value)
 314 {
 315         /* lexical analysis routine */
 316         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 317         /* return DIGIT for a digit, yylval = 0 through 9 */
 318         /* all other characters are returned immediately */
 319
 320     int c;
 321
 322     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 323
 324     /* c is now nonblank */
 325
 326     if( islower( c )) {
 327         *value = c - 'a';
 328         return ( LETTER );
 329     }
 330     if( isdigit( c )) {
 331         *value = c - '0';
 332         return ( DIGIT );
 333     }
 334     return( c );
 335 }
 336 #line 337 "pure_calc.tab.c"
 337
 338 #if YYDEBUG
 339 #include <stdio.h>              /* needed for printf */
 340 #endif
 341
 342 #include <stdlib.h>     /* needed for malloc, etc */
 343 #include <string.h>     /* needed for memset */
 344
 345 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 346 static int yygrowstack(YYSTACKDATA *data)
 347 {
 348     int i;
 349     unsigned newsize;
 350     short *newss;
 351     YYSTYPE *newvs;
 352
 353     if ((newsize = data->stacksize) == 0)
 354         newsize = YYINITSTACKSIZE;
 355     else if (newsize >= YYMAXDEPTH)
 356         return -1;
 357     else if ((newsize *= 2) > YYMAXDEPTH)
 358         newsize = YYMAXDEPTH;
 359
 360     i = data->s_mark - data->s_base;
 361     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 362     if (newss == 0)
 363         return -1;
 364
 365     data->s_base = newss;
 366     data->s_mark = newss + i;
 367
 368     newvs = (YYSTYPE *)realloc(data->l_base, 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("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 25 "pure_calc.y"
 551         {  yyerrok ; }
 552 break;
 553 case 4:
 554 #line 29 "pure_calc.y"
 555         {  printf("%d\n",yystack.l_mark[0]);}
 556 break;
 557 case 5:
 558 #line 31 "pure_calc.y"
 559         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 560 break;
 561 case 6:
 562 #line 35 "pure_calc.y"
 563         {  yyval = yystack.l_mark[-1]; }
 564 break;
 565 case 7:
 566 #line 37 "pure_calc.y"
 567         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 568 break;
 569 case 8:
 570 #line 39 "pure_calc.y"
 571         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 572 break;
 573 case 9:
 574 #line 41 "pure_calc.y"
 575         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 576 break;
 577 case 10:
 578 #line 43 "pure_calc.y"
 579         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 580 break;
 581 case 11:
 582 #line 45 "pure_calc.y"
 583         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 584 break;
 585 case 12:
 586 #line 47 "pure_calc.y"
 587         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 588 break;
 589 case 13:
 590 #line 49 "pure_calc.y"
 591         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 592 break;
 593 case 14:
 594 #line 51 "pure_calc.y"
 595         {  yyval = - yystack.l_mark[0]; }
 596 break;
 597 case 15:
 598 #line 53 "pure_calc.y"
 599         {  yyval = regs[yystack.l_mark[0]]; }
 600 break;
 601 case 17:
 602 #line 58 "pure_calc.y"
 603         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 604 break;
 605 case 18:
 606 #line 60 "pure_calc.y"
 607         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 608 break;
 609 #line 610 "pure_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 = 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("yacc stack overflow");
 662
 663 yyabort:
 664     yyfreestack(&yystack);
 665     return (1);
 666
 667 yyaccept:
 668     yyfreestack(&yystack);
 669     return (0);
 670 }