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#undef YYBTYACC
17#define YYBTYACC 0
18#define YYDEBUGSTR YYPREFIX "debug"
19
20#ifndef yyparse
21#define yyparse    calc3_parse
22#endif /* yyparse */
23
24#ifndef yylex
25#define yylex      calc3_lex
26#endif /* yylex */
27
28#ifndef yyerror
29#define yyerror    calc3_error
30#endif /* yyerror */
31
32#ifndef yychar
33#define yychar     calc3_char
34#endif /* yychar */
35
36#ifndef yyval
37#define yyval      calc3_val
38#endif /* yyval */
39
40#ifndef yylval
41#define yylval     calc3_lval
42#endif /* yylval */
43
44#ifndef yydebug
45#define yydebug    calc3_debug
46#endif /* yydebug */
47
48#ifndef yynerrs
49#define yynerrs    calc3_nerrs
50#endif /* yynerrs */
51
52#ifndef yyerrflag
53#define yyerrflag  calc3_errflag
54#endif /* yyerrflag */
55
56#ifndef yylhs
57#define yylhs      calc3_lhs
58#endif /* yylhs */
59
60#ifndef yylen
61#define yylen      calc3_len
62#endif /* yylen */
63
64#ifndef yydefred
65#define yydefred   calc3_defred
66#endif /* yydefred */
67
68#ifndef yystos
69#define yystos     calc3_stos
70#endif /* yystos */
71
72#ifndef yydgoto
73#define yydgoto    calc3_dgoto
74#endif /* yydgoto */
75
76#ifndef yysindex
77#define yysindex   calc3_sindex
78#endif /* yysindex */
79
80#ifndef yyrindex
81#define yyrindex   calc3_rindex
82#endif /* yyrindex */
83
84#ifndef yygindex
85#define yygindex   calc3_gindex
86#endif /* yygindex */
87
88#ifndef yytable
89#define yytable    calc3_table
90#endif /* yytable */
91
92#ifndef yycheck
93#define yycheck    calc3_check
94#endif /* yycheck */
95
96#ifndef yyname
97#define yyname     calc3_name
98#endif /* yyname */
99
100#ifndef yyrule
101#define yyrule     calc3_rule
102#endif /* yyrule */
103
104#if YYBTYACC
105
106#ifndef yycindex
107#define yycindex   calc3_cindex
108#endif /* yycindex */
109
110#ifndef yyctable
111#define yyctable   calc3_ctable
112#endif /* yyctable */
113
114#endif /* YYBTYACC */
115
116#define YYPREFIX "calc3_"
117
118#define YYPURE 1
119
120#line 9 "calc3.y"
121# include <stdio.h>
122# include <ctype.h>
123
124#ifdef YYBISON
125#define YYSTYPE int
126#define YYLEX_PARAM base
127#define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
128#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
129int YYLEX_DECL();
130static void YYERROR_DECL();
131#endif
132
133#line 134 "calc3.tab.c"
134
135#if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
136/* Default: YYSTYPE is the semantic value type. */
137typedef int YYSTYPE;
138# define YYSTYPE_IS_DECLARED 1
139#endif
140
141/* compatibility with bison */
142#ifdef YYPARSE_PARAM
143/* compatibility with FreeBSD */
144# ifdef YYPARSE_PARAM_TYPE
145#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
146# else
147#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
148# endif
149#else
150# define YYPARSE_DECL() yyparse(int regs[26], int *base)
151#endif
152
153/* Parameters sent to lex. */
154#ifdef YYLEX_PARAM
155# ifdef YYLEX_PARAM_TYPE
156#  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
157# else
158#  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
159# endif
160# define YYLEX yylex(&yylval, YYLEX_PARAM)
161#else
162# define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
163# define YYLEX yylex(&yylval, base)
164#endif
165
166/* Parameters sent to yyerror. */
167#ifndef YYERROR_DECL
168#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
169#endif
170#ifndef YYERROR_CALL
171#define YYERROR_CALL(msg) yyerror(regs, base, msg)
172#endif
173
174extern int YYPARSE_DECL();
175
176#define DIGIT 257
177#define LETTER 258
178#define UMINUS 259
179#define YYERRCODE 256
180typedef int YYINT;
181static const YYINT calc3_lhs[] = {                       -1,
182    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
183    2,    2,    2,    2,    2,    2,    3,    3,
184};
185static const YYINT calc3_len[] = {                        2,
186    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
187    3,    3,    3,    2,    1,    1,    1,    2,
188};
189static const YYINT calc3_defred[] = {                     1,
190    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
191    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
192    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
193   10,   11,
194};
195#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
196static const YYINT calc3_stos[] = {                       0,
197  261,  256,  257,  258,   45,   40,  262,  263,  264,   10,
198   61,  258,  263,  263,   10,  124,   38,   43,   45,   42,
199   47,   37,  257,  263,   41,  263,  263,  263,  263,  263,
200  263,  263,
201};
202#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
203static const YYINT calc3_dgoto[] = {                      1,
204    7,    8,    9,
205};
206static const YYINT calc3_sindex[] = {                     0,
207  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
208  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
209  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
210    0,    0,
211};
212static const YYINT calc3_rindex[] = {                     0,
213    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
214    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
215    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
216    0,    0,
217};
218#if YYBTYACC
219static const YYINT calc3_cindex[] = {                     0,
220    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
221    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
222    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
223    0,    0,
224};
225#endif
226static const YYINT calc3_gindex[] = {                     0,
227    0,   65,    0,
228};
229#define YYTABLESIZE 220
230static const YYINT calc3_table[] = {                      6,
231   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
232   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
233    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
234    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
235    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
236    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
237    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
238   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
239   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
240    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
241    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
242    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
243    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
244    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
245    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
246    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
247    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
248    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
249    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
250    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
251    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
252    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
253};
254static const YYINT calc3_check[] = {                     40,
255   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
256   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
257   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
258   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
259   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
260   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
261   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
262    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
263   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
264   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
265   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
266   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
267   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
268   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
269   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
270   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
271   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
272   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
273   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
274   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
275   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
276   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
277};
278#if YYBTYACC
279static const YYINT calc3_ctable[] = {                    -1,
280   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
281   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
282   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
283   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
284   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
285   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
286   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
287   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
288   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
289   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
290   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
291   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
292   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
293   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
294   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
295   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
296   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
297   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
298   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
299   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
300   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
301   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
302};
303#endif
304#define YYFINAL 1
305#ifndef YYDEBUG
306#define YYDEBUG 0
307#endif
308#define YYMAXTOKEN 259
309#define YYUNDFTOKEN 265
310#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
311#if YYDEBUG
312static const char *const calc3_name[] = {
313
314"$end",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3150,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
3160,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3170,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
3180,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3190,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3200,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3210,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
322"illegal-symbol",
323};
324static const char *const calc3_rule[] = {
325"$accept : list",
326"list :",
327"list : list stat '\\n'",
328"list : list error '\\n'",
329"stat : expr",
330"stat : LETTER '=' expr",
331"expr : '(' expr ')'",
332"expr : expr '+' expr",
333"expr : expr '-' expr",
334"expr : expr '*' expr",
335"expr : expr '/' expr",
336"expr : expr '%' expr",
337"expr : expr '&' expr",
338"expr : expr '|' expr",
339"expr : '-' expr",
340"expr : LETTER",
341"expr : number",
342"number : DIGIT",
343"number : number DIGIT",
344
345};
346#endif
347
348#if YYDEBUG
349int      yydebug;
350#endif
351
352#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
353#ifndef YYLLOC_DEFAULT
354#define YYLLOC_DEFAULT(loc, rhs, n) \
355do \
356{ \
357    if (n == 0) \
358    { \
359        (loc).first_line   = YYRHSLOC(rhs, 0).last_line; \
360        (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
361        (loc).last_line    = YYRHSLOC(rhs, 0).last_line; \
362        (loc).last_column  = YYRHSLOC(rhs, 0).last_column; \
363    } \
364    else \
365    { \
366        (loc).first_line   = YYRHSLOC(rhs, 1).first_line; \
367        (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
368        (loc).last_line    = YYRHSLOC(rhs, n).last_line; \
369        (loc).last_column  = YYRHSLOC(rhs, n).last_column; \
370    } \
371} while (0)
372#endif /* YYLLOC_DEFAULT */
373#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
374#if YYBTYACC
375
376#ifndef YYLVQUEUEGROWTH
377#define YYLVQUEUEGROWTH 32
378#endif
379#endif /* YYBTYACC */
380
381/* define the initial stack-sizes */
382#ifdef YYSTACKSIZE
383#undef YYMAXDEPTH
384#define YYMAXDEPTH  YYSTACKSIZE
385#else
386#ifdef YYMAXDEPTH
387#define YYSTACKSIZE YYMAXDEPTH
388#else
389#define YYSTACKSIZE 10000
390#define YYMAXDEPTH  10000
391#endif
392#endif
393
394#ifndef YYINITSTACKSIZE
395#define YYINITSTACKSIZE 200
396#endif
397
398typedef struct {
399    unsigned stacksize;
400    YYINT    *s_base;
401    YYINT    *s_mark;
402    YYINT    *s_last;
403    YYSTYPE  *l_base;
404    YYSTYPE  *l_mark;
405#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
406    YYLTYPE  *p_base;
407    YYLTYPE  *p_mark;
408#endif
409} YYSTACKDATA;
410#if YYBTYACC
411
412struct YYParseState_s
413{
414    struct YYParseState_s *save;    /* Previously saved parser state */
415    YYSTACKDATA            yystack; /* saved parser stack */
416    int                    state;   /* saved parser state */
417    int                    errflag; /* saved error recovery status */
418    int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
419    YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
420};
421typedef struct YYParseState_s YYParseState;
422#endif /* YYBTYACC */
423#line 76 "calc3.y"
424 /* start of programs */
425
426#ifdef YYBYACC
427extern int YYLEX_DECL();
428#endif
429
430int
431main (void)
432{
433    int regs[26];
434    int base = 10;
435
436    while(!feof(stdin)) {
437	yyparse(regs, &base);
438    }
439    return 0;
440}
441
442#define UNUSED(x) ((void)(x))
443
444static void
445YYERROR_DECL()
446{
447    UNUSED(regs); /* %parse-param regs is not actually used here */
448    UNUSED(base); /* %parse-param base is not actually used here */
449    fprintf(stderr, "%s\n", s);
450}
451
452int
453YYLEX_DECL()
454{
455	/* lexical analysis routine */
456	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
457	/* return DIGIT for a digit, yylval = 0 through 9 */
458	/* all other characters are returned immediately */
459
460    int c;
461
462    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
463
464    /* c is now nonblank */
465
466    if( islower( c )) {
467	*yylval = (c - 'a');
468	return ( LETTER );
469    }
470    if( isdigit( c )) {
471	*yylval = (c - '0') % (*base);
472	return ( DIGIT );
473    }
474    return( c );
475}
476#line 477 "calc3.tab.c"
477
478/* For use in generated program */
479#define yydepth (int)(yystack.s_mark - yystack.s_base)
480#if YYBTYACC
481#define yytrial (yyps->save)
482#endif /* YYBTYACC */
483
484#if YYDEBUG
485#include <stdio.h>	/* needed for printf */
486#endif
487
488#include <stdlib.h>	/* needed for malloc, etc */
489#include <string.h>	/* needed for memset */
490
491/* allocate initial stack or double stack size, up to YYMAXDEPTH */
492static int yygrowstack(YYSTACKDATA *data)
493{
494    int i;
495    unsigned newsize;
496    YYINT *newss;
497    YYSTYPE *newvs;
498#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
499    YYLTYPE *newps;
500#endif
501
502    if ((newsize = data->stacksize) == 0)
503        newsize = YYINITSTACKSIZE;
504    else if (newsize >= YYMAXDEPTH)
505        return YYENOMEM;
506    else if ((newsize *= 2) > YYMAXDEPTH)
507        newsize = YYMAXDEPTH;
508
509    i = (int) (data->s_mark - data->s_base);
510    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
511    if (newss == 0)
512        return YYENOMEM;
513
514    data->s_base = newss;
515    data->s_mark = newss + i;
516
517    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
518    if (newvs == 0)
519        return YYENOMEM;
520
521    data->l_base = newvs;
522    data->l_mark = newvs + i;
523
524#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
525    newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
526    if (newps == 0)
527        return YYENOMEM;
528
529    data->p_base = newps;
530    data->p_mark = newps + i;
531#endif
532
533    data->stacksize = newsize;
534    data->s_last = data->s_base + newsize - 1;
535
536#if YYDEBUG
537    if (yydebug)
538        fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
539#endif
540    return 0;
541}
542
543#if YYPURE || defined(YY_NO_LEAKS)
544static void yyfreestack(YYSTACKDATA *data)
545{
546    free(data->s_base);
547    free(data->l_base);
548#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
549    free(data->p_base);
550#endif
551    memset(data, 0, sizeof(*data));
552}
553#else
554#define yyfreestack(data) /* nothing */
555#endif /* YYPURE || defined(YY_NO_LEAKS) */
556#if YYBTYACC
557
558static YYParseState *
559yyNewState(unsigned size)
560{
561    YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
562    if (p == NULL) return NULL;
563
564    p->yystack.stacksize = size;
565    if (size == 0)
566    {
567        p->yystack.s_base = NULL;
568        p->yystack.l_base = NULL;
569#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
570        p->yystack.p_base = NULL;
571#endif
572        return p;
573    }
574    p->yystack.s_base    = (YYINT *) malloc(size * sizeof(YYINT));
575    if (p->yystack.s_base == NULL) return NULL;
576    p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
577    if (p->yystack.l_base == NULL) return NULL;
578    memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
579#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
580    p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
581    if (p->yystack.p_base == NULL) return NULL;
582    memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
583#endif
584
585    return p;
586}
587
588static void
589yyFreeState(YYParseState *p)
590{
591    yyfreestack(&p->yystack);
592    free(p);
593}
594#endif /* YYBTYACC */
595
596#define YYABORT  goto yyabort
597#define YYREJECT goto yyabort
598#define YYACCEPT goto yyaccept
599#define YYERROR  goto yyerrlab
600#if YYBTYACC
601#define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
602#define YYVALID_NESTED do { if (yyps->save && \
603                                yyps->save->save == 0) goto yyvalid; } while(0)
604#endif /* YYBTYACC */
605
606int
607YYPARSE_DECL()
608{
609    int      yyerrflag;
610    int      yychar;
611    YYSTYPE  yyval;
612    YYSTYPE  yylval;
613    int      yynerrs;
614
615#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
616    YYLTYPE  yyloc; /* position returned by actions */
617    YYLTYPE  yylloc; /* position from the lexer */
618#endif
619
620    /* variables for the parser stack */
621    YYSTACKDATA yystack;
622#if YYBTYACC
623
624    /* Current parser state */
625    static YYParseState *yyps = 0;
626
627    /* yypath != NULL: do the full parse, starting at *yypath parser state. */
628    static YYParseState *yypath = 0;
629
630    /* Base of the lexical value queue */
631    static YYSTYPE *yylvals = 0;
632
633    /* Current position at lexical value queue */
634    static YYSTYPE *yylvp = 0;
635
636    /* End position of lexical value queue */
637    static YYSTYPE *yylve = 0;
638
639    /* The last allocated position at the lexical value queue */
640    static YYSTYPE *yylvlim = 0;
641
642#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
643    /* Base of the lexical position queue */
644    static YYLTYPE *yylpsns = 0;
645
646    /* Current position at lexical position queue */
647    static YYLTYPE *yylpp = 0;
648
649    /* End position of lexical position queue */
650    static YYLTYPE *yylpe = 0;
651
652    /* The last allocated position at the lexical position queue */
653    static YYLTYPE *yylplim = 0;
654#endif
655
656    /* Current position at lexical token queue */
657    static YYINT  *yylexp = 0;
658
659    static YYINT  *yylexemes = 0;
660#endif /* YYBTYACC */
661    int yym, yyn, yystate, yyresult;
662#if YYBTYACC
663    int yynewerrflag;
664    YYParseState *yyerrctx = NULL;
665#endif /* YYBTYACC */
666#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
667    YYLTYPE  yyerror_loc_range[3]; /* position of error start/end (0 unused) */
668#endif
669#if YYDEBUG
670    const char *yys;
671
672    if ((yys = getenv("YYDEBUG")) != 0)
673    {
674        yyn = *yys;
675        if (yyn >= '0' && yyn <= '9')
676            yydebug = yyn - '0';
677    }
678    if (yydebug)
679        fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
680#endif
681#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
682    memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
683#endif
684
685    yyerrflag = 0;
686    yychar = 0;
687    memset(&yyval,  0, sizeof(yyval));
688    memset(&yylval, 0, sizeof(yylval));
689#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
690    memset(&yyloc,  0, sizeof(yyloc));
691    memset(&yylloc, 0, sizeof(yylloc));
692#endif
693
694#if YYBTYACC
695    yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
696    yyps->save = 0;
697#endif /* YYBTYACC */
698    yym = 0;
699    yyn = 0;
700    yynerrs = 0;
701    yyerrflag = 0;
702    yychar = YYEMPTY;
703    yystate = 0;
704
705#if YYPURE
706    memset(&yystack, 0, sizeof(yystack));
707#endif
708
709    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
710    yystack.s_mark = yystack.s_base;
711    yystack.l_mark = yystack.l_base;
712#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
713    yystack.p_mark = yystack.p_base;
714#endif
715    yystate = 0;
716    *yystack.s_mark = 0;
717
718yyloop:
719    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
720    if (yychar < 0)
721    {
722#if YYBTYACC
723        do {
724        if (yylvp < yylve)
725        {
726            /* we're currently re-reading tokens */
727            yylval = *yylvp++;
728#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
729            yylloc = *yylpp++;
730#endif
731            yychar = *yylexp++;
732            break;
733        }
734        if (yyps->save)
735        {
736            /* in trial mode; save scanner results for future parse attempts */
737            if (yylvp == yylvlim)
738            {   /* Enlarge lexical value queue */
739                size_t p = (size_t) (yylvp - yylvals);
740                size_t s = (size_t) (yylvlim - yylvals);
741
742                s += YYLVQUEUEGROWTH;
743                if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
744                if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
745#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
746                if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
747#endif
748                yylvp   = yylve = yylvals + p;
749                yylvlim = yylvals + s;
750#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
751                yylpp   = yylpe = yylpsns + p;
752                yylplim = yylpsns + s;
753#endif
754                yylexp  = yylexemes + p;
755            }
756            *yylexp = (YYINT) YYLEX;
757            *yylvp++ = yylval;
758            yylve++;
759#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
760            *yylpp++ = yylloc;
761            yylpe++;
762#endif
763            yychar = *yylexp++;
764            break;
765        }
766        /* normal operation, no conflict encountered */
767#endif /* YYBTYACC */
768        yychar = YYLEX;
769#if YYBTYACC
770        } while (0);
771#endif /* YYBTYACC */
772        if (yychar < 0) yychar = YYEOF;
773#if YYDEBUG
774        if (yydebug)
775        {
776            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
777            fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
778                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
779#ifdef YYSTYPE_TOSTRING
780#if YYBTYACC
781            if (!yytrial)
782#endif /* YYBTYACC */
783                fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
784#endif
785            fputc('\n', stderr);
786        }
787#endif
788    }
789#if YYBTYACC
790
791    /* Do we have a conflict? */
792    if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
793        yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
794    {
795        YYINT ctry;
796
797        if (yypath)
798        {
799            YYParseState *save;
800#if YYDEBUG
801            if (yydebug)
802                fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
803                                YYDEBUGSTR, yydepth, yystate);
804#endif
805            /* Switch to the next conflict context */
806            save = yypath;
807            yypath = save->save;
808            save->save = NULL;
809            ctry = save->ctry;
810            if (save->state != yystate) YYABORT;
811            yyFreeState(save);
812
813        }
814        else
815        {
816
817            /* Unresolved conflict - start/continue trial parse */
818            YYParseState *save;
819#if YYDEBUG
820            if (yydebug)
821            {
822                fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
823                if (yyps->save)
824                    fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
825                else
826                    fputs("Starting trial parse.\n", stderr);
827            }
828#endif
829            save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
830            if (save == NULL) goto yyenomem;
831            save->save            = yyps->save;
832            save->state           = yystate;
833            save->errflag         = yyerrflag;
834            save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
835            memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
836            save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
837            memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
838#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
839            save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
840            memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
841#endif
842            ctry                  = yytable[yyn];
843            if (yyctable[ctry] == -1)
844            {
845#if YYDEBUG
846                if (yydebug && yychar >= YYEOF)
847                    fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
848#endif
849                ctry++;
850            }
851            save->ctry = ctry;
852            if (yyps->save == NULL)
853            {
854                /* If this is a first conflict in the stack, start saving lexemes */
855                if (!yylexemes)
856                {
857                    yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
858                    if (yylexemes == NULL) goto yyenomem;
859                    yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
860                    if (yylvals == NULL) goto yyenomem;
861                    yylvlim   = yylvals + YYLVQUEUEGROWTH;
862#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
863                    yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
864                    if (yylpsns == NULL) goto yyenomem;
865                    yylplim   = yylpsns + YYLVQUEUEGROWTH;
866#endif
867                }
868                if (yylvp == yylve)
869                {
870                    yylvp  = yylve = yylvals;
871#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
872                    yylpp  = yylpe = yylpsns;
873#endif
874                    yylexp = yylexemes;
875                    if (yychar >= YYEOF)
876                    {
877                        *yylve++ = yylval;
878#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
879                        *yylpe++ = yylloc;
880#endif
881                        *yylexp  = (YYINT) yychar;
882                        yychar   = YYEMPTY;
883                    }
884                }
885            }
886            if (yychar >= YYEOF)
887            {
888                yylvp--;
889#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
890                yylpp--;
891#endif
892                yylexp--;
893                yychar = YYEMPTY;
894            }
895            save->lexeme = (int) (yylvp - yylvals);
896            yyps->save   = save;
897        }
898        if (yytable[yyn] == ctry)
899        {
900#if YYDEBUG
901            if (yydebug)
902                fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
903                                YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
904#endif
905            if (yychar < 0)
906            {
907                yylvp++;
908#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
909                yylpp++;
910#endif
911                yylexp++;
912            }
913            if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
914                goto yyoverflow;
915            yystate = yyctable[ctry];
916            *++yystack.s_mark = (YYINT) yystate;
917            *++yystack.l_mark = yylval;
918#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
919            *++yystack.p_mark = yylloc;
920#endif
921            yychar  = YYEMPTY;
922            if (yyerrflag > 0) --yyerrflag;
923            goto yyloop;
924        }
925        else
926        {
927            yyn = yyctable[ctry];
928            goto yyreduce;
929        }
930    } /* End of code dealing with conflicts */
931#endif /* YYBTYACC */
932    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
933            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
934    {
935#if YYDEBUG
936        if (yydebug)
937            fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
938                            YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
939#endif
940        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
941        yystate = yytable[yyn];
942        *++yystack.s_mark = yytable[yyn];
943        *++yystack.l_mark = yylval;
944#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
945        *++yystack.p_mark = yylloc;
946#endif
947        yychar = YYEMPTY;
948        if (yyerrflag > 0)  --yyerrflag;
949        goto yyloop;
950    }
951    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
952            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
953    {
954        yyn = yytable[yyn];
955        goto yyreduce;
956    }
957    if (yyerrflag != 0) goto yyinrecovery;
958#if YYBTYACC
959
960    yynewerrflag = 1;
961    goto yyerrhandler;
962    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
963
964yyerrlab:
965    /* explicit YYERROR from an action -- pop the rhs of the rule reduced
966     * before looking for error recovery */
967    yystack.s_mark -= yym;
968    yystate = *yystack.s_mark;
969    yystack.l_mark -= yym;
970#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
971    yystack.p_mark -= yym;
972#endif
973
974    yynewerrflag = 0;
975yyerrhandler:
976    while (yyps->save)
977    {
978        int ctry;
979        YYParseState *save = yyps->save;
980#if YYDEBUG
981        if (yydebug)
982            fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
983                            YYDEBUGSTR, yydepth, yystate, yyps->save->state,
984                    (int)(yylvp - yylvals - yyps->save->lexeme));
985#endif
986        /* Memorize most forward-looking error state in case it's really an error. */
987        if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
988        {
989            /* Free old saved error context state */
990            if (yyerrctx) yyFreeState(yyerrctx);
991            /* Create and fill out new saved error context state */
992            yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
993            if (yyerrctx == NULL) goto yyenomem;
994            yyerrctx->save           = yyps->save;
995            yyerrctx->state          = yystate;
996            yyerrctx->errflag        = yyerrflag;
997            yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
998            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
999            yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1000            memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1001#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1002            yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1003            memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1004#endif
1005            yyerrctx->lexeme         = (int) (yylvp - yylvals);
1006        }
1007        yylvp          = yylvals   + save->lexeme;
1008#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1009        yylpp          = yylpsns   + save->lexeme;
1010#endif
1011        yylexp         = yylexemes + save->lexeme;
1012        yychar         = YYEMPTY;
1013        yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1014        memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1015        yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1016        memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1017#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1018        yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1019        memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1020#endif
1021        ctry           = ++save->ctry;
1022        yystate        = save->state;
1023        /* We tried shift, try reduce now */
1024        if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1025        yyps->save     = save->save;
1026        save->save     = NULL;
1027        yyFreeState(save);
1028
1029        /* Nothing left on the stack -- error */
1030        if (!yyps->save)
1031        {
1032#if YYDEBUG
1033            if (yydebug)
1034                fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1035                                YYPREFIX, yydepth);
1036#endif
1037            /* Restore state as it was in the most forward-advanced error */
1038            yylvp          = yylvals   + yyerrctx->lexeme;
1039#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1040            yylpp          = yylpsns   + yyerrctx->lexeme;
1041#endif
1042            yylexp         = yylexemes + yyerrctx->lexeme;
1043            yychar         = yylexp[-1];
1044            yylval         = yylvp[-1];
1045#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1046            yylloc         = yylpp[-1];
1047#endif
1048            yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1049            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1050            yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1051            memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1052#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1053            yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1054            memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1055#endif
1056            yystate        = yyerrctx->state;
1057            yyFreeState(yyerrctx);
1058            yyerrctx       = NULL;
1059        }
1060        yynewerrflag = 1;
1061    }
1062    if (yynewerrflag == 0) goto yyinrecovery;
1063#endif /* YYBTYACC */
1064
1065    YYERROR_CALL("syntax error");
1066#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1067    yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1068#endif
1069
1070#if !YYBTYACC
1071    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1072yyerrlab:
1073#endif
1074    ++yynerrs;
1075
1076yyinrecovery:
1077    if (yyerrflag < 3)
1078    {
1079        yyerrflag = 3;
1080        for (;;)
1081        {
1082            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1083                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1084            {
1085#if YYDEBUG
1086                if (yydebug)
1087                    fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1088                                    YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1089#endif
1090                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1091                yystate = yytable[yyn];
1092                *++yystack.s_mark = yytable[yyn];
1093                *++yystack.l_mark = yylval;
1094#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1095                /* lookahead position is error end position */
1096                yyerror_loc_range[2] = yylloc;
1097                YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1098                *++yystack.p_mark = yyloc;
1099#endif
1100                goto yyloop;
1101            }
1102            else
1103            {
1104#if YYDEBUG
1105                if (yydebug)
1106                    fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1107                                    YYDEBUGSTR, yydepth, *yystack.s_mark);
1108#endif
1109                if (yystack.s_mark <= yystack.s_base) goto yyabort;
1110#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1111                /* the current TOS position is the error start position */
1112                yyerror_loc_range[1] = *yystack.p_mark;
1113#endif
1114#if defined(YYDESTRUCT_CALL)
1115#if YYBTYACC
1116                if (!yytrial)
1117#endif /* YYBTYACC */
1118#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1119                    YYDESTRUCT_CALL("error: discarding state",
1120                                    yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1121#else
1122                    YYDESTRUCT_CALL("error: discarding state",
1123                                    yystos[*yystack.s_mark], yystack.l_mark);
1124#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1125#endif /* defined(YYDESTRUCT_CALL) */
1126                --yystack.s_mark;
1127                --yystack.l_mark;
1128#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1129                --yystack.p_mark;
1130#endif
1131            }
1132        }
1133    }
1134    else
1135    {
1136        if (yychar == YYEOF) goto yyabort;
1137#if YYDEBUG
1138        if (yydebug)
1139        {
1140            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1141            fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1142                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
1143        }
1144#endif
1145#if defined(YYDESTRUCT_CALL)
1146#if YYBTYACC
1147        if (!yytrial)
1148#endif /* YYBTYACC */
1149#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1150            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1151#else
1152            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1153#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1154#endif /* defined(YYDESTRUCT_CALL) */
1155        yychar = YYEMPTY;
1156        goto yyloop;
1157    }
1158
1159yyreduce:
1160    yym = yylen[yyn];
1161#if YYDEBUG
1162    if (yydebug)
1163    {
1164        fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1165                        YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1166#ifdef YYSTYPE_TOSTRING
1167#if YYBTYACC
1168        if (!yytrial)
1169#endif /* YYBTYACC */
1170            if (yym > 0)
1171            {
1172                int i;
1173                fputc('<', stderr);
1174                for (i = yym; i > 0; i--)
1175                {
1176                    if (i != yym) fputs(", ", stderr);
1177                    fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1178                                           yystack.l_mark[1-i]), stderr);
1179                }
1180                fputc('>', stderr);
1181            }
1182#endif
1183        fputc('\n', stderr);
1184    }
1185#endif
1186    if (yym > 0)
1187        yyval = yystack.l_mark[1-yym];
1188    else
1189        memset(&yyval, 0, sizeof yyval);
1190#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1191
1192    /* Perform position reduction */
1193    memset(&yyloc, 0, sizeof(yyloc));
1194#if YYBTYACC
1195    if (!yytrial)
1196#endif /* YYBTYACC */
1197    {
1198        YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1199        /* just in case YYERROR is invoked within the action, save
1200           the start of the rhs as the error start position */
1201        yyerror_loc_range[1] = yystack.p_mark[1-yym];
1202    }
1203#endif
1204
1205    switch (yyn)
1206    {
1207case 3:
1208#line 38 "calc3.y"
1209	{  yyerrok ; }
1210break;
1211case 4:
1212#line 42 "calc3.y"
1213	{  printf("%d\n",yystack.l_mark[0]);}
1214break;
1215case 5:
1216#line 44 "calc3.y"
1217	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1218break;
1219case 6:
1220#line 48 "calc3.y"
1221	{  yyval = yystack.l_mark[-1]; }
1222break;
1223case 7:
1224#line 50 "calc3.y"
1225	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1226break;
1227case 8:
1228#line 52 "calc3.y"
1229	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1230break;
1231case 9:
1232#line 54 "calc3.y"
1233	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1234break;
1235case 10:
1236#line 56 "calc3.y"
1237	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1238break;
1239case 11:
1240#line 58 "calc3.y"
1241	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1242break;
1243case 12:
1244#line 60 "calc3.y"
1245	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1246break;
1247case 13:
1248#line 62 "calc3.y"
1249	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1250break;
1251case 14:
1252#line 64 "calc3.y"
1253	{  yyval = - yystack.l_mark[0]; }
1254break;
1255case 15:
1256#line 66 "calc3.y"
1257	{  yyval = regs[yystack.l_mark[0]]; }
1258break;
1259case 17:
1260#line 71 "calc3.y"
1261	{  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
1262break;
1263case 18:
1264#line 73 "calc3.y"
1265	{  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
1266break;
1267#line 1268 "calc3.tab.c"
1268    default:
1269        break;
1270    }
1271    yystack.s_mark -= yym;
1272    yystate = *yystack.s_mark;
1273    yystack.l_mark -= yym;
1274#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1275    yystack.p_mark -= yym;
1276#endif
1277    yym = yylhs[yyn];
1278    if (yystate == 0 && yym == 0)
1279    {
1280#if YYDEBUG
1281        if (yydebug)
1282        {
1283            fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1284#ifdef YYSTYPE_TOSTRING
1285#if YYBTYACC
1286            if (!yytrial)
1287#endif /* YYBTYACC */
1288                fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1289#endif
1290            fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1291        }
1292#endif
1293        yystate = YYFINAL;
1294        *++yystack.s_mark = YYFINAL;
1295        *++yystack.l_mark = yyval;
1296#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1297        *++yystack.p_mark = yyloc;
1298#endif
1299        if (yychar < 0)
1300        {
1301#if YYBTYACC
1302            do {
1303            if (yylvp < yylve)
1304            {
1305                /* we're currently re-reading tokens */
1306                yylval = *yylvp++;
1307#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1308                yylloc = *yylpp++;
1309#endif
1310                yychar = *yylexp++;
1311                break;
1312            }
1313            if (yyps->save)
1314            {
1315                /* in trial mode; save scanner results for future parse attempts */
1316                if (yylvp == yylvlim)
1317                {   /* Enlarge lexical value queue */
1318                    size_t p = (size_t) (yylvp - yylvals);
1319                    size_t s = (size_t) (yylvlim - yylvals);
1320
1321                    s += YYLVQUEUEGROWTH;
1322                    if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1323                        goto yyenomem;
1324                    if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1325                        goto yyenomem;
1326#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1327                    if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1328                        goto yyenomem;
1329#endif
1330                    yylvp   = yylve = yylvals + p;
1331                    yylvlim = yylvals + s;
1332#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1333                    yylpp   = yylpe = yylpsns + p;
1334                    yylplim = yylpsns + s;
1335#endif
1336                    yylexp  = yylexemes + p;
1337                }
1338                *yylexp = (YYINT) YYLEX;
1339                *yylvp++ = yylval;
1340                yylve++;
1341#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1342                *yylpp++ = yylloc;
1343                yylpe++;
1344#endif
1345                yychar = *yylexp++;
1346                break;
1347            }
1348            /* normal operation, no conflict encountered */
1349#endif /* YYBTYACC */
1350            yychar = YYLEX;
1351#if YYBTYACC
1352            } while (0);
1353#endif /* YYBTYACC */
1354            if (yychar < 0) yychar = YYEOF;
1355#if YYDEBUG
1356            if (yydebug)
1357            {
1358                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1359                fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1360                                YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1361            }
1362#endif
1363        }
1364        if (yychar == YYEOF) goto yyaccept;
1365        goto yyloop;
1366    }
1367    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1368            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1369        yystate = yytable[yyn];
1370    else
1371        yystate = yydgoto[yym];
1372#if YYDEBUG
1373    if (yydebug)
1374    {
1375        fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1376#ifdef YYSTYPE_TOSTRING
1377#if YYBTYACC
1378        if (!yytrial)
1379#endif /* YYBTYACC */
1380            fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1381#endif
1382        fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1383    }
1384#endif
1385    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1386    *++yystack.s_mark = (YYINT) yystate;
1387    *++yystack.l_mark = yyval;
1388#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1389    *++yystack.p_mark = yyloc;
1390#endif
1391    goto yyloop;
1392#if YYBTYACC
1393
1394    /* Reduction declares that this path is valid. Set yypath and do a full parse */
1395yyvalid:
1396    if (yypath) YYABORT;
1397    while (yyps->save)
1398    {
1399        YYParseState *save = yyps->save;
1400        yyps->save = save->save;
1401        save->save = yypath;
1402        yypath = save;
1403    }
1404#if YYDEBUG
1405    if (yydebug)
1406        fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1407                        YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1408#endif
1409    if (yyerrctx)
1410    {
1411        yyFreeState(yyerrctx);
1412        yyerrctx = NULL;
1413    }
1414    yylvp          = yylvals + yypath->lexeme;
1415#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1416    yylpp          = yylpsns + yypath->lexeme;
1417#endif
1418    yylexp         = yylexemes + yypath->lexeme;
1419    yychar         = YYEMPTY;
1420    yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1421    memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1422    yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1423    memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1424#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1425    yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1426    memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1427#endif
1428    yystate        = yypath->state;
1429    goto yyloop;
1430#endif /* YYBTYACC */
1431
1432yyoverflow:
1433    YYERROR_CALL("yacc stack overflow");
1434#if YYBTYACC
1435    goto yyabort_nomem;
1436yyenomem:
1437    YYERROR_CALL("memory exhausted");
1438yyabort_nomem:
1439#endif /* YYBTYACC */
1440    yyresult = 2;
1441    goto yyreturn;
1442
1443yyabort:
1444    yyresult = 1;
1445    goto yyreturn;
1446
1447yyaccept:
1448#if YYBTYACC
1449    if (yyps->save) goto yyvalid;
1450#endif /* YYBTYACC */
1451    yyresult = 0;
1452
1453yyreturn:
1454#if defined(YYDESTRUCT_CALL)
1455    if (yychar != YYEOF && yychar != YYEMPTY)
1456#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1457        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1458#else
1459        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1460#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1461
1462    {
1463        YYSTYPE *pv;
1464#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1465        YYLTYPE *pp;
1466
1467        for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1468             YYDESTRUCT_CALL("cleanup: discarding state",
1469                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1470#else
1471        for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1472             YYDESTRUCT_CALL("cleanup: discarding state",
1473                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1474#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1475    }
1476#endif /* defined(YYDESTRUCT_CALL) */
1477
1478#if YYBTYACC
1479    if (yyerrctx)
1480    {
1481        yyFreeState(yyerrctx);
1482        yyerrctx = NULL;
1483    }
1484    while (yyps)
1485    {
1486        YYParseState *save = yyps;
1487        yyps = save->save;
1488        save->save = NULL;
1489        yyFreeState(save);
1490    }
1491    while (yypath)
1492    {
1493        YYParseState *save = yypath;
1494        yypath = save->save;
1495        save->save = NULL;
1496        yyFreeState(save);
1497    }
1498#endif /* YYBTYACC */
1499    yyfreestack(&yystack);
1500    return (yyresult);
1501}
1502