1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
8 #define YYCHECK "yyyymmdd"
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
18 #define YYDEBUGSTR YYPREFIX "debug"
21 #define yyparse quote_calc2_parse
25 #define yylex quote_calc2_lex
29 #define yyerror quote_calc2_error
33 #define yychar quote_calc2_char
37 #define yyval quote_calc2_val
41 #define yylval quote_calc2_lval
45 #define yydebug quote_calc2_debug
49 #define yynerrs quote_calc2_nerrs
53 #define yyerrflag quote_calc2_errflag
54 #endif /* yyerrflag */
57 #define yylhs quote_calc2_lhs
61 #define yylen quote_calc2_len
65 #define yydefred quote_calc2_defred
69 #define yystos quote_calc2_stos
73 #define yydgoto quote_calc2_dgoto
77 #define yysindex quote_calc2_sindex
81 #define yyrindex quote_calc2_rindex
85 #define yygindex quote_calc2_gindex
89 #define yytable quote_calc2_table
93 #define yycheck quote_calc2_check
97 #define yyname quote_calc2_name
101 #define yyrule quote_calc2_rule
107 #define yycindex quote_calc2_cindex
108 #endif /* yycindex */
111 #define yyctable quote_calc2_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "quote_calc2_"
120 #line 2 "quote_calc2.y"
128 static void yyerror(const char *s);
130 #line 131 "quote_calc2.tab.c"
132 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
133 /* Default: YYSTYPE is the semantic value type. */
135 # define YYSTYPE_IS_DECLARED 1
138 /* compatibility with bison */
140 /* compatibility with FreeBSD */
141 # ifdef YYPARSE_PARAM_TYPE
142 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
144 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
147 # define YYPARSE_DECL() yyparse(void)
150 /* Parameters sent to lex. */
152 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
153 # define YYLEX yylex(YYLEX_PARAM)
155 # define YYLEX_DECL() yylex(void)
156 # define YYLEX yylex()
159 /* Parameters sent to yyerror. */
161 #define YYERROR_DECL() yyerror(const char *s)
164 #define YYERROR_CALL(msg) yyerror(msg)
167 extern int YYPARSE_DECL();
184 #define YYERRCODE 256
186 static const YYINT quote_calc2_lhs[] = { -1,
187 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
188 2, 2, 2, 2, 2, 2, 3, 3,
190 static const YYINT quote_calc2_len[] = { 2,
191 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
192 3, 3, 3, 2, 1, 1, 1, 2,
194 static const YYINT quote_calc2_defred[] = { 1,
195 0, 0, 0, 17, 0, 0, 0, 0, 0, 3,
196 15, 0, 0, 0, 2, 0, 0, 0, 0, 0,
197 0, 0, 18, 0, 6, 0, 0, 0, 0, 0,
200 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
201 static const YYINT quote_calc2_stos[] = { 0,
202 273, 256, 260, 269, 270, 40, 274, 275, 276, 10,
203 270, 275, 61, 275, 10, 258, 260, 262, 264, 266,
204 268, 124, 269, 275, 41, 275, 275, 275, 275, 275,
207 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
208 static const YYINT quote_calc2_dgoto[] = { 1,
211 static const YYINT quote_calc2_sindex[] = { 0,
212 -38, 4, -36, 0, -51, -36, 6, -121, -249, 0,
213 0, -243, -36, -23, 0, -36, -36, -36, -36, -36,
214 -36, -36, 0, -121, 0, -121, -121, -121, -121, -121,
217 static const YYINT quote_calc2_rindex[] = { 0,
218 0, 0, 0, 0, -9, 0, 0, 12, -10, 0,
219 0, -5, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 14, 0, -3, -2, -1, 1, 2,
224 static const YYINT quote_calc2_cindex[] = { 0,
225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
226 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
227 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
231 static const YYINT quote_calc2_gindex[] = { 0,
234 #define YYTABLESIZE 259
235 static const YYINT quote_calc2_table[] = { 16,
236 15, 6, 22, 6, 14, 13, 7, 8, 9, 13,
237 10, 11, 12, 10, 16, 15, 17, 25, 18, 23,
238 19, 4, 20, 5, 21, 0, 0, 0, 0, 0,
239 16, 0, 0, 0, 0, 14, 13, 7, 8, 9,
240 0, 10, 11, 12, 12, 0, 0, 14, 0, 0,
241 0, 0, 0, 0, 24, 0, 0, 26, 27, 28,
242 29, 30, 31, 32, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
246 22, 0, 0, 0, 0, 0, 0, 0, 0, 0,
247 0, 0, 0, 16, 15, 0, 0, 0, 14, 13,
248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 16, 0, 17, 0,
250 18, 0, 19, 0, 20, 0, 21, 0, 0, 0,
251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
258 0, 3, 0, 3, 0, 0, 0, 0, 0, 0,
259 4, 5, 4, 11, 16, 0, 17, 0, 18, 0,
260 19, 0, 20, 0, 21, 0, 0, 16, 15, 16,
261 15, 16, 15, 16, 15, 16, 15, 16, 15,
263 static const YYINT quote_calc2_check[] = { 10,
264 10, 40, 124, 40, 10, 10, 10, 10, 10, 61,
265 10, 10, 10, 10, 258, 10, 260, 41, 262, 269,
266 264, 10, 266, 10, 268, -1, -1, -1, -1, -1,
267 41, -1, -1, -1, -1, 41, 41, 41, 41, 41,
268 -1, 41, 41, 41, 3, -1, -1, 6, -1, -1,
269 -1, -1, -1, -1, 13, -1, -1, 16, 17, 18,
270 19, 20, 21, 22, -1, -1, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
275 -1, -1, -1, 124, 124, -1, -1, -1, 124, 124,
276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
277 -1, -1, -1, -1, -1, -1, 258, -1, 260, -1,
278 262, -1, 264, -1, 266, -1, 268, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
285 -1, -1, -1, -1, -1, -1, -1, 256, -1, -1,
286 -1, 260, -1, 260, -1, -1, -1, -1, -1, -1,
287 269, 270, 269, 270, 258, -1, 260, -1, 262, -1,
288 264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
289 260, 262, 262, 264, 264, 266, 266, 268, 268,
292 static const YYINT quote_calc2_ctable[] = { -1,
293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
296 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
298 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
299 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
312 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
313 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
314 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
315 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
316 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
317 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
318 -1, -1, -1, -1, -1, -1, -1, -1,
325 #define YYMAXTOKEN 271
326 #define YYUNDFTOKEN 277
327 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
329 static const char *const quote_calc2_name[] = {
331 "$end",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
332 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
333 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
334 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
335 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
336 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
337 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
338 0,0,"error","OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
339 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
340 "$accept","list","stat","expr","number","illegal-symbol",
342 static const char *const quote_calc2_rule[] = {
345 "list : list stat '\\n'",
346 "list : list error '\\n'",
348 "stat : LETTER '=' expr",
349 "expr : '(' expr ')'",
350 "expr : expr \"ADD\" expr",
351 "expr : expr \"SUB\" expr",
352 "expr : expr \"MUL\" expr",
353 "expr : expr \"DIV\" expr",
354 "expr : expr \"MOD\" expr",
355 "expr : expr \"AND\" expr",
356 "expr : expr '|' expr",
357 "expr : \"SUB\" expr",
361 "number : number DIGIT",
373 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
374 YYLTYPE yyloc; /* position returned by actions */
375 YYLTYPE yylloc; /* position from the lexer */
378 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
379 #ifndef YYLLOC_DEFAULT
380 #define YYLLOC_DEFAULT(loc, rhs, n) \
385 (loc).first_line = ((rhs)[-1]).last_line; \
386 (loc).first_column = ((rhs)[-1]).last_column; \
387 (loc).last_line = ((rhs)[-1]).last_line; \
388 (loc).last_column = ((rhs)[-1]).last_column; \
392 (loc).first_line = ((rhs)[ 0 ]).first_line; \
393 (loc).first_column = ((rhs)[ 0 ]).first_column; \
394 (loc).last_line = ((rhs)[n-1]).last_line; \
395 (loc).last_column = ((rhs)[n-1]).last_column; \
398 #endif /* YYLLOC_DEFAULT */
399 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
402 #ifndef YYLVQUEUEGROWTH
403 #define YYLVQUEUEGROWTH 32
405 #endif /* YYBTYACC */
407 /* define the initial stack-sizes */
410 #define YYMAXDEPTH YYSTACKSIZE
413 #define YYSTACKSIZE YYMAXDEPTH
415 #define YYSTACKSIZE 10000
416 #define YYMAXDEPTH 10000
420 #ifndef YYINITSTACKSIZE
421 #define YYINITSTACKSIZE 200
431 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
438 struct YYParseState_s
440 struct YYParseState_s *save; /* Previously saved parser state */
441 YYSTACKDATA yystack; /* saved parser stack */
442 int state; /* saved parser state */
443 int errflag; /* saved error recovery status */
444 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
445 YYINT ctry; /* saved index in yyctable[] for this conflict */
447 typedef struct YYParseState_s YYParseState;
448 #endif /* YYBTYACC */
449 /* variables for the parser stack */
450 static YYSTACKDATA yystack;
453 /* Current parser state */
454 static YYParseState *yyps = 0;
456 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
457 static YYParseState *yypath = 0;
459 /* Base of the lexical value queue */
460 static YYSTYPE *yylvals = 0;
462 /* Current position at lexical value queue */
463 static YYSTYPE *yylvp = 0;
465 /* End position of lexical value queue */
466 static YYSTYPE *yylve = 0;
468 /* The last allocated position at the lexical value queue */
469 static YYSTYPE *yylvlim = 0;
471 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
472 /* Base of the lexical position queue */
473 static YYLTYPE *yylpsns = 0;
475 /* Current position at lexical position queue */
476 static YYLTYPE *yylpp = 0;
478 /* End position of lexical position queue */
479 static YYLTYPE *yylpe = 0;
481 /* The last allocated position at the lexical position queue */
482 static YYLTYPE *yylplim = 0;
485 /* Current position at lexical token queue */
486 static YYINT *yylexp = 0;
488 static YYINT *yylexemes = 0;
489 #endif /* YYBTYACC */
490 #line 73 "quote_calc2.y"
491 /* start of programs */
496 while(!feof(stdin)) {
503 yyerror(const char *s)
505 fprintf(stderr, "%s\n", s);
510 /* lexical analysis routine */
511 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
512 /* return DIGIT for a digit, yylval = 0 through 9 */
513 /* all other characters are returned immediately */
517 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
519 /* c is now nonblank */
531 #line 532 "quote_calc2.tab.c"
533 /* For use in generated program */
534 #define yydepth (int)(yystack.s_mark - yystack.s_base)
536 #define yytrial (yyps->save)
537 #endif /* YYBTYACC */
540 #include <stdio.h> /* needed for printf */
543 #include <stdlib.h> /* needed for malloc, etc */
544 #include <string.h> /* needed for memset */
546 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
547 static int yygrowstack(YYSTACKDATA *data)
553 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
557 if ((newsize = data->stacksize) == 0)
558 newsize = YYINITSTACKSIZE;
559 else if (newsize >= YYMAXDEPTH)
561 else if ((newsize *= 2) > YYMAXDEPTH)
562 newsize = YYMAXDEPTH;
564 i = (int) (data->s_mark - data->s_base);
565 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
569 data->s_base = newss;
570 data->s_mark = newss + i;
572 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
576 data->l_base = newvs;
577 data->l_mark = newvs + i;
579 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
580 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
584 data->p_base = newps;
585 data->p_mark = newps + i;
588 data->stacksize = newsize;
589 data->s_last = data->s_base + newsize - 1;
593 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
598 #if YYPURE || defined(YY_NO_LEAKS)
599 static void yyfreestack(YYSTACKDATA *data)
603 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
606 memset(data, 0, sizeof(*data));
609 #define yyfreestack(data) /* nothing */
610 #endif /* YYPURE || defined(YY_NO_LEAKS) */
613 static YYParseState *
614 yyNewState(unsigned size)
616 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
617 if (p == NULL) return NULL;
619 p->yystack.stacksize = size;
622 p->yystack.s_base = NULL;
623 p->yystack.l_base = NULL;
624 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
625 p->yystack.p_base = NULL;
629 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
630 if (p->yystack.s_base == NULL) return NULL;
631 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
632 if (p->yystack.l_base == NULL) return NULL;
633 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
634 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
635 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
636 if (p->yystack.p_base == NULL) return NULL;
637 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
644 yyFreeState(YYParseState *p)
646 yyfreestack(&p->yystack);
649 #endif /* YYBTYACC */
651 #define YYABORT goto yyabort
652 #define YYREJECT goto yyabort
653 #define YYACCEPT goto yyaccept
654 #define YYERROR goto yyerrlab
656 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
657 #define YYVALID_NESTED do { if (yyps->save && \
658 yyps->save->save == 0) goto yyvalid; } while(0)
659 #endif /* YYBTYACC */
664 int yym, yyn, yystate, yyresult;
667 YYParseState *yyerrctx = NULL;
668 #endif /* YYBTYACC */
669 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
670 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
675 if ((yys = getenv("YYDEBUG")) != 0)
678 if (yyn >= '0' && yyn <= '9')
682 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
686 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
688 #endif /* YYBTYACC */
697 memset(&yystack, 0, sizeof(yystack));
700 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
701 yystack.s_mark = yystack.s_base;
702 yystack.l_mark = yystack.l_base;
703 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
704 yystack.p_mark = yystack.p_base;
710 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
717 /* we're currently re-reading tokens */
719 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
727 /* in trial mode; save scanner results for future parse attempts */
728 if (yylvp == yylvlim)
729 { /* Enlarge lexical value queue */
730 size_t p = (size_t) (yylvp - yylvals);
731 size_t s = (size_t) (yylvlim - yylvals);
733 s += YYLVQUEUEGROWTH;
734 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
735 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
736 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
737 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
739 yylvp = yylve = yylvals + p;
740 yylvlim = yylvals + s;
741 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
742 yylpp = yylpe = yylpsns + p;
743 yylplim = yylpsns + s;
745 yylexp = yylexemes + p;
747 *yylexp = (YYINT) YYLEX;
750 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
757 /* normal operation, no conflict encountered */
758 #endif /* YYBTYACC */
762 #endif /* YYBTYACC */
763 if (yychar < 0) yychar = YYEOF;
767 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
768 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
769 YYDEBUGSTR, yydepth, yystate, yychar, yys);
770 #ifdef YYSTYPE_TOSTRING
773 #endif /* YYBTYACC */
774 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
782 /* Do we have a conflict? */
783 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
784 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
793 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
794 YYDEBUGSTR, yydepth, yystate);
796 /* Switch to the next conflict context */
801 if (save->state != yystate) YYABORT;
808 /* Unresolved conflict - start/continue trial parse */
813 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
815 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
817 fputs("Starting trial parse.\n", stderr);
820 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
821 if (save == NULL) goto yyenomem;
822 save->save = yyps->save;
823 save->state = yystate;
824 save->errflag = yyerrflag;
825 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
826 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
827 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
828 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
829 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
830 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
831 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
834 if (yyctable[ctry] == -1)
837 if (yydebug && yychar >= YYEOF)
838 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
843 if (yyps->save == NULL)
845 /* If this is a first conflict in the stack, start saving lexemes */
848 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
849 if (yylexemes == NULL) goto yyenomem;
850 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
851 if (yylvals == NULL) goto yyenomem;
852 yylvlim = yylvals + YYLVQUEUEGROWTH;
853 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
854 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
855 if (yylpsns == NULL) goto yyenomem;
856 yylplim = yylpsns + YYLVQUEUEGROWTH;
861 yylvp = yylve = yylvals;
862 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
863 yylpp = yylpe = yylpsns;
869 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
872 *yylexp = (YYINT) yychar;
880 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
886 save->lexeme = (int) (yylvp - yylvals);
889 if (yytable[yyn] == ctry)
893 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
894 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
899 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
904 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
906 yystate = yyctable[ctry];
907 *++yystack.s_mark = (YYINT) yystate;
908 *++yystack.l_mark = yylval;
909 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
910 *++yystack.p_mark = yylloc;
913 if (yyerrflag > 0) --yyerrflag;
918 yyn = yyctable[ctry];
921 } /* End of code dealing with conflicts */
922 #endif /* YYBTYACC */
923 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
924 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
928 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
929 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
931 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
932 yystate = yytable[yyn];
933 *++yystack.s_mark = yytable[yyn];
934 *++yystack.l_mark = yylval;
935 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
936 *++yystack.p_mark = yylloc;
939 if (yyerrflag > 0) --yyerrflag;
942 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
943 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
948 if (yyerrflag != 0) goto yyinrecovery;
953 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
956 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
957 * before looking for error recovery */
958 yystack.s_mark -= yym;
959 yystate = *yystack.s_mark;
960 yystack.l_mark -= yym;
961 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
962 yystack.p_mark -= yym;
970 YYParseState *save = yyps->save;
973 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
974 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
975 (int)(yylvp - yylvals - yyps->save->lexeme));
977 /* Memorize most forward-looking error state in case it's really an error. */
978 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
980 /* Free old saved error context state */
981 if (yyerrctx) yyFreeState(yyerrctx);
982 /* Create and fill out new saved error context state */
983 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
984 if (yyerrctx == NULL) goto yyenomem;
985 yyerrctx->save = yyps->save;
986 yyerrctx->state = yystate;
987 yyerrctx->errflag = yyerrflag;
988 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
989 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
990 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
991 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
992 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
993 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
994 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
996 yyerrctx->lexeme = (int) (yylvp - yylvals);
998 yylvp = yylvals + save->lexeme;
999 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1000 yylpp = yylpsns + save->lexeme;
1002 yylexp = yylexemes + save->lexeme;
1004 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1005 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1006 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1007 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1008 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1009 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1010 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1012 ctry = ++save->ctry;
1013 yystate = save->state;
1014 /* We tried shift, try reduce now */
1015 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1016 yyps->save = save->save;
1020 /* Nothing left on the stack -- error */
1025 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1028 /* Restore state as it was in the most forward-advanced error */
1029 yylvp = yylvals + yyerrctx->lexeme;
1030 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1031 yylpp = yylpsns + yyerrctx->lexeme;
1033 yylexp = yylexemes + yyerrctx->lexeme;
1034 yychar = yylexp[-1];
1036 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1039 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1040 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1041 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1042 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1043 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1044 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1045 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1047 yystate = yyerrctx->state;
1048 yyFreeState(yyerrctx);
1053 if (yynewerrflag == 0) goto yyinrecovery;
1054 #endif /* YYBTYACC */
1056 YYERROR_CALL("syntax error");
1057 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1058 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1062 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1073 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1074 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1078 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1079 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1081 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1082 yystate = yytable[yyn];
1083 *++yystack.s_mark = yytable[yyn];
1084 *++yystack.l_mark = yylval;
1085 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1086 /* lookahead position is error end position */
1087 yyerror_loc_range[1] = yylloc;
1088 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1089 *++yystack.p_mark = yyloc;
1097 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1098 YYDEBUGSTR, yydepth, *yystack.s_mark);
1100 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1101 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1102 /* the current TOS position is the error start position */
1103 yyerror_loc_range[0] = *yystack.p_mark;
1105 #if defined(YYDESTRUCT_CALL)
1108 #endif /* YYBTYACC */
1109 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1110 YYDESTRUCT_CALL("error: discarding state",
1111 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1113 YYDESTRUCT_CALL("error: discarding state",
1114 yystos[*yystack.s_mark], yystack.l_mark);
1115 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1116 #endif /* defined(YYDESTRUCT_CALL) */
1119 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1127 if (yychar == YYEOF) goto yyabort;
1131 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1132 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1133 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1136 #if defined(YYDESTRUCT_CALL)
1139 #endif /* YYBTYACC */
1140 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1141 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1143 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1144 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1145 #endif /* defined(YYDESTRUCT_CALL) */
1155 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1156 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1157 #ifdef YYSTYPE_TOSTRING
1160 #endif /* YYBTYACC */
1165 for (i = yym; i > 0; i--)
1167 if (i != yym) fputs(", ", stderr);
1168 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1169 yystack.l_mark[1-i]), stderr);
1174 fputc('\n', stderr);
1178 yyval = yystack.l_mark[1-yym];
1180 memset(&yyval, 0, sizeof yyval);
1181 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1183 /* Perform position reduction */
1184 memset(&yyloc, 0, sizeof(yyloc));
1187 #endif /* YYBTYACC */
1189 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1190 /* just in case YYERROR is invoked within the action, save
1191 the start of the rhs as the error start position */
1192 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1199 #line 35 "quote_calc2.y"
1203 #line 39 "quote_calc2.y"
1204 { printf("%d\n",yystack.l_mark[0]);}
1207 #line 41 "quote_calc2.y"
1208 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1211 #line 45 "quote_calc2.y"
1212 { yyval = yystack.l_mark[-1]; }
1215 #line 47 "quote_calc2.y"
1216 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1219 #line 49 "quote_calc2.y"
1220 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1223 #line 51 "quote_calc2.y"
1224 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1227 #line 53 "quote_calc2.y"
1228 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1231 #line 55 "quote_calc2.y"
1232 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1235 #line 57 "quote_calc2.y"
1236 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1239 #line 59 "quote_calc2.y"
1240 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1243 #line 61 "quote_calc2.y"
1244 { yyval = - yystack.l_mark[0]; }
1247 #line 63 "quote_calc2.y"
1248 { yyval = regs[yystack.l_mark[0]]; }
1251 #line 68 "quote_calc2.y"
1252 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1255 #line 70 "quote_calc2.y"
1256 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1258 #line 1259 "quote_calc2.tab.c"
1262 yystack.s_mark -= yym;
1263 yystate = *yystack.s_mark;
1264 yystack.l_mark -= yym;
1265 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1266 yystack.p_mark -= yym;
1269 if (yystate == 0 && yym == 0)
1274 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1275 #ifdef YYSTYPE_TOSTRING
1278 #endif /* YYBTYACC */
1279 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1281 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1285 *++yystack.s_mark = YYFINAL;
1286 *++yystack.l_mark = yyval;
1287 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1288 *++yystack.p_mark = yyloc;
1296 /* we're currently re-reading tokens */
1298 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1306 /* in trial mode; save scanner results for future parse attempts */
1307 if (yylvp == yylvlim)
1308 { /* Enlarge lexical value queue */
1309 size_t p = (size_t) (yylvp - yylvals);
1310 size_t s = (size_t) (yylvlim - yylvals);
1312 s += YYLVQUEUEGROWTH;
1313 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1315 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1317 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1318 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1321 yylvp = yylve = yylvals + p;
1322 yylvlim = yylvals + s;
1323 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1324 yylpp = yylpe = yylpsns + p;
1325 yylplim = yylpsns + s;
1327 yylexp = yylexemes + p;
1329 *yylexp = (YYINT) YYLEX;
1332 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1339 /* normal operation, no conflict encountered */
1340 #endif /* YYBTYACC */
1344 #endif /* YYBTYACC */
1345 if (yychar < 0) yychar = YYEOF;
1349 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1350 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1351 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1355 if (yychar == YYEOF) goto yyaccept;
1358 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1359 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1360 yystate = yytable[yyn];
1362 yystate = yydgoto[yym];
1366 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1367 #ifdef YYSTYPE_TOSTRING
1370 #endif /* YYBTYACC */
1371 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1373 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1376 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1377 *++yystack.s_mark = (YYINT) yystate;
1378 *++yystack.l_mark = yyval;
1379 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1380 *++yystack.p_mark = yyloc;
1385 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1387 if (yypath) YYABORT;
1390 YYParseState *save = yyps->save;
1391 yyps->save = save->save;
1392 save->save = yypath;
1397 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1398 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1402 yyFreeState(yyerrctx);
1405 yylvp = yylvals + yypath->lexeme;
1406 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1407 yylpp = yylpsns + yypath->lexeme;
1409 yylexp = yylexemes + yypath->lexeme;
1411 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1412 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1413 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1414 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1415 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1416 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1417 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1419 yystate = yypath->state;
1421 #endif /* YYBTYACC */
1424 YYERROR_CALL("yacc stack overflow");
1428 YYERROR_CALL("memory exhausted");
1430 #endif /* YYBTYACC */
1440 if (yyps->save) goto yyvalid;
1441 #endif /* YYBTYACC */
1445 #if defined(YYDESTRUCT_CALL)
1446 if (yychar != YYEOF && yychar != YYEMPTY)
1447 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1448 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1450 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1451 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1455 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1458 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1459 YYDESTRUCT_CALL("cleanup: discarding state",
1460 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1462 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1463 YYDESTRUCT_CALL("cleanup: discarding state",
1464 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1465 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1467 #endif /* defined(YYDESTRUCT_CALL) */
1472 yyFreeState(yyerrctx);
1477 YYParseState *save = yyps;
1484 YYParseState *save = yypath;
1485 yypath = save->save;
1489 #endif /* YYBTYACC */
1490 yyfreestack(&yystack);