Home | History | Annotate | Line # | Download | only in yacc
ok_syntax1.tab.c revision 1.1.1.3 
      1 /*	$NetBSD: ok_syntax1.tab.c,v 1.1.1.3 2016/01/09 21:59:45 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 #line 43 "ok_syntax1.y"
    116 #ifdef YYSTYPE
    117 #undef  YYSTYPE_IS_DECLARED
    118 #define YYSTYPE_IS_DECLARED 1
    119 #endif
    120 #ifndef YYSTYPE_IS_DECLARED
    121 #define YYSTYPE_IS_DECLARED 1
    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     yynerrs = 0;
    473     yyerrflag = 0;
    474     yychar = YYEMPTY;
    475     yystate = 0;
    476 
    477 #if YYPURE
    478     memset(&yystack, 0, sizeof(yystack));
    479 #endif
    480 
    481     if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
    482     yystack.s_mark = yystack.s_base;
    483     yystack.l_mark = yystack.l_base;
    484     yystate = 0;
    485     *yystack.s_mark = 0;
    486 
    487 yyloop:
    488     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    489     if (yychar < 0)
    490     {
    491         if ((yychar = YYLEX) < 0) yychar = YYEOF;
    492 #if YYDEBUG
    493         if (yydebug)
    494         {
    495             yys = yyname[YYTRANSLATE(yychar)];
    496             printf("%sdebug: state %d, reading %d (%s)\n",
    497                     YYPREFIX, yystate, yychar, yys);
    498         }
    499 #endif
    500     }
    501     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
    502             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    503     {
    504 #if YYDEBUG
    505         if (yydebug)
    506             printf("%sdebug: state %d, shifting to state %d\n",
    507                     YYPREFIX, yystate, yytable[yyn]);
    508 #endif
    509         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
    510         {
    511             goto yyoverflow;
    512         }
    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]) && (yyn += yychar) >= 0 &&
    521             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    522     {
    523         yyn = yytable[yyn];
    524         goto yyreduce;
    525     }
    526     if (yyerrflag) goto yyinrecovery;
    527 
    528     YYERROR_CALL("syntax error");
    529 
    530     goto yyerrlab;
    531 
    532 yyerrlab:
    533     ++yynerrs;
    534 
    535 yyinrecovery:
    536     if (yyerrflag < 3)
    537     {
    538         yyerrflag = 3;
    539         for (;;)
    540         {
    541             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
    542                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
    543             {
    544 #if YYDEBUG
    545                 if (yydebug)
    546                     printf("%sdebug: state %d, error recovery shifting\
    547  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
    548 #endif
    549                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
    550                 {
    551                     goto yyoverflow;
    552                 }
    553                 yystate = yytable[yyn];
    554                 *++yystack.s_mark = yytable[yyn];
    555                 *++yystack.l_mark = yylval;
    556                 goto yyloop;
    557             }
    558             else
    559             {
    560 #if YYDEBUG
    561                 if (yydebug)
    562                     printf("%sdebug: error recovery discarding state %d\n",
    563                             YYPREFIX, *yystack.s_mark);
    564 #endif
    565                 if (yystack.s_mark <= yystack.s_base) goto yyabort;
    566                 --yystack.s_mark;
    567                 --yystack.l_mark;
    568             }
    569         }
    570     }
    571     else
    572     {
    573         if (yychar == YYEOF) goto yyabort;
    574 #if YYDEBUG
    575         if (yydebug)
    576         {
    577             yys = yyname[YYTRANSLATE(yychar)];
    578             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
    579                     YYPREFIX, yystate, yychar, yys);
    580         }
    581 #endif
    582         yychar = YYEMPTY;
    583         goto yyloop;
    584     }
    585 
    586 yyreduce:
    587 #if YYDEBUG
    588     if (yydebug)
    589         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
    590                 YYPREFIX, yystate, yyn, yyrule[yyn]);
    591 #endif
    592     yym = yylen[yyn];
    593     if (yym)
    594         yyval = yystack.l_mark[1-yym];
    595     else
    596         memset(&yyval, 0, sizeof yyval);
    597     switch (yyn)
    598     {
    599 case 3:
    600 #line 66 "ok_syntax1.y"
    601 	{  yyerrok ; }
    602 break;
    603 case 4:
    604 #line 70 "ok_syntax1.y"
    605 	{  printf("%d\n",yystack.l_mark[0].ival);}
    606 break;
    607 case 5:
    608 #line 72 "ok_syntax1.y"
    609 	{  regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
    610 break;
    611 case 6:
    612 #line 76 "ok_syntax1.y"
    613 	{  yyval.ival = yystack.l_mark[-1].ival; }
    614 break;
    615 case 7:
    616 #line 78 "ok_syntax1.y"
    617 	{  yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
    618 break;
    619 case 8:
    620 #line 80 "ok_syntax1.y"
    621 	{  yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
    622 break;
    623 case 9:
    624 #line 82 "ok_syntax1.y"
    625 	{  yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
    626 break;
    627 case 10:
    628 #line 84 "ok_syntax1.y"
    629 	{  yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
    630 break;
    631 case 11:
    632 #line 86 "ok_syntax1.y"
    633 	{  yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
    634 break;
    635 case 12:
    636 #line 88 "ok_syntax1.y"
    637 	{  yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
    638 break;
    639 case 13:
    640 #line 90 "ok_syntax1.y"
    641 	{  yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
    642 break;
    643 case 14:
    644 #line 92 "ok_syntax1.y"
    645 	{  yyval.ival = - yystack.l_mark[0].ival; }
    646 break;
    647 case 15:
    648 #line 94 "ok_syntax1.y"
    649 	{  yyval.ival = regs[yystack.l_mark[0].ival]; }
    650 break;
    651 case 17:
    652 #line 99 "ok_syntax1.y"
    653 	{  yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
    654 break;
    655 case 18:
    656 #line 101 "ok_syntax1.y"
    657 	{  yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
    658 break;
    659 #line 658 "ok_syntax1.tab.c"
    660     }
    661     yystack.s_mark -= yym;
    662     yystate = *yystack.s_mark;
    663     yystack.l_mark -= yym;
    664     yym = yylhs[yyn];
    665     if (yystate == 0 && yym == 0)
    666     {
    667 #if YYDEBUG
    668         if (yydebug)
    669             printf("%sdebug: after reduction, shifting from state 0 to\
    670  state %d\n", YYPREFIX, YYFINAL);
    671 #endif
    672         yystate = YYFINAL;
    673         *++yystack.s_mark = YYFINAL;
    674         *++yystack.l_mark = yyval;
    675         if (yychar < 0)
    676         {
    677             if ((yychar = YYLEX) < 0) yychar = YYEOF;
    678 #if YYDEBUG
    679             if (yydebug)
    680             {
    681                 yys = yyname[YYTRANSLATE(yychar)];
    682                 printf("%sdebug: state %d, reading %d (%s)\n",
    683                         YYPREFIX, YYFINAL, yychar, yys);
    684             }
    685 #endif
    686         }
    687         if (yychar == YYEOF) goto yyaccept;
    688         goto yyloop;
    689     }
    690     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
    691             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
    692         yystate = yytable[yyn];
    693     else
    694         yystate = yydgoto[yym];
    695 #if YYDEBUG
    696     if (yydebug)
    697         printf("%sdebug: after reduction, shifting from state %d \
    698 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
    699 #endif
    700     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
    701     {
    702         goto yyoverflow;
    703     }
    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