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