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