Home | History | Annotate | Line # | Download | only in yacc
calc_code_top.tab.c revision 1.1 
      1 /*	$NetBSD: calc_code_top.tab.c,v 1.1 2021/02/20 20:30:08 christos Exp $	*/
      2 
      3 /* original parser id follows */
      4 /* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
      5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
      6 
      7 #define YYBYACC 1
      8 #define YYMAJOR 2
      9 #define YYMINOR 0
     10 #define YYCHECK "yyyymmdd"
     11 
     12 #define YYEMPTY        (-1)
     13 #define yyclearin      (yychar = YYEMPTY)
     14 #define yyerrok        (yyerrflag = 0)
     15 #define YYRECOVERING() (yyerrflag != 0)
     16 #define YYENOMEM       (-2)
     17 #define YYEOF          0
     18 
     19 /* %code "top" block start */
     20 #line 1 "calc_code_top.y"
     21 /* CODE-TOP */
     22 #line 2 "calc_code_top.y"
     23 /* CODE-TOP2 */
     24 /* %code "top" block end */
     25 #line 24 "calc_code_top.tab.c"
     26 
     27 #ifndef yyparse
     28 #define yyparse    calc_code_top_parse
     29 #endif /* yyparse */
     30 
     31 #ifndef yylex
     32 #define yylex      calc_code_top_lex
     33 #endif /* yylex */
     34 
     35 #ifndef yyerror
     36 #define yyerror    calc_code_top_error
     37 #endif /* yyerror */
     38 
     39 #ifndef yychar
     40 #define yychar     calc_code_top_char
     41 #endif /* yychar */
     42 
     43 #ifndef yyval
     44 #define yyval      calc_code_top_val
     45 #endif /* yyval */
     46 
     47 #ifndef yylval
     48 #define yylval     calc_code_top_lval
     49 #endif /* yylval */
     50 
     51 #ifndef yydebug
     52 #define yydebug    calc_code_top_debug
     53 #endif /* yydebug */
     54 
     55 #ifndef yynerrs
     56 #define yynerrs    calc_code_top_nerrs
     57 #endif /* yynerrs */
     58 
     59 #ifndef yyerrflag
     60 #define yyerrflag  calc_code_top_errflag
     61 #endif /* yyerrflag */
     62 
     63 #ifndef yylhs
     64 #define yylhs      calc_code_top_lhs
     65 #endif /* yylhs */
     66 
     67 #ifndef yylen
     68 #define yylen      calc_code_top_len
     69 #endif /* yylen */
     70 
     71 #ifndef yydefred
     72 #define yydefred   calc_code_top_defred
     73 #endif /* yydefred */
     74 
     75 #ifndef yydgoto
     76 #define yydgoto    calc_code_top_dgoto
     77 #endif /* yydgoto */
     78 
     79 #ifndef yysindex
     80 #define yysindex   calc_code_top_sindex
     81 #endif /* yysindex */
     82 
     83 #ifndef yyrindex
     84 #define yyrindex   calc_code_top_rindex
     85 #endif /* yyrindex */
     86 
     87 #ifndef yygindex
     88 #define yygindex   calc_code_top_gindex
     89 #endif /* yygindex */
     90 
     91 #ifndef yytable
     92 #define yytable    calc_code_top_table
     93 #endif /* yytable */
     94 
     95 #ifndef yycheck
     96 #define yycheck    calc_code_top_check
     97 #endif /* yycheck */
     98 
     99 #ifndef yyname
    100 #define yyname     calc_code_top_name
    101 #endif /* yyname */
    102 
    103 #ifndef yyrule
    104 #define yyrule     calc_code_top_rule
    105 #endif /* yyrule */
    106 #define YYPREFIX "calc_code_top_"
    107 
    108 #define YYPURE 0
    109 
    110 #line 5 "calc_code_top.y"
    111 # include <stdio.h>
    112 # include <ctype.h>
    113 
    114 int regs[26];
    115 int base;
    116 
    117 extern int yylex(void);
    118 static void yyerror(const char *s);
    119 
    120 #line 119 "calc_code_top.tab.c"
    121 
    122 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
    123 /* Default: YYSTYPE is the semantic value type. */
    124 typedef int YYSTYPE;
    125 # define YYSTYPE_IS_DECLARED 1
    126 #endif
    127 
    128 /* compatibility with bison */
    129 #ifdef YYPARSE_PARAM
    130 /* compatibility with FreeBSD */
    131 # ifdef YYPARSE_PARAM_TYPE
    132 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
    133 # else
    134 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
    135 # endif
    136 #else
    137 # define YYPARSE_DECL() yyparse(void)
    138 #endif
    139 
    140 /* Parameters sent to lex. */
    141 #ifdef YYLEX_PARAM
    142 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
    143 # define YYLEX yylex(YYLEX_PARAM)
    144 #else
    145 # define YYLEX_DECL() yylex(void)
    146 # define YYLEX yylex()
    147 #endif
    148 
    149 /* Parameters sent to yyerror. */
    150 #ifndef YYERROR_DECL
    151 #define YYERROR_DECL() yyerror(const char *s)
    152 #endif
    153 #ifndef YYERROR_CALL
    154 #define YYERROR_CALL(msg) yyerror(msg)
    155 #endif
    156 
    157 extern int YYPARSE_DECL();
    158 
    159 #define DIGIT 257
    160 #define LETTER 258
    161 #define UMINUS 259
    162 #define YYERRCODE 256
    163 typedef short YYINT;
    164 static const YYINT calc_code_top_lhs[] = {               -1,
    165     0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
    166     2,    2,    2,    2,    2,    2,    3,    3,
    167 };
    168 static const YYINT calc_code_top_len[] = {                2,
    169     0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
    170     3,    3,    3,    2,    1,    1,    1,    2,
    171 };
    172 static const YYINT calc_code_top_defred[] = {             1,
    173     0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
    174     0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
    175     0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
    176    10,   11,
    177 };
    178 static const YYINT calc_code_top_dgoto[] = {              1,
    179     7,    8,    9,
    180 };
    181 static const YYINT calc_code_top_sindex[] = {             0,
    182   -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
    183   -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
    184   -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
    185     0,    0,
    186 };
    187 static const YYINT calc_code_top_rindex[] = {             0,
    188     0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
    189     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    190     0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
    191     0,    0,
    192 };
    193 static const YYINT calc_code_top_gindex[] = {             0,
    194     0,   65,    0,
    195 };
    196 #define YYTABLESIZE 220
    197 static const YYINT calc_code_top_table[] = {              6,
    198    16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
    199    15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
    200     0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
    201     0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
    202     0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
    203     8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
    204     0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
    205    14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
    206    26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
    207     0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
    208     0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
    209     0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
    210     0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
    211     0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
    212     0,    0,    0,    0,    0,   16,    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,    0,    0,    0,
    219     0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
    220 };
    221 static const YYINT calc_code_top_check[] = {             40,
    222    10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
    223    10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
    224    -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
    225    -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
    226    -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
    227    38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
    228    -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
    229     6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
    230    16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
    231    -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
    232    -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
    233    -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
    234    -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
    235    -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
    236    -1,   -1,   -1,   -1,   -1,  124,   -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,   -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,  256,  257,  258,  257,  258,
    244 };
    245 #define YYFINAL 1
    246 #ifndef YYDEBUG
    247 #define YYDEBUG 0
    248 #endif
    249 #define YYMAXTOKEN 259
    250 #define YYUNDFTOKEN 265
    251 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
    252 #if YYDEBUG
    253 static const char *const calc_code_top_name[] = {
    254 
    255 "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,
    256 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,
    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,0,0,0,0,0,0,0,0,0,0,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,"DIGIT","LETTER","UMINUS",0,0,0,0,0,"illegal-symbol",
    263 };
    264 static const char *const calc_code_top_rule[] = {
    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 '+' expr",
    273 "expr : expr '-' expr",
    274 "expr : expr '*' expr",
    275 "expr : expr '/' expr",
    276 "expr : expr '%' expr",
    277 "expr : expr '&' expr",
    278 "expr : expr '|' expr",
    279 "expr : '-' expr",
    280 "expr : LETTER",
    281 "expr : number",
    282 "number : DIGIT",
    283 "number : number DIGIT",
    284 
    285 };
    286 #endif
    287 
    288 #if YYDEBUG
    289 int      yydebug;
    290 #endif
    291 
    292 int      yyerrflag;
    293 int      yychar;
    294 YYSTYPE  yyval;
    295 YYSTYPE  yylval;
    296 int      yynerrs;
    297 
    298 /* define the initial stack-sizes */
    299 #ifdef YYSTACKSIZE
    300 #undef YYMAXDEPTH
    301 #define YYMAXDEPTH  YYSTACKSIZE
    302 #else
    303 #ifdef YYMAXDEPTH
    304 #define YYSTACKSIZE YYMAXDEPTH
    305 #else
    306 #define YYSTACKSIZE 10000
    307 #define YYMAXDEPTH  10000
    308 #endif
    309 #endif
    310 
    311 #define YYINITSTACKSIZE 200
    312 
    313 typedef struct {
    314     unsigned stacksize;
    315     YYINT    *s_base;
    316     YYINT    *s_mark;
    317     YYINT    *s_last;
    318     YYSTYPE  *l_base;
    319     YYSTYPE  *l_mark;
    320 } YYSTACKDATA;
    321 /* variables for the parser stack */
    322 static YYSTACKDATA yystack;
    323 #line 69 "calc_code_top.y"
    324  /* start of programs */
    325 
    326 int
    327 main (void)
    328 {
    329     while(!feof(stdin)) {
    330 	yyparse();
    331     }
    332     return 0;
    333 }
    334 
    335 static void
    336 yyerror(const char *s)
    337 {
    338     fprintf(stderr, "%s\n", s);
    339 }
    340 
    341 int
    342 yylex(void)
    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';
    361 	return ( DIGIT );
    362     }
    363     return( c );
    364 }
    365 #line 364 "calc_code_top.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 yym, yyn, yystate;
    429 #if YYDEBUG
    430     const char *yys;
    431 
    432     if ((yys = getenv("YYDEBUG")) != 0)
    433     {
    434         yyn = *yys;
    435         if (yyn >= '0' && yyn <= '9')
    436             yydebug = yyn - '0';
    437     }
    438 #endif
    439 
    440     yym = 0;
    441     yyn = 0;
    442     yynerrs = 0;
    443     yyerrflag = 0;
    444     yychar = YYEMPTY;
    445     yystate = 0;
    446 
    447 #if YYPURE
    448     memset(&yystack, 0, sizeof(yystack));
    449 #endif
    450 
    451     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    452     yystack.s_mark = yystack.s_base;
    453     yystack.l_mark = yystack.l_base;
    454     yystate = 0;
    455     *yystack.s_mark = 0;
    456 
    457 yyloop:
    458     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    459     if (yychar < 0)
    460     {
    461         yychar = YYLEX;
    462         if (yychar < 0) yychar = YYEOF;
    463 #if YYDEBUG
    464         if (yydebug)
    465         {
    466             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    467             printf("%sdebug: state %d, reading %d (%s)\n",
    468                     YYPREFIX, yystate, yychar, yys);
    469         }
    470 #endif
    471     }
    472     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
    473             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) 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) goto yyoverflow;
    481         yystate = yytable[yyn];
    482         *++yystack.s_mark = yytable[yyn];
    483         *++yystack.l_mark = yylval;
    484         yychar = YYEMPTY;
    485         if (yyerrflag > 0)  --yyerrflag;
    486         goto yyloop;
    487     }
    488     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
    489             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
    490     {
    491         yyn = yytable[yyn];
    492         goto yyreduce;
    493     }
    494     if (yyerrflag != 0) goto yyinrecovery;
    495 
    496     YYERROR_CALL("syntax error");
    497 
    498     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
    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]) != 0) && (yyn += YYERRCODE) >= 0 &&
    509                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) 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) == YYENOMEM) goto yyoverflow;
    517                 yystate = yytable[yyn];
    518                 *++yystack.s_mark = yytable[yyn];
    519                 *++yystack.l_mark = yylval;
    520                 goto yyloop;
    521             }
    522             else
    523             {
    524 #if YYDEBUG
    525                 if (yydebug)
    526                     printf("%sdebug: error recovery discarding state %d\n",
    527                             YYPREFIX, *yystack.s_mark);
    528 #endif
    529                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
    530                 --yystack.s_mark;
    531                 --yystack.l_mark;
    532             }
    533         }
    534     }
    535     else
    536     {
    537         if (yychar == YYEOF) goto yyabort;
    538 #if YYDEBUG
    539         if (yydebug)
    540         {
    541             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    542             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
    543                     YYPREFIX, yystate, yychar, yys);
    544         }
    545 #endif
    546         yychar = YYEMPTY;
    547         goto yyloop;
    548     }
    549 
    550 yyreduce:
    551 #if YYDEBUG
    552     if (yydebug)
    553         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
    554                 YYPREFIX, yystate, yyn, yyrule[yyn]);
    555 #endif
    556     yym = yylen[yyn];
    557     if (yym > 0)
    558         yyval = yystack.l_mark[1-yym];
    559     else
    560         memset(&yyval, 0, sizeof yyval);
    561 
    562     switch (yyn)
    563     {
    564 case 3:
    565 #line 31 "calc_code_top.y"
    566 	{  yyerrok ; }
    567 break;
    568 case 4:
    569 #line 35 "calc_code_top.y"
    570 	{  printf("%d\n",yystack.l_mark[0]);}
    571 break;
    572 case 5:
    573 #line 37 "calc_code_top.y"
    574 	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
    575 break;
    576 case 6:
    577 #line 41 "calc_code_top.y"
    578 	{  yyval = yystack.l_mark[-1]; }
    579 break;
    580 case 7:
    581 #line 43 "calc_code_top.y"
    582 	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
    583 break;
    584 case 8:
    585 #line 45 "calc_code_top.y"
    586 	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
    587 break;
    588 case 9:
    589 #line 47 "calc_code_top.y"
    590 	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
    591 break;
    592 case 10:
    593 #line 49 "calc_code_top.y"
    594 	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
    595 break;
    596 case 11:
    597 #line 51 "calc_code_top.y"
    598 	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
    599 break;
    600 case 12:
    601 #line 53 "calc_code_top.y"
    602 	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
    603 break;
    604 case 13:
    605 #line 55 "calc_code_top.y"
    606 	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
    607 break;
    608 case 14:
    609 #line 57 "calc_code_top.y"
    610 	{  yyval = - yystack.l_mark[0]; }
    611 break;
    612 case 15:
    613 #line 59 "calc_code_top.y"
    614 	{  yyval = regs[yystack.l_mark[0]]; }
    615 break;
    616 case 17:
    617 #line 64 "calc_code_top.y"
    618 	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
    619 break;
    620 case 18:
    621 #line 66 "calc_code_top.y"
    622 	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
    623 break;
    624 #line 623 "calc_code_top.tab.c"
    625     }
    626     yystack.s_mark -= yym;
    627     yystate = *yystack.s_mark;
    628     yystack.l_mark -= yym;
    629     yym = yylhs[yyn];
    630     if (yystate == 0 && yym == 0)
    631     {
    632 #if YYDEBUG
    633         if (yydebug)
    634             printf("%sdebug: after reduction, shifting from state 0 to\
    635  state %d\n", YYPREFIX, YYFINAL);
    636 #endif
    637         yystate = YYFINAL;
    638         *++yystack.s_mark = YYFINAL;
    639         *++yystack.l_mark = yyval;
    640         if (yychar < 0)
    641         {
    642             yychar = YYLEX;
    643             if (yychar < 0) yychar = YYEOF;
    644 #if YYDEBUG
    645             if (yydebug)
    646             {
    647                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    648                 printf("%sdebug: state %d, reading %d (%s)\n",
    649                         YYPREFIX, YYFINAL, yychar, yys);
    650             }
    651 #endif
    652         }
    653         if (yychar == YYEOF) goto yyaccept;
    654         goto yyloop;
    655     }
    656     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
    657             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
    658         yystate = yytable[yyn];
    659     else
    660         yystate = yydgoto[yym];
    661 #if YYDEBUG
    662     if (yydebug)
    663         printf("%sdebug: after reduction, shifting from state %d \
    664 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
    665 #endif
    666     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    667     *++yystack.s_mark = (YYINT) yystate;
    668     *++yystack.l_mark = yyval;
    669     goto yyloop;
    670 
    671 yyoverflow:
    672     YYERROR_CALL("yacc stack overflow");
    673 
    674 yyabort:
    675     yyfreestack(&yystack);
    676     return (1);
    677 
    678 yyaccept:
    679     yyfreestack(&yystack);
    680     return (0);
    681 }
    682