contrib/byacc/test/yacc/quote_calc2-s.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    quote_calc2_parse
  19 #endif /* yyparse */
  20
  21 #ifndef yylex
  22 #define yylex      quote_calc2_lex
  23 #endif /* yylex */
  24
  25 #ifndef yyerror
  26 #define yyerror    quote_calc2_error
  27 #endif /* yyerror */
  28
  29 #ifndef yychar
  30 #define yychar     quote_calc2_char
  31 #endif /* yychar */
  32
  33 #ifndef yyval
  34 #define yyval      quote_calc2_val
  35 #endif /* yyval */
  36
  37 #ifndef yylval
  38 #define yylval     quote_calc2_lval
  39 #endif /* yylval */
  40
  41 #ifndef yydebug
  42 #define yydebug    quote_calc2_debug
  43 #endif /* yydebug */
  44
  45 #ifndef yynerrs
  46 #define yynerrs    quote_calc2_nerrs
  47 #endif /* yynerrs */
  48
  49 #ifndef yyerrflag
  50 #define yyerrflag  quote_calc2_errflag
  51 #endif /* yyerrflag */
  52
  53 #ifndef yylhs
  54 #define yylhs      quote_calc2_lhs
  55 #endif /* yylhs */
  56
  57 #ifndef yylen
  58 #define yylen      quote_calc2_len
  59 #endif /* yylen */
  60
  61 #ifndef yydefred
  62 #define yydefred   quote_calc2_defred
  63 #endif /* yydefred */
  64
  65 #ifndef yydgoto
  66 #define yydgoto    quote_calc2_dgoto
  67 #endif /* yydgoto */
  68
  69 #ifndef yysindex
  70 #define yysindex   quote_calc2_sindex
  71 #endif /* yysindex */
  72
  73 #ifndef yyrindex
  74 #define yyrindex   quote_calc2_rindex
  75 #endif /* yyrindex */
  76
  77 #ifndef yygindex
  78 #define yygindex   quote_calc2_gindex
  79 #endif /* yygindex */
  80
  81 #ifndef yytable
  82 #define yytable    quote_calc2_table
  83 #endif /* yytable */
  84
  85 #ifndef yycheck
  86 #define yycheck    quote_calc2_check
  87 #endif /* yycheck */
  88
  89 #ifndef yyname
  90 #define yyname     quote_calc2_name
  91 #endif /* yyname */
  92
  93 #ifndef yyrule
  94 #define yyrule     quote_calc2_rule
  95 #endif /* yyrule */
  96 #define YYPREFIX "quote_calc2_"
  97
  98 #define YYPURE 0
  99
 100 #line 2 "quote_calc2.y"
 101 # include <stdio.h>
 102 # include <ctype.h>
 103
 104 int regs[26];
 105 int base;
 106
 107 int yylex(void);
 108 static void yyerror(const char *s);
 109
 110 #line 111 "quote_calc2-s.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 OP_ADD 257
 150 #define OP_SUB 259
 151 #define OP_MUL 261
 152 #define OP_DIV 263
 153 #define OP_MOD 265
 154 #define OP_AND 267
 155 #define DIGIT 269
 156 #define LETTER 270
 157 #define UMINUS 271
 158 #define YYERRCODE 256
 159 typedef int YYINT;
 160 static const YYINT quote_calc2_lhs[] = {                 -1,
 161     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 162     2,    2,    2,    2,    2,    2,    3,    3,
 163 };
 164 static const YYINT quote_calc2_len[] = {                  2,
 165     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 166     3,    3,    3,    2,    1,    1,    1,    2,
 167 };
 168 static const YYINT quote_calc2_defred[] = {               1,
 169     0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
 170    15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
 171     0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
 172     0,    0,
 173 };
 174 static const YYINT quote_calc2_dgoto[] = {                1,
 175     7,    8,    9,
 176 };
 177 static const YYINT quote_calc2_sindex[] = {               0,
 178   -38,    4,  -36,    0,  -51,  -36,    6, -121, -249,    0,
 179     0, -243,  -36,  -23,    0,  -36,  -36,  -36,  -36,  -36,
 180   -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
 181  -121, -243,
 182 };
 183 static const YYINT quote_calc2_rindex[] = {               0,
 184     0,    0,    0,    0,   -9,    0,    0,   12,  -10,    0,
 185     0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
 186     0,    0,    0,   14,    0,   -3,   -2,   -1,    1,    2,
 187     3,   -4,
 188 };
 189 static const YYINT quote_calc2_gindex[] = {               0,
 190     0,   42,    0,
 191 };
 192 #define YYTABLESIZE 259
 193 static const YYINT quote_calc2_table[] = {               16,
 194    15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
 195    10,   11,   12,   10,   16,   15,   17,   25,   18,   23,
 196    19,    4,   20,    5,   21,    0,    0,    0,    0,    0,
 197    16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
 198     0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
 199     0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
 200    29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
 201     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 202     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 203     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 204    22,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 205     0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
 206     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 207     0,    0,    0,    0,    0,    0,   16,    0,   17,    0,
 208    18,    0,   19,    0,   20,    0,   21,    0,    0,    0,
 209     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 210     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 211     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 212     0,    0,    0,    0,    0,    0,    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,    2,    0,    0,
 216     0,    3,    0,    3,    0,    0,    0,    0,    0,    0,
 217     4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
 218    19,    0,   20,    0,   21,    0,    0,   16,   15,   16,
 219    15,   16,   15,   16,   15,   16,   15,   16,   15,
 220 };
 221 static const YYINT quote_calc2_check[] = {               10,
 222    10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
 223    10,   10,   10,   10,  258,   10,  260,   41,  262,  269,
 224   264,   10,  266,   10,  268,   -1,   -1,   -1,   -1,   -1,
 225    41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
 226    -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
 227    -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
 228    19,   20,   21,   22,   -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   124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 233    -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
 234    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 235    -1,   -1,   -1,   -1,   -1,   -1,  258,   -1,  260,   -1,
 236   262,   -1,  264,   -1,  266,   -1,  268,   -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,   -1,   -1,  256,   -1,   -1,
 244    -1,  260,   -1,  260,   -1,   -1,   -1,   -1,   -1,   -1,
 245   269,  270,  269,  270,  258,   -1,  260,   -1,  262,   -1,
 246   264,   -1,  266,   -1,  268,   -1,   -1,  258,  258,  260,
 247   260,  262,  262,  264,  264,  266,  266,  268,  268,
 248 };
 249 #define YYFINAL 1
 250 #ifndef YYDEBUG
 251 #define YYDEBUG 0
 252 #endif
 253 #define YYMAXTOKEN 271
 254 #define YYUNDFTOKEN 277
 255 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
 256 #if YYDEBUG
 257 static const char *const quote_calc2_name[] = {
 258
 259 "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,
 260 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,
 262 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
 263 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 264 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 265 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 266 0,0,0,0,0,0,"OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
 267 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",0,0,0,
 268 0,0,"illegal-symbol",
 269 };
 270 static const char *const quote_calc2_rule[] = {
 271 "$accept : list",
 272 "list :",
 273 "list : list stat '\\n'",
 274 "list : list error '\\n'",
 275 "stat : expr",
 276 "stat : LETTER '=' expr",
 277 "expr : '(' expr ')'",
 278 "expr : expr \"ADD\" expr",
 279 "expr : expr \"SUB\" expr",
 280 "expr : expr \"MUL\" expr",
 281 "expr : expr \"DIV\" expr",
 282 "expr : expr \"MOD\" expr",
 283 "expr : expr \"AND\" expr",
 284 "expr : expr '|' expr",
 285 "expr : \"SUB\" expr",
 286 "expr : LETTER",
 287 "expr : number",
 288 "number : DIGIT",
 289 "number : number DIGIT",
 290
 291 };
 292 #endif
 293
 294 int      yydebug;
 295 int      yynerrs;
 296
 297 int      yyerrflag;
 298 int      yychar;
 299 YYSTYPE  yyval;
 300 YYSTYPE  yylval;
 301
 302 /* define the initial stack-sizes */
 303 #ifdef YYSTACKSIZE
 304 #undef YYMAXDEPTH
 305 #define YYMAXDEPTH  YYSTACKSIZE
 306 #else
 307 #ifdef YYMAXDEPTH
 308 #define YYSTACKSIZE YYMAXDEPTH
 309 #else
 310 #define YYSTACKSIZE 10000
 311 #define YYMAXDEPTH  10000
 312 #endif
 313 #endif
 314
 315 #define YYINITSTACKSIZE 200
 316
 317 typedef struct {
 318     unsigned stacksize;
 319     YYINT    *s_base;
 320     YYINT    *s_mark;
 321     YYINT    *s_last;
 322     YYSTYPE  *l_base;
 323     YYSTYPE  *l_mark;
 324 } YYSTACKDATA;
 325 /* variables for the parser stack */
 326 static YYSTACKDATA yystack;
 327 #line 73 "quote_calc2.y"
 328  /* start of programs */
 329
 330 int
 331 main (void)
 332 {
 333     while(!feof(stdin)) {
 334         yyparse();
 335     }
 336     return 0;
 337 }
 338
 339 static void
 340 yyerror(const char *s)
 341 {
 342     fprintf(stderr, "%s\n", s);
 343 }
 344
 345 int
 346 yylex(void) {
 347         /* lexical analysis routine */
 348         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 349         /* return DIGIT for a digit, yylval = 0 through 9 */
 350         /* all other characters are returned immediately */
 351
 352     int c;
 353
 354     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 355
 356     /* c is now nonblank */
 357
 358     if( islower( c )) {
 359         yylval = c - 'a';
 360         return ( LETTER );
 361     }
 362     if( isdigit( c )) {
 363         yylval = c - '0';
 364         return ( DIGIT );
 365     }
 366     return( c );
 367 }
 368 #line 369 "quote_calc2-s.tab.c"
 369
 370 #if YYDEBUG
 371 #include <stdio.h>              /* needed for printf */
 372 #endif
 373
 374 #include <stdlib.h>     /* needed for malloc, etc */
 375 #include <string.h>     /* needed for memset */
 376
 377 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 378 static int yygrowstack(YYSTACKDATA *data)
 379 {
 380     int i;
 381     unsigned newsize;
 382     YYINT *newss;
 383     YYSTYPE *newvs;
 384
 385     if ((newsize = data->stacksize) == 0)
 386         newsize = YYINITSTACKSIZE;
 387     else if (newsize >= YYMAXDEPTH)
 388         return YYENOMEM;
 389     else if ((newsize *= 2) > YYMAXDEPTH)
 390         newsize = YYMAXDEPTH;
 391
 392     i = (int) (data->s_mark - data->s_base);
 393     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
 394     if (newss == 0)
 395         return YYENOMEM;
 396
 397     data->s_base = newss;
 398     data->s_mark = newss + i;
 399
 400     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 401     if (newvs == 0)
 402         return YYENOMEM;
 403
 404     data->l_base = newvs;
 405     data->l_mark = newvs + i;
 406
 407     data->stacksize = newsize;
 408     data->s_last = data->s_base + newsize - 1;
 409     return 0;
 410 }
 411
 412 #if YYPURE || defined(YY_NO_LEAKS)
 413 static void yyfreestack(YYSTACKDATA *data)
 414 {
 415     free(data->s_base);
 416     free(data->l_base);
 417     memset(data, 0, sizeof(*data));
 418 }
 419 #else
 420 #define yyfreestack(data) /* nothing */
 421 #endif
 422
 423 #define YYABORT  goto yyabort
 424 #define YYREJECT goto yyabort
 425 #define YYACCEPT goto yyaccept
 426 #define YYERROR  goto yyerrlab
 427
 428 int
 429 YYPARSE_DECL()
 430 {
 431     int yym, yyn, yystate;
 432 #if YYDEBUG
 433     const char *yys;
 434
 435     if ((yys = getenv("YYDEBUG")) != 0)
 436     {
 437         yyn = *yys;
 438         if (yyn >= '0' && yyn <= '9')
 439             yydebug = yyn - '0';
 440     }
 441 #endif
 442
 443     yynerrs = 0;
 444     yyerrflag = 0;
 445     yychar = YYEMPTY;
 446     yystate = 0;
 447
 448 #if YYPURE
 449     memset(&yystack, 0, sizeof(yystack));
 450 #endif
 451
 452     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
 453     yystack.s_mark = yystack.s_base;
 454     yystack.l_mark = yystack.l_base;
 455     yystate = 0;
 456     *yystack.s_mark = 0;
 457
 458 yyloop:
 459     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 460     if (yychar < 0)
 461     {
 462         if ((yychar = YYLEX) < 0) yychar = YYEOF;
 463 #if YYDEBUG
 464         if (yydebug)
 465         {
 466             yys = yyname[YYTRANSLATE(yychar)];
 467             printf("%sdebug: state %d, reading %d (%s)\n",
 468                     YYPREFIX, yystate, yychar, yys);
 469         }
 470 #endif
 471     }
 472     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 473             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 474     {
 475 #if YYDEBUG
 476         if (yydebug)
 477             printf("%sdebug: state %d, shifting to state %d\n",
 478                     YYPREFIX, yystate, yytable[yyn]);
 479 #endif
 480         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 481         {
 482             goto yyoverflow;
 483         }
 484         yystate = yytable[yyn];
 485         *++yystack.s_mark = yytable[yyn];
 486         *++yystack.l_mark = yylval;
 487         yychar = YYEMPTY;
 488         if (yyerrflag > 0)  --yyerrflag;
 489         goto yyloop;
 490     }
 491     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 492             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 493     {
 494         yyn = yytable[yyn];
 495         goto yyreduce;
 496     }
 497     if (yyerrflag) goto yyinrecovery;
 498
 499     YYERROR_CALL("syntax error");
 500
 501     goto yyerrlab;
 502
 503 yyerrlab:
 504     ++yynerrs;
 505
 506 yyinrecovery:
 507     if (yyerrflag < 3)
 508     {
 509         yyerrflag = 3;
 510         for (;;)
 511         {
 512             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 513                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 514             {
 515 #if YYDEBUG
 516                 if (yydebug)
 517                     printf("%sdebug: state %d, error recovery shifting\
 518  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 519 #endif
 520                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 521                 {
 522                     goto yyoverflow;
 523                 }
 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             yys = yyname[YYTRANSLATE(yychar)];
 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)
 565         yyval = yystack.l_mark[1-yym];
 566     else
 567         memset(&yyval, 0, sizeof yyval);
 568     switch (yyn)
 569     {
 570 case 3:
 571 #line 35 "quote_calc2.y"
 572         {  yyerrok ; }
 573 break;
 574 case 4:
 575 #line 39 "quote_calc2.y"
 576         {  printf("%d\n",yystack.l_mark[0]);}
 577 break;
 578 case 5:
 579 #line 41 "quote_calc2.y"
 580         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 581 break;
 582 case 6:
 583 #line 45 "quote_calc2.y"
 584         {  yyval = yystack.l_mark[-1]; }
 585 break;
 586 case 7:
 587 #line 47 "quote_calc2.y"
 588         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 589 break;
 590 case 8:
 591 #line 49 "quote_calc2.y"
 592         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 593 break;
 594 case 9:
 595 #line 51 "quote_calc2.y"
 596         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 597 break;
 598 case 10:
 599 #line 53 "quote_calc2.y"
 600         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 601 break;
 602 case 11:
 603 #line 55 "quote_calc2.y"
 604         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 605 break;
 606 case 12:
 607 #line 57 "quote_calc2.y"
 608         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 609 break;
 610 case 13:
 611 #line 59 "quote_calc2.y"
 612         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 613 break;
 614 case 14:
 615 #line 61 "quote_calc2.y"
 616         {  yyval = - yystack.l_mark[0]; }
 617 break;
 618 case 15:
 619 #line 63 "quote_calc2.y"
 620         {  yyval = regs[yystack.l_mark[0]]; }
 621 break;
 622 case 17:
 623 #line 68 "quote_calc2.y"
 624         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 625 break;
 626 case 18:
 627 #line 70 "quote_calc2.y"
 628         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 629 break;
 630 #line 631 "quote_calc2-s.tab.c"
 631     }
 632     yystack.s_mark -= yym;
 633     yystate = *yystack.s_mark;
 634     yystack.l_mark -= yym;
 635     yym = yylhs[yyn];
 636     if (yystate == 0 && yym == 0)
 637     {
 638 #if YYDEBUG
 639         if (yydebug)
 640             printf("%sdebug: after reduction, shifting from state 0 to\
 641  state %d\n", YYPREFIX, YYFINAL);
 642 #endif
 643         yystate = YYFINAL;
 644         *++yystack.s_mark = YYFINAL;
 645         *++yystack.l_mark = yyval;
 646         if (yychar < 0)
 647         {
 648             if ((yychar = YYLEX) < 0) yychar = YYEOF;
 649 #if YYDEBUG
 650             if (yydebug)
 651             {
 652                 yys = yyname[YYTRANSLATE(yychar)];
 653                 printf("%sdebug: state %d, reading %d (%s)\n",
 654                         YYPREFIX, YYFINAL, yychar, yys);
 655             }
 656 #endif
 657         }
 658         if (yychar == YYEOF) goto yyaccept;
 659         goto yyloop;
 660     }
 661     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 662             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 663         yystate = yytable[yyn];
 664     else
 665         yystate = yydgoto[yym];
 666 #if YYDEBUG
 667     if (yydebug)
 668         printf("%sdebug: after reduction, shifting from state %d \
 669 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 670 #endif
 671     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
 672     {
 673         goto yyoverflow;
 674     }
 675     *++yystack.s_mark = (YYINT) yystate;
 676     *++yystack.l_mark = yyval;
 677     goto yyloop;
 678
 679 yyoverflow:
 680     YYERROR_CALL("yacc stack overflow");
 681
 682 yyabort:
 683     yyfreestack(&yystack);
 684     return (1);
 685
 686 yyaccept:
 687     yyfreestack(&yystack);
 688     return (0);
 689 }