external/bsd/byacc/dist/test/quote_calc-s.tab.c

   1 /*      $NetBSD: quote_calc-s.tab.c,v 1.1.1.1 2013/04/06 14:45:27 christos Exp $        */
   2
   3 #ifndef lint
   4 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
   5 #endif
   6
   7 #define YYBYACC 1
   8 #define YYMAJOR 1
   9 #define YYMINOR 9
  10
  11 #define YYEMPTY        (-1)
  12 #define yyclearin      (yychar = YYEMPTY)
  13 #define yyerrok        (yyerrflag = 0)
  14 #define YYRECOVERING() (yyerrflag != 0)
  15
  16
  17 #ifndef yyparse
  18 #define yyparse    quote_calc_parse
  19 #endif /* yyparse */
  20
  21 #ifndef yylex
  22 #define yylex      quote_calc_lex
  23 #endif /* yylex */
  24
  25 #ifndef yyerror
  26 #define yyerror    quote_calc_error
  27 #endif /* yyerror */
  28
  29 #ifndef yychar
  30 #define yychar     quote_calc_char
  31 #endif /* yychar */
  32
  33 #ifndef yyval
  34 #define yyval      quote_calc_val
  35 #endif /* yyval */
  36
  37 #ifndef yylval
  38 #define yylval     quote_calc_lval
  39 #endif /* yylval */
  40
  41 #ifndef yydebug
  42 #define yydebug    quote_calc_debug
  43 #endif /* yydebug */
  44
  45 #ifndef yynerrs
  46 #define yynerrs    quote_calc_nerrs
  47 #endif /* yynerrs */
  48
  49 #ifndef yyerrflag
  50 #define yyerrflag  quote_calc_errflag
  51 #endif /* yyerrflag */
  52
  53 #ifndef yylhs
  54 #define yylhs      quote_calc_lhs
  55 #endif /* yylhs */
  56
  57 #ifndef yylen
  58 #define yylen      quote_calc_len
  59 #endif /* yylen */
  60
  61 #ifndef yydefred
  62 #define yydefred   quote_calc_defred
  63 #endif /* yydefred */
  64
  65 #ifndef yydgoto
  66 #define yydgoto    quote_calc_dgoto
  67 #endif /* yydgoto */
  68
  69 #ifndef yysindex
  70 #define yysindex   quote_calc_sindex
  71 #endif /* yysindex */
  72
  73 #ifndef yyrindex
  74 #define yyrindex   quote_calc_rindex
  75 #endif /* yyrindex */
  76
  77 #ifndef yygindex
  78 #define yygindex   quote_calc_gindex
  79 #endif /* yygindex */
  80
  81 #ifndef yytable
  82 #define yytable    quote_calc_table
  83 #endif /* yytable */
  84
  85 #ifndef yycheck
  86 #define yycheck    quote_calc_check
  87 #endif /* yycheck */
  88
  89 #ifndef yyname
  90 #define yyname     quote_calc_name
  91 #endif /* yyname */
  92
  93 #ifndef yyrule
  94 #define yyrule     quote_calc_rule
  95 #endif /* yyrule */
  96 #define YYPREFIX "quote_calc_"
  97
  98 #define YYPURE 0
  99
 100 #line 2 "quote_calc.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 109 "quote_calc-s.tab.c"
 111
 112 #ifndef YYSTYPE
 113 typedef int YYSTYPE;
 114 #endif
 115
 116 /* compatibility with bison */
 117 #ifdef YYPARSE_PARAM
 118 /* compatibility with FreeBSD */
 119 # ifdef YYPARSE_PARAM_TYPE
 120 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
 121 # else
 122 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
 123 # endif
 124 #else
 125 # define YYPARSE_DECL() yyparse(void)
 126 #endif
 127
 128 /* Parameters sent to lex. */
 129 #ifdef YYLEX_PARAM
 130 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
 131 # define YYLEX yylex(YYLEX_PARAM)
 132 #else
 133 # define YYLEX_DECL() yylex(void)
 134 # define YYLEX yylex()
 135 #endif
 136
 137 /* Parameters sent to yyerror. */
 138 #ifndef YYERROR_DECL
 139 #define YYERROR_DECL() yyerror(const char *s)
 140 #endif
 141 #ifndef YYERROR_CALL
 142 #define YYERROR_CALL(msg) yyerror(msg)
 143 #endif
 144
 145 extern int YYPARSE_DECL();
 146
 147 #define OP_ADD 257
 148 #define OP_SUB 259
 149 #define OP_MUL 261
 150 #define OP_DIV 263
 151 #define OP_MOD 265
 152 #define OP_AND 267
 153 #define DIGIT 269
 154 #define LETTER 270
 155 #define UMINUS 271
 156 #define YYERRCODE 256
 157 static const short quote_calc_lhs[] = {                  -1,
 158     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 159     2,    2,    2,    2,    2,    2,    3,    3,
 160 };
 161 static const short quote_calc_len[] = {                   2,
 162     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 163     3,    3,    3,    2,    1,    1,    1,    2,
 164 };
 165 static const short quote_calc_defred[] = {                1,
 166     0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
 167    15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
 168     0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
 169     0,    0,
 170 };
 171 static const short quote_calc_dgoto[] = {                 1,
 172     7,    8,    9,
 173 };
 174 static const short quote_calc_sindex[] = {                0,
 175   -38,    5,  -36,    0,  -51,  -36,    7, -121, -248,    0,
 176     0, -243,  -36,  -22,    0,  -36,  -36,  -36,  -36,  -36,
 177   -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
 178  -121, -243,
 179 };
 180 static const short quote_calc_rindex[] = {                0,
 181     0,    0,    0,    0,   -9,    0,    0,   13,  -10,    0,
 182     0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
 183     0,    0,    0,   15,    0,   -3,   -2,   -1,    1,    2,
 184     3,   -4,
 185 };
 186 static const short quote_calc_gindex[] = {                0,
 187     0,   42,    0,
 188 };
 189 #define YYTABLESIZE 258
 190 static const short quote_calc_table[] = {                16,
 191    15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
 192    10,   11,   12,   16,   10,   17,   15,   18,   25,   19,
 193    23,   20,    4,   21,    5,    0,    0,    0,    0,    0,
 194    16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
 195     0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
 196     0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
 197    29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
 198     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 199     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 200     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 201     0,   22,    0,    0,    0,    0,    0,    0,    0,    0,
 202     0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
 203     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 204     0,    0,    0,    0,    0,   16,    0,   17,    0,   18,
 205     0,   19,    0,   20,    0,   21,    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,    0,    0,    0,
 211     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 212     0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
 213     3,    0,    3,    0,    0,    0,    0,    0,    0,    0,
 214     4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
 215    19,    0,   20,    0,   21,    0,   16,   15,   16,   15,
 216    16,   15,   16,   15,   16,   15,   16,   15,
 217 };
 218 static const short quote_calc_check[] = {                10,
 219    10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
 220    10,   10,   10,  257,   10,  259,   10,  261,   41,  263,
 221   269,  265,   10,  267,   10,   -1,   -1,   -1,   -1,   -1,
 222    41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
 223    -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
 224    -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
 225    19,   20,   21,   22,   -1,   -1,   -1,   -1,   -1,   -1,
 226    -1,   -1,   -1,   -1,   -1,   -1,   -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,  124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 230    -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
 231    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 232    -1,   -1,   -1,   -1,   -1,  257,   -1,  259,   -1,  261,
 233    -1,  263,   -1,  265,   -1,  267,   -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,   -1,   -1,   -1,
 239    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 240    -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
 241   259,   -1,  259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 242   269,  270,  269,  270,  257,   -1,  259,   -1,  261,   -1,
 243   263,   -1,  265,   -1,  267,   -1,  257,  257,  259,  259,
 244   261,  261,  263,  263,  265,  265,  267,  267,
 245 };
 246 #define YYFINAL 1
 247 #ifndef YYDEBUG
 248 #define YYDEBUG 0
 249 #endif
 250 #define YYMAXTOKEN 271
 251 #if YYDEBUG
 252 static const char *yyname[] = {
 253
 254 "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,
 255 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,
 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,
 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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 261 0,0,0,0,0,0,"OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
 262 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
 263 };
 264 static const char *yyrule[] = {
 265 "$accept : list",
 266 "list :",
 267 "list : list stat '\\n'",
 268 "list : list error '\\n'",
 269 "stat : expr",
 270 "stat : LETTER '=' expr",
 271 "expr : '(' expr ')'",
 272 "expr : expr OP_ADD expr",
 273 "expr : expr OP_SUB expr",
 274 "expr : expr OP_MUL expr",
 275 "expr : expr OP_DIV expr",
 276 "expr : expr OP_MOD expr",
 277 "expr : expr OP_AND expr",
 278 "expr : expr '|' expr",
 279 "expr : OP_SUB expr",
 280 "expr : LETTER",
 281 "expr : number",
 282 "number : DIGIT",
 283 "number : number DIGIT",
 284
 285 };
 286 #endif
 287
 288 int      yydebug;
 289 int      yynerrs;
 290
 291 int      yyerrflag;
 292 int      yychar;
 293 YYSTYPE  yyval;
 294 YYSTYPE  yylval;
 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 500
 305 #define YYMAXDEPTH  500
 306 #endif
 307 #endif
 308
 309 #define YYINITSTACKSIZE 500
 310
 311 typedef struct {
 312     unsigned stacksize;
 313     short    *s_base;
 314     short    *s_mark;
 315     short    *s_last;
 316     YYSTYPE  *l_base;
 317     YYSTYPE  *l_mark;
 318 } YYSTACKDATA;
 319 /* variables for the parser stack */
 320 static YYSTACKDATA yystack;
 321 #line 73 "quote_calc.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         /* lexical analysis routine */
 342         /* returns LETTER for a lower case letter, yylval = 0 through 25 */
 343         /* return DIGIT for a digit, yylval = 0 through 9 */
 344         /* all other characters are returned immediately */
 345
 346     int c;
 347
 348     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
 349
 350     /* c is now nonblank */
 351
 352     if( islower( c )) {
 353         yylval = c - 'a';
 354         return ( LETTER );
 355     }
 356     if( isdigit( c )) {
 357         yylval = c - '0';
 358         return ( DIGIT );
 359     }
 360     return( c );
 361 }
 362 #line 361 "quote_calc-s.tab.c"
 363
 364 #if YYDEBUG
 365 #include <stdio.h>              /* needed for printf */
 366 #endif
 367
 368 #include <stdlib.h>     /* needed for malloc, etc */
 369 #include <string.h>     /* needed for memset */
 370
 371 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 372 static int yygrowstack(YYSTACKDATA *data)
 373 {
 374     int i;
 375     unsigned newsize;
 376     short *newss;
 377     YYSTYPE *newvs;
 378
 379     if ((newsize = data->stacksize) == 0)
 380         newsize = YYINITSTACKSIZE;
 381     else if (newsize >= YYMAXDEPTH)
 382         return -1;
 383     else if ((newsize *= 2) > YYMAXDEPTH)
 384         newsize = YYMAXDEPTH;
 385
 386     i = (int) (data->s_mark - data->s_base);
 387     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 388     if (newss == 0)
 389         return -1;
 390
 391     data->s_base = newss;
 392     data->s_mark = newss + i;
 393
 394     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
 395     if (newvs == 0)
 396         return -1;
 397
 398     data->l_base = newvs;
 399     data->l_mark = newvs + i;
 400
 401     data->stacksize = newsize;
 402     data->s_last = data->s_base + newsize - 1;
 403     return 0;
 404 }
 405
 406 #if YYPURE || defined(YY_NO_LEAKS)
 407 static void yyfreestack(YYSTACKDATA *data)
 408 {
 409     free(data->s_base);
 410     free(data->l_base);
 411     memset(data, 0, sizeof(*data));
 412 }
 413 #else
 414 #define yyfreestack(data) /* nothing */
 415 #endif
 416
 417 #define YYABORT  goto yyabort
 418 #define YYREJECT goto yyabort
 419 #define YYACCEPT goto yyaccept
 420 #define YYERROR  goto yyerrlab
 421
 422 int
 423 YYPARSE_DECL()
 424 {
 425     int yym, yyn, yystate;
 426 #if YYDEBUG
 427     const char *yys;
 428
 429     if ((yys = getenv("YYDEBUG")) != 0)
 430     {
 431         yyn = *yys;
 432         if (yyn >= '0' && yyn <= '9')
 433             yydebug = yyn - '0';
 434     }
 435 #endif
 436
 437     yynerrs = 0;
 438     yyerrflag = 0;
 439     yychar = YYEMPTY;
 440     yystate = 0;
 441
 442 #if YYPURE
 443     memset(&yystack, 0, sizeof(yystack));
 444 #endif
 445
 446     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
 447     yystack.s_mark = yystack.s_base;
 448     yystack.l_mark = yystack.l_base;
 449     yystate = 0;
 450     *yystack.s_mark = 0;
 451
 452 yyloop:
 453     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 454     if (yychar < 0)
 455     {
 456         if ((yychar = YYLEX) < 0) yychar = 0;
 457 #if YYDEBUG
 458         if (yydebug)
 459         {
 460             yys = 0;
 461             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 462             if (!yys) yys = "illegal-symbol";
 463             printf("%sdebug: state %d, reading %d (%s)\n",
 464                     YYPREFIX, yystate, yychar, yys);
 465         }
 466 #endif
 467     }
 468     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 469             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 470     {
 471 #if YYDEBUG
 472         if (yydebug)
 473             printf("%sdebug: state %d, shifting to state %d\n",
 474                     YYPREFIX, yystate, yytable[yyn]);
 475 #endif
 476         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 477         {
 478             goto yyoverflow;
 479         }
 480         yystate = yytable[yyn];
 481         *++yystack.s_mark = yytable[yyn];
 482         *++yystack.l_mark = yylval;
 483         yychar = YYEMPTY;
 484         if (yyerrflag > 0)  --yyerrflag;
 485         goto yyloop;
 486     }
 487     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 488             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 489     {
 490         yyn = yytable[yyn];
 491         goto yyreduce;
 492     }
 493     if (yyerrflag) goto yyinrecovery;
 494
 495     yyerror("syntax error");
 496
 497     goto yyerrlab;
 498
 499 yyerrlab:
 500     ++yynerrs;
 501
 502 yyinrecovery:
 503     if (yyerrflag < 3)
 504     {
 505         yyerrflag = 3;
 506         for (;;)
 507         {
 508             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 509                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 510             {
 511 #if YYDEBUG
 512                 if (yydebug)
 513                     printf("%sdebug: state %d, error recovery shifting\
 514  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 515 #endif
 516                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 517                 {
 518                     goto yyoverflow;
 519                 }
 520                 yystate = yytable[yyn];
 521                 *++yystack.s_mark = yytable[yyn];
 522                 *++yystack.l_mark = yylval;
 523                 goto yyloop;
 524             }
 525             else
 526             {
 527 #if YYDEBUG
 528                 if (yydebug)
 529                     printf("%sdebug: error recovery discarding state %d\n",
 530                             YYPREFIX, *yystack.s_mark);
 531 #endif
 532                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 533                 --yystack.s_mark;
 534                 --yystack.l_mark;
 535             }
 536         }
 537     }
 538     else
 539     {
 540         if (yychar == 0) goto yyabort;
 541 #if YYDEBUG
 542         if (yydebug)
 543         {
 544             yys = 0;
 545             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 546             if (!yys) yys = "illegal-symbol";
 547             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 548                     YYPREFIX, yystate, yychar, yys);
 549         }
 550 #endif
 551         yychar = YYEMPTY;
 552         goto yyloop;
 553     }
 554
 555 yyreduce:
 556 #if YYDEBUG
 557     if (yydebug)
 558         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 559                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 560 #endif
 561     yym = yylen[yyn];
 562     if (yym)
 563         yyval = yystack.l_mark[1-yym];
 564     else
 565         memset(&yyval, 0, sizeof yyval);
 566     switch (yyn)
 567     {
 568 case 3:
 569 #line 35 "quote_calc.y"
 570         {  yyerrok ; }
 571 break;
 572 case 4:
 573 #line 39 "quote_calc.y"
 574         {  printf("%d\n",yystack.l_mark[0]);}
 575 break;
 576 case 5:
 577 #line 41 "quote_calc.y"
 578         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 579 break;
 580 case 6:
 581 #line 45 "quote_calc.y"
 582         {  yyval = yystack.l_mark[-1]; }
 583 break;
 584 case 7:
 585 #line 47 "quote_calc.y"
 586         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 587 break;
 588 case 8:
 589 #line 49 "quote_calc.y"
 590         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 591 break;
 592 case 9:
 593 #line 51 "quote_calc.y"
 594         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 595 break;
 596 case 10:
 597 #line 53 "quote_calc.y"
 598         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 599 break;
 600 case 11:
 601 #line 55 "quote_calc.y"
 602         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 603 break;
 604 case 12:
 605 #line 57 "quote_calc.y"
 606         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 607 break;
 608 case 13:
 609 #line 59 "quote_calc.y"
 610         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 611 break;
 612 case 14:
 613 #line 61 "quote_calc.y"
 614         {  yyval = - yystack.l_mark[0]; }
 615 break;
 616 case 15:
 617 #line 63 "quote_calc.y"
 618         {  yyval = regs[yystack.l_mark[0]]; }
 619 break;
 620 case 17:
 621 #line 68 "quote_calc.y"
 622         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 623 break;
 624 case 18:
 625 #line 70 "quote_calc.y"
 626         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 627 break;
 628 #line 627 "quote_calc-s.tab.c"
 629     }
 630     yystack.s_mark -= yym;
 631     yystate = *yystack.s_mark;
 632     yystack.l_mark -= yym;
 633     yym = yylhs[yyn];
 634     if (yystate == 0 && yym == 0)
 635     {
 636 #if YYDEBUG
 637         if (yydebug)
 638             printf("%sdebug: after reduction, shifting from state 0 to\
 639  state %d\n", YYPREFIX, YYFINAL);
 640 #endif
 641         yystate = YYFINAL;
 642         *++yystack.s_mark = YYFINAL;
 643         *++yystack.l_mark = yyval;
 644         if (yychar < 0)
 645         {
 646             if ((yychar = YYLEX) < 0) yychar = 0;
 647 #if YYDEBUG
 648             if (yydebug)
 649             {
 650                 yys = 0;
 651                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 652                 if (!yys) yys = "illegal-symbol";
 653                 printf("%sdebug: state %d, reading %d (%s)\n",
 654                         YYPREFIX, YYFINAL, yychar, yys);
 655             }
 656 #endif
 657         }
 658         if (yychar == 0) 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))
 672     {
 673         goto yyoverflow;
 674     }
 675     *++yystack.s_mark = (short) yystate;
 676     *++yystack.l_mark = yyval;
 677     goto yyloop;
 678
 679 yyoverflow:
 680     yyerror("yacc stack overflow");
 681
 682 yyabort:
 683     yyfreestack(&yystack);
 684     return (1);
 685
 686 yyaccept:
 687     yyfreestack(&yystack);
 688     return (0);
 689 }