contrib/byacc/test/quote_calc2-s.tab.c

   1 #ifndef lint
   2 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
   3 #endif
   4
   5 #define YYBYACC 1
   6 #define YYMAJOR 1
   7 #define YYMINOR 9
   8
   9 #define YYEMPTY        (-1)
  10 #define yyclearin      (yychar = YYEMPTY)
  11 #define yyerrok        (yyerrflag = 0)
  12 #define YYRECOVERING() (yyerrflag != 0)
  13
  14
  15 #ifndef yyparse
  16 #define yyparse    quote_calc2_parse
  17 #endif /* yyparse */
  18
  19 #ifndef yylex
  20 #define yylex      quote_calc2_lex
  21 #endif /* yylex */
  22
  23 #ifndef yyerror
  24 #define yyerror    quote_calc2_error
  25 #endif /* yyerror */
  26
  27 #ifndef yychar
  28 #define yychar     quote_calc2_char
  29 #endif /* yychar */
  30
  31 #ifndef yyval
  32 #define yyval      quote_calc2_val
  33 #endif /* yyval */
  34
  35 #ifndef yylval
  36 #define yylval     quote_calc2_lval
  37 #endif /* yylval */
  38
  39 #ifndef yydebug
  40 #define yydebug    quote_calc2_debug
  41 #endif /* yydebug */
  42
  43 #ifndef yynerrs
  44 #define yynerrs    quote_calc2_nerrs
  45 #endif /* yynerrs */
  46
  47 #ifndef yyerrflag
  48 #define yyerrflag  quote_calc2_errflag
  49 #endif /* yyerrflag */
  50
  51 #ifndef yylhs
  52 #define yylhs      quote_calc2_lhs
  53 #endif /* yylhs */
  54
  55 #ifndef yylen
  56 #define yylen      quote_calc2_len
  57 #endif /* yylen */
  58
  59 #ifndef yydefred
  60 #define yydefred   quote_calc2_defred
  61 #endif /* yydefred */
  62
  63 #ifndef yydgoto
  64 #define yydgoto    quote_calc2_dgoto
  65 #endif /* yydgoto */
  66
  67 #ifndef yysindex
  68 #define yysindex   quote_calc2_sindex
  69 #endif /* yysindex */
  70
  71 #ifndef yyrindex
  72 #define yyrindex   quote_calc2_rindex
  73 #endif /* yyrindex */
  74
  75 #ifndef yygindex
  76 #define yygindex   quote_calc2_gindex
  77 #endif /* yygindex */
  78
  79 #ifndef yytable
  80 #define yytable    quote_calc2_table
  81 #endif /* yytable */
  82
  83 #ifndef yycheck
  84 #define yycheck    quote_calc2_check
  85 #endif /* yycheck */
  86
  87 #ifndef yyname
  88 #define yyname     quote_calc2_name
  89 #endif /* yyname */
  90
  91 #ifndef yyrule
  92 #define yyrule     quote_calc2_rule
  93 #endif /* yyrule */
  94 #define YYPREFIX "quote_calc2_"
  95
  96 #define YYPURE 0
  97
  98 #line 2 "quote_calc2.y"
  99 # include <stdio.h>
 100 # include <ctype.h>
 101
 102 int regs[26];
 103 int base;
 104
 105 int yylex(void);
 106 static void yyerror(const char *s);
 107
 108 #line 109 "quote_calc2-s.tab.c"
 109
 110 #ifndef YYSTYPE
 111 typedef int YYSTYPE;
 112 #endif
 113
 114 /* compatibility with bison */
 115 #ifdef YYPARSE_PARAM
 116 /* compatibility with FreeBSD */
 117 # ifdef YYPARSE_PARAM_TYPE
 118 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 119 # else
 120 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 121 # endif
 122 #else
 123 # define YYPARSE_DECL() yyparse(void)
 124 #endif
 125
 126 /* Parameters sent to lex. */
 127 #ifdef YYLEX_PARAM
 128 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 129 # define YYLEX yylex(YYLEX_PARAM)
 130 #else
 131 # define YYLEX_DECL() yylex(void)
 132 # define YYLEX yylex()
 133 #endif
 134
 135 /* Parameters sent to yyerror. */
 136 #ifndef YYERROR_DECL
 137 #define YYERROR_DECL() yyerror(const char *s)
 138 #endif
 139 #ifndef YYERROR_CALL
 140 #define YYERROR_CALL(msg) yyerror(msg)
 141 #endif
 142
 143 extern int YYPARSE_DECL();
 144
 145 #define OP_ADD 257
 146 #define OP_SUB 259
 147 #define OP_MUL 261
 148 #define OP_DIV 263
 149 #define OP_MOD 265
 150 #define OP_AND 267
 151 #define DIGIT 269
 152 #define LETTER 270
 153 #define UMINUS 271
 154 #define YYERRCODE 256
 155 static const short quote_calc2_lhs[] = {                 -1,
 156     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 157     2,    2,    2,    2,    2,    2,    3,    3,
 158 };
 159 static const short quote_calc2_len[] = {                  2,
 160     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 161     3,    3,    3,    2,    1,    1,    1,    2,
 162 };
 163 static const short quote_calc2_defred[] = {               1,
 164     0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
 165    15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
 166     0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
 167     0,    0,
 168 };
 169 static const short quote_calc2_dgoto[] = {                1,
 170     7,    8,    9,
 171 };
 172 static const short quote_calc2_sindex[] = {               0,
 173   -38,    4,  -36,    0,  -51,  -36,    6, -121, -249,    0,
 174     0, -243,  -36,  -23,    0,  -36,  -36,  -36,  -36,  -36,
 175   -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
 176  -121, -243,
 177 };
 178 static const short quote_calc2_rindex[] = {               0,
 179     0,    0,    0,    0,   -9,    0,    0,   12,  -10,    0,
 180     0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
 181     0,    0,    0,   14,    0,   -3,   -2,   -1,    1,    2,
 182     3,   -4,
 183 };
 184 static const short quote_calc2_gindex[] = {               0,
 185     0,   42,    0,
 186 };
 187 #define YYTABLESIZE 259
 188 static const short quote_calc2_table[] = {               16,
 189    15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
 190    10,   11,   12,   10,   16,   15,   17,   25,   18,   23,
 191    19,    4,   20,    5,   21,    0,    0,    0,    0,    0,
 192    16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
 193     0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
 194     0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
 195    29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
 196     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 197     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 198     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 199    22,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 200     0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
 201     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 202     0,    0,    0,    0,    0,    0,   16,    0,   17,    0,
 203    18,    0,   19,    0,   20,    0,   21,    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,    0,    0,    0,    0,    0,
 210     0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
 211     0,    3,    0,    3,    0,    0,    0,    0,    0,    0,
 212     4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
 213    19,    0,   20,    0,   21,    0,    0,   16,   15,   16,
 214    15,   16,   15,   16,   15,   16,   15,   16,   15,
 215 };
 216 static const short quote_calc2_check[] = {               10,
 217    10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
 218    10,   10,   10,   10,  258,   10,  260,   41,  262,  269,
 219   264,   10,  266,   10,  268,   -1,   -1,   -1,   -1,   -1,
 220    41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
 221    -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
 222    -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
 223    19,   20,   21,   22,   -1,   -1,   -1,   -1,   -1,   -1,
 224    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 225    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 226    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 227   124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 228    -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
 229    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 230    -1,   -1,   -1,   -1,   -1,   -1,  258,   -1,  260,   -1,
 231   262,   -1,  264,   -1,  266,   -1,  268,   -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,   -1,   -1,   -1,   -1,   -1,
 236    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 237    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 238    -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
 239    -1,  260,   -1,  260,   -1,   -1,   -1,   -1,   -1,   -1,
 240   269,  270,  269,  270,  258,   -1,  260,   -1,  262,   -1,
 241   264,   -1,  266,   -1,  268,   -1,   -1,  258,  258,  260,
 242   260,  262,  262,  264,  264,  266,  266,  268,  268,
 243 };
 244 #define YYFINAL 1
 245 #ifndef YYDEBUG
 246 #define YYDEBUG 0
 247 #endif
 248 #define YYMAXTOKEN 271
 249 #if YYDEBUG
 250 static const char *yyname[] = {
 251
 252 "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,
 253 0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
 254 0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 255 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,0,0,0,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,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,0,0,0,
 259 0,0,0,0,0,0,"OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
 260 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
 261 };
 262 static const char *yyrule[] = {
 263 "$accept : list",
 264 "list :",
 265 "list : list stat '\\n'",
 266 "list : list error '\\n'",
 267 "stat : expr",
 268 "stat : LETTER '=' expr",
 269 "expr : '(' expr ')'",
 270 "expr : expr \"ADD\" expr",
 271 "expr : expr \"SUB\" expr",
 272 "expr : expr \"MUL\" expr",
 273 "expr : expr \"DIV\" expr",
 274 "expr : expr \"MOD\" expr",
 275 "expr : expr \"AND\" expr",
 276 "expr : expr '|' expr",
 277 "expr : \"SUB\" expr",
 278 "expr : LETTER",
 279 "expr : number",
 280 "number : DIGIT",
 281 "number : number DIGIT",
 282
 283 };
 284 #endif
 285
 286 int      yydebug;
 287 int      yynerrs;
 288
 289 int      yyerrflag;
 290 int      yychar;
 291 YYSTYPE  yyval;
 292 YYSTYPE  yylval;
 293
 294 /* define the initial stack-sizes */
 295 #ifdef YYSTACKSIZE
 296 #undef YYMAXDEPTH
 297 #define YYMAXDEPTH  YYSTACKSIZE
 298 #else
 299 #ifdef YYMAXDEPTH
 300 #define YYSTACKSIZE YYMAXDEPTH
 301 #else
 302 #define YYSTACKSIZE 500
 303 #define YYMAXDEPTH  500
 304 #endif
 305 #endif
 306
 307 #define YYINITSTACKSIZE 500
 308
 309 typedef struct {
 310     unsigned stacksize;
 311     short    *s_base;
 312     short    *s_mark;
 313     short    *s_last;
 314     YYSTYPE  *l_base;
 315     YYSTYPE  *l_mark;
 316 } YYSTACKDATA;
 317 /* variables for the parser stack */
 318 static YYSTACKDATA yystack;
 319 #line 73 "quote_calc2.y"
 320  /* start of programs */
 321
 322 int
 323 main (void)
 324 {
 325     while(!feof(stdin)) {
 326         yyparse();
 327     }
 328     return 0;
 329 }
 330
 331 static void
 332 yyerror(const char *s)
 333 {
 334     fprintf(stderr, "%s\n", s);
 335 }
 336
 337 int
 338 yylex(void) {
 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 "quote_calc2-s.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     short *newss;
 375     YYSTYPE *newvs;
 376
 377     if ((newsize = data->stacksize) == 0)
 378         newsize = YYINITSTACKSIZE;
 379     else if (newsize >= YYMAXDEPTH)
 380         return -1;
 381     else if ((newsize *= 2) > YYMAXDEPTH)
 382         newsize = YYMAXDEPTH;
 383
 384     i = (int) (data->s_mark - data->s_base);
 385     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 386     if (newss == 0)
 387         return -1;
 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 -1;
 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 yym, yyn, yystate;
 424 #if YYDEBUG
 425     const char *yys;
 426
 427     if ((yys = getenv("YYDEBUG")) != 0)
 428     {
 429         yyn = *yys;
 430         if (yyn >= '0' && yyn <= '9')
 431             yydebug = yyn - '0';
 432     }
 433 #endif
 434
 435     yynerrs = 0;
 436     yyerrflag = 0;
 437     yychar = YYEMPTY;
 438     yystate = 0;
 439
 440 #if YYPURE
 441     memset(&yystack, 0, sizeof(yystack));
 442 #endif
 443
 444     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 445     yystack.s_mark = yystack.s_base;
 446     yystack.l_mark = yystack.l_base;
 447     yystate = 0;
 448     *yystack.s_mark = 0;
 449
 450 yyloop:
 451     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 452     if (yychar < 0)
 453     {
 454         if ((yychar = YYLEX) < 0) yychar = 0;
 455 #if YYDEBUG
 456         if (yydebug)
 457         {
 458             yys = 0;
 459             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 460             if (!yys) yys = "illegal-symbol";
 461             printf("%sdebug: state %d, reading %d (%s)\n",
 462                     YYPREFIX, yystate, yychar, yys);
 463         }
 464 #endif
 465     }
 466     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 467             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 468     {
 469 #if YYDEBUG
 470         if (yydebug)
 471             printf("%sdebug: state %d, shifting to state %d\n",
 472                     YYPREFIX, yystate, yytable[yyn]);
 473 #endif
 474         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 475         {
 476             goto yyoverflow;
 477         }
 478         yystate = yytable[yyn];
 479         *++yystack.s_mark = yytable[yyn];
 480         *++yystack.l_mark = yylval;
 481         yychar = YYEMPTY;
 482         if (yyerrflag > 0)  --yyerrflag;
 483         goto yyloop;
 484     }
 485     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 486             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 487     {
 488         yyn = yytable[yyn];
 489         goto yyreduce;
 490     }
 491     if (yyerrflag) goto yyinrecovery;
 492
 493     yyerror("syntax error");
 494
 495     goto yyerrlab;
 496
 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]) && (yyn += YYERRCODE) >= 0 &&
 507                     yyn <= YYTABLESIZE && yycheck[yyn] == 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))
 515                 {
 516                     goto yyoverflow;
 517                 }
 518                 yystate = yytable[yyn];
 519                 *++yystack.s_mark = yytable[yyn];
 520                 *++yystack.l_mark = yylval;
 521                 goto yyloop;
 522             }
 523             else
 524             {
 525 #if YYDEBUG
 526                 if (yydebug)
 527                     printf("%sdebug: error recovery discarding state %d\n",
 528                             YYPREFIX, *yystack.s_mark);
 529 #endif
 530                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 531                 --yystack.s_mark;
 532                 --yystack.l_mark;
 533             }
 534         }
 535     }
 536     else
 537     {
 538         if (yychar == 0) goto yyabort;
 539 #if YYDEBUG
 540         if (yydebug)
 541         {
 542             yys = 0;
 543             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 544             if (!yys) yys = "illegal-symbol";
 545             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 546                     YYPREFIX, yystate, yychar, yys);
 547         }
 548 #endif
 549         yychar = YYEMPTY;
 550         goto yyloop;
 551     }
 552
 553 yyreduce:
 554 #if YYDEBUG
 555     if (yydebug)
 556         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 557                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 558 #endif
 559     yym = yylen[yyn];
 560     if (yym)
 561         yyval = yystack.l_mark[1-yym];
 562     else
 563         memset(&yyval, 0, sizeof yyval);
 564     switch (yyn)
 565     {
 566 case 3:
 567 #line 35 "quote_calc2.y"
 568         {  yyerrok ; }
 569 break;
 570 case 4:
 571 #line 39 "quote_calc2.y"
 572         {  printf("%d\n",yystack.l_mark[0]);}
 573 break;
 574 case 5:
 575 #line 41 "quote_calc2.y"
 576         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 577 break;
 578 case 6:
 579 #line 45 "quote_calc2.y"
 580         {  yyval = yystack.l_mark[-1]; }
 581 break;
 582 case 7:
 583 #line 47 "quote_calc2.y"
 584         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 585 break;
 586 case 8:
 587 #line 49 "quote_calc2.y"
 588         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 589 break;
 590 case 9:
 591 #line 51 "quote_calc2.y"
 592         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 593 break;
 594 case 10:
 595 #line 53 "quote_calc2.y"
 596         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 597 break;
 598 case 11:
 599 #line 55 "quote_calc2.y"
 600         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 601 break;
 602 case 12:
 603 #line 57 "quote_calc2.y"
 604         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 605 break;
 606 case 13:
 607 #line 59 "quote_calc2.y"
 608         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 609 break;
 610 case 14:
 611 #line 61 "quote_calc2.y"
 612         {  yyval = - yystack.l_mark[0]; }
 613 break;
 614 case 15:
 615 #line 63 "quote_calc2.y"
 616         {  yyval = regs[yystack.l_mark[0]]; }
 617 break;
 618 case 17:
 619 #line 68 "quote_calc2.y"
 620         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 621 break;
 622 case 18:
 623 #line 70 "quote_calc2.y"
 624         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 625 break;
 626 #line 627 "quote_calc2-s.tab.c"
 627     }
 628     yystack.s_mark -= yym;
 629     yystate = *yystack.s_mark;
 630     yystack.l_mark -= yym;
 631     yym = yylhs[yyn];
 632     if (yystate == 0 && yym == 0)
 633     {
 634 #if YYDEBUG
 635         if (yydebug)
 636             printf("%sdebug: after reduction, shifting from state 0 to\
 637  state %d\n", YYPREFIX, YYFINAL);
 638 #endif
 639         yystate = YYFINAL;
 640         *++yystack.s_mark = YYFINAL;
 641         *++yystack.l_mark = yyval;
 642         if (yychar < 0)
 643         {
 644             if ((yychar = YYLEX) < 0) yychar = 0;
 645 #if YYDEBUG
 646             if (yydebug)
 647             {
 648                 yys = 0;
 649                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 650                 if (!yys) yys = "illegal-symbol";
 651                 printf("%sdebug: state %d, reading %d (%s)\n",
 652                         YYPREFIX, YYFINAL, yychar, yys);
 653             }
 654 #endif
 655         }
 656         if (yychar == 0) 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))
 670     {
 671         goto yyoverflow;
 672     }
 673     *++yystack.s_mark = (short) yystate;
 674     *++yystack.l_mark = yyval;
 675     goto yyloop;
 676
 677 yyoverflow:
 678     yyerror("yacc stack overflow");
 679
 680 yyabort:
 681     yyfreestack(&yystack);
 682     return (1);
 683
 684 yyaccept:
 685     yyfreestack(&yystack);
 686     return (0);
 687 }