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