external/bsd/byacc/dist/test/calc3.tab.c

   1 /*      $NetBSD: calc3.tab.c,v 1.1.1.4 2013/04/06 14:45:29 christos Exp $       */
   2
   3 #ifndef lint
   4 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
   5 #endif
   6
   7 #define YYBYACC 1
   8 #define YYMAJOR 1
   9 #define YYMINOR 9
  10
  11 #define YYEMPTY        (-1)
  12 #define yyclearin      (yychar = YYEMPTY)
  13 #define yyerrok        (yyerrflag = 0)
  14 #define YYRECOVERING() (yyerrflag != 0)
  15
  16
  17 #ifndef yyparse
  18 #define yyparse    calc3_parse
  19 #endif /* yyparse */
  20
  21 #ifndef yylex
  22 #define yylex      calc3_lex
  23 #endif /* yylex */
  24
  25 #ifndef yyerror
  26 #define yyerror    calc3_error
  27 #endif /* yyerror */
  28
  29 #ifndef yychar
  30 #define yychar     calc3_char
  31 #endif /* yychar */
  32
  33 #ifndef yyval
  34 #define yyval      calc3_val
  35 #endif /* yyval */
  36
  37 #ifndef yylval
  38 #define yylval     calc3_lval
  39 #endif /* yylval */
  40
  41 #ifndef yydebug
  42 #define yydebug    calc3_debug
  43 #endif /* yydebug */
  44
  45 #ifndef yynerrs
  46 #define yynerrs    calc3_nerrs
  47 #endif /* yynerrs */
  48
  49 #ifndef yyerrflag
  50 #define yyerrflag  calc3_errflag
  51 #endif /* yyerrflag */
  52
  53 #ifndef yylhs
  54 #define yylhs      calc3_lhs
  55 #endif /* yylhs */
  56
  57 #ifndef yylen
  58 #define yylen      calc3_len
  59 #endif /* yylen */
  60
  61 #ifndef yydefred
  62 #define yydefred   calc3_defred
  63 #endif /* yydefred */
  64
  65 #ifndef yydgoto
  66 #define yydgoto    calc3_dgoto
  67 #endif /* yydgoto */
  68
  69 #ifndef yysindex
  70 #define yysindex   calc3_sindex
  71 #endif /* yysindex */
  72
  73 #ifndef yyrindex
  74 #define yyrindex   calc3_rindex
  75 #endif /* yyrindex */
  76
  77 #ifndef yygindex
  78 #define yygindex   calc3_gindex
  79 #endif /* yygindex */
  80
  81 #ifndef yytable
  82 #define yytable    calc3_table
  83 #endif /* yytable */
  84
  85 #ifndef yycheck
  86 #define yycheck    calc3_check
  87 #endif /* yycheck */
  88
  89 #ifndef yyname
  90 #define yyname     calc3_name
  91 #endif /* yyname */
  92
  93 #ifndef yyrule
  94 #define yyrule     calc3_rule
  95 #endif /* yyrule */
  96 #define YYPREFIX "calc3_"
  97
  98 #define YYPURE 1
  99
 100 #line 9 "calc3.y"
 101 # include <stdio.h>
 102 # include <ctype.h>
 103
 104 #ifdef YYBISON
 105 #define YYSTYPE int
 106 #define YYLEX_PARAM base
 107 #define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
 108 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
 109 int YYLEX_DECL();
 110 static void YYERROR_DECL();
 111 #endif
 112
 113 #line 112 "calc3.tab.c"
 114
 115 #ifndef YYSTYPE
 116 typedef int YYSTYPE;
 117 #endif
 118
 119 /* compatibility with bison */
 120 #ifdef YYPARSE_PARAM
 121 /* compatibility with FreeBSD */
 122 # ifdef YYPARSE_PARAM_TYPE
 123 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 124 # else
 125 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 126 # endif
 127 #else
 128 # define YYPARSE_DECL() yyparse(int  regs[26], int * base)
 129 #endif
 130
 131 /* Parameters sent to lex. */
 132 #ifdef YYLEX_PARAM
 133 # ifdef YYLEX_PARAM_TYPE
 134 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
 135 # else
 136 #  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
 137 # endif
 138 # define YYLEX yylex(&yylval, YYLEX_PARAM)
 139 #else
 140 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
 141 # define YYLEX yylex(&yylval, base)
 142 #endif
 143
 144 /* Parameters sent to yyerror. */
 145 #ifndef YYERROR_DECL
 146 #define YYERROR_DECL() yyerror(int  regs[26], int * base, const char *s)
 147 #endif
 148 #ifndef YYERROR_CALL
 149 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
 150 #endif
 151
 152 extern int YYPARSE_DECL();
 153
 154 #define DIGIT 257
 155 #define LETTER 258
 156 #define UMINUS 259
 157 #define YYERRCODE 256
 158 static const short calc3_lhs[] = {                       -1,
 159     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 160     2,    2,    2,    2,    2,    2,    3,    3,
 161 };
 162 static const short calc3_len[] = {                        2,
 163     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 164     3,    3,    3,    2,    1,    1,    1,    2,
 165 };
 166 static const short calc3_defred[] = {                     1,
 167     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
 168     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
 169     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
 170    10,   11,
 171 };
 172 static const short calc3_dgoto[] = {                      1,
 173     7,    8,    9,
 174 };
 175 static const short calc3_sindex[] = {                     0,
 176   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
 177   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
 178   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
 179     0,    0,
 180 };
 181 static const short calc3_rindex[] = {                     0,
 182     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
 183     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 184     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
 185     0,    0,
 186 };
 187 static const short calc3_gindex[] = {                     0,
 188     0,   65,    0,
 189 };
 190 #define YYTABLESIZE 220
 191 static const short calc3_table[] = {                      6,
 192    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
 193    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
 194     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
 195     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
 196     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
 197     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
 198     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
 199    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
 200    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
 201     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
 202     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
 203     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
 204     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
 205     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
 206     0,    0,    0,    0,    0,   16,    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,    0,    0,    0,    0,    0,
 212     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 213     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
 214 };
 215 static const short calc3_check[] = {                     40,
 216    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
 217    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
 218    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
 219    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
 220    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
 221    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
 222    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
 223     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
 224    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
 225    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
 226    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
 227    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
 228    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
 229    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
 230    -1,   -1,   -1,   -1,   -1,  124,   -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,   -1,   -1,   -1,   -1,   -1,
 236    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 237    -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
 238 };
 239 #define YYFINAL 1
 240 #ifndef YYDEBUG
 241 #define YYDEBUG 0
 242 #endif
 243 #define YYMAXTOKEN 259
 244 #if YYDEBUG
 245 static const char *yyname[] = {
 246
 247 "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,
 248 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,
 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,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,"DIGIT","LETTER","UMINUS",
 255 };
 256 static const char *yyrule[] = {
 257 "$accept : list",
 258 "list :",
 259 "list : list stat '\\n'",
 260 "list : list error '\\n'",
 261 "stat : expr",
 262 "stat : LETTER '=' expr",
 263 "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 '&' expr",
 270 "expr : expr '|' expr",
 271 "expr : '-' expr",
 272 "expr : LETTER",
 273 "expr : number",
 274 "number : DIGIT",
 275 "number : number DIGIT",
 276
 277 };
 278 #endif
 279
 280 int      yydebug;
 281 int      yynerrs;
 282
 283 /* define the initial stack-sizes */
 284 #ifdef YYSTACKSIZE
 285 #undef YYMAXDEPTH
 286 #define YYMAXDEPTH  YYSTACKSIZE
 287 #else
 288 #ifdef YYMAXDEPTH
 289 #define YYSTACKSIZE YYMAXDEPTH
 290 #else
 291 #define YYSTACKSIZE 500
 292 #define YYMAXDEPTH  500
 293 #endif
 294 #endif
 295
 296 #define YYINITSTACKSIZE 500
 297
 298 typedef struct {
 299     unsigned stacksize;
 300     short    *s_base;
 301     short    *s_mark;
 302     short    *s_last;
 303     YYSTYPE  *l_base;
 304     YYSTYPE  *l_mark;
 305 } YYSTACKDATA;
 306 #line 76 "calc3.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 354 "calc3.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      yyerrflag;
 419     int      yychar;
 420     YYSTYPE  yyval;
 421     YYSTYPE  yylval;
 422
 423     /* variables for the parser stack */
 424     YYSTACKDATA yystack;
 425     int yym, yyn, yystate;
 426 #if YYDEBUG
 427     const char *yys;
 428
 429     if ((yys = getenv("YYDEBUG")) != 0)
 430     {
 431         yyn = *yys;
 432         if (yyn >= '0' && yyn <= '9')
 433             yydebug = yyn - '0';
 434     }
 435 #endif
 436
 437     yynerrs = 0;
 438     yyerrflag = 0;
 439     yychar = YYEMPTY;
 440     yystate = 0;
 441
 442 #if YYPURE
 443     memset(&yystack, 0, sizeof(yystack));
 444 #endif
 445
 446     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 447     yystack.s_mark = yystack.s_base;
 448     yystack.l_mark = yystack.l_base;
 449     yystate = 0;
 450     *yystack.s_mark = 0;
 451
 452 yyloop:
 453     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 454     if (yychar < 0)
 455     {
 456         if ((yychar = YYLEX) < 0) yychar = 0;
 457 #if YYDEBUG
 458         if (yydebug)
 459         {
 460             yys = 0;
 461             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 462             if (!yys) yys = "illegal-symbol";
 463             printf("%sdebug: state %d, reading %d (%s)\n",
 464                     YYPREFIX, yystate, yychar, yys);
 465         }
 466 #endif
 467     }
 468     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 469             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 470     {
 471 #if YYDEBUG
 472         if (yydebug)
 473             printf("%sdebug: state %d, shifting to state %d\n",
 474                     YYPREFIX, yystate, yytable[yyn]);
 475 #endif
 476         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 477         {
 478             goto yyoverflow;
 479         }
 480         yystate = yytable[yyn];
 481         *++yystack.s_mark = yytable[yyn];
 482         *++yystack.l_mark = yylval;
 483         yychar = YYEMPTY;
 484         if (yyerrflag > 0)  --yyerrflag;
 485         goto yyloop;
 486     }
 487     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 488             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 489     {
 490         yyn = yytable[yyn];
 491         goto yyreduce;
 492     }
 493     if (yyerrflag) goto yyinrecovery;
 494
 495     yyerror(regs, base, "syntax error");
 496
 497     goto yyerrlab;
 498
 499 yyerrlab:
 500     ++yynerrs;
 501
 502 yyinrecovery:
 503     if (yyerrflag < 3)
 504     {
 505         yyerrflag = 3;
 506         for (;;)
 507         {
 508             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 509                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 510             {
 511 #if YYDEBUG
 512                 if (yydebug)
 513                     printf("%sdebug: state %d, error recovery shifting\
 514  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 515 #endif
 516                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 517                 {
 518                     goto yyoverflow;
 519                 }
 520                 yystate = yytable[yyn];
 521                 *++yystack.s_mark = yytable[yyn];
 522                 *++yystack.l_mark = yylval;
 523                 goto yyloop;
 524             }
 525             else
 526             {
 527 #if YYDEBUG
 528                 if (yydebug)
 529                     printf("%sdebug: error recovery discarding state %d\n",
 530                             YYPREFIX, *yystack.s_mark);
 531 #endif
 532                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 533                 --yystack.s_mark;
 534                 --yystack.l_mark;
 535             }
 536         }
 537     }
 538     else
 539     {
 540         if (yychar == 0) goto yyabort;
 541 #if YYDEBUG
 542         if (yydebug)
 543         {
 544             yys = 0;
 545             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 546             if (!yys) yys = "illegal-symbol";
 547             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 548                     YYPREFIX, yystate, yychar, yys);
 549         }
 550 #endif
 551         yychar = YYEMPTY;
 552         goto yyloop;
 553     }
 554
 555 yyreduce:
 556 #if YYDEBUG
 557     if (yydebug)
 558         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 559                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 560 #endif
 561     yym = yylen[yyn];
 562     if (yym)
 563         yyval = yystack.l_mark[1-yym];
 564     else
 565         memset(&yyval, 0, sizeof yyval);
 566     switch (yyn)
 567     {
 568 case 3:
 569 #line 38 "calc3.y"
 570         {  yyerrok ; }
 571 break;
 572 case 4:
 573 #line 42 "calc3.y"
 574         {  printf("%d\n",yystack.l_mark[0]);}
 575 break;
 576 case 5:
 577 #line 44 "calc3.y"
 578         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 579 break;
 580 case 6:
 581 #line 48 "calc3.y"
 582         {  yyval = yystack.l_mark[-1]; }
 583 break;
 584 case 7:
 585 #line 50 "calc3.y"
 586         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 587 break;
 588 case 8:
 589 #line 52 "calc3.y"
 590         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 591 break;
 592 case 9:
 593 #line 54 "calc3.y"
 594         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 595 break;
 596 case 10:
 597 #line 56 "calc3.y"
 598         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 599 break;
 600 case 11:
 601 #line 58 "calc3.y"
 602         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 603 break;
 604 case 12:
 605 #line 60 "calc3.y"
 606         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 607 break;
 608 case 13:
 609 #line 62 "calc3.y"
 610         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 611 break;
 612 case 14:
 613 #line 64 "calc3.y"
 614         {  yyval = - yystack.l_mark[0]; }
 615 break;
 616 case 15:
 617 #line 66 "calc3.y"
 618         {  yyval = regs[yystack.l_mark[0]]; }
 619 break;
 620 case 17:
 621 #line 71 "calc3.y"
 622         {  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
 623 break;
 624 case 18:
 625 #line 73 "calc3.y"
 626         {  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
 627 break;
 628 #line 627 "calc3.tab.c"
 629     }
 630     yystack.s_mark -= yym;
 631     yystate = *yystack.s_mark;
 632     yystack.l_mark -= yym;
 633     yym = yylhs[yyn];
 634     if (yystate == 0 && yym == 0)
 635     {
 636 #if YYDEBUG
 637         if (yydebug)
 638             printf("%sdebug: after reduction, shifting from state 0 to\
 639  state %d\n", YYPREFIX, YYFINAL);
 640 #endif
 641         yystate = YYFINAL;
 642         *++yystack.s_mark = YYFINAL;
 643         *++yystack.l_mark = yyval;
 644         if (yychar < 0)
 645         {
 646             if ((yychar = YYLEX) < 0) yychar = 0;
 647 #if YYDEBUG
 648             if (yydebug)
 649             {
 650                 yys = 0;
 651                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 652                 if (!yys) yys = "illegal-symbol";
 653                 printf("%sdebug: state %d, reading %d (%s)\n",
 654                         YYPREFIX, YYFINAL, yychar, yys);
 655             }
 656 #endif
 657         }
 658         if (yychar == 0) goto yyaccept;
 659         goto yyloop;
 660     }
 661     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 662             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 663         yystate = yytable[yyn];
 664     else
 665         yystate = yydgoto[yym];
 666 #if YYDEBUG
 667     if (yydebug)
 668         printf("%sdebug: after reduction, shifting from state %d \
 669 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 670 #endif
 671     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 672     {
 673         goto yyoverflow;
 674     }
 675     *++yystack.s_mark = (short) yystate;
 676     *++yystack.l_mark = yyval;
 677     goto yyloop;
 678
 679 yyoverflow:
 680     yyerror(regs, base, "yacc stack overflow");
 681
 682 yyabort:
 683     yyfreestack(&yystack);
 684     return (1);
 685
 686 yyaccept:
 687     yyfreestack(&yystack);
 688     return (0);
 689 }