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

   1 /*      $NetBSD: quote_calc.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.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 ADD 258
 149 #define OP_SUB 259
 150 #define SUB 260
 151 #define OP_MUL 261
 152 #define MUL 262
 153 #define OP_DIV 263
 154 #define DIV 264
 155 #define OP_MOD 265
 156 #define MOD 266
 157 #define OP_AND 267
 158 #define AND 268
 159 #define DIGIT 269
 160 #define LETTER 270
 161 #define UMINUS 271
 162 #define YYERRCODE 256
 163 static const short quote_calc_lhs[] = {                  -1,
 164     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
 165     2,    2,    2,    2,    2,    2,    3,    3,
 166 };
 167 static const short quote_calc_len[] = {                   2,
 168     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
 169     3,    3,    3,    2,    1,    1,    1,    2,
 170 };
 171 static const short quote_calc_defred[] = {                1,
 172     0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
 173    15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
 174     0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
 175     0,    0,
 176 };
 177 static const short quote_calc_dgoto[] = {                 1,
 178     7,    8,    9,
 179 };
 180 static const short quote_calc_sindex[] = {                0,
 181   -38,    5,  -36,    0,  -51,  -36,    7, -121, -248,    0,
 182     0, -243,  -36,  -22,    0,  -36,  -36,  -36,  -36,  -36,
 183   -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
 184  -121, -243,
 185 };
 186 static const short quote_calc_rindex[] = {                0,
 187     0,    0,    0,    0,   -9,    0,    0,   13,  -10,    0,
 188     0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
 189     0,    0,    0,   15,    0,   -3,   -2,   -1,    1,    2,
 190     3,   -4,
 191 };
 192 static const short quote_calc_gindex[] = {                0,
 193     0,   42,    0,
 194 };
 195 #define YYTABLESIZE 258
 196 static const short quote_calc_table[] = {                16,
 197    15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
 198    10,   11,   12,   16,   10,   17,   15,   18,   25,   19,
 199    23,   20,    4,   21,    5,    0,    0,    0,    0,    0,
 200    16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
 201     0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
 202     0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
 203    29,   30,   31,   32,    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,   22,    0,    0,    0,    0,    0,    0,    0,    0,
 208     0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
 209     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 210     0,    0,    0,    0,    0,   16,    0,   17,    0,   18,
 211     0,   19,    0,   20,    0,   21,    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,    0,    0,    0,
 216     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 217     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 218     0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
 219     3,    0,    3,    0,    0,    0,    0,    0,    0,    0,
 220     4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
 221    19,    0,   20,    0,   21,    0,   16,   15,   16,   15,
 222    16,   15,   16,   15,   16,   15,   16,   15,
 223 };
 224 static const short quote_calc_check[] = {                10,
 225    10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
 226    10,   10,   10,  257,   10,  259,   10,  261,   41,  263,
 227   269,  265,   10,  267,   10,   -1,   -1,   -1,   -1,   -1,
 228    41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
 229    -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
 230    -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
 231    19,   20,   21,   22,   -1,   -1,   -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,  124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 236    -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
 237    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 238    -1,   -1,   -1,   -1,   -1,  257,   -1,  259,   -1,  261,
 239    -1,  263,   -1,  265,   -1,  267,   -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,   -1,   -1,   -1,
 244    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 245    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 246    -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
 247   259,   -1,  259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 248   269,  270,  269,  270,  257,   -1,  259,   -1,  261,   -1,
 249   263,   -1,  265,   -1,  267,   -1,  257,  257,  259,  259,
 250   261,  261,  263,  263,  265,  265,  267,  267,
 251 };
 252 #define YYFINAL 1
 253 #ifndef YYDEBUG
 254 #define YYDEBUG 0
 255 #endif
 256 #define YYMAXTOKEN 271
 257 #if YYDEBUG
 258 static const char *yyname[] = {
 259
 260 "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,
 261 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,
 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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 267 0,0,0,0,0,0,"OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
 268 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
 269 };
 270 static const char *yyrule[] = {
 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 OP_ADD expr",
 279 "expr : expr OP_SUB expr",
 280 "expr : expr OP_MUL expr",
 281 "expr : expr OP_DIV expr",
 282 "expr : expr OP_MOD expr",
 283 "expr : expr OP_AND expr",
 284 "expr : expr '|' expr",
 285 "expr : OP_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 500
 311 #define YYMAXDEPTH  500
 312 #endif
 313 #endif
 314
 315 #define YYINITSTACKSIZE 500
 316
 317 typedef struct {
 318     unsigned stacksize;
 319     short    *s_base;
 320     short    *s_mark;
 321     short    *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_calc.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 367 "quote_calc.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     short *newss;
 383     YYSTYPE *newvs;
 384
 385     if ((newsize = data->stacksize) == 0)
 386         newsize = YYINITSTACKSIZE;
 387     else if (newsize >= YYMAXDEPTH)
 388         return -1;
 389     else if ((newsize *= 2) > YYMAXDEPTH)
 390         newsize = YYMAXDEPTH;
 391
 392     i = (int) (data->s_mark - data->s_base);
 393     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
 394     if (newss == 0)
 395         return -1;
 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 -1;
 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)) 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 = 0;
 463 #if YYDEBUG
 464         if (yydebug)
 465         {
 466             yys = 0;
 467             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 468             if (!yys) yys = "illegal-symbol";
 469             printf("%sdebug: state %d, reading %d (%s)\n",
 470                     YYPREFIX, yystate, yychar, yys);
 471         }
 472 #endif
 473     }
 474     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 475             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 476     {
 477 #if YYDEBUG
 478         if (yydebug)
 479             printf("%sdebug: state %d, shifting to state %d\n",
 480                     YYPREFIX, yystate, yytable[yyn]);
 481 #endif
 482         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 483         {
 484             goto yyoverflow;
 485         }
 486         yystate = yytable[yyn];
 487         *++yystack.s_mark = yytable[yyn];
 488         *++yystack.l_mark = yylval;
 489         yychar = YYEMPTY;
 490         if (yyerrflag > 0)  --yyerrflag;
 491         goto yyloop;
 492     }
 493     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 494             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 495     {
 496         yyn = yytable[yyn];
 497         goto yyreduce;
 498     }
 499     if (yyerrflag) goto yyinrecovery;
 500
 501     yyerror("syntax error");
 502
 503     goto yyerrlab;
 504
 505 yyerrlab:
 506     ++yynerrs;
 507
 508 yyinrecovery:
 509     if (yyerrflag < 3)
 510     {
 511         yyerrflag = 3;
 512         for (;;)
 513         {
 514             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
 515                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 516             {
 517 #if YYDEBUG
 518                 if (yydebug)
 519                     printf("%sdebug: state %d, error recovery shifting\
 520  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
 521 #endif
 522                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 523                 {
 524                     goto yyoverflow;
 525                 }
 526                 yystate = yytable[yyn];
 527                 *++yystack.s_mark = yytable[yyn];
 528                 *++yystack.l_mark = yylval;
 529                 goto yyloop;
 530             }
 531             else
 532             {
 533 #if YYDEBUG
 534                 if (yydebug)
 535                     printf("%sdebug: error recovery discarding state %d\n",
 536                             YYPREFIX, *yystack.s_mark);
 537 #endif
 538                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
 539                 --yystack.s_mark;
 540                 --yystack.l_mark;
 541             }
 542         }
 543     }
 544     else
 545     {
 546         if (yychar == 0) goto yyabort;
 547 #if YYDEBUG
 548         if (yydebug)
 549         {
 550             yys = 0;
 551             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 552             if (!yys) yys = "illegal-symbol";
 553             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 554                     YYPREFIX, yystate, yychar, yys);
 555         }
 556 #endif
 557         yychar = YYEMPTY;
 558         goto yyloop;
 559     }
 560
 561 yyreduce:
 562 #if YYDEBUG
 563     if (yydebug)
 564         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 565                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 566 #endif
 567     yym = yylen[yyn];
 568     if (yym)
 569         yyval = yystack.l_mark[1-yym];
 570     else
 571         memset(&yyval, 0, sizeof yyval);
 572     switch (yyn)
 573     {
 574 case 3:
 575 #line 35 "quote_calc.y"
 576         {  yyerrok ; }
 577 break;
 578 case 4:
 579 #line 39 "quote_calc.y"
 580         {  printf("%d\n",yystack.l_mark[0]);}
 581 break;
 582 case 5:
 583 #line 41 "quote_calc.y"
 584         {  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
 585 break;
 586 case 6:
 587 #line 45 "quote_calc.y"
 588         {  yyval = yystack.l_mark[-1]; }
 589 break;
 590 case 7:
 591 #line 47 "quote_calc.y"
 592         {  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
 593 break;
 594 case 8:
 595 #line 49 "quote_calc.y"
 596         {  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
 597 break;
 598 case 9:
 599 #line 51 "quote_calc.y"
 600         {  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
 601 break;
 602 case 10:
 603 #line 53 "quote_calc.y"
 604         {  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
 605 break;
 606 case 11:
 607 #line 55 "quote_calc.y"
 608         {  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
 609 break;
 610 case 12:
 611 #line 57 "quote_calc.y"
 612         {  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
 613 break;
 614 case 13:
 615 #line 59 "quote_calc.y"
 616         {  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
 617 break;
 618 case 14:
 619 #line 61 "quote_calc.y"
 620         {  yyval = - yystack.l_mark[0]; }
 621 break;
 622 case 15:
 623 #line 63 "quote_calc.y"
 624         {  yyval = regs[yystack.l_mark[0]]; }
 625 break;
 626 case 17:
 627 #line 68 "quote_calc.y"
 628         {  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
 629 break;
 630 case 18:
 631 #line 70 "quote_calc.y"
 632         {  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
 633 break;
 634 #line 633 "quote_calc.tab.c"
 635     }
 636     yystack.s_mark -= yym;
 637     yystate = *yystack.s_mark;
 638     yystack.l_mark -= yym;
 639     yym = yylhs[yyn];
 640     if (yystate == 0 && yym == 0)
 641     {
 642 #if YYDEBUG
 643         if (yydebug)
 644             printf("%sdebug: after reduction, shifting from state 0 to\
 645  state %d\n", YYPREFIX, YYFINAL);
 646 #endif
 647         yystate = YYFINAL;
 648         *++yystack.s_mark = YYFINAL;
 649         *++yystack.l_mark = yyval;
 650         if (yychar < 0)
 651         {
 652             if ((yychar = YYLEX) < 0) yychar = 0;
 653 #if YYDEBUG
 654             if (yydebug)
 655             {
 656                 yys = 0;
 657                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 658                 if (!yys) yys = "illegal-symbol";
 659                 printf("%sdebug: state %d, reading %d (%s)\n",
 660                         YYPREFIX, YYFINAL, yychar, yys);
 661             }
 662 #endif
 663         }
 664         if (yychar == 0) goto yyaccept;
 665         goto yyloop;
 666     }
 667     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 668             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 669         yystate = yytable[yyn];
 670     else
 671         yystate = yydgoto[yym];
 672 #if YYDEBUG
 673     if (yydebug)
 674         printf("%sdebug: after reduction, shifting from state %d \
 675 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
 676 #endif
 677     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
 678     {
 679         goto yyoverflow;
 680     }
 681     *++yystack.s_mark = (short) yystate;
 682     *++yystack.l_mark = yyval;
 683     goto yyloop;
 684
 685 yyoverflow:
 686     yyerror("yacc stack overflow");
 687
 688 yyabort:
 689     yyfreestack(&yystack);
 690     return (1);
 691
 692 yyaccept:
 693     yyfreestack(&yystack);
 694     return (0);
 695 }