Home | History | Annotate | Line # | Download | only in yacc
ok_syntax1.tab.c revision 1.1.1.7 
      1 /*	$NetBSD: ok_syntax1.tab.c,v 1.1.1.7 2021/02/20 20:30:07 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 #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 #if YYDEBUG
    312 int      yydebug;
    313 #endif
    314 
    315 /* define the initial stack-sizes */
    316 #ifdef YYSTACKSIZE
    317 #undef YYMAXDEPTH
    318 #define YYMAXDEPTH  YYSTACKSIZE
    319 #else
    320 #ifdef YYMAXDEPTH
    321 #define YYSTACKSIZE YYMAXDEPTH
    322 #else
    323 #define YYSTACKSIZE 10000
    324 #define YYMAXDEPTH  10000
    325 #endif
    326 #endif
    327 
    328 #define YYINITSTACKSIZE 200
    329 
    330 typedef struct {
    331     unsigned stacksize;
    332     YYINT    *s_base;
    333     YYINT    *s_mark;
    334     YYINT    *s_last;
    335     YYSTYPE  *l_base;
    336     YYSTYPE  *l_mark;
    337 } YYSTACKDATA;
    338 #line 104 "ok_syntax1.y"
    339  /* start of programs */
    340 
    341 #ifdef YYBYACC
    342 extern int YYLEX_DECL();
    343 #endif
    344 
    345 int
    346 main (void)
    347 {
    348     int regs[26];
    349     int base = 10;
    350 
    351     while(!feof(stdin)) {
    352 	yyparse(regs, &base);
    353     }
    354     return 0;
    355 }
    356 
    357 #define UNUSED(x) ((void)(x))
    358 
    359 static void
    360 YYERROR_DECL()
    361 {
    362     UNUSED(regs); /* %parse-param regs is not actually used here */
    363     UNUSED(base); /* %parse-param base is not actually used here */
    364     fprintf(stderr, "%s\n", s);
    365 }
    366 
    367 int
    368 YYLEX_DECL()
    369 {
    370 	/* lexical analysis routine */
    371 	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
    372 	/* return DIGIT for a digit, yylval = 0 through 9 */
    373 	/* all other characters are returned immediately */
    374 
    375     int c;
    376 
    377     while( (c=getchar()) == ' ' )   { /* skip blanks */ }
    378 
    379     /* c is now nonblank */
    380 
    381     if( islower( c )) {
    382 	yylval->ival = (c - 'a');
    383 	return ( LETTER );
    384     }
    385     if( isdigit( c )) {
    386 	yylval->ival = (c - '0') % (*base);
    387 	return ( DIGIT );
    388     }
    389     return( c );
    390 }
    391 #line 390 "ok_syntax1.tab.c"
    392 
    393 #if YYDEBUG
    394 #include <stdio.h>	/* needed for printf */
    395 #endif
    396 
    397 #include <stdlib.h>	/* needed for malloc, etc */
    398 #include <string.h>	/* needed for memset */
    399 
    400 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
    401 static int yygrowstack(YYSTACKDATA *data)
    402 {
    403     int i;
    404     unsigned newsize;
    405     YYINT *newss;
    406     YYSTYPE *newvs;
    407 
    408     if ((newsize = data->stacksize) == 0)
    409         newsize = YYINITSTACKSIZE;
    410     else if (newsize >= YYMAXDEPTH)
    411         return YYENOMEM;
    412     else if ((newsize *= 2) > YYMAXDEPTH)
    413         newsize = YYMAXDEPTH;
    414 
    415     i = (int) (data->s_mark - data->s_base);
    416     newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
    417     if (newss == 0)
    418         return YYENOMEM;
    419 
    420     data->s_base = newss;
    421     data->s_mark = newss + i;
    422 
    423     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
    424     if (newvs == 0)
    425         return YYENOMEM;
    426 
    427     data->l_base = newvs;
    428     data->l_mark = newvs + i;
    429 
    430     data->stacksize = newsize;
    431     data->s_last = data->s_base + newsize - 1;
    432     return 0;
    433 }
    434 
    435 #if YYPURE || defined(YY_NO_LEAKS)
    436 static void yyfreestack(YYSTACKDATA *data)
    437 {
    438     free(data->s_base);
    439     free(data->l_base);
    440     memset(data, 0, sizeof(*data));
    441 }
    442 #else
    443 #define yyfreestack(data) /* nothing */
    444 #endif
    445 
    446 #define YYABORT  goto yyabort
    447 #define YYREJECT goto yyabort
    448 #define YYACCEPT goto yyaccept
    449 #define YYERROR  goto yyerrlab
    450 
    451 int
    452 YYPARSE_DECL()
    453 {
    454     int      yyerrflag;
    455     int      yychar;
    456     YYSTYPE  yyval;
    457     YYSTYPE  yylval;
    458     int      yynerrs;
    459 
    460     /* variables for the parser stack */
    461     YYSTACKDATA yystack;
    462     int yym, yyn, yystate;
    463 #if YYDEBUG
    464     const char *yys;
    465 
    466     if ((yys = getenv("YYDEBUG")) != 0)
    467     {
    468         yyn = *yys;
    469         if (yyn >= '0' && yyn <= '9')
    470             yydebug = yyn - '0';
    471     }
    472 #endif
    473 
    474     memset(&yyval,  0, sizeof(yyval));
    475     memset(&yylval, 0, sizeof(yylval));
    476 
    477     yym = 0;
    478     yyn = 0;
    479     yynerrs = 0;
    480     yyerrflag = 0;
    481     yychar = YYEMPTY;
    482     yystate = 0;
    483 
    484 #if YYPURE
    485     memset(&yystack, 0, sizeof(yystack));
    486 #endif
    487 
    488     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    489     yystack.s_mark = yystack.s_base;
    490     yystack.l_mark = yystack.l_base;
    491     yystate = 0;
    492     *yystack.s_mark = 0;
    493 
    494 yyloop:
    495     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    496     if (yychar < 0)
    497     {
    498         yychar = YYLEX;
    499         if (yychar < 0) yychar = YYEOF;
    500 #if YYDEBUG
    501         if (yydebug)
    502         {
    503             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    504             printf("%sdebug: state %d, reading %d (%s)\n",
    505                     YYPREFIX, yystate, yychar, yys);
    506         }
    507 #endif
    508     }
    509     if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
    510             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
    511     {
    512 #if YYDEBUG
    513         if (yydebug)
    514             printf("%sdebug: state %d, shifting to state %d\n",
    515                     YYPREFIX, yystate, yytable[yyn]);
    516 #endif
    517         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    518         yystate = yytable[yyn];
    519         *++yystack.s_mark = yytable[yyn];
    520         *++yystack.l_mark = yylval;
    521         yychar = YYEMPTY;
    522         if (yyerrflag > 0)  --yyerrflag;
    523         goto yyloop;
    524     }
    525     if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
    526             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
    527     {
    528         yyn = yytable[yyn];
    529         goto yyreduce;
    530     }
    531     if (yyerrflag != 0) goto yyinrecovery;
    532 
    533     YYERROR_CALL("syntax error");
    534 
    535     goto yyerrlab; /* redundant goto avoids 'unused label' warning */
    536 yyerrlab:
    537     ++yynerrs;
    538 
    539 yyinrecovery:
    540     if (yyerrflag < 3)
    541     {
    542         yyerrflag = 3;
    543         for (;;)
    544         {
    545             if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
    546                     yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
    547             {
    548 #if YYDEBUG
    549                 if (yydebug)
    550                     printf("%sdebug: state %d, error recovery shifting\
    551  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
    552 #endif
    553                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    554                 yystate = yytable[yyn];
    555                 *++yystack.s_mark = yytable[yyn];
    556                 *++yystack.l_mark = yylval;
    557                 goto yyloop;
    558             }
    559             else
    560             {
    561 #if YYDEBUG
    562                 if (yydebug)
    563                     printf("%sdebug: error recovery discarding state %d\n",
    564                             YYPREFIX, *yystack.s_mark);
    565 #endif
    566                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
    567                 --yystack.s_mark;
    568                 --yystack.l_mark;
    569             }
    570         }
    571     }
    572     else
    573     {
    574         if (yychar == YYEOF) goto yyabort;
    575 #if YYDEBUG
    576         if (yydebug)
    577         {
    578             if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    579             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
    580                     YYPREFIX, yystate, yychar, yys);
    581         }
    582 #endif
    583         yychar = YYEMPTY;
    584         goto yyloop;
    585     }
    586 
    587 yyreduce:
    588 #if YYDEBUG
    589     if (yydebug)
    590         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
    591                 YYPREFIX, yystate, yyn, yyrule[yyn]);
    592 #endif
    593     yym = yylen[yyn];
    594     if (yym > 0)
    595         yyval = yystack.l_mark[1-yym];
    596     else
    597         memset(&yyval, 0, sizeof yyval);
    598 
    599     switch (yyn)
    600     {
    601 case 3:
    602 #line 66 "ok_syntax1.y"
    603 	{  yyerrok ; }
    604 break;
    605 case 4:
    606 #line 70 "ok_syntax1.y"
    607 	{  printf("%d\n",yystack.l_mark[0].ival);}
    608 break;
    609 case 5:
    610 #line 72 "ok_syntax1.y"
    611 	{  regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
    612 break;
    613 case 6:
    614 #line 76 "ok_syntax1.y"
    615 	{  yyval.ival = yystack.l_mark[-1].ival; }
    616 break;
    617 case 7:
    618 #line 78 "ok_syntax1.y"
    619 	{  yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
    620 break;
    621 case 8:
    622 #line 80 "ok_syntax1.y"
    623 	{  yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
    624 break;
    625 case 9:
    626 #line 82 "ok_syntax1.y"
    627 	{  yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
    628 break;
    629 case 10:
    630 #line 84 "ok_syntax1.y"
    631 	{  yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
    632 break;
    633 case 11:
    634 #line 86 "ok_syntax1.y"
    635 	{  yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
    636 break;
    637 case 12:
    638 #line 88 "ok_syntax1.y"
    639 	{  yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
    640 break;
    641 case 13:
    642 #line 90 "ok_syntax1.y"
    643 	{  yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
    644 break;
    645 case 14:
    646 #line 92 "ok_syntax1.y"
    647 	{  yyval.ival = - yystack.l_mark[0].ival; }
    648 break;
    649 case 15:
    650 #line 94 "ok_syntax1.y"
    651 	{  yyval.ival = regs[yystack.l_mark[0].ival]; }
    652 break;
    653 case 17:
    654 #line 99 "ok_syntax1.y"
    655 	{  yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
    656 break;
    657 case 18:
    658 #line 101 "ok_syntax1.y"
    659 	{  yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
    660 break;
    661 #line 660 "ok_syntax1.tab.c"
    662     }
    663     yystack.s_mark -= yym;
    664     yystate = *yystack.s_mark;
    665     yystack.l_mark -= yym;
    666     yym = yylhs[yyn];
    667     if (yystate == 0 && yym == 0)
    668     {
    669 #if YYDEBUG
    670         if (yydebug)
    671             printf("%sdebug: after reduction, shifting from state 0 to\
    672  state %d\n", YYPREFIX, YYFINAL);
    673 #endif
    674         yystate = YYFINAL;
    675         *++yystack.s_mark = YYFINAL;
    676         *++yystack.l_mark = yyval;
    677         if (yychar < 0)
    678         {
    679             yychar = YYLEX;
    680             if (yychar < 0) yychar = YYEOF;
    681 #if YYDEBUG
    682             if (yydebug)
    683             {
    684                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
    685                 printf("%sdebug: state %d, reading %d (%s)\n",
    686                         YYPREFIX, YYFINAL, yychar, yys);
    687             }
    688 #endif
    689         }
    690         if (yychar == YYEOF) goto yyaccept;
    691         goto yyloop;
    692     }
    693     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
    694             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
    695         yystate = yytable[yyn];
    696     else
    697         yystate = yydgoto[yym];
    698 #if YYDEBUG
    699     if (yydebug)
    700         printf("%sdebug: after reduction, shifting from state %d \
    701 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
    702 #endif
    703     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    704     *++yystack.s_mark = (YYINT) yystate;
    705     *++yystack.l_mark = yyval;
    706     goto yyloop;
    707 
    708 yyoverflow:
    709     YYERROR_CALL("yacc stack overflow");
    710 
    711 yyabort:
    712     yyfreestack(&yystack);
    713     return (1);
    714 
    715 yyaccept:
    716     yyfreestack(&yystack);
    717     return (0);
    718 }
    719