1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent of 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_calc_parse
25 #define yylex quote_calc_lex
29 #define yyerror quote_calc_error
33 #define yychar quote_calc_char
37 #define yyval quote_calc_val
41 #define yylval quote_calc_lval
45 #define yydebug quote_calc_debug
49 #define yynerrs quote_calc_nerrs
53 #define yyerrflag quote_calc_errflag
54 #endif /* yyerrflag */
57 #define yylhs quote_calc_lhs
61 #define yylen quote_calc_len
65 #define yydefred quote_calc_defred
69 #define yystos quote_calc_stos
73 #define yydgoto quote_calc_dgoto
77 #define yysindex quote_calc_sindex
81 #define yyrindex quote_calc_rindex
85 #define yygindex quote_calc_gindex
89 #define yytable quote_calc_table
93 #define yycheck quote_calc_check
97 #define yyname quote_calc_name
101 #define yyrule quote_calc_rule
107 #define yycindex quote_calc_cindex
108 #endif /* yycindex */
111 #define yyctable quote_calc_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "quote_calc_"
120 #line 2 "quote_calc.y"
128 static void yyerror(const char *s);
130 #line 131 "quote_calc-s.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();
178 #define YYERRCODE 256
180 static const YYINT quote_calc_lhs[] = { -1,
181 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
182 2, 2, 2, 2, 2, 2, 3, 3,
184 static const YYINT quote_calc_len[] = { 2,
185 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
186 3, 3, 3, 2, 1, 1, 1, 2,
188 static const YYINT quote_calc_defred[] = { 1,
189 0, 0, 0, 17, 0, 0, 0, 0, 0, 3,
190 15, 0, 0, 0, 2, 0, 0, 0, 0, 0,
191 0, 0, 18, 0, 6, 0, 0, 0, 0, 0,
194 static const YYINT quote_calc_stos[] = { 0,
195 273, 256, 259, 269, 270, 40, 274, 275, 276, 10,
196 270, 275, 61, 275, 10, 257, 259, 261, 263, 265,
197 267, 124, 269, 275, 41, 275, 275, 275, 275, 275,
200 static const YYINT quote_calc_dgoto[] = { 1,
203 static const YYINT quote_calc_sindex[] = { 0,
204 -38, 5, -36, 0, -51, -36, 7, -121, -248, 0,
205 0, -243, -36, -22, 0, -36, -36, -36, -36, -36,
206 -36, -36, 0, -121, 0, -121, -121, -121, -121, -121,
209 static const YYINT quote_calc_rindex[] = { 0,
210 0, 0, 0, 0, -9, 0, 0, 13, -10, 0,
211 0, -5, 0, 0, 0, 0, 0, 0, 0, 0,
212 0, 0, 0, 15, 0, -3, -2, -1, 1, 2,
216 static const YYINT quote_calc_cindex[] = { 0,
217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
218 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
223 static const YYINT quote_calc_gindex[] = { 0,
226 #define YYTABLESIZE 258
227 static const YYINT quote_calc_table[] = { 16,
228 15, 6, 22, 6, 14, 13, 7, 8, 9, 13,
229 10, 11, 12, 16, 10, 17, 15, 18, 25, 19,
230 23, 20, 4, 21, 5, 0, 0, 0, 0, 0,
231 16, 0, 0, 0, 0, 14, 13, 7, 8, 9,
232 0, 10, 11, 12, 12, 0, 0, 14, 0, 0,
233 0, 0, 0, 0, 24, 0, 0, 26, 27, 28,
234 29, 30, 31, 32, 0, 0, 0, 0, 0, 0,
235 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
236 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
238 0, 22, 0, 0, 0, 0, 0, 0, 0, 0,
239 0, 0, 0, 16, 15, 0, 0, 0, 14, 13,
240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 0, 0, 0, 0, 0, 16, 0, 17, 0, 18,
242 0, 19, 0, 20, 0, 21, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
246 0, 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, 2, 0, 0,
250 3, 0, 3, 0, 0, 0, 0, 0, 0, 0,
251 4, 5, 4, 11, 16, 0, 17, 0, 18, 0,
252 19, 0, 20, 0, 21, 0, 16, 15, 16, 15,
253 16, 15, 16, 15, 16, 15, 16, 15,
255 static const YYINT quote_calc_check[] = { 10,
256 10, 40, 124, 40, 10, 10, 10, 10, 10, 61,
257 10, 10, 10, 257, 10, 259, 10, 261, 41, 263,
258 269, 265, 10, 267, 10, -1, -1, -1, -1, -1,
259 41, -1, -1, -1, -1, 41, 41, 41, 41, 41,
260 -1, 41, 41, 41, 3, -1, -1, 6, -1, -1,
261 -1, -1, -1, -1, 13, -1, -1, 16, 17, 18,
262 19, 20, 21, 22, -1, -1, -1, -1, -1, -1,
263 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
264 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
265 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
266 -1, 124, -1, -1, -1, -1, -1, -1, -1, -1,
267 -1, -1, -1, 124, 124, -1, -1, -1, 124, 124,
268 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, -1, -1, 257, -1, 259, -1, 261,
270 -1, 263, -1, 265, -1, 267, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 -1, -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, 256, -1, -1,
278 259, -1, 259, -1, -1, -1, -1, -1, -1, -1,
279 269, 270, 269, 270, 257, -1, 259, -1, 261, -1,
280 263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
281 261, 261, 263, 263, 265, 265, 267, 267,
284 static const YYINT quote_calc_ctable[] = { -1,
285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -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,
317 #define YYMAXTOKEN 271
318 #define YYUNDFTOKEN 277
319 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
321 static const char *const quote_calc_name[] = {
323 "$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,
324 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
325 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,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,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,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,"error","OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
331 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
332 "$accept","list","stat","expr","number","illegal-symbol",
334 static const char *const quote_calc_rule[] = {
337 "list : list stat '\\n'",
338 "list : list error '\\n'",
340 "stat : LETTER '=' expr",
341 "expr : '(' expr ')'",
342 "expr : expr OP_ADD expr",
343 "expr : expr OP_SUB expr",
344 "expr : expr OP_MUL expr",
345 "expr : expr OP_DIV expr",
346 "expr : expr OP_MOD expr",
347 "expr : expr OP_AND expr",
348 "expr : expr '|' expr",
349 "expr : OP_SUB expr",
353 "number : number DIGIT",
365 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
366 YYLTYPE yyloc; /* position returned by actions */
367 YYLTYPE yylloc; /* position from the lexer */
370 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
371 #ifndef YYLLOC_DEFAULT
372 #define YYLLOC_DEFAULT(loc, rhs, n) \
377 (loc).first_line = ((rhs)[-1]).last_line; \
378 (loc).first_column = ((rhs)[-1]).last_column; \
379 (loc).last_line = ((rhs)[-1]).last_line; \
380 (loc).last_column = ((rhs)[-1]).last_column; \
384 (loc).first_line = ((rhs)[ 0 ]).first_line; \
385 (loc).first_column = ((rhs)[ 0 ]).first_column; \
386 (loc).last_line = ((rhs)[n-1]).last_line; \
387 (loc).last_column = ((rhs)[n-1]).last_column; \
390 #endif /* YYLLOC_DEFAULT */
391 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
394 #ifndef YYLVQUEUEGROWTH
395 #define YYLVQUEUEGROWTH 32
397 #endif /* YYBTYACC */
399 /* define the initial stack-sizes */
402 #define YYMAXDEPTH YYSTACKSIZE
405 #define YYSTACKSIZE YYMAXDEPTH
407 #define YYSTACKSIZE 10000
408 #define YYMAXDEPTH 10000
412 #ifndef YYINITSTACKSIZE
413 #define YYINITSTACKSIZE 200
423 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
430 struct YYParseState_s
432 struct YYParseState_s *save; /* Previously saved parser state */
433 YYSTACKDATA yystack; /* saved parser stack */
434 int state; /* saved parser state */
435 int errflag; /* saved error recovery status */
436 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
437 YYINT ctry; /* saved index in yyctable[] for this conflict */
439 typedef struct YYParseState_s YYParseState;
440 #endif /* YYBTYACC */
441 /* variables for the parser stack */
442 static YYSTACKDATA yystack;
445 /* Current parser state */
446 static YYParseState *yyps = 0;
448 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
449 static YYParseState *yypath = 0;
451 /* Base of the lexical value queue */
452 static YYSTYPE *yylvals = 0;
454 /* Current position at lexical value queue */
455 static YYSTYPE *yylvp = 0;
457 /* End position of lexical value queue */
458 static YYSTYPE *yylve = 0;
460 /* The last allocated position at the lexical value queue */
461 static YYSTYPE *yylvlim = 0;
463 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
464 /* Base of the lexical position queue */
465 static YYLTYPE *yylpsns = 0;
467 /* Current position at lexical position queue */
468 static YYLTYPE *yylpp = 0;
470 /* End position of lexical position queue */
471 static YYLTYPE *yylpe = 0;
473 /* The last allocated position at the lexical position queue */
474 static YYLTYPE *yylplim = 0;
477 /* Current position at lexical token queue */
478 static short *yylexp = 0;
480 static short *yylexemes = 0;
481 #endif /* YYBTYACC */
482 #line 73 "quote_calc.y"
483 /* start of programs */
488 while(!feof(stdin)) {
495 yyerror(const char *s)
497 fprintf(stderr, "%s\n", s);
502 /* lexical analysis routine */
503 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
504 /* return DIGIT for a digit, yylval = 0 through 9 */
505 /* all other characters are returned immediately */
509 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
511 /* c is now nonblank */
523 #line 524 "quote_calc-s.tab.c"
525 /* For use in generated program */
526 #define yydepth (int)(yystack.s_mark - yystack.s_base)
528 #define yytrial (yyps->save)
529 #endif /* YYBTYACC */
532 #include <stdio.h> /* needed for printf */
535 #include <stdlib.h> /* needed for malloc, etc */
536 #include <string.h> /* needed for memset */
538 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
539 static int yygrowstack(YYSTACKDATA *data)
545 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
549 if ((newsize = data->stacksize) == 0)
550 newsize = YYINITSTACKSIZE;
551 else if (newsize >= YYMAXDEPTH)
553 else if ((newsize *= 2) > YYMAXDEPTH)
554 newsize = YYMAXDEPTH;
556 i = (int) (data->s_mark - data->s_base);
557 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
561 data->s_base = newss;
562 data->s_mark = newss + i;
564 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
568 data->l_base = newvs;
569 data->l_mark = newvs + i;
571 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
572 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
576 data->p_base = newps;
577 data->p_mark = newps + i;
580 data->stacksize = newsize;
581 data->s_last = data->s_base + newsize - 1;
585 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
590 #if YYPURE || defined(YY_NO_LEAKS)
591 static void yyfreestack(YYSTACKDATA *data)
595 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
598 memset(data, 0, sizeof(*data));
601 #define yyfreestack(data) /* nothing */
602 #endif /* YYPURE || defined(YY_NO_LEAKS) */
605 static YYParseState *
606 yyNewState(unsigned size)
608 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
609 if (p == NULL) return NULL;
611 p->yystack.stacksize = size;
614 p->yystack.s_base = NULL;
615 p->yystack.l_base = NULL;
616 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
617 p->yystack.p_base = NULL;
621 p->yystack.s_base = (short *) malloc(size * sizeof(short));
622 if (p->yystack.s_base == NULL) return NULL;
623 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
624 if (p->yystack.l_base == NULL) return NULL;
625 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
626 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
627 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
628 if (p->yystack.p_base == NULL) return NULL;
629 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
636 yyFreeState(YYParseState *p)
638 yyfreestack(&p->yystack);
641 #endif /* YYBTYACC */
643 #define YYABORT goto yyabort
644 #define YYREJECT goto yyabort
645 #define YYACCEPT goto yyaccept
646 #define YYERROR goto yyerrlab
648 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
649 #define YYVALID_NESTED do { if (yyps->save && \
650 yyps->save->save == 0) goto yyvalid; } while(0)
651 #endif /* YYBTYACC */
656 int yym, yyn, yystate, yyresult;
659 YYParseState *yyerrctx = NULL;
660 #endif /* YYBTYACC */
661 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
662 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
667 if ((yys = getenv("YYDEBUG")) != 0)
670 if (yyn >= '0' && yyn <= '9')
674 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
678 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
680 #endif /* YYBTYACC */
687 memset(&yystack, 0, sizeof(yystack));
690 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
691 yystack.s_mark = yystack.s_base;
692 yystack.l_mark = yystack.l_base;
693 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
694 yystack.p_mark = yystack.p_base;
700 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
707 /* we're currently re-reading tokens */
709 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
717 /* in trial mode; save scanner results for future parse attempts */
718 if (yylvp == yylvlim)
719 { /* Enlarge lexical value queue */
720 size_t p = (size_t) (yylvp - yylvals);
721 size_t s = (size_t) (yylvlim - yylvals);
723 s += YYLVQUEUEGROWTH;
724 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
725 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
726 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
727 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
729 yylvp = yylve = yylvals + p;
730 yylvlim = yylvals + s;
731 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
732 yylpp = yylpe = yylpsns + p;
733 yylplim = yylpsns + s;
735 yylexp = yylexemes + p;
737 *yylexp = (short) YYLEX;
740 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
747 /* normal operation, no conflict encountered */
748 #endif /* YYBTYACC */
752 #endif /* YYBTYACC */
753 if (yychar < 0) yychar = YYEOF;
754 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
758 yys = yyname[YYTRANSLATE(yychar)];
759 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
760 YYDEBUGSTR, yydepth, yystate, yychar, yys);
761 #ifdef YYSTYPE_TOSTRING
764 #endif /* YYBTYACC */
765 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
773 /* Do we have a conflict? */
774 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
775 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
784 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
785 YYDEBUGSTR, yydepth, yystate);
787 /* Switch to the next conflict context */
792 if (save->state != yystate) YYABORT;
799 /* Unresolved conflict - start/continue trial parse */
804 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
806 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
808 fputs("Starting trial parse.\n", stderr);
811 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
812 if (save == NULL) goto yyenomem;
813 save->save = yyps->save;
814 save->state = yystate;
815 save->errflag = yyerrflag;
816 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
817 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
818 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
819 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
820 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
821 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
822 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
825 if (yyctable[ctry] == -1)
828 if (yydebug && yychar >= YYEOF)
829 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
834 if (yyps->save == NULL)
836 /* If this is a first conflict in the stack, start saving lexemes */
839 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
840 if (yylexemes == NULL) goto yyenomem;
841 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
842 if (yylvals == NULL) goto yyenomem;
843 yylvlim = yylvals + YYLVQUEUEGROWTH;
844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
845 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
846 if (yylpsns == NULL) goto yyenomem;
847 yylplim = yylpsns + YYLVQUEUEGROWTH;
852 yylvp = yylve = yylvals;
853 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
854 yylpp = yylpe = yylpsns;
860 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
863 *yylexp = (short) yychar;
871 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
877 save->lexeme = (int) (yylvp - yylvals);
880 if (yytable[yyn] == ctry)
884 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
885 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
890 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
895 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
897 yystate = yyctable[ctry];
898 *++yystack.s_mark = (short) yystate;
899 *++yystack.l_mark = yylval;
900 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
901 *++yystack.p_mark = yylloc;
904 if (yyerrflag > 0) --yyerrflag;
909 yyn = yyctable[ctry];
912 } /* End of code dealing with conflicts */
913 #endif /* YYBTYACC */
914 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
915 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
919 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
920 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
922 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
923 yystate = yytable[yyn];
924 *++yystack.s_mark = yytable[yyn];
925 *++yystack.l_mark = yylval;
926 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
927 *++yystack.p_mark = yylloc;
930 if (yyerrflag > 0) --yyerrflag;
933 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
934 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
939 if (yyerrflag != 0) goto yyinrecovery;
952 YYParseState *save = yyps->save;
955 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
956 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
957 (int)(yylvp - yylvals - yyps->save->lexeme));
959 /* Memorize most forward-looking error state in case it's really an error. */
960 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
962 /* Free old saved error context state */
963 if (yyerrctx) yyFreeState(yyerrctx);
964 /* Create and fill out new saved error context state */
965 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
966 if (yyerrctx == NULL) goto yyenomem;
967 yyerrctx->save = yyps->save;
968 yyerrctx->state = yystate;
969 yyerrctx->errflag = yyerrflag;
970 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
971 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
972 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
973 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
974 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
975 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
976 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
978 yyerrctx->lexeme = (int) (yylvp - yylvals);
980 yylvp = yylvals + save->lexeme;
981 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
982 yylpp = yylpsns + save->lexeme;
984 yylexp = yylexemes + save->lexeme;
986 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
987 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
988 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
989 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
990 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
991 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
992 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
995 yystate = save->state;
996 /* We tried shift, try reduce now */
997 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
998 yyps->save = save->save;
1002 /* Nothing left on the stack -- error */
1007 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1010 /* Restore state as it was in the most forward-advanced error */
1011 yylvp = yylvals + yyerrctx->lexeme;
1012 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1013 yylpp = yylpsns + yyerrctx->lexeme;
1015 yylexp = yylexemes + yyerrctx->lexeme;
1016 yychar = yylexp[-1];
1018 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1021 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1022 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1023 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1024 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1025 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1026 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1027 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1029 yystate = yyerrctx->state;
1030 yyFreeState(yyerrctx);
1035 if (yynewerrflag == 0) goto yyinrecovery;
1036 #endif /* YYBTYACC */
1038 YYERROR_CALL("syntax error");
1039 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1040 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1055 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1056 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1060 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1061 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1063 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1064 yystate = yytable[yyn];
1065 *++yystack.s_mark = yytable[yyn];
1066 *++yystack.l_mark = yylval;
1067 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1068 /* lookahead position is error end position */
1069 yyerror_loc_range[1] = yylloc;
1070 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1071 *++yystack.p_mark = yyloc;
1079 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1080 YYDEBUGSTR, yydepth, *yystack.s_mark);
1082 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1083 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1084 /* the current TOS position is the error start position */
1085 yyerror_loc_range[0] = *yystack.p_mark;
1087 #if defined(YYDESTRUCT_CALL)
1090 #endif /* YYBTYACC */
1091 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1092 YYDESTRUCT_CALL("error: discarding state",
1093 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1095 YYDESTRUCT_CALL("error: discarding state",
1096 yystos[*yystack.s_mark], yystack.l_mark);
1097 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1098 #endif /* defined(YYDESTRUCT_CALL) */
1101 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1109 if (yychar == YYEOF) goto yyabort;
1113 yys = yyname[YYTRANSLATE(yychar)];
1114 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1115 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1118 #if defined(YYDESTRUCT_CALL)
1121 #endif /* YYBTYACC */
1122 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1123 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1125 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1126 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1127 #endif /* defined(YYDESTRUCT_CALL) */
1137 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1138 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1139 #ifdef YYSTYPE_TOSTRING
1142 #endif /* YYBTYACC */
1147 for (i = yym; i > 0; i--)
1149 if (i != yym) fputs(", ", stderr);
1150 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1151 yystack.l_mark[1-i]), stderr);
1156 fputc('\n', stderr);
1160 yyval = yystack.l_mark[1-yym];
1162 memset(&yyval, 0, sizeof yyval);
1163 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1165 /* Perform position reduction */
1166 memset(&yyloc, 0, sizeof(yyloc));
1169 #endif /* YYBTYACC */
1171 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1172 /* just in case YYERROR is invoked within the action, save
1173 the start of the rhs as the error start position */
1174 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1181 #line 35 "quote_calc.y"
1185 #line 39 "quote_calc.y"
1186 { printf("%d\n",yystack.l_mark[0]);}
1189 #line 41 "quote_calc.y"
1190 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1193 #line 45 "quote_calc.y"
1194 { yyval = yystack.l_mark[-1]; }
1197 #line 47 "quote_calc.y"
1198 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1201 #line 49 "quote_calc.y"
1202 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1205 #line 51 "quote_calc.y"
1206 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1209 #line 53 "quote_calc.y"
1210 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1213 #line 55 "quote_calc.y"
1214 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1217 #line 57 "quote_calc.y"
1218 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1221 #line 59 "quote_calc.y"
1222 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1225 #line 61 "quote_calc.y"
1226 { yyval = - yystack.l_mark[0]; }
1229 #line 63 "quote_calc.y"
1230 { yyval = regs[yystack.l_mark[0]]; }
1233 #line 68 "quote_calc.y"
1234 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1237 #line 70 "quote_calc.y"
1238 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1240 #line 1241 "quote_calc-s.tab.c"
1244 yystack.s_mark -= yym;
1245 yystate = *yystack.s_mark;
1246 yystack.l_mark -= yym;
1247 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1248 yystack.p_mark -= yym;
1251 if (yystate == 0 && yym == 0)
1256 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1257 #ifdef YYSTYPE_TOSTRING
1260 #endif /* YYBTYACC */
1261 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1263 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1267 *++yystack.s_mark = YYFINAL;
1268 *++yystack.l_mark = yyval;
1269 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1270 *++yystack.p_mark = yyloc;
1278 /* we're currently re-reading tokens */
1280 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1288 /* in trial mode; save scanner results for future parse attempts */
1289 if (yylvp == yylvlim)
1290 { /* Enlarge lexical value queue */
1291 size_t p = (size_t) (yylvp - yylvals);
1292 size_t s = (size_t) (yylvlim - yylvals);
1294 s += YYLVQUEUEGROWTH;
1295 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1297 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1299 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1300 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1303 yylvp = yylve = yylvals + p;
1304 yylvlim = yylvals + s;
1305 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1306 yylpp = yylpe = yylpsns + p;
1307 yylplim = yylpsns + s;
1309 yylexp = yylexemes + p;
1311 *yylexp = (short) YYLEX;
1314 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1321 /* normal operation, no conflict encountered */
1322 #endif /* YYBTYACC */
1326 #endif /* YYBTYACC */
1327 if (yychar < 0) yychar = YYEOF;
1328 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1332 yys = yyname[YYTRANSLATE(yychar)];
1333 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1334 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1338 if (yychar == YYEOF) goto yyaccept;
1341 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1342 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1343 yystate = yytable[yyn];
1345 yystate = yydgoto[yym];
1349 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1350 #ifdef YYSTYPE_TOSTRING
1353 #endif /* YYBTYACC */
1354 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1356 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1359 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1360 *++yystack.s_mark = (short) yystate;
1361 *++yystack.l_mark = yyval;
1362 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1363 *++yystack.p_mark = yyloc;
1368 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1370 if (yypath) YYABORT;
1373 YYParseState *save = yyps->save;
1374 yyps->save = save->save;
1375 save->save = yypath;
1380 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1381 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1385 yyFreeState(yyerrctx);
1388 yylvp = yylvals + yypath->lexeme;
1389 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1390 yylpp = yylpsns + yypath->lexeme;
1392 yylexp = yylexemes + yypath->lexeme;
1394 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1395 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1396 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1397 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1398 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1399 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1400 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1402 yystate = yypath->state;
1404 #endif /* YYBTYACC */
1407 YYERROR_CALL("yacc stack overflow");
1411 YYERROR_CALL("memory exhausted");
1413 #endif /* YYBTYACC */
1423 if (yyps->save) goto yyvalid;
1424 #endif /* YYBTYACC */
1428 #if defined(YYDESTRUCT_CALL)
1429 if (yychar != YYEOF && yychar != YYEMPTY)
1430 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1431 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1433 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1434 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1438 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1441 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1442 YYDESTRUCT_CALL("cleanup: discarding state",
1443 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1445 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1446 YYDESTRUCT_CALL("cleanup: discarding state",
1447 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1448 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1450 #endif /* defined(YYDESTRUCT_CALL) */
1455 yyFreeState(yyerrctx);
1460 YYParseState *save = yyps;
1467 YYParseState *save = yypath;
1468 yypath = save->save;
1472 #endif /* YYBTYACC */
1473 yyfreestack(&yystack);