contrib/byacc/test/calc3.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    calc3_parse
  17 #endif /* yyparse */
  18
  19 #ifndef yylex
  20 #define yylex      calc3_lex
  21 #endif /* yylex */
  22
  23 #ifndef yyerror
  24 #define yyerror    calc3_error
  25 #endif /* yyerror */
  26
  27 #ifndef yychar
  28 #define yychar     calc3_char
  29 #endif /* yychar */
  30
  31 #ifndef yyval
  32 #define yyval      calc3_val
  33 #endif /* yyval */
  34
  35 #ifndef yylval
  36 #define yylval     calc3_lval
  37 #endif /* yylval */
  38
  39 #ifndef yydebug
  40 #define yydebug    calc3_debug
  41 #endif /* yydebug */
  42
  43 #ifndef yynerrs
  44 #define yynerrs    calc3_nerrs
  45 #endif /* yynerrs */
  46
  47 #ifndef yyerrflag
  48 #define yyerrflag  calc3_errflag
  49 #endif /* yyerrflag */
  50
  51 #ifndef yylhs
  52 #define yylhs      calc3_lhs
  53 #endif /* yylhs */
  54
  55 #ifndef yylen
  56 #define yylen      calc3_len
  57 #endif /* yylen */
  58
  59 #ifndef yydefred
  60 #define yydefred   calc3_defred
  61 #endif /* yydefred */
  62
  63 #ifndef yydgoto
  64 #define yydgoto    calc3_dgoto
  65 #endif /* yydgoto */
  66
  67 #ifndef yysindex
  68 #define yysindex   calc3_sindex
  69 #endif /* yysindex */
  70
  71 #ifndef yyrindex
  72 #define yyrindex   calc3_rindex
  73 #endif /* yyrindex */
  74
  75 #ifndef yygindex
  76 #define yygindex   calc3_gindex
  77 #endif /* yygindex */
  78
  79 #ifndef yytable
  80 #define yytable    calc3_table
  81 #endif /* yytable */
  82
  83 #ifndef yycheck
  84 #define yycheck    calc3_check
  85 #endif /* yycheck */
  86
  87 #ifndef yyname
  88 #define yyname     calc3_name
  89 #endif /* yyname */
  90
  91 #ifndef yyrule
  92 #define yyrule     calc3_rule
  93 #endif /* yyrule */
  94 #define YYPREFIX "calc3_"
  95
  96 #define YYPURE 1
  97
  98 #line 9 "calc3.y"
  99 # include <stdio.h>
 100 # include <ctype.h>
 101
 102 #ifdef YYBISON
 103 #define YYSTYPE int
 104 #define YYLEX_PARAM base
 105 #define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
 106 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
 107 int YYLEX_DECL();
 108 static void YYERROR_DECL();
 109 #endif
 110
 111 #line 112 "calc3.tab.c"
 112
 113 #ifndef YYSTYPE
 114 typedef int YYSTYPE;
 115 #endif
 116
 117 /* compatibility with bison */
 118 #ifdef YYPARSE_PARAM
 119 /* compatibility with FreeBSD */
 120 # ifdef YYPARSE_PARAM_TYPE
 121 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 122 # else
 123 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 124 # endif
 125 #else
 126 # define YYPARSE_DECL() yyparse(int  regs[26], int * base)
 127 #endif
 128
 129 /* Parameters sent to lex. */
 130 #ifdef YYLEX_PARAM
 131 # ifdef YYLEX_PARAM_TYPE
 132 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
 133 # else
 134 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
 135 # endif
 136 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 137 #else
 138 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
 139 # define YYLEX yylex(&yylval, base)
 140 #endif
 141
 142 /* Parameters sent to yyerror. */
 143 #ifndef YYERROR_DECL
 144 #define YYERROR_DECL() yyerror(int  regs[26], int * base, const char *s)
 145 #endif
 146 #ifndef YYERROR_CALL
 147 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
 148 #endif
 149
 150 extern int YYPARSE_DECL();
 151
 152 #define DIGIT 257
 153 #define LETTER 258
 154 #define UMINUS 259
 155 #define YYERRCODE 256
 156 static const short calc3_lhs[] = {                       -1,
 157     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 158     2,    2,    2,    2,    2,    2,    3,    3,
 159 };
 160 static const short calc3_len[] = {                        2,
 161     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 162     3,    3,    3,    2,    1,    1,    1,    2,
 163 };
 164 static const short calc3_defred[] = {                     1,
 165     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 166     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 167     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 168    10,   11,
 169 };
 170 static const short calc3_dgoto[] = {                      1,
 171     7,    8,    9,
 172 };
 173 static const short calc3_sindex[] = {                     0,
 174   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 175   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 176   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 177     0,    0,
 178 };
 179 static const short calc3_rindex[] = {                     0,
 180     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 181     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 182     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 183     0,    0,
 184 };
 185 static const short calc3_gindex[] = {                     0,
 186     0,   65,    0,
 187 };
 188 #define YYTABLESIZE 220
 189 static const short calc3_table[] = {                      6,
 190    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 191    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 192     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 193     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 194     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 195     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 196     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 197    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 198    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 199     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 200     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 201     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 202     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 203     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 204     0,    0,    0,    0,    0,   16,    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,    0,    0,    0,    0,    0,
 210     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 211     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 212 };
 213 static const short calc3_check[] = {                     40,
 214    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 215    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 216    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 217    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 218    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 219    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 220    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 221     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 222    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 223    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 224    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 225    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 226    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 227    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 228    -1,   -1,   -1,   -1,   -1,  124,   -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,   -1,   -1,   -1,   -1,   -1,
 234    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 235    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 236 };
 237 #define YYFINAL 1
 238 #ifndef YYDEBUG
 239 #define YYDEBUG 0
 240 #endif
 241 #define YYMAXTOKEN 259
 242 #if YYDEBUG
 243 static const char *yyname[] = {
 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",
 253 };
 254 static const char *yyrule[] = {
 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 /* 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 #line 76 "calc3.y"
 305  /* start of programs */
 306
 307 #ifdef YYBYACC
 308 extern int YYLEX_DECL();
 309 #endif
 310
 311 int
 312 main (void)
 313 {
 314     int regs[26];
 315     int base = 10;
 316
 317     while(!feof(stdin)) {
 318         yyparse(regs, &base);
 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') % (*base);
 349         return ( DIGIT );
 350     }
 351     return( c );
 352 }
 353 #line 354 "calc3.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(regs, base, "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 38 "calc3.y"
 568         {  yyerrok ; }
 569 break;
 570 case 4:
 571 #line 42 "calc3.y"
 572         {  printf("%d\n",yystack.l_mark[0]);}
 573 break;
 574 case 5:
 575 #line 44 "calc3.y"
 576         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 577 break;
 578 case 6:
 579 #line 48 "calc3.y"
 580         {  yyval = yystack.l_mark[-1]; }
 581 break;
 582 case 7:
 583 #line 50 "calc3.y"
 584         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 585 break;
 586 case 8:
 587 #line 52 "calc3.y"
 588         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 589 break;
 590 case 9:
 591 #line 54 "calc3.y"
 592         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 593 break;
 594 case 10:
 595 #line 56 "calc3.y"
 596         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 597 break;
 598 case 11:
 599 #line 58 "calc3.y"
 600         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 601 break;
 602 case 12:
 603 #line 60 "calc3.y"
 604         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 605 break;
 606 case 13:
 607 #line 62 "calc3.y"
 608         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 609 break;
 610 case 14:
 611 #line 64 "calc3.y"
 612         {  yyval = - yystack.l_mark[0]; }
 613 break;
 614 case 15:
 615 #line 66 "calc3.y"
 616         {  yyval = regs[yystack.l_mark[0]]; }
 617 break;
 618 case 17:
 619 #line 71 "calc3.y"
 620         {  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
 621 break;
 622 case 18:
 623 #line 73 "calc3.y"
 624         {  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
 625 break;
 626 #line 627 "calc3.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(regs, base, "yacc stack overflow");
 679
 680 yyabort:
 681     yyfreestack(&yystack);
 682     return (1);
 683
 684 yyaccept:
 685     yyfreestack(&yystack);
 686     return (0);
 687 }