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