test/yacc/calc_code_provides.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_code_provides_parse
  19 #endif /* yyparse */
  20
  21 #ifndef yylex
  22 #define yylex      calc_code_provides_lex
  23 #endif /* yylex */
  24
  25 #ifndef yyerror
  26 #define yyerror    calc_code_provides_error
  27 #endif /* yyerror */
  28
  29 #ifndef yychar
  30 #define yychar     calc_code_provides_char
  31 #endif /* yychar */
  32
  33 #ifndef yyval
  34 #define yyval      calc_code_provides_val
  35 #endif /* yyval */
  36
  37 #ifndef yylval
  38 #define yylval     calc_code_provides_lval
  39 #endif /* yylval */
  40
  41 #ifndef yydebug
  42 #define yydebug    calc_code_provides_debug
  43 #endif /* yydebug */
  44
  45 #ifndef yynerrs
  46 #define yynerrs    calc_code_provides_nerrs
  47 #endif /* yynerrs */
  48
  49 #ifndef yyerrflag
  50 #define yyerrflag  calc_code_provides_errflag
  51 #endif /* yyerrflag */
  52
  53 #ifndef yylhs
  54 #define yylhs      calc_code_provides_lhs
  55 #endif /* yylhs */
  56
  57 #ifndef yylen
  58 #define yylen      calc_code_provides_len
  59 #endif /* yylen */
  60
  61 #ifndef yydefred
  62 #define yydefred   calc_code_provides_defred
  63 #endif /* yydefred */
  64
  65 #ifndef yydgoto
  66 #define yydgoto    calc_code_provides_dgoto
  67 #endif /* yydgoto */
  68
  69 #ifndef yysindex
  70 #define yysindex   calc_code_provides_sindex
  71 #endif /* yysindex */
  72
  73 #ifndef yyrindex
  74 #define yyrindex   calc_code_provides_rindex
  75 #endif /* yyrindex */
  76
  77 #ifndef yygindex
  78 #define yygindex   calc_code_provides_gindex
  79 #endif /* yygindex */
  80
  81 #ifndef yytable
  82 #define yytable    calc_code_provides_table
  83 #endif /* yytable */
  84
  85 #ifndef yycheck
  86 #define yycheck    calc_code_provides_check
  87 #endif /* yycheck */
  88
  89 #ifndef yyname
  90 #define yyname     calc_code_provides_name
  91 #endif /* yyname */
  92
  93 #ifndef yyrule
  94 #define yyrule     calc_code_provides_rule
  95 #endif /* yyrule */
  96 #define YYPREFIX "calc_code_provides_"
  97
  98 #define YYPURE 0
  99
 100 #line 5 "calc_code_provides.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_provides.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 short YYINT;
 154 static const YYINT calc_code_provides_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_provides_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_provides_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_provides_dgoto[] = {         1,
 169     7,    8,    9,
 170 };
 171 static const YYINT calc_code_provides_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_provides_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_provides_gindex[] = {        0,
 184     0,   65,    0,
 185 };
 186 #define YYTABLESIZE 220
 187 static const YYINT calc_code_provides_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_provides_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_provides_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_provides_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 /* 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
 314 /* %code "provides" block start */
 315 #line 1 "calc_code_provides.y"
 316 /* CODE-PROVIDES */
 317 #line 2 "calc_code_provides.y"
 318 /* CODE-PROVIDES2 */
 319 /* %code "provides" block end */
 320 #line 321 "calc_code_provides.tab.c"
 321 #line 69 "calc_code_provides.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_provides.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 = 0;
 439     yyn = 0;
 440     yynerrs = 0;
 441     yyerrflag = 0;
 442     yychar = YYEMPTY;
 443     yystate = 0;
 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_provides.y"
 564         {  yyerrok ; }
 565 break;
 566 case 4:
 567 #line 35 "calc_code_provides.y"
 568         {  printf("%d\n",yystack.l_mark[0]);}
 569 break;
 570 case 5:
 571 #line 37 "calc_code_provides.y"
 572         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 573 break;
 574 case 6:
 575 #line 41 "calc_code_provides.y"
 576         {  yyval = yystack.l_mark[-1]; }
 577 break;
 578 case 7:
 579 #line 43 "calc_code_provides.y"
 580         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 581 break;
 582 case 8:
 583 #line 45 "calc_code_provides.y"
 584         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 585 break;
 586 case 9:
 587 #line 47 "calc_code_provides.y"
 588         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 589 break;
 590 case 10:
 591 #line 49 "calc_code_provides.y"
 592         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 593 break;
 594 case 11:
 595 #line 51 "calc_code_provides.y"
 596         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 597 break;
 598 case 12:
 599 #line 53 "calc_code_provides.y"
 600         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 601 break;
 602 case 13:
 603 #line 55 "calc_code_provides.y"
 604         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 605 break;
 606 case 14:
 607 #line 57 "calc_code_provides.y"
 608         {  yyval = - yystack.l_mark[0]; }
 609 break;
 610 case 15:
 611 #line 59 "calc_code_provides.y"
 612         {  yyval = regs[yystack.l_mark[0]]; }
 613 break;
 614 case 17:
 615 #line 64 "calc_code_provides.y"
 616         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 617 break;
 618 case 18:
 619 #line 66 "calc_code_provides.y"
 620         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 621 break;
 622 #line 623 "calc_code_provides.tab.c"
 623     }
 624     yystack.s_mark -= yym;
 625     yystate = *yystack.s_mark;
 626     yystack.l_mark -= yym;
 627     yym = yylhs[yyn];
 628     if (yystate == 0 && yym == 0)
 629     {
 630 #if YYDEBUG
 631         if (yydebug)
 632             printf("%sdebug: after reduction, shifting from state 0 to\
 633  state %d\n", YYPREFIX, YYFINAL);
 634 #endif
 635         yystate = YYFINAL;
 636         *++yystack.s_mark = YYFINAL;
 637         *++yystack.l_mark = yyval;
 638         if (yychar < 0)
 639         {
 640             yychar = YYLEX;
 641             if (yychar < 0) yychar = YYEOF;
 642 #if YYDEBUG
 643             if (yydebug)
 644             {
 645                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
 646                 printf("%sdebug: state %d, reading %d (%s)\n",
 647                         YYPREFIX, YYFINAL, yychar, yys);
 648             }
 649 #endif
 650         }
 651         if (yychar == YYEOF) goto yyaccept;
 652         goto yyloop;
 653     }
 654     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
 655             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
 656         yystate = yytable[yyn];
 657     else
 658         yystate = yydgoto[yym];
 659 #if YYDEBUG
 660     if (yydebug)
 661         printf("%sdebug: after reduction, shifting from state %d \
 662 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 663 #endif
 664     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 665     *++yystack.s_mark = (YYINT) yystate;
 666     *++yystack.l_mark = yyval;
 667     goto yyloop;
 668
 669 yyoverflow:
 670     YYERROR_CALL("yacc stack overflow");
 671
 672 yyabort:
 673     yyfreestack(&yystack);
 674     return (1);
 675
 676 yyaccept:
 677     yyfreestack(&yystack);
 678     return (0);
 679 }