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