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