contrib/byacc/test/yacc/calc2.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    calc2_parse
  19 #endif /* yyparse */
  20
  21 #ifndef yylex
  22 #define yylex      calc2_lex
  23 #endif /* yylex */
  24
  25 #ifndef yyerror
  26 #define yyerror    calc2_error
  27 #endif /* yyerror */
  28
  29 #ifndef yychar
  30 #define yychar     calc2_char
  31 #endif /* yychar */
  32
  33 #ifndef yyval
  34 #define yyval      calc2_val
  35 #endif /* yyval */
  36
  37 #ifndef yylval
  38 #define yylval     calc2_lval
  39 #endif /* yylval */
  40
  41 #ifndef yydebug
  42 #define yydebug    calc2_debug
  43 #endif /* yydebug */
  44
  45 #ifndef yynerrs
  46 #define yynerrs    calc2_nerrs
  47 #endif /* yynerrs */
  48
  49 #ifndef yyerrflag
  50 #define yyerrflag  calc2_errflag
  51 #endif /* yyerrflag */
  52
  53 #ifndef yylhs
  54 #define yylhs      calc2_lhs
  55 #endif /* yylhs */
  56
  57 #ifndef yylen
  58 #define yylen      calc2_len
  59 #endif /* yylen */
  60
  61 #ifndef yydefred
  62 #define yydefred   calc2_defred
  63 #endif /* yydefred */
  64
  65 #ifndef yydgoto
  66 #define yydgoto    calc2_dgoto
  67 #endif /* yydgoto */
  68
  69 #ifndef yysindex
  70 #define yysindex   calc2_sindex
  71 #endif /* yysindex */
  72
  73 #ifndef yyrindex
  74 #define yyrindex   calc2_rindex
  75 #endif /* yyrindex */
  76
  77 #ifndef yygindex
  78 #define yygindex   calc2_gindex
  79 #endif /* yygindex */
  80
  81 #ifndef yytable
  82 #define yytable    calc2_table
  83 #endif /* yytable */
  84
  85 #ifndef yycheck
  86 #define yycheck    calc2_check
  87 #endif /* yycheck */
  88
  89 #ifndef yyname
  90 #define yyname     calc2_name
  91 #endif /* yyname */
  92
  93 #ifndef yyrule
  94 #define yyrule     calc2_rule
  95 #endif /* yyrule */
  96 #define YYPREFIX "calc2_"
  97
  98 #define YYPURE 0
  99
 100 #line 7 "calc2.y"
 101 # include <stdio.h>
 102 # include <ctype.h>
 103
 104 #ifdef YYBISON
 105 #define YYLEX_PARAM base
 106 #define YYLEX_DECL() yylex(int *YYLEX_PARAM)
 107 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
 108 int YYLEX_DECL();
 109 static void YYERROR_DECL();
 110 #endif
 111
 112 #line 113 "calc2.tab.c"
 113
 114 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
 115 /* Default: YYSTYPE is the semantic value type. */
 116 typedef int YYSTYPE;
 117 # define YYSTYPE_IS_DECLARED 1
 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(int regs[26], int *base)
 130 #endif
 131
 132 /* Parameters sent to lex. */
 133 #ifdef YYLEX_PARAM
 134 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 135 # define YYLEX yylex(YYLEX_PARAM)
 136 #else
 137 # define YYLEX_DECL() yylex(int *base)
 138 # define YYLEX yylex(base)
 139 #endif
 140
 141 /* Parameters sent to yyerror. */
 142 #ifndef YYERROR_DECL
 143 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
 144 #endif
 145 #ifndef YYERROR_CALL
 146 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
 147 #endif
 148
 149 extern int YYPARSE_DECL();
 150
 151 #define DIGIT 257
 152 #define LETTER 258
 153 #define UMINUS 259
 154 #define YYERRCODE 256
 155 typedef int YYINT;
 156 static const YYINT calc2_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 YYINT calc2_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 YYINT calc2_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 YYINT calc2_dgoto[] = {                      1,
 171     7,    8,    9,
 172 };
 173 static const YYINT calc2_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 YYINT calc2_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 YYINT calc2_gindex[] = {                     0,
 186     0,   65,    0,
 187 };
 188 #define YYTABLESIZE 220
 189 static const YYINT calc2_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 YYINT calc2_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 #define YYUNDFTOKEN 265
 243 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 244 #if YYDEBUG
 245 static const char *const calc2_name[] = {
 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",0,0,0,0,0,"illegal-symbol",
 255 };
 256 static const char *const calc2_rule[] = {
 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 int      yyerrflag;
 284 int      yychar;
 285 YYSTYPE  yyval;
 286 YYSTYPE  yylval;
 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 73 "calc2.y"
 314  /* start of programs */
 315
 316 #ifdef YYBYACC
 317 extern int YYLEX_DECL();
 318 #endif
 319
 320 int
 321 main (void)
 322 {
 323     int regs[26];
 324     int base = 10;
 325
 326     while(!feof(stdin)) {
 327         yyparse(regs, &base);
 328     }
 329     return 0;
 330 }
 331
 332 #define UNUSED(x) ((void)(x))
 333
 334 static void
 335 YYERROR_DECL()
 336 {
 337     UNUSED(regs); /* %parse-param regs is not actually used here */
 338     UNUSED(base); /* %parse-param base is not actually used here */
 339     fprintf(stderr, "%s\n", s);
 340 }
 341
 342 int
 343 YYLEX_DECL()
 344 {
 345         /* lexical analysis routine */
 346         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 347         /* return DIGIT for a digit, yylval = 0 through 9 */
 348         /* all other characters are returned immediately */
 349
 350     int c;
 351
 352     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 353
 354     /* c is now nonblank */
 355
 356     if( islower( c )) {
 357         yylval = c - 'a';
 358         return ( LETTER );
 359     }
 360     if( isdigit( c )) {
 361         yylval = (c - '0') % (*base);
 362         return ( DIGIT );
 363     }
 364     return( c );
 365 }
 366 #line 367 "calc2.tab.c"
 367
 368 #if YYDEBUG
 369 #include <stdio.h>              /* needed for printf */
 370 #endif
 371
 372 #include <stdlib.h>     /* needed for malloc, etc */
 373 #include <string.h>     /* needed for memset */
 374
 375 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 376 static int yygrowstack(YYSTACKDATA *data)
 377 {
 378     int i;
 379     unsigned newsize;
 380     YYINT *newss;
 381     YYSTYPE *newvs;
 382
 383     if ((newsize = data->stacksize) == 0)
 384         newsize = YYINITSTACKSIZE;
 385     else if (newsize >= YYMAXDEPTH)
 386         return YYENOMEM;
 387     else if ((newsize *= 2) > YYMAXDEPTH)
 388         newsize = YYMAXDEPTH;
 389
 390     i = (int) (data->s_mark - data->s_base);
 391     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
 392     if (newss == 0)
 393         return YYENOMEM;
 394
 395     data->s_base = newss;
 396     data->s_mark = newss + i;
 397
 398     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 399     if (newvs == 0)
 400         return YYENOMEM;
 401
 402     data->l_base = newvs;
 403     data->l_mark = newvs + i;
 404
 405     data->stacksize = newsize;
 406     data->s_last = data->s_base + newsize - 1;
 407     return 0;
 408 }
 409
 410 #if YYPURE || defined(YY_NO_LEAKS)
 411 static void yyfreestack(YYSTACKDATA *data)
 412 {
 413     free(data->s_base);
 414     free(data->l_base);
 415     memset(data, 0, sizeof(*data));
 416 }
 417 #else
 418 #define yyfreestack(data) /* nothing */
 419 #endif
 420
 421 #define YYABORT  goto yyabort
 422 #define YYREJECT goto yyabort
 423 #define YYACCEPT goto yyaccept
 424 #define YYERROR  goto yyerrlab
 425
 426 int
 427 YYPARSE_DECL()
 428 {
 429     int yym, yyn, yystate;
 430 #if YYDEBUG
 431     const char *yys;
 432
 433     if ((yys = getenv("YYDEBUG")) != 0)
 434     {
 435         yyn = *yys;
 436         if (yyn >= '0' && yyn <= '9')
 437             yydebug = yyn - '0';
 438     }
 439 #endif
 440
 441     yynerrs = 0;
 442     yyerrflag = 0;
 443     yychar = YYEMPTY;
 444     yystate = 0;
 445
 446 #if YYPURE
 447     memset(&yystack, 0, sizeof(yystack));
 448 #endif
 449
 450     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 451     yystack.s_mark = yystack.s_base;
 452     yystack.l_mark = yystack.l_base;
 453     yystate = 0;
 454     *yystack.s_mark = 0;
 455
 456 yyloop:
 457     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 458     if (yychar < 0)
 459     {
 460         if ((yychar = YYLEX) < 0) yychar = YYEOF;
 461 #if YYDEBUG
 462         if (yydebug)
 463         {
 464             yys = yyname[YYTRANSLATE(yychar)];
 465             printf("%sdebug: state %d, reading %d (%s)\n",
 466                     YYPREFIX, yystate, yychar, yys);
 467         }
 468 #endif
 469     }
 470     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 471             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 472     {
 473 #if YYDEBUG
 474         if (yydebug)
 475             printf("%sdebug: state %d, shifting to state %d\n",
 476                     YYPREFIX, yystate, yytable[yyn]);
 477 #endif
 478         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 479         {
 480             goto yyoverflow;
 481         }
 482         yystate = yytable[yyn];
 483         *++yystack.s_mark = yytable[yyn];
 484         *++yystack.l_mark = yylval;
 485         yychar = YYEMPTY;
 486         if (yyerrflag > 0)  --yyerrflag;
 487         goto yyloop;
 488     }
 489     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 490             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 491     {
 492         yyn = yytable[yyn];
 493         goto yyreduce;
 494     }
 495     if (yyerrflag) goto yyinrecovery;
 496
 497     YYERROR_CALL("syntax error");
 498
 499     goto yyerrlab;
 500
 501 yyerrlab:
 502     ++yynerrs;
 503
 504 yyinrecovery:
 505     if (yyerrflag < 3)
 506     {
 507         yyerrflag = 3;
 508         for (;;)
 509         {
 510             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 511                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 512             {
 513 #if YYDEBUG
 514                 if (yydebug)
 515                     printf("%sdebug: state %d, error recovery shifting\
 516  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 517 #endif
 518                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 519                 {
 520                     goto yyoverflow;
 521                 }
 522                 yystate = yytable[yyn];
 523                 *++yystack.s_mark = yytable[yyn];
 524                 *++yystack.l_mark = yylval;
 525                 goto yyloop;
 526             }
 527             else
 528             {
 529 #if YYDEBUG
 530                 if (yydebug)
 531                     printf("%sdebug: error recovery discarding state %d\n",
 532                             YYPREFIX, *yystack.s_mark);
 533 #endif
 534                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 535                 --yystack.s_mark;
 536                 --yystack.l_mark;
 537             }
 538         }
 539     }
 540     else
 541     {
 542         if (yychar == YYEOF) goto yyabort;
 543 #if YYDEBUG
 544         if (yydebug)
 545         {
 546             yys = yyname[YYTRANSLATE(yychar)];
 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 35 "calc2.y"
 570         {  yyerrok ; }
 571 break;
 572 case 4:
 573 #line 39 "calc2.y"
 574         {  printf("%d\n",yystack.l_mark[0]);}
 575 break;
 576 case 5:
 577 #line 41 "calc2.y"
 578         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 579 break;
 580 case 6:
 581 #line 45 "calc2.y"
 582         {  yyval = yystack.l_mark[-1]; }
 583 break;
 584 case 7:
 585 #line 47 "calc2.y"
 586         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 587 break;
 588 case 8:
 589 #line 49 "calc2.y"
 590         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 591 break;
 592 case 9:
 593 #line 51 "calc2.y"
 594         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 595 break;
 596 case 10:
 597 #line 53 "calc2.y"
 598         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 599 break;
 600 case 11:
 601 #line 55 "calc2.y"
 602         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 603 break;
 604 case 12:
 605 #line 57 "calc2.y"
 606         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 607 break;
 608 case 13:
 609 #line 59 "calc2.y"
 610         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 611 break;
 612 case 14:
 613 #line 61 "calc2.y"
 614         {  yyval = - yystack.l_mark[0]; }
 615 break;
 616 case 15:
 617 #line 63 "calc2.y"
 618         {  yyval = regs[yystack.l_mark[0]]; }
 619 break;
 620 case 17:
 621 #line 68 "calc2.y"
 622         {  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
 623 break;
 624 case 18:
 625 #line 70 "calc2.y"
 626         {  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
 627 break;
 628 #line 629 "calc2.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 = YYEOF;
 647 #if YYDEBUG
 648             if (yydebug)
 649             {
 650                 yys = yyname[YYTRANSLATE(yychar)];
 651                 printf("%sdebug: state %d, reading %d (%s)\n",
 652                         YYPREFIX, YYFINAL, yychar, yys);
 653             }
 654 #endif
 655         }
 656         if (yychar == YYEOF) 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) == YYENOMEM)
 670     {
 671         goto yyoverflow;
 672     }
 673     *++yystack.s_mark = (YYINT) yystate;
 674     *++yystack.l_mark = yyval;
 675     goto yyloop;
 676
 677 yyoverflow:
 678     YYERROR_CALL("yacc stack overflow");
 679
 680 yyabort:
 681     yyfreestack(&yystack);
 682     return (1);
 683
 684 yyaccept:
 685     yyfreestack(&yystack);
 686     return (0);
 687 }