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