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 2
   7 #define YYMINOR 0
   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 #if YYDEBUG
 279 int      yydebug;
 280 #endif
 281
 282 int      yyerrflag;
 283 int      yychar;
 284 YYSTYPE  yyval;
 285 YYSTYPE  yylval;
 286 int      yynerrs;
 287
 288 /* define the initial stack-sizes */
 289 #ifdef YYSTACKSIZE
 290 #undef YYMAXDEPTH
 291 #define YYMAXDEPTH  YYSTACKSIZE
 292 #else
 293 #ifdef YYMAXDEPTH
 294 #define YYSTACKSIZE YYMAXDEPTH
 295 #else
 296 #define YYSTACKSIZE 10000
 297 #define YYMAXDEPTH  10000
 298 #endif
 299 #endif
 300
 301 #define YYINITSTACKSIZE 200
 302
 303 typedef struct {
 304     unsigned stacksize;
 305     YYINT    *s_base;
 306     YYINT    *s_mark;
 307     YYINT    *s_last;
 308     YYSTYPE  *l_base;
 309     YYSTYPE  *l_mark;
 310 } YYSTACKDATA;
 311 /* variables for the parser stack */
 312 static YYSTACKDATA yystack;
 313 #line 66 "calc.y"
 314  /* start of programs */
 315
 316 int
 317 main (void)
 318 {
 319     while(!feof(stdin)) {
 320         yyparse();
 321     }
 322     return 0;
 323 }
 324
 325 static void
 326 yyerror(const char *s)
 327 {
 328     fprintf(stderr, "%s\n", s);
 329 }
 330
 331 int
 332 yylex(void)
 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';
 351         return ( DIGIT );
 352     }
 353     return( c );
 354 }
 355 #line 356 "calc.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     YYINT *newss;
 370     YYSTYPE *newvs;
 371
 372     if ((newsize = data->stacksize) == 0)
 373         newsize = YYINITSTACKSIZE;
 374     else if (newsize >= YYMAXDEPTH)
 375         return YYENOMEM;
 376     else if ((newsize *= 2) > YYMAXDEPTH)
 377         newsize = YYMAXDEPTH;
 378
 379     i = (int) (data->s_mark - data->s_base);
 380     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
 381     if (newss == 0)
 382         return YYENOMEM;
 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 YYENOMEM;
 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     /* yym is set below */
 431     /* yyn is set below */
 432     yynerrs = 0;
 433     yyerrflag = 0;
 434     yychar = YYEMPTY;
 435     /* yystate is set below */
 436
 437 #if YYPURE
 438     memset(&yystack, 0, sizeof(yystack));
 439 #endif
 440
 441     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 442     yystack.s_mark = yystack.s_base;
 443     yystack.l_mark = yystack.l_base;
 444     yystate = 0;
 445     *yystack.s_mark = 0;
 446
 447 yyloop:
 448     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 449     if (yychar < 0)
 450     {
 451         yychar = YYLEX;
 452         if (yychar < 0) yychar = YYEOF;
 453 #if YYDEBUG
 454         if (yydebug)
 455         {
 456             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 457             printf("%sdebug: state %d, reading %d (%s)\n",
 458                     YYPREFIX, yystate, yychar, yys);
 459         }
 460 #endif
 461     }
 462     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 463             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 464     {
 465 #if YYDEBUG
 466         if (yydebug)
 467             printf("%sdebug: state %d, shifting to state %d\n",
 468                     YYPREFIX, yystate, yytable[yyn]);
 469 #endif
 470         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 471         yystate = yytable[yyn];
 472         *++yystack.s_mark = yytable[yyn];
 473         *++yystack.l_mark = yylval;
 474         yychar = YYEMPTY;
 475         if (yyerrflag > 0)  --yyerrflag;
 476         goto yyloop;
 477     }
 478     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 479             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 480     {
 481         yyn = yytable[yyn];
 482         goto yyreduce;
 483     }
 484     if (yyerrflag != 0) goto yyinrecovery;
 485
 486     YYERROR_CALL("syntax error");
 487
 488     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
 489 yyerrlab:
 490     ++yynerrs;
 491
 492 yyinrecovery:
 493     if (yyerrflag < 3)
 494     {
 495         yyerrflag = 3;
 496         for (;;)
 497         {
 498             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
 499                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
 500             {
 501 #if YYDEBUG
 502                 if (yydebug)
 503                     printf("%sdebug: state %d, error recovery shifting\
 504  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 505 #endif
 506                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 507                 yystate = yytable[yyn];
 508                 *++yystack.s_mark = yytable[yyn];
 509                 *++yystack.l_mark = yylval;
 510                 goto yyloop;
 511             }
 512             else
 513             {
 514 #if YYDEBUG
 515                 if (yydebug)
 516                     printf("%sdebug: error recovery discarding state %d\n",
 517                             YYPREFIX, *yystack.s_mark);
 518 #endif
 519                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 520                 --yystack.s_mark;
 521                 --yystack.l_mark;
 522             }
 523         }
 524     }
 525     else
 526     {
 527         if (yychar == YYEOF) goto yyabort;
 528 #if YYDEBUG
 529         if (yydebug)
 530         {
 531             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 532             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 533                     YYPREFIX, yystate, yychar, yys);
 534         }
 535 #endif
 536         yychar = YYEMPTY;
 537         goto yyloop;
 538     }
 539
 540 yyreduce:
 541 #if YYDEBUG
 542     if (yydebug)
 543         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 544                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 545 #endif
 546     yym = yylen[yyn];
 547     if (yym > 0)
 548         yyval = yystack.l_mark[1-yym];
 549     else
 550         memset(&yyval, 0, sizeof yyval);
 551
 552     switch (yyn)
 553     {
 554 case 3:
 555 #line 28 "calc.y"
 556         {  yyerrok ; }
 557 break;
 558 case 4:
 559 #line 32 "calc.y"
 560         {  printf("%d\n",yystack.l_mark[0]);}
 561 break;
 562 case 5:
 563 #line 34 "calc.y"
 564         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 565 break;
 566 case 6:
 567 #line 38 "calc.y"
 568         {  yyval = yystack.l_mark[-1]; }
 569 break;
 570 case 7:
 571 #line 40 "calc.y"
 572         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 573 break;
 574 case 8:
 575 #line 42 "calc.y"
 576         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 577 break;
 578 case 9:
 579 #line 44 "calc.y"
 580         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 581 break;
 582 case 10:
 583 #line 46 "calc.y"
 584         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 585 break;
 586 case 11:
 587 #line 48 "calc.y"
 588         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 589 break;
 590 case 12:
 591 #line 50 "calc.y"
 592         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 593 break;
 594 case 13:
 595 #line 52 "calc.y"
 596         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 597 break;
 598 case 14:
 599 #line 54 "calc.y"
 600         {  yyval = - yystack.l_mark[0]; }
 601 break;
 602 case 15:
 603 #line 56 "calc.y"
 604         {  yyval = regs[yystack.l_mark[0]]; }
 605 break;
 606 case 17:
 607 #line 61 "calc.y"
 608         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 609 break;
 610 case 18:
 611 #line 63 "calc.y"
 612         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 613 break;
 614 #line 615 "calc.tab.c"
 615     }
 616     yystack.s_mark -= yym;
 617     yystate = *yystack.s_mark;
 618     yystack.l_mark -= yym;
 619     yym = yylhs[yyn];
 620     if (yystate == 0 && yym == 0)
 621     {
 622 #if YYDEBUG
 623         if (yydebug)
 624             printf("%sdebug: after reduction, shifting from state 0 to\
 625  state %d\n", YYPREFIX, YYFINAL);
 626 #endif
 627         yystate = YYFINAL;
 628         *++yystack.s_mark = YYFINAL;
 629         *++yystack.l_mark = yyval;
 630         if (yychar < 0)
 631         {
 632             yychar = YYLEX;
 633             if (yychar < 0) yychar = YYEOF;
 634 #if YYDEBUG
 635             if (yydebug)
 636             {
 637                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 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]) != 0) && (yyn += yystate) >= 0 &&
 647             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) 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) goto yyoverflow;
 657     *++yystack.s_mark = (YYINT) yystate;
 658     *++yystack.l_mark = yyval;
 659     goto yyloop;
 660
 661 yyoverflow:
 662     YYERROR_CALL("yacc stack overflow");
 663
 664 yyabort:
 665     yyfreestack(&yystack);
 666     return (1);
 667
 668 yyaccept:
 669     yyfreestack(&yystack);
 670     return (0);
 671 }