xref: /freebsd/contrib/byacc/test/btyacc/calc_code_requires.tab.c (revision 8e022d3cdea10ee1039a632f670c27fd93f65625) 
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 2
7 #define YYMINOR 0
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 
124 int regs[26];
125 int base;
126 
127 extern int yylex(void);
128 static 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. */
134 typedef 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 
167 extern int YYPARSE_DECL();
168 
169 #define DIGIT 257
170 #define LETTER 258
171 #define UMINUS 259
172 #define YYERRCODE 256
173 typedef int YYINT;
174 static 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 };
178 static 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 };
182 static 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)
189 static 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 */
196 static const YYINT calc_code_requires_dgoto[] = {         1,
197     7,    8,    9,
198 };
199 static 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 };
205 static 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
212 static 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
219 static const YYINT calc_code_requires_gindex[] = {        0,
220     0,   65,    0,
221 };
222 #define YYTABLESIZE 220
223 static 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 };
247 static 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
272 static 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
305 static 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,
308 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
309 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
310 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
311 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
312 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
313 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
314 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
315 "illegal-symbol",
316 };
317 static 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
342 int      yydebug;
343 #endif
344 
345 int      yyerrflag;
346 int      yychar;
347 YYSTYPE  yyval;
348 YYSTYPE  yylval;
349 int      yynerrs;
350 
351 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
352 YYLTYPE  yyloc; /* position returned by actions */
353 YYLTYPE  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) \
367 do \
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 
410 typedef 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 
424 struct 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 };
433 typedef struct YYParseState_s YYParseState;
434 #endif /* YYBTYACC */
435 /* variables for the parser stack */
436 static YYSTACKDATA yystack;
437 #if YYBTYACC
438 
439 /* Current parser state */
440 static YYParseState *yyps = 0;
441 
442 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
443 static YYParseState *yypath = 0;
444 
445 /* Base of the lexical value queue */
446 static YYSTYPE *yylvals = 0;
447 
448 /* Current position at lexical value queue */
449 static YYSTYPE *yylvp = 0;
450 
451 /* End position of lexical value queue */
452 static YYSTYPE *yylve = 0;
453 
454 /* The last allocated position at the lexical value queue */
455 static YYSTYPE *yylvlim = 0;
456 
457 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
458 /* Base of the lexical position queue */
459 static YYLTYPE *yylpsns = 0;
460 
461 /* Current position at lexical position queue */
462 static YYLTYPE *yylpp = 0;
463 
464 /* End position of lexical position queue */
465 static YYLTYPE *yylpe = 0;
466 
467 /* The last allocated position at the lexical position queue */
468 static YYLTYPE *yylplim = 0;
469 #endif
470 
471 /* Current position at lexical token queue */
472 static YYINT  *yylexp = 0;
473 
474 static YYINT  *yylexemes = 0;
475 #endif /* YYBTYACC */
476 #line 69 "calc_code_requires.y"
477  /* start of programs */
478 
479 int
main(void)480 main (void)
481 {
482     while(!feof(stdin)) {
483 	yyparse();
484     }
485     return 0;
486 }
487 
488 static void
yyerror(const char * s)489 yyerror(const char *s)
490 {
491     fprintf(stderr, "%s\n", s);
492 }
493 
494 int
yylex(void)495 yylex(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 */
yygrowstack(YYSTACKDATA * data)534 static 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 == NULL)
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 == NULL)
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 == NULL)
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)
yyfreestack(YYSTACKDATA * data)586 static 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 
600 static YYParseState *
yyNewState(unsigned size)601 yyNewState(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 
630 static void
yyFreeState(YYParseState * p)631 yyFreeState(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 
648 int
YYPARSE_DECL()649 YYPARSE_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")) != NULL)
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 is set below */
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 
699 yyloop:
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 
945 yyerrlab:
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;
956 yyerrhandler:
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 */
1053 yyerrlab:
1054 #endif
1055     ++yynerrs;
1056 
1057 yyinrecovery:
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 
1140 yyreduce:
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     {
1188 case 3:
1189 #line 31 "calc_code_requires.y"
1190 	{  yyerrok ; }
1191 #line 1192 "calc_code_requires.tab.c"
1192 break;
1193 case 4:
1194 #line 35 "calc_code_requires.y"
1195 	{  printf("%d\n",yystack.l_mark[0]);}
1196 #line 1197 "calc_code_requires.tab.c"
1197 break;
1198 case 5:
1199 #line 37 "calc_code_requires.y"
1200 	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1201 #line 1202 "calc_code_requires.tab.c"
1202 break;
1203 case 6:
1204 #line 41 "calc_code_requires.y"
1205 	{  yyval = yystack.l_mark[-1]; }
1206 #line 1207 "calc_code_requires.tab.c"
1207 break;
1208 case 7:
1209 #line 43 "calc_code_requires.y"
1210 	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1211 #line 1212 "calc_code_requires.tab.c"
1212 break;
1213 case 8:
1214 #line 45 "calc_code_requires.y"
1215 	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1216 #line 1217 "calc_code_requires.tab.c"
1217 break;
1218 case 9:
1219 #line 47 "calc_code_requires.y"
1220 	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1221 #line 1222 "calc_code_requires.tab.c"
1222 break;
1223 case 10:
1224 #line 49 "calc_code_requires.y"
1225 	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1226 #line 1227 "calc_code_requires.tab.c"
1227 break;
1228 case 11:
1229 #line 51 "calc_code_requires.y"
1230 	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1231 #line 1232 "calc_code_requires.tab.c"
1232 break;
1233 case 12:
1234 #line 53 "calc_code_requires.y"
1235 	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1236 #line 1237 "calc_code_requires.tab.c"
1237 break;
1238 case 13:
1239 #line 55 "calc_code_requires.y"
1240 	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1241 #line 1242 "calc_code_requires.tab.c"
1242 break;
1243 case 14:
1244 #line 57 "calc_code_requires.y"
1245 	{  yyval = - yystack.l_mark[0]; }
1246 #line 1247 "calc_code_requires.tab.c"
1247 break;
1248 case 15:
1249 #line 59 "calc_code_requires.y"
1250 	{  yyval = regs[yystack.l_mark[0]]; }
1251 #line 1252 "calc_code_requires.tab.c"
1252 break;
1253 case 17:
1254 #line 64 "calc_code_requires.y"
1255 	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1256 #line 1257 "calc_code_requires.tab.c"
1257 break;
1258 case 18:
1259 #line 66 "calc_code_requires.y"
1260 	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1261 #line 1262 "calc_code_requires.tab.c"
1262 break;
1263 #line 1264 "calc_code_requires.tab.c"
1264     default:
1265         break;
1266     }
1267     yystack.s_mark -= yym;
1268     yystate = *yystack.s_mark;
1269     yystack.l_mark -= yym;
1270 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1271     yystack.p_mark -= yym;
1272 #endif
1273     yym = yylhs[yyn];
1274     if (yystate == 0 && yym == 0)
1275     {
1276 #if YYDEBUG
1277         if (yydebug)
1278         {
1279             fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1280 #ifdef YYSTYPE_TOSTRING
1281 #if YYBTYACC
1282             if (!yytrial)
1283 #endif /* YYBTYACC */
1284                 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1285 #endif
1286             fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1287         }
1288 #endif
1289         yystate = YYFINAL;
1290         *++yystack.s_mark = YYFINAL;
1291         *++yystack.l_mark = yyval;
1292 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1293         *++yystack.p_mark = yyloc;
1294 #endif
1295         if (yychar < 0)
1296         {
1297 #if YYBTYACC
1298             do {
1299             if (yylvp < yylve)
1300             {
1301                 /* we're currently re-reading tokens */
1302                 yylval = *yylvp++;
1303 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1304                 yylloc = *yylpp++;
1305 #endif
1306                 yychar = *yylexp++;
1307                 break;
1308             }
1309             if (yyps->save)
1310             {
1311                 /* in trial mode; save scanner results for future parse attempts */
1312                 if (yylvp == yylvlim)
1313                 {   /* Enlarge lexical value queue */
1314                     size_t p = (size_t) (yylvp - yylvals);
1315                     size_t s = (size_t) (yylvlim - yylvals);
1316 
1317                     s += YYLVQUEUEGROWTH;
1318                     if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1319                         goto yyenomem;
1320                     if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1321                         goto yyenomem;
1322 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1323                     if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1324                         goto yyenomem;
1325 #endif
1326                     yylvp   = yylve = yylvals + p;
1327                     yylvlim = yylvals + s;
1328 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1329                     yylpp   = yylpe = yylpsns + p;
1330                     yylplim = yylpsns + s;
1331 #endif
1332                     yylexp  = yylexemes + p;
1333                 }
1334                 *yylexp = (YYINT) YYLEX;
1335                 *yylvp++ = yylval;
1336                 yylve++;
1337 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1338                 *yylpp++ = yylloc;
1339                 yylpe++;
1340 #endif
1341                 yychar = *yylexp++;
1342                 break;
1343             }
1344             /* normal operation, no conflict encountered */
1345 #endif /* YYBTYACC */
1346             yychar = YYLEX;
1347 #if YYBTYACC
1348             } while (0);
1349 #endif /* YYBTYACC */
1350             if (yychar < 0) yychar = YYEOF;
1351 #if YYDEBUG
1352             if (yydebug)
1353             {
1354                 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1355                 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1356                                 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1357             }
1358 #endif
1359         }
1360         if (yychar == YYEOF) goto yyaccept;
1361         goto yyloop;
1362     }
1363     if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1364             yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1365         yystate = yytable[yyn];
1366     else
1367         yystate = yydgoto[yym];
1368 #if YYDEBUG
1369     if (yydebug)
1370     {
1371         fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1372 #ifdef YYSTYPE_TOSTRING
1373 #if YYBTYACC
1374         if (!yytrial)
1375 #endif /* YYBTYACC */
1376             fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1377 #endif
1378         fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1379     }
1380 #endif
1381     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1382     *++yystack.s_mark = (YYINT) yystate;
1383     *++yystack.l_mark = yyval;
1384 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1385     *++yystack.p_mark = yyloc;
1386 #endif
1387     goto yyloop;
1388 #if YYBTYACC
1389 
1390     /* Reduction declares that this path is valid. Set yypath and do a full parse */
1391 yyvalid:
1392     if (yypath) YYABORT;
1393     while (yyps->save)
1394     {
1395         YYParseState *save = yyps->save;
1396         yyps->save = save->save;
1397         save->save = yypath;
1398         yypath = save;
1399     }
1400 #if YYDEBUG
1401     if (yydebug)
1402         fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1403                         YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1404 #endif
1405     if (yyerrctx)
1406     {
1407         yyFreeState(yyerrctx);
1408         yyerrctx = NULL;
1409     }
1410     yylvp          = yylvals + yypath->lexeme;
1411 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1412     yylpp          = yylpsns + yypath->lexeme;
1413 #endif
1414     yylexp         = yylexemes + yypath->lexeme;
1415     yychar         = YYEMPTY;
1416     yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1417     memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1418     yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1419     memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1420 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1421     yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1422     memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1423 #endif
1424     yystate        = yypath->state;
1425     goto yyloop;
1426 #endif /* YYBTYACC */
1427 
1428 yyoverflow:
1429     YYERROR_CALL("yacc stack overflow");
1430 #if YYBTYACC
1431     goto yyabort_nomem;
1432 yyenomem:
1433     YYERROR_CALL("memory exhausted");
1434 yyabort_nomem:
1435 #endif /* YYBTYACC */
1436     yyresult = 2;
1437     goto yyreturn;
1438 
1439 yyabort:
1440     yyresult = 1;
1441     goto yyreturn;
1442 
1443 yyaccept:
1444 #if YYBTYACC
1445     if (yyps->save) goto yyvalid;
1446 #endif /* YYBTYACC */
1447     yyresult = 0;
1448 
1449 yyreturn:
1450 #if defined(YYDESTRUCT_CALL)
1451     if (yychar != YYEOF && yychar != YYEMPTY)
1452 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1453         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1454 #else
1455         YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1456 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1457 
1458     {
1459         YYSTYPE *pv;
1460 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1461         YYLTYPE *pp;
1462 
1463         for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1464              YYDESTRUCT_CALL("cleanup: discarding state",
1465                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1466 #else
1467         for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1468              YYDESTRUCT_CALL("cleanup: discarding state",
1469                              yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1470 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1471     }
1472 #endif /* defined(YYDESTRUCT_CALL) */
1473 
1474 #if YYBTYACC
1475     if (yyerrctx)
1476     {
1477         yyFreeState(yyerrctx);
1478         yyerrctx = NULL;
1479     }
1480     while (yyps)
1481     {
1482         YYParseState *save = yyps;
1483         yyps = save->save;
1484         save->save = NULL;
1485         yyFreeState(save);
1486     }
1487     while (yypath)
1488     {
1489         YYParseState *save = yypath;
1490         yypath = save->save;
1491         save->save = NULL;
1492         yyFreeState(save);
1493     }
1494 #endif /* YYBTYACC */
1495     yyfreestack(&yystack);
1496     return (yyresult);
1497 }
1498