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