contrib/byacc/test/yacc/calc.tab.c

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