contrib/byacc/test/quote_calc3-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_calc3_parse
  17 #endif /* yyparse */
  18
  19 #ifndef yylex
  20 #define yylex      quote_calc3_lex
  21 #endif /* yylex */
  22
  23 #ifndef yyerror
  24 #define yyerror    quote_calc3_error
  25 #endif /* yyerror */
  26
  27 #ifndef yychar
  28 #define yychar     quote_calc3_char
  29 #endif /* yychar */
  30
  31 #ifndef yyval
  32 #define yyval      quote_calc3_val
  33 #endif /* yyval */
  34
  35 #ifndef yylval
  36 #define yylval     quote_calc3_lval
  37 #endif /* yylval */
  38
  39 #ifndef yydebug
  40 #define yydebug    quote_calc3_debug
  41 #endif /* yydebug */
  42
  43 #ifndef yynerrs
  44 #define yynerrs    quote_calc3_nerrs
  45 #endif /* yynerrs */
  46
  47 #ifndef yyerrflag
  48 #define yyerrflag  quote_calc3_errflag
  49 #endif /* yyerrflag */
  50
  51 #ifndef yylhs
  52 #define yylhs      quote_calc3_lhs
  53 #endif /* yylhs */
  54
  55 #ifndef yylen
  56 #define yylen      quote_calc3_len
  57 #endif /* yylen */
  58
  59 #ifndef yydefred
  60 #define yydefred   quote_calc3_defred
  61 #endif /* yydefred */
  62
  63 #ifndef yydgoto
  64 #define yydgoto    quote_calc3_dgoto
  65 #endif /* yydgoto */
  66
  67 #ifndef yysindex
  68 #define yysindex   quote_calc3_sindex
  69 #endif /* yysindex */
  70
  71 #ifndef yyrindex
  72 #define yyrindex   quote_calc3_rindex
  73 #endif /* yyrindex */
  74
  75 #ifndef yygindex
  76 #define yygindex   quote_calc3_gindex
  77 #endif /* yygindex */
  78
  79 #ifndef yytable
  80 #define yytable    quote_calc3_table
  81 #endif /* yytable */
  82
  83 #ifndef yycheck
  84 #define yycheck    quote_calc3_check
  85 #endif /* yycheck */
  86
  87 #ifndef yyname
  88 #define yyname     quote_calc3_name
  89 #endif /* yyname */
  90
  91 #ifndef yyrule
  92 #define yyrule     quote_calc3_rule
  93 #endif /* yyrule */
  94 #define YYPREFIX "quote_calc3_"
  95
  96 #define YYPURE 0
  97
  98 #line 2 "quote_calc3.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_calc3-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_calc3_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_calc3_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_calc3_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_calc3_dgoto[] = {                1,
 170     7,    8,    9,
 171 };
 172 static const short quote_calc3_sindex[] = {               0,
 173   -38,    5,  -36,    0,  -51,  -36,    7, -121, -248,    0,
 174     0, -243,  -36,  -22,    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_calc3_rindex[] = {               0,
 179     0,    0,    0,    0,   -9,    0,    0,   13,  -10,    0,
 180     0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
 181     0,    0,    0,   15,    0,   -3,   -2,   -1,    1,    2,
 182     3,   -4,
 183 };
 184 static const short quote_calc3_gindex[] = {               0,
 185     0,   42,    0,
 186 };
 187 #define YYTABLESIZE 258
 188 static const short quote_calc3_table[] = {               16,
 189    15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
 190    10,   11,   12,   16,   10,   17,   15,   18,   25,   19,
 191    23,   20,    4,   21,    5,    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     0,   22,    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,   16,    0,   17,    0,   18,
 203     0,   19,    0,   20,    0,   21,    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,    0,    0,    0,    0,    0,
 210     0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
 211     3,    0,    3,    0,    0,    0,    0,    0,    0,    0,
 212     4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
 213    19,    0,   20,    0,   21,    0,   16,   15,   16,   15,
 214    16,   15,   16,   15,   16,   15,   16,   15,
 215 };
 216 static const short quote_calc3_check[] = {               10,
 217    10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
 218    10,   10,   10,  257,   10,  259,   10,  261,   41,  263,
 219   269,  265,   10,  267,   10,   -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    -1,  124,   -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,  257,   -1,  259,   -1,  261,
 231    -1,  263,   -1,  265,   -1,  267,   -1,   -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   259,   -1,  259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 240   269,  270,  269,  270,  257,   -1,  259,   -1,  261,   -1,
 241   263,   -1,  265,   -1,  267,   -1,  257,  257,  259,  259,
 242   261,  261,  263,  263,  265,  265,  267,  267,
 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-operator\"","OP_SUB","\"SUB-operator\"","OP_MUL",
 260 "\"MUL-operator\"","OP_DIV","\"DIV-operator\"","OP_MOD","\"MOD-operator\"",
 261 "OP_AND","\"AND-operator\"","DIGIT","LETTER","UMINUS",
 262 };
 263 static const char *yyrule[] = {
 264 "$accept : list",
 265 "list :",
 266 "list : list stat '\\n'",
 267 "list : list error '\\n'",
 268 "stat : expr",
 269 "stat : LETTER '=' expr",
 270 "expr : '(' expr ')'",
 271 "expr : expr OP_ADD expr",
 272 "expr : expr OP_SUB expr",
 273 "expr : expr OP_MUL expr",
 274 "expr : expr OP_DIV expr",
 275 "expr : expr OP_MOD expr",
 276 "expr : expr OP_AND expr",
 277 "expr : expr '|' expr",
 278 "expr : OP_SUB expr",
 279 "expr : LETTER",
 280 "expr : number",
 281 "number : DIGIT",
 282 "number : number DIGIT",
 283
 284 };
 285 #endif
 286
 287 int      yydebug;
 288 int      yynerrs;
 289
 290 int      yyerrflag;
 291 int      yychar;
 292 YYSTYPE  yyval;
 293 YYSTYPE  yylval;
 294
 295 /* define the initial stack-sizes */
 296 #ifdef YYSTACKSIZE
 297 #undef YYMAXDEPTH
 298 #define YYMAXDEPTH  YYSTACKSIZE
 299 #else
 300 #ifdef YYMAXDEPTH
 301 #define YYSTACKSIZE YYMAXDEPTH
 302 #else
 303 #define YYSTACKSIZE 500
 304 #define YYMAXDEPTH  500
 305 #endif
 306 #endif
 307
 308 #define YYINITSTACKSIZE 500
 309
 310 typedef struct {
 311     unsigned stacksize;
 312     short    *s_base;
 313     short    *s_mark;
 314     short    *s_last;
 315     YYSTYPE  *l_base;
 316     YYSTYPE  *l_mark;
 317 } YYSTACKDATA;
 318 /* variables for the parser stack */
 319 static YYSTACKDATA yystack;
 320 #line 73 "quote_calc3.y"
 321  /* start of programs */
 322
 323 int
 324 main (void)
 325 {
 326     while(!feof(stdin)) {
 327         yyparse();
 328     }
 329     return 0;
 330 }
 331
 332 static void
 333 yyerror(const char *s)
 334 {
 335     fprintf(stderr, "%s\n", s);
 336 }
 337
 338 int
 339 yylex(void) {
 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 "quote_calc3-s.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     short *newss;
 376     YYSTYPE *newvs;
 377
 378     if ((newsize = data->stacksize) == 0)
 379         newsize = YYINITSTACKSIZE;
 380     else if (newsize >= YYMAXDEPTH)
 381         return -1;
 382     else if ((newsize *= 2) > YYMAXDEPTH)
 383         newsize = YYMAXDEPTH;
 384
 385     i = (int) (data->s_mark - data->s_base);
 386     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 387     if (newss == 0)
 388         return -1;
 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 -1;
 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 yym, yyn, yystate;
 425 #if YYDEBUG
 426     const char *yys;
 427
 428     if ((yys = getenv("YYDEBUG")) != 0)
 429     {
 430         yyn = *yys;
 431         if (yyn >= '0' && yyn <= '9')
 432             yydebug = yyn - '0';
 433     }
 434 #endif
 435
 436     yynerrs = 0;
 437     yyerrflag = 0;
 438     yychar = YYEMPTY;
 439     yystate = 0;
 440
 441 #if YYPURE
 442     memset(&yystack, 0, sizeof(yystack));
 443 #endif
 444
 445     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 446     yystack.s_mark = yystack.s_base;
 447     yystack.l_mark = yystack.l_base;
 448     yystate = 0;
 449     *yystack.s_mark = 0;
 450
 451 yyloop:
 452     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 453     if (yychar < 0)
 454     {
 455         if ((yychar = YYLEX) < 0) yychar = 0;
 456 #if YYDEBUG
 457         if (yydebug)
 458         {
 459             yys = 0;
 460             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 461             if (!yys) yys = "illegal-symbol";
 462             printf("%sdebug: state %d, reading %d (%s)\n",
 463                     YYPREFIX, yystate, yychar, yys);
 464         }
 465 #endif
 466     }
 467     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 468             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 469     {
 470 #if YYDEBUG
 471         if (yydebug)
 472             printf("%sdebug: state %d, shifting to state %d\n",
 473                     YYPREFIX, yystate, yytable[yyn]);
 474 #endif
 475         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 476         {
 477             goto yyoverflow;
 478         }
 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]) && (yyn += yychar) >= 0 &&
 487             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 488     {
 489         yyn = yytable[yyn];
 490         goto yyreduce;
 491     }
 492     if (yyerrflag) goto yyinrecovery;
 493
 494     yyerror("syntax error");
 495
 496     goto yyerrlab;
 497
 498 yyerrlab:
 499     ++yynerrs;
 500
 501 yyinrecovery:
 502     if (yyerrflag < 3)
 503     {
 504         yyerrflag = 3;
 505         for (;;)
 506         {
 507             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 508                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 509             {
 510 #if YYDEBUG
 511                 if (yydebug)
 512                     printf("%sdebug: state %d, error recovery shifting\
 513  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 514 #endif
 515                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 516                 {
 517                     goto yyoverflow;
 518                 }
 519                 yystate = yytable[yyn];
 520                 *++yystack.s_mark = yytable[yyn];
 521                 *++yystack.l_mark = yylval;
 522                 goto yyloop;
 523             }
 524             else
 525             {
 526 #if YYDEBUG
 527                 if (yydebug)
 528                     printf("%sdebug: error recovery discarding state %d\n",
 529                             YYPREFIX, *yystack.s_mark);
 530 #endif
 531                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 532                 --yystack.s_mark;
 533                 --yystack.l_mark;
 534             }
 535         }
 536     }
 537     else
 538     {
 539         if (yychar == 0) goto yyabort;
 540 #if YYDEBUG
 541         if (yydebug)
 542         {
 543             yys = 0;
 544             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 545             if (!yys) yys = "illegal-symbol";
 546             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 547                     YYPREFIX, yystate, yychar, yys);
 548         }
 549 #endif
 550         yychar = YYEMPTY;
 551         goto yyloop;
 552     }
 553
 554 yyreduce:
 555 #if YYDEBUG
 556     if (yydebug)
 557         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 558                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 559 #endif
 560     yym = yylen[yyn];
 561     if (yym)
 562         yyval = yystack.l_mark[1-yym];
 563     else
 564         memset(&yyval, 0, sizeof yyval);
 565     switch (yyn)
 566     {
 567 case 3:
 568 #line 35 "quote_calc3.y"
 569         {  yyerrok ; }
 570 break;
 571 case 4:
 572 #line 39 "quote_calc3.y"
 573         {  printf("%d\n",yystack.l_mark[0]);}
 574 break;
 575 case 5:
 576 #line 41 "quote_calc3.y"
 577         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 578 break;
 579 case 6:
 580 #line 45 "quote_calc3.y"
 581         {  yyval = yystack.l_mark[-1]; }
 582 break;
 583 case 7:
 584 #line 47 "quote_calc3.y"
 585         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 586 break;
 587 case 8:
 588 #line 49 "quote_calc3.y"
 589         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 590 break;
 591 case 9:
 592 #line 51 "quote_calc3.y"
 593         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 594 break;
 595 case 10:
 596 #line 53 "quote_calc3.y"
 597         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 598 break;
 599 case 11:
 600 #line 55 "quote_calc3.y"
 601         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 602 break;
 603 case 12:
 604 #line 57 "quote_calc3.y"
 605         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 606 break;
 607 case 13:
 608 #line 59 "quote_calc3.y"
 609         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 610 break;
 611 case 14:
 612 #line 61 "quote_calc3.y"
 613         {  yyval = - yystack.l_mark[0]; }
 614 break;
 615 case 15:
 616 #line 63 "quote_calc3.y"
 617         {  yyval = regs[yystack.l_mark[0]]; }
 618 break;
 619 case 17:
 620 #line 68 "quote_calc3.y"
 621         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 622 break;
 623 case 18:
 624 #line 70 "quote_calc3.y"
 625         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 626 break;
 627 #line 628 "quote_calc3-s.tab.c"
 628     }
 629     yystack.s_mark -= yym;
 630     yystate = *yystack.s_mark;
 631     yystack.l_mark -= yym;
 632     yym = yylhs[yyn];
 633     if (yystate == 0 && yym == 0)
 634     {
 635 #if YYDEBUG
 636         if (yydebug)
 637             printf("%sdebug: after reduction, shifting from state 0 to\
 638  state %d\n", YYPREFIX, YYFINAL);
 639 #endif
 640         yystate = YYFINAL;
 641         *++yystack.s_mark = YYFINAL;
 642         *++yystack.l_mark = yyval;
 643         if (yychar < 0)
 644         {
 645             if ((yychar = YYLEX) < 0) yychar = 0;
 646 #if YYDEBUG
 647             if (yydebug)
 648             {
 649                 yys = 0;
 650                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 651                 if (!yys) yys = "illegal-symbol";
 652                 printf("%sdebug: state %d, reading %d (%s)\n",
 653                         YYPREFIX, YYFINAL, yychar, yys);
 654             }
 655 #endif
 656         }
 657         if (yychar == 0) goto yyaccept;
 658         goto yyloop;
 659     }
 660     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 661             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 662         yystate = yytable[yyn];
 663     else
 664         yystate = yydgoto[yym];
 665 #if YYDEBUG
 666     if (yydebug)
 667         printf("%sdebug: after reduction, shifting from state %d \
 668 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 669 #endif
 670     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 671     {
 672         goto yyoverflow;
 673     }
 674     *++yystack.s_mark = (short) yystate;
 675     *++yystack.l_mark = yyval;
 676     goto yyloop;
 677
 678 yyoverflow:
 679     yyerror("yacc stack overflow");
 680
 681 yyabort:
 682     yyfreestack(&yystack);
 683     return (1);
 684
 685 yyaccept:
 686     yyfreestack(&yystack);
 687     return (0);
 688 }