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