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 #if YYDEBUG
 289 int      yydebug;
 290 #endif
 291
 292 /* define the initial stack-sizes */
 293 #ifdef YYSTACKSIZE
 294 #undef YYMAXDEPTH
 295 #define YYMAXDEPTH  YYSTACKSIZE
 296 #else
 297 #ifdef YYMAXDEPTH
 298 #define YYSTACKSIZE YYMAXDEPTH
 299 #else
 300 #define YYSTACKSIZE 10000
 301 #define YYMAXDEPTH  10000
 302 #endif
 303 #endif
 304
 305 #define YYINITSTACKSIZE 200
 306
 307 typedef struct {
 308     unsigned stacksize;
 309     YYINT    *s_base;
 310     YYINT    *s_mark;
 311     YYINT    *s_last;
 312     YYSTYPE  *l_base;
 313     YYSTYPE  *l_mark;
 314 } YYSTACKDATA;
 315 #line 72 "pure_calc.y"
 316  /* start of programs */
 317
 318 #ifdef YYBYACC
 319 static int YYLEX_DECL();
 320 #endif
 321
 322 int
 323 main (void)
 324 {
 325     while(!feof(stdin)) {
 326         yyparse();
 327     }
 328     return 0;
 329 }
 330
 331 static void
 332 YYERROR_DECL()
 333 {
 334     fprintf(stderr, "%s\n", s);
 335 }
 336
 337 int
 338 YYLEX_DECL()
 339 {
 340         /* lexical analysis routine */
 341         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 342         /* return DIGIT for a digit, yylval = 0 through 9 */
 343         /* all other characters are returned immediately */
 344
 345     int c;
 346
 347     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 348
 349     /* c is now nonblank */
 350
 351     if( islower( c )) {
 352         *yylval = c - 'a';
 353         return ( LETTER );
 354     }
 355     if( isdigit( c )) {
 356         *yylval = c - '0';
 357         return ( DIGIT );
 358     }
 359     return( c );
 360 }
 361 #line 362 "pure_calc.tab.c"
 362
 363 #if YYDEBUG
 364 #include <stdio.h>      /* needed for printf */
 365 #endif
 366
 367 #include <stdlib.h>     /* needed for malloc, etc */
 368 #include <string.h>     /* needed for memset */
 369
 370 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 371 static int yygrowstack(YYSTACKDATA *data)
 372 {
 373     int i;
 374     unsigned newsize;
 375     YYINT *newss;
 376     YYSTYPE *newvs;
 377
 378     if ((newsize = data->stacksize) == 0)
 379         newsize = YYINITSTACKSIZE;
 380     else if (newsize >= YYMAXDEPTH)
 381         return YYENOMEM;
 382     else if ((newsize *= 2) > YYMAXDEPTH)
 383         newsize = YYMAXDEPTH;
 384
 385     i = (int) (data->s_mark - data->s_base);
 386     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
 387     if (newss == 0)
 388         return YYENOMEM;
 389
 390     data->s_base = newss;
 391     data->s_mark = newss + i;
 392
 393     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 394     if (newvs == 0)
 395         return YYENOMEM;
 396
 397     data->l_base = newvs;
 398     data->l_mark = newvs + i;
 399
 400     data->stacksize = newsize;
 401     data->s_last = data->s_base + newsize - 1;
 402     return 0;
 403 }
 404
 405 #if YYPURE || defined(YY_NO_LEAKS)
 406 static void yyfreestack(YYSTACKDATA *data)
 407 {
 408     free(data->s_base);
 409     free(data->l_base);
 410     memset(data, 0, sizeof(*data));
 411 }
 412 #else
 413 #define yyfreestack(data) /* nothing */
 414 #endif
 415
 416 #define YYABORT  goto yyabort
 417 #define YYREJECT goto yyabort
 418 #define YYACCEPT goto yyaccept
 419 #define YYERROR  goto yyerrlab
 420
 421 int
 422 YYPARSE_DECL()
 423 {
 424     int      yyerrflag;
 425     int      yychar;
 426     YYSTYPE  yyval;
 427     YYSTYPE  yylval;
 428     int      yynerrs;
 429
 430     /* variables for the parser stack */
 431     YYSTACKDATA yystack;
 432     int yym, yyn, yystate;
 433 #if YYDEBUG
 434     const char *yys;
 435
 436     if ((yys = getenv("YYDEBUG")) != 0)
 437     {
 438         yyn = *yys;
 439         if (yyn >= '0' && yyn <= '9')
 440             yydebug = yyn - '0';
 441     }
 442 #endif
 443
 444     memset(&yyval,  0, sizeof(yyval));
 445     memset(&yylval, 0, sizeof(yylval));
 446
 447     yym = 0;
 448     yyn = 0;
 449     yynerrs = 0;
 450     yyerrflag = 0;
 451     yychar = YYEMPTY;
 452     yystate = 0;
 453
 454 #if YYPURE
 455     memset(&yystack, 0, sizeof(yystack));
 456 #endif
 457
 458     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 459     yystack.s_mark = yystack.s_base;
 460     yystack.l_mark = yystack.l_base;
 461     yystate = 0;
 462     *yystack.s_mark = 0;
 463
 464 yyloop:
 465     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 466     if (yychar < 0)
 467     {
 468         yychar = YYLEX;
 469         if (yychar < 0) yychar = YYEOF;
 470 #if YYDEBUG
 471         if (yydebug)
 472         {
 473             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 474             printf("%sdebug: state %d, reading %d (%s)\n",
 475                     YYPREFIX, yystate, yychar, yys);
 476         }
 477 #endif
 478     }
 479     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 480             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 481     {
 482 #if YYDEBUG
 483         if (yydebug)
 484             printf("%sdebug: state %d, shifting to state %d\n",
 485                     YYPREFIX, yystate, yytable[yyn]);
 486 #endif
 487         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 488         yystate = yytable[yyn];
 489         *++yystack.s_mark = yytable[yyn];
 490         *++yystack.l_mark = yylval;
 491         yychar = YYEMPTY;
 492         if (yyerrflag > 0)  --yyerrflag;
 493         goto yyloop;
 494     }
 495     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
 496             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
 497     {
 498         yyn = yytable[yyn];
 499         goto yyreduce;
 500     }
 501     if (yyerrflag != 0) goto yyinrecovery;
 502
 503     YYERROR_CALL("syntax error");
 504
 505     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
 506 yyerrlab:
 507     ++yynerrs;
 508
 509 yyinrecovery:
 510     if (yyerrflag < 3)
 511     {
 512         yyerrflag = 3;
 513         for (;;)
 514         {
 515             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
 516                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
 517             {
 518 #if YYDEBUG
 519                 if (yydebug)
 520                     printf("%sdebug: state %d, error recovery shifting\
 521  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 522 #endif
 523                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 524                 yystate = yytable[yyn];
 525                 *++yystack.s_mark = yytable[yyn];
 526                 *++yystack.l_mark = yylval;
 527                 goto yyloop;
 528             }
 529             else
 530             {
 531 #if YYDEBUG
 532                 if (yydebug)
 533                     printf("%sdebug: error recovery discarding state %d\n",
 534                             YYPREFIX, *yystack.s_mark);
 535 #endif
 536                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 537                 --yystack.s_mark;
 538                 --yystack.l_mark;
 539             }
 540         }
 541     }
 542     else
 543     {
 544         if (yychar == YYEOF) goto yyabort;
 545 #if YYDEBUG
 546         if (yydebug)
 547         {
 548             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 549             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 550                     YYPREFIX, yystate, yychar, yys);
 551         }
 552 #endif
 553         yychar = YYEMPTY;
 554         goto yyloop;
 555     }
 556
 557 yyreduce:
 558 #if YYDEBUG
 559     if (yydebug)
 560         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 561                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 562 #endif
 563     yym = yylen[yyn];
 564     if (yym > 0)
 565         yyval = yystack.l_mark[1-yym];
 566     else
 567         memset(&yyval, 0, sizeof yyval);
 568
 569     switch (yyn)
 570     {
 571 case 3:
 572 #line 34 "pure_calc.y"
 573         {  yyerrok ; }
 574 break;
 575 case 4:
 576 #line 38 "pure_calc.y"
 577         {  printf("%d\n",yystack.l_mark[0]);}
 578 break;
 579 case 5:
 580 #line 40 "pure_calc.y"
 581         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 582 break;
 583 case 6:
 584 #line 44 "pure_calc.y"
 585         {  yyval = yystack.l_mark[-1]; }
 586 break;
 587 case 7:
 588 #line 46 "pure_calc.y"
 589         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 590 break;
 591 case 8:
 592 #line 48 "pure_calc.y"
 593         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 594 break;
 595 case 9:
 596 #line 50 "pure_calc.y"
 597         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 598 break;
 599 case 10:
 600 #line 52 "pure_calc.y"
 601         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 602 break;
 603 case 11:
 604 #line 54 "pure_calc.y"
 605         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 606 break;
 607 case 12:
 608 #line 56 "pure_calc.y"
 609         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 610 break;
 611 case 13:
 612 #line 58 "pure_calc.y"
 613         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 614 break;
 615 case 14:
 616 #line 60 "pure_calc.y"
 617         {  yyval = - yystack.l_mark[0]; }
 618 break;
 619 case 15:
 620 #line 62 "pure_calc.y"
 621         {  yyval = regs[yystack.l_mark[0]]; }
 622 break;
 623 case 17:
 624 #line 67 "pure_calc.y"
 625         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 626 break;
 627 case 18:
 628 #line 69 "pure_calc.y"
 629         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 630 break;
 631 #line 632 "pure_calc.tab.c"
 632     }
 633     yystack.s_mark -= yym;
 634     yystate = *yystack.s_mark;
 635     yystack.l_mark -= yym;
 636     yym = yylhs[yyn];
 637     if (yystate == 0 && yym == 0)
 638     {
 639 #if YYDEBUG
 640         if (yydebug)
 641             printf("%sdebug: after reduction, shifting from state 0 to\
 642  state %d\n", YYPREFIX, YYFINAL);
 643 #endif
 644         yystate = YYFINAL;
 645         *++yystack.s_mark = YYFINAL;
 646         *++yystack.l_mark = yyval;
 647         if (yychar < 0)
 648         {
 649             yychar = YYLEX;
 650             if (yychar < 0) yychar = YYEOF;
 651 #if YYDEBUG
 652             if (yydebug)
 653             {
 654                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 655                 printf("%sdebug: state %d, reading %d (%s)\n",
 656                         YYPREFIX, YYFINAL, yychar, yys);
 657             }
 658 #endif
 659         }
 660         if (yychar == YYEOF) goto yyaccept;
 661         goto yyloop;
 662     }
 663     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
 664             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
 665         yystate = yytable[yyn];
 666     else
 667         yystate = yydgoto[yym];
 668 #if YYDEBUG
 669     if (yydebug)
 670         printf("%sdebug: after reduction, shifting from state %d \
 671 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 672 #endif
 673     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 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 }