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