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