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