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