contrib/byacc/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 #ifdef YYBISON
 106 #define YYSTYPE int
 107 #define YYLEX_PARAM &yylval
 108 #define YYLEX_DECL() yylex(YYSTYPE *yylval)
 109 #define YYERROR_DECL() yyerror(const char *s)
 110 int YYLEX_DECL();
 111 static void YYERROR_DECL();
 112 #endif
 113
 114 #line 115 "pure_calc.tab.c"
 115
 116 #ifndef YYSTYPE
 117 typedef int YYSTYPE;
 118 #endif
 119
 120 /* compatibility with bison */
 121 #ifdef YYPARSE_PARAM
 122 /* compatibility with FreeBSD */
 123 # ifdef YYPARSE_PARAM_TYPE
 124 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 125 # else
 126 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 127 # endif
 128 #else
 129 # define YYPARSE_DECL() yyparse(void)
 130 #endif
 131
 132 /* Parameters sent to lex. */
 133 #ifdef YYLEX_PARAM
 134 # ifdef YYLEX_PARAM_TYPE
 135 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
 136 # else
 137 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
 138 # endif
 139 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 140 #else
 141 # define YYLEX_DECL() yylex(YYSTYPE *yylval)
 142 # define YYLEX yylex(&yylval)
 143 #endif
 144
 145 /* Parameters sent to yyerror. */
 146 #ifndef YYERROR_DECL
 147 #define YYERROR_DECL() yyerror(const char *s)
 148 #endif
 149 #ifndef YYERROR_CALL
 150 #define YYERROR_CALL(msg) yyerror(msg)
 151 #endif
 152
 153 extern int YYPARSE_DECL();
 154
 155 #define DIGIT 257
 156 #define LETTER 258
 157 #define UMINUS 259
 158 #define YYERRCODE 256
 159 static const short calc_lhs[] = {                        -1,
 160     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 161     2,    2,    2,    2,    2,    2,    3,    3,
 162 };
 163 static const short calc_len[] = {                         2,
 164     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 165     3,    3,    3,    2,    1,    1,    1,    2,
 166 };
 167 static const short calc_defred[] = {                      1,
 168     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 169     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 170     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 171    10,   11,
 172 };
 173 static const short calc_dgoto[] = {                       1,
 174     7,    8,    9,
 175 };
 176 static const short calc_sindex[] = {                      0,
 177   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 178   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 179   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 180     0,    0,
 181 };
 182 static const short calc_rindex[] = {                      0,
 183     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 184     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 185     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 186     0,    0,
 187 };
 188 static const short calc_gindex[] = {                      0,
 189     0,   65,    0,
 190 };
 191 #define YYTABLESIZE 220
 192 static const short calc_table[] = {                       6,
 193    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 194    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 195     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 196     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 197     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 198     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 199     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 200    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 201    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 202     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 203     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 204     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 205     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 206     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 207     0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
 208     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 209     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 210     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 211     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 212     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 213     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 214     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 215 };
 216 static const short calc_check[] = {                      40,
 217    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 218    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 219    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 220    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 221    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 222    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 223    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 224     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 225    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 226    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 227    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 228    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 229    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 230    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 231    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
 232    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 233    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 234    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 235    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 236    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 237    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 238    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 239 };
 240 #define YYFINAL 1
 241 #ifndef YYDEBUG
 242 #define YYDEBUG 0
 243 #endif
 244 #define YYMAXTOKEN 259
 245 #if YYDEBUG
 246 static const char *yyname[] = {
 247
 248 "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,
 249 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,
 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,
 252 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 253 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 254 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 255 0,0,0,0,0,0,"DIGIT","LETTER","UMINUS",
 256 };
 257 static const char *yyrule[] = {
 258 "$accept : list",
 259 "list :",
 260 "list : list stat '\\n'",
 261 "list : list error '\\n'",
 262 "stat : expr",
 263 "stat : LETTER '=' expr",
 264 "expr : '(' expr ')'",
 265 "expr : expr '+' expr",
 266 "expr : expr '-' expr",
 267 "expr : expr '*' expr",
 268 "expr : expr '/' expr",
 269 "expr : expr '%' expr",
 270 "expr : expr '&' expr",
 271 "expr : expr '|' expr",
 272 "expr : '-' expr",
 273 "expr : LETTER",
 274 "expr : number",
 275 "number : DIGIT",
 276 "number : number DIGIT",
 277
 278 };
 279 #endif
 280
 281 int      yydebug;
 282 int      yynerrs;
 283
 284 /* define the initial stack-sizes */
 285 #ifdef YYSTACKSIZE
 286 #undef YYMAXDEPTH
 287 #define YYMAXDEPTH  YYSTACKSIZE
 288 #else
 289 #ifdef YYMAXDEPTH
 290 #define YYSTACKSIZE YYMAXDEPTH
 291 #else
 292 #define YYSTACKSIZE 500
 293 #define YYMAXDEPTH  500
 294 #endif
 295 #endif
 296
 297 #define YYINITSTACKSIZE 500
 298
 299 typedef struct {
 300     unsigned stacksize;
 301     short    *s_base;
 302     short    *s_mark;
 303     short    *s_last;
 304     YYSTYPE  *l_base;
 305     YYSTYPE  *l_mark;
 306 } YYSTACKDATA;
 307 #line 72 "pure_calc.y"
 308  /* start of programs */
 309
 310 #ifdef YYBYACC
 311 static int YYLEX_DECL();
 312 #endif
 313
 314 int
 315 main (void)
 316 {
 317     while(!feof(stdin)) {
 318         yyparse();
 319     }
 320     return 0;
 321 }
 322
 323 static void
 324 YYERROR_DECL()
 325 {
 326     fprintf(stderr, "%s\n", s);
 327 }
 328
 329 int
 330 YYLEX_DECL()
 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 "pure_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     short *newss;
 368     YYSTYPE *newvs;
 369
 370     if ((newsize = data->stacksize) == 0)
 371         newsize = YYINITSTACKSIZE;
 372     else if (newsize >= YYMAXDEPTH)
 373         return -1;
 374     else if ((newsize *= 2) > YYMAXDEPTH)
 375         newsize = YYMAXDEPTH;
 376
 377     i = (int) (data->s_mark - data->s_base);
 378     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 379     if (newss == 0)
 380         return -1;
 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 -1;
 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      yyerrflag;
 417     int      yychar;
 418     YYSTYPE  yyval;
 419     YYSTYPE  yylval;
 420
 421     /* variables for the parser stack */
 422     YYSTACKDATA yystack;
 423     int yym, yyn, yystate;
 424 #if YYDEBUG
 425     const char *yys;
 426
 427     if ((yys = getenv("YYDEBUG")) != 0)
 428     {
 429         yyn = *yys;
 430         if (yyn >= '0' && yyn <= '9')
 431             yydebug = yyn - '0';
 432     }
 433 #endif
 434
 435     yynerrs = 0;
 436     yyerrflag = 0;
 437     yychar = YYEMPTY;
 438     yystate = 0;
 439
 440 #if YYPURE
 441     memset(&yystack, 0, sizeof(yystack));
 442 #endif
 443
 444     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 445     yystack.s_mark = yystack.s_base;
 446     yystack.l_mark = yystack.l_base;
 447     yystate = 0;
 448     *yystack.s_mark = 0;
 449
 450 yyloop:
 451     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 452     if (yychar < 0)
 453     {
 454         if ((yychar = YYLEX) < 0) yychar = 0;
 455 #if YYDEBUG
 456         if (yydebug)
 457         {
 458             yys = 0;
 459             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 460             if (!yys) yys = "illegal-symbol";
 461             printf("%sdebug: state %d, reading %d (%s)\n",
 462                     YYPREFIX, yystate, yychar, yys);
 463         }
 464 #endif
 465     }
 466     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 467             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 468     {
 469 #if YYDEBUG
 470         if (yydebug)
 471             printf("%sdebug: state %d, shifting to state %d\n",
 472                     YYPREFIX, yystate, yytable[yyn]);
 473 #endif
 474         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 475         {
 476             goto yyoverflow;
 477         }
 478         yystate = yytable[yyn];
 479         *++yystack.s_mark = yytable[yyn];
 480         *++yystack.l_mark = yylval;
 481         yychar = YYEMPTY;
 482         if (yyerrflag > 0)  --yyerrflag;
 483         goto yyloop;
 484     }
 485     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 486             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 487     {
 488         yyn = yytable[yyn];
 489         goto yyreduce;
 490     }
 491     if (yyerrflag) goto yyinrecovery;
 492
 493     yyerror("syntax error");
 494
 495     goto yyerrlab;
 496
 497 yyerrlab:
 498     ++yynerrs;
 499
 500 yyinrecovery:
 501     if (yyerrflag < 3)
 502     {
 503         yyerrflag = 3;
 504         for (;;)
 505         {
 506             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 507                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 508             {
 509 #if YYDEBUG
 510                 if (yydebug)
 511                     printf("%sdebug: state %d, error recovery shifting\
 512  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 513 #endif
 514                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 515                 {
 516                     goto yyoverflow;
 517                 }
 518                 yystate = yytable[yyn];
 519                 *++yystack.s_mark = yytable[yyn];
 520                 *++yystack.l_mark = yylval;
 521                 goto yyloop;
 522             }
 523             else
 524             {
 525 #if YYDEBUG
 526                 if (yydebug)
 527                     printf("%sdebug: error recovery discarding state %d\n",
 528                             YYPREFIX, *yystack.s_mark);
 529 #endif
 530                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 531                 --yystack.s_mark;
 532                 --yystack.l_mark;
 533             }
 534         }
 535     }
 536     else
 537     {
 538         if (yychar == 0) goto yyabort;
 539 #if YYDEBUG
 540         if (yydebug)
 541         {
 542             yys = 0;
 543             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 544             if (!yys) yys = "illegal-symbol";
 545             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 546                     YYPREFIX, yystate, yychar, yys);
 547         }
 548 #endif
 549         yychar = YYEMPTY;
 550         goto yyloop;
 551     }
 552
 553 yyreduce:
 554 #if YYDEBUG
 555     if (yydebug)
 556         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 557                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 558 #endif
 559     yym = yylen[yyn];
 560     if (yym)
 561         yyval = yystack.l_mark[1-yym];
 562     else
 563         memset(&yyval, 0, sizeof yyval);
 564     switch (yyn)
 565     {
 566 case 3:
 567 #line 34 "pure_calc.y"
 568         {  yyerrok ; }
 569 break;
 570 case 4:
 571 #line 38 "pure_calc.y"
 572         {  printf("%d\n",yystack.l_mark[0]);}
 573 break;
 574 case 5:
 575 #line 40 "pure_calc.y"
 576         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 577 break;
 578 case 6:
 579 #line 44 "pure_calc.y"
 580         {  yyval = yystack.l_mark[-1]; }
 581 break;
 582 case 7:
 583 #line 46 "pure_calc.y"
 584         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 585 break;
 586 case 8:
 587 #line 48 "pure_calc.y"
 588         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 589 break;
 590 case 9:
 591 #line 50 "pure_calc.y"
 592         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 593 break;
 594 case 10:
 595 #line 52 "pure_calc.y"
 596         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 597 break;
 598 case 11:
 599 #line 54 "pure_calc.y"
 600         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 601 break;
 602 case 12:
 603 #line 56 "pure_calc.y"
 604         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 605 break;
 606 case 13:
 607 #line 58 "pure_calc.y"
 608         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 609 break;
 610 case 14:
 611 #line 60 "pure_calc.y"
 612         {  yyval = - yystack.l_mark[0]; }
 613 break;
 614 case 15:
 615 #line 62 "pure_calc.y"
 616         {  yyval = regs[yystack.l_mark[0]]; }
 617 break;
 618 case 17:
 619 #line 67 "pure_calc.y"
 620         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 621 break;
 622 case 18:
 623 #line 69 "pure_calc.y"
 624         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 625 break;
 626 #line 627 "pure_calc.tab.c"
 627     }
 628     yystack.s_mark -= yym;
 629     yystate = *yystack.s_mark;
 630     yystack.l_mark -= yym;
 631     yym = yylhs[yyn];
 632     if (yystate == 0 && yym == 0)
 633     {
 634 #if YYDEBUG
 635         if (yydebug)
 636             printf("%sdebug: after reduction, shifting from state 0 to\
 637  state %d\n", YYPREFIX, YYFINAL);
 638 #endif
 639         yystate = YYFINAL;
 640         *++yystack.s_mark = YYFINAL;
 641         *++yystack.l_mark = yyval;
 642         if (yychar < 0)
 643         {
 644             if ((yychar = YYLEX) < 0) yychar = 0;
 645 #if YYDEBUG
 646             if (yydebug)
 647             {
 648                 yys = 0;
 649                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 650                 if (!yys) yys = "illegal-symbol";
 651                 printf("%sdebug: state %d, reading %d (%s)\n",
 652                         YYPREFIX, YYFINAL, yychar, yys);
 653             }
 654 #endif
 655         }
 656         if (yychar == 0) goto yyaccept;
 657         goto yyloop;
 658     }
 659     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 660             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 661         yystate = yytable[yyn];
 662     else
 663         yystate = yydgoto[yym];
 664 #if YYDEBUG
 665     if (yydebug)
 666         printf("%sdebug: after reduction, shifting from state %d \
 667 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 668 #endif
 669     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 670     {
 671         goto yyoverflow;
 672     }
 673     *++yystack.s_mark = (short) yystate;
 674     *++yystack.l_mark = yyval;
 675     goto yyloop;
 676
 677 yyoverflow:
 678     yyerror("yacc stack overflow");
 679
 680 yyabort:
 681     yyfreestack(&yystack);
 682     return (1);
 683
 684 yyaccept:
 685     yyfreestack(&yystack);
 686     return (0);
 687 }