ok_syntax1.tab.c revision 277086 
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)
109int YYLEX_DECL();
110static 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
120typedef 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
162extern 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
181typedef int YYINT;
182static 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};
186static 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};
190static 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};
196static const YYINT ok_syntax1_dgoto[] = {                 1,
197    7,    8,    9,
198};
199static 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};
205static 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};
211static const YYINT ok_syntax1_gindex[] = {                0,
212    0,   65,    0,
213};
214#define YYTABLESIZE 220
215static 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};
239static 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
271static 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,
2760,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'^'",0,0,0,0,0,0,0,0,0,0,
2770,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,
2780,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2790,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2800,0,0,0,0,0,0,0,0,0,0,0,0,0,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,
2830,0,0,0,"illegal-symbol",
284};
285static 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
309int      yydebug;
310int      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
327typedef 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
339extern int YYLEX_DECL();
340#endif
341
342int
343main (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
356static void
357YYERROR_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
364int
365YYLEX_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 */
398static 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)
433static 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
448int
449YYPARSE_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
485yyloop:
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
530yyerrlab:
531    ++yynerrs;
532
533yyinrecovery:
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
584yyreduce:
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    {
597case 3:
598#line 66 "ok_syntax1.y"
599	{  yyerrok ; }
600break;
601case 4:
602#line 70 "ok_syntax1.y"
603	{  printf("%d\n",yystack.l_mark[0].ival);}
604break;
605case 5:
606#line 72 "ok_syntax1.y"
607	{  regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
608break;
609case 6:
610#line 76 "ok_syntax1.y"
611	{  yyval.ival = yystack.l_mark[-1].ival; }
612break;
613case 7:
614#line 78 "ok_syntax1.y"
615	{  yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
616break;
617case 8:
618#line 80 "ok_syntax1.y"
619	{  yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
620break;
621case 9:
622#line 82 "ok_syntax1.y"
623	{  yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
624break;
625case 10:
626#line 84 "ok_syntax1.y"
627	{  yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
628break;
629case 11:
630#line 86 "ok_syntax1.y"
631	{  yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
632break;
633case 12:
634#line 88 "ok_syntax1.y"
635	{  yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
636break;
637case 13:
638#line 90 "ok_syntax1.y"
639	{  yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
640break;
641case 14:
642#line 92 "ok_syntax1.y"
643	{  yyval.ival = - yystack.l_mark[0].ival; }
644break;
645case 15:
646#line 94 "ok_syntax1.y"
647	{  yyval.ival = regs[yystack.l_mark[0].ival]; }
648break;
649case 17:
650#line 99 "ok_syntax1.y"
651	{  yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
652break;
653case 18:
654#line 101 "ok_syntax1.y"
655	{  yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
656break;
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 \
696to 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
706yyoverflow:
707    YYERROR_CALL("yacc stack overflow");
708
709yyabort:
710    yyfreestack(&yystack);
711    return (1);
712
713yyaccept:
714    yyfreestack(&yystack);
715    return (0);
716}
717