1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4
5 #define YYBYACC 1
6 #define YYMAJOR 1
7 #define YYMINOR 9
8 #define YYCHECK "yyyymmdd"
9
10 #define YYEMPTY (-1)
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
14 #define YYENOMEM (-2)
15 #define YYEOF 0
16 #undef YYBTYACC
17 #define YYBTYACC 0
18 #define YYDEBUGSTR YYPREFIX "debug"
19
20 #ifndef yyparse
21 #define yyparse expr.oxout_parse
22 #endif /* yyparse */
23
24 #ifndef yylex
25 #define yylex expr.oxout_lex
26 #endif /* yylex */
27
28 #ifndef yyerror
29 #define yyerror expr.oxout_error
30 #endif /* yyerror */
31
32 #ifndef yychar
33 #define yychar expr.oxout_char
34 #endif /* yychar */
35
36 #ifndef yyval
37 #define yyval expr.oxout_val
38 #endif /* yyval */
39
40 #ifndef yylval
41 #define yylval expr.oxout_lval
42 #endif /* yylval */
43
44 #ifndef yydebug
45 #define yydebug expr.oxout_debug
46 #endif /* yydebug */
47
48 #ifndef yynerrs
49 #define yynerrs expr.oxout_nerrs
50 #endif /* yynerrs */
51
52 #ifndef yyerrflag
53 #define yyerrflag expr.oxout_errflag
54 #endif /* yyerrflag */
55
56 #ifndef yylhs
57 #define yylhs expr.oxout_lhs
58 #endif /* yylhs */
59
60 #ifndef yylen
61 #define yylen expr.oxout_len
62 #endif /* yylen */
63
64 #ifndef yydefred
65 #define yydefred expr.oxout_defred
66 #endif /* yydefred */
67
68 #ifndef yystos
69 #define yystos expr.oxout_stos
70 #endif /* yystos */
71
72 #ifndef yydgoto
73 #define yydgoto expr.oxout_dgoto
74 #endif /* yydgoto */
75
76 #ifndef yysindex
77 #define yysindex expr.oxout_sindex
78 #endif /* yysindex */
79
80 #ifndef yyrindex
81 #define yyrindex expr.oxout_rindex
82 #endif /* yyrindex */
83
84 #ifndef yygindex
85 #define yygindex expr.oxout_gindex
86 #endif /* yygindex */
87
88 #ifndef yytable
89 #define yytable expr.oxout_table
90 #endif /* yytable */
91
92 #ifndef yycheck
93 #define yycheck expr.oxout_check
94 #endif /* yycheck */
95
96 #ifndef yyname
97 #define yyname expr.oxout_name
98 #endif /* yyname */
99
100 #ifndef yyrule
101 #define yyrule expr.oxout_rule
102 #endif /* yyrule */
103
104 #if YYBTYACC
105
106 #ifndef yycindex
107 #define yycindex expr.oxout_cindex
108 #endif /* yycindex */
109
110 #ifndef yyctable
111 #define yyctable expr.oxout_ctable
112 #endif /* yyctable */
113
114 #endif /* YYBTYACC */
115
116 #define YYPREFIX "expr.oxout_"
117
118 #define YYPURE 0
119
120 #line 5 "expr.oxout.y"
121 #include <stdlib.h>
122 #include <string.h>
123 #line 8 "expr.Y"
124
125 #include "expr.oxout.h"
126 #include <stdio.h>
127
128 extern int yylex(void);
129 extern void yyerror(const char *);
130 #line 27 "expr.oxout.y"
131 #include <limits.h>
132 #define yyyR USHRT_MAX
133 #ifdef YYSTYPE
134 #undef YYSTYPE_IS_DECLARED
135 #define YYSTYPE_IS_DECLARED 1
136 #endif
137 #ifndef YYSTYPE_IS_DECLARED
138 #define YYSTYPE_IS_DECLARED 1
139 #line 31 "expr.oxout.y"
140 typedef union {
141 struct yyyOxAttrbs {
142 struct yyyStackItem *yyyOxStackItem;
143 } yyyOxAttrbs;
144 } YYSTYPE;
145 #endif /* !YYSTYPE_IS_DECLARED */
146 #line 38 "expr.oxout.y"
147 #include <stdio.h>
148 #include <stdarg.h>
149
150 static int yyyYok = 1;
151
152 extern yyyFT yyyRCIL[];
153
154 void yyyExecuteRRsection(yyyGNT *rootNode);
155 void yyyYoxInit(void);
156 void yyyDecorate(void);
157 struct yyyOxAttrbs; /* hack required to compensate for 'msta' behavior */
158 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
159 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...);
160 void yyyCheckUnsolvedInstTrav(yyyGNT *rootNode,long *nNZrc,long *cycleSum);
161 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode);
162 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode);
163 void yyyabort(void);
164
165 #line 166 "expr.oxout.tab.c"
166
167 /* compatibility with bison */
168 #ifdef YYPARSE_PARAM
169 /* compatibility with FreeBSD */
170 # ifdef YYPARSE_PARAM_TYPE
171 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
172 # else
173 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
174 # endif
175 #else
176 # define YYPARSE_DECL() yyparse(void)
177 #endif
178
179 /* Parameters sent to lex. */
180 #ifdef YYLEX_PARAM
181 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
182 # define YYLEX yylex(YYLEX_PARAM)
183 #else
184 # define YYLEX_DECL() yylex(void)
185 # define YYLEX yylex()
186 #endif
187
188 /* Parameters sent to yyerror. */
189 #ifndef YYERROR_DECL
190 #define YYERROR_DECL() yyerror(const char *s)
191 #endif
192 #ifndef YYERROR_CALL
193 #define YYERROR_CALL(msg) yyerror(msg)
194 #endif
195
196 extern int YYPARSE_DECL();
197
198 #define ID 257
199 #define CONST 258
200 #define YYERRCODE 256
201 typedef short YYINT;
202 static const YYINT expr.oxout_lhs[] = { -1,
203 2, 0, 1, 3, 3, 3, 3, 3, 3, 3,
204 };
205 static const YYINT expr.oxout_len[] = { 2,
206 0, 2, 1, 3, 3, 3, 3, 3, 1, 1,
207 };
208 static const YYINT expr.oxout_defred[] = { 1,
209 0, 0, 9, 10, 0, 2, 0, 0, 0, 0,
210 0, 0, 8, 0, 0, 4, 0,
211 };
212 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
213 static const YYINT expr.oxout_stos[] = { 0,
214 260, 262, 257, 258, 40, 261, 263, 263, 43, 45,
215 42, 47, 41, 263, 263, 263, 263,
216 };
217 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
218 static const YYINT expr.oxout_dgoto[] = { 1,
219 6, 2, 7,
220 };
221 static const YYINT expr.oxout_sindex[] = { 0,
222 0, -40, 0, 0, -40, 0, -18, -24, -40, -40,
223 -40, -40, 0, -37, -37, 0, -39,
224 };
225 static const YYINT expr.oxout_rindex[] = { 0,
226 0, 0, 0, 0, 0, 0, 6, 0, 0, 0,
227 0, 0, 0, 2, 8, 0, 1,
228 };
229 #if YYBTYACC
230 static const YYINT expr.oxout_cindex[] = { 0,
231 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
232 0, 0, 0, 0, 0, 0, 0,
233 };
234 #endif
235 static const YYINT expr.oxout_gindex[] = { 0,
236 0, 0, 4,
237 };
238 #define YYTABLESIZE 218
239 static const YYINT expr.oxout_table[] = { 5,
240 6, 5, 11, 0, 11, 3, 0, 7, 8, 12,
241 0, 0, 14, 15, 16, 17, 13, 11, 9, 0,
242 10, 0, 12, 11, 9, 0, 10, 0, 12, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 6, 5, 6, 5, 6, 5, 6, 7, 0,
245 7, 0, 7, 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, 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, 0, 0, 0,
258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
261 0, 0, 0, 0, 0, 0, 3, 4,
262 };
263 static const YYINT expr.oxout_check[] = { 40,
264 0, 0, 42, -1, 42, 0, -1, 0, 5, 47,
265 -1, -1, 9, 10, 11, 12, 41, 42, 43, -1,
266 45, -1, 47, 42, 43, -1, 45, -1, 47, -1,
267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
268 -1, 41, 41, 43, 43, 45, 45, 47, 41, -1,
269 43, -1, 45, -1, -1, -1, -1, -1, -1, -1,
270 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 -1, -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, -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, 257, 258,
286 };
287 #if YYBTYACC
288 static const YYINT expr.oxout_ctable[] = { -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,
311 };
312 #endif
313 #define YYFINAL 1
314 #ifndef YYDEBUG
315 #define YYDEBUG 0
316 #endif
317 #define YYMAXTOKEN 258
318 #define YYUNDFTOKEN 264
319 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
320 #if YYDEBUG
321 static const char *const expr.oxout_name[] = {
322
323 "$end",0,0,0,0,0,0,0,0,0,0,0,0,0,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,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,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,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,"error","ID",
330 "CONST","$accept","yyyAugNonterm","s","$$1","expr","illegal-symbol",
331 };
332 static const char *const expr.oxout_rule[] = {
333 "$accept : yyyAugNonterm",
334 "$$1 :",
335 "yyyAugNonterm : $$1 s",
336 "s : expr",
337 "expr : expr '*' expr",
338 "expr : expr '+' expr",
339 "expr : expr '/' expr",
340 "expr : expr '-' expr",
341 "expr : '(' expr ')'",
342 "expr : ID",
343 "expr : CONST",
344
345 };
346 #endif
347
348 int yydebug;
349 int yynerrs;
350
351 int yyerrflag;
352 int yychar;
353 YYSTYPE yyval;
354 YYSTYPE yylval;
355 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
356 YYLTYPE yyloc; /* position returned by actions */
357 YYLTYPE yylloc; /* position from the lexer */
358 #endif
359
360 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
361 #ifndef YYLLOC_DEFAULT
362 #define YYLLOC_DEFAULT(loc, rhs, n) \
363 do \
364 { \
365 if (n == 0) \
366 { \
367 (loc).first_line = ((rhs)[-1]).last_line; \
368 (loc).first_column = ((rhs)[-1]).last_column; \
369 (loc).last_line = ((rhs)[-1]).last_line; \
370 (loc).last_column = ((rhs)[-1]).last_column; \
371 } \
372 else \
373 { \
374 (loc).first_line = ((rhs)[ 0 ]).first_line; \
375 (loc).first_column = ((rhs)[ 0 ]).first_column; \
376 (loc).last_line = ((rhs)[n-1]).last_line; \
377 (loc).last_column = ((rhs)[n-1]).last_column; \
378 } \
379 } while (0)
380 #endif /* YYLLOC_DEFAULT */
381 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
382 #if YYBTYACC
383
384 #ifndef YYLVQUEUEGROWTH
385 #define YYLVQUEUEGROWTH 32
386 #endif
387 #endif /* YYBTYACC */
388
389 /* define the initial stack-sizes */
390 #ifdef YYSTACKSIZE
391 #undef YYMAXDEPTH
392 #define YYMAXDEPTH YYSTACKSIZE
393 #else
394 #ifdef YYMAXDEPTH
395 #define YYSTACKSIZE YYMAXDEPTH
396 #else
397 #define YYSTACKSIZE 10000
398 #define YYMAXDEPTH 10000
399 #endif
400 #endif
401
402 #ifndef YYINITSTACKSIZE
403 #define YYINITSTACKSIZE 200
404 #endif
405
406 typedef struct {
407 unsigned stacksize;
408 YYINT *s_base;
409 YYINT *s_mark;
410 YYINT *s_last;
411 YYSTYPE *l_base;
412 YYSTYPE *l_mark;
413 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
414 YYLTYPE *p_base;
415 YYLTYPE *p_mark;
416 #endif
417 } YYSTACKDATA;
418 #if YYBTYACC
419
420 struct YYParseState_s
421 {
422 struct YYParseState_s *save; /* Previously saved parser state */
423 YYSTACKDATA yystack; /* saved parser stack */
424 int state; /* saved parser state */
425 int errflag; /* saved error recovery status */
426 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
427 YYINT ctry; /* saved index in yyctable[] for this conflict */
428 };
429 typedef struct YYParseState_s YYParseState;
430 #endif /* YYBTYACC */
431 /* variables for the parser stack */
432 static YYSTACKDATA yystack;
433 #if YYBTYACC
434
435 /* Current parser state */
436 static YYParseState *yyps = 0;
437
438 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
439 static YYParseState *yypath = 0;
440
441 /* Base of the lexical value queue */
442 static YYSTYPE *yylvals = 0;
443
444 /* Current position at lexical value queue */
445 static YYSTYPE *yylvp = 0;
446
447 /* End position of lexical value queue */
448 static YYSTYPE *yylve = 0;
449
450 /* The last allocated position at the lexical value queue */
451 static YYSTYPE *yylvlim = 0;
452
453 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
454 /* Base of the lexical position queue */
455 static YYLTYPE *yylpsns = 0;
456
457 /* Current position at lexical position queue */
458 static YYLTYPE *yylpp = 0;
459
460 /* End position of lexical position queue */
461 static YYLTYPE *yylpe = 0;
462
463 /* The last allocated position at the lexical position queue */
464 static YYLTYPE *yylplim = 0;
465 #endif
466
467 /* Current position at lexical token queue */
468 static YYINT *yylexp = 0;
469
470 static YYINT *yylexemes = 0;
471 #endif /* YYBTYACC */
472 #line 53 "expr.Y"
473
474
475 int yyparse(void);
476
main()477 int main()
478 {yyparse();
479 }
480
481
482
483 #line 138 "expr.oxout.y"
484 long yyySSALspaceSize = 20000;
485 long yyyRSmaxSize = 1000;
486 long yyyTravStackMaxSize = 2000;
487
488 struct yyySolvedSAlistCell {yyyWAT attrbNum;
489 long next;
490 };
491
492 #define yyyLambdaSSAL 0
493 long yyySSALCfreeList = yyyLambdaSSAL;
494 long yyyNewSSALC = 1;
495
496 struct yyySolvedSAlistCell *yyySSALspace;
497
498 long yyyNbytesStackStg;
499
500
501
502 yyyFT yyyRCIL[1];
503
504 short yyyIIIEL[] = {0,
505 0,2,6,10,14,18,22,24,
506 };
507
508 long yyyIIEL[] = {
509 0,0,0,0,0,0,0,0,0,0,0,0,
510 0,0,0,0,0,0,0,0,0,0,0,0,
511 1,1,
512 };
513
514 long yyyIEL[] = {
515 0,0,0,
516 };
517
518 yyyFT yyyEntL[1];
519
yyyfatal(char * msg)520 void yyyfatal(char *msg)
521 {fputs(msg,stderr);exit(-1);}
522
523
524
525 #define yyySSALof 'S'
526 #define yyyRSof 'q'
527 #define yyyTSof 't'
528
529
530
yyyHandleOverflow(char which)531 void yyyHandleOverflow(char which)
532 {char *msg1,*msg2;
533 long oldSize,newSize;
534 switch(which)
535 {
536 case yyySSALof :
537 msg1 = "SSAL overflow: ";
538 oldSize = yyySSALspaceSize;
539 break;
540 case yyyRSof :
541 msg1 = "ready set overflow: ";
542 oldSize = yyyRSmaxSize;
543 break;
544 case yyyTSof :
545 msg1 = "traversal stack overflow: ";
546 oldSize = yyyTravStackMaxSize;
547 break;
548 default :;
549 }
550 newSize = (3*oldSize)/2;
551 if (newSize < 100) newSize = 100;
552 fputs(msg1,stderr);
553 fprintf(stderr,"size was %ld.\n",oldSize);
554 msg2 = " Have to modify evaluator: -Y%c%ld.\n";
555 fprintf(stderr,msg2,which,newSize);
556 exit(-1);
557 }
558
559
560
yyySignalEnts(yyyGNT * node,long startP,long stopP)561 void yyySignalEnts(yyyGNT *node,long startP,long stopP)
562 {yyyGNT *dumNode;
563
564 while (startP < stopP)
565 {
566 if (!yyyEntL[startP]) dumNode = node;
567 else dumNode = (node->cL)[yyyEntL[startP]-1];
568 if (!(--((dumNode->refCountList)[yyyEntL[startP+1]]
569 )
570 )
571 )
572 {
573 if (++yyyRSTop == yyyAfterRS)
574 {yyyHandleOverflow(yyyRSof);
575 break;
576 }
577 yyyRSTop->node = dumNode;
578 yyyRSTop->whichSym = yyyEntL[startP];
579 yyyRSTop->wa = yyyEntL[startP+1];
580 }
581 startP += 2;
582 }
583 }
584
585
586
587
588
589
yyySolveAndSignal()590 void yyySolveAndSignal() {
591 long yyyiDum,*yyypL;
592 int yyyws,yyywa;
593 yyyGNT *yyyRSTopN,*yyyRefN;
594 yyyParent yyyRSTopNp;
595
596
597 yyyRSTopNp = (yyyRSTopN = yyyRSTop->node)->parent;
598 yyyRefN= (yyyws = (yyyRSTop->whichSym))?yyyRSTopNp.noderef:yyyRSTopN;
599 yyywa = yyyRSTop->wa;
600 yyyRSTop--;
601 switch(yyyRefN->prodNum) {
602 case 1: /***yacc rule 1***/
603 switch (yyyws) {
604 }
605 break;
606 case 2: /***yacc rule 2***/
607 switch (yyyws) {
608 }
609 break;
610 case 3: /***yacc rule 3***/
611 switch (yyyws) {
612 }
613 break;
614 case 4: /***yacc rule 4***/
615 switch (yyyws) {
616 }
617 break;
618 case 5: /***yacc rule 5***/
619 switch (yyyws) {
620 }
621 break;
622 case 6: /***yacc rule 6***/
623 switch (yyyws) {
624 }
625 break;
626 case 7: /***yacc rule 7***/
627 switch (yyyws) {
628 case 1: /**/
629 switch (yyywa) {
630 }
631 break;
632 }
633 break;
634 case 8: /***yacc rule 8***/
635 switch (yyyws) {
636 case 1: /**/
637 switch (yyywa) {
638 }
639 break;
640 }
641 break;
642 } /* switch */
643
644 if (yyyws) /* the just-solved instance was inherited. */
645 {if (yyyRSTopN->prodNum)
646 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopN->prodNum]] + yyywa;
647 yyySignalEnts(yyyRSTopN,yyyIEL[yyyiDum],
648 yyyIEL[yyyiDum+1]
649 );
650 }
651 }
652 else /* the just-solved instance was synthesized. */
653 {if (!(yyyRSTopN->parentIsStack)) /* node has a parent. */
654 {yyyiDum = yyyIIEL[yyyIIIEL[yyyRSTopNp.noderef->prodNum] +
655 yyyRSTopN->whichSym
656 ] +
657 yyywa;
658 yyySignalEnts(yyyRSTopNp.noderef,
659 yyyIEL[yyyiDum],
660 yyyIEL[yyyiDum+1]
661 );
662 }
663 else /* node is still on the stack--it has no parent yet. */
664 {yyypL = &(yyyRSTopNp.stackref->solvedSAlist);
665 if (yyySSALCfreeList == yyyLambdaSSAL)
666 {yyySSALspace[yyyNewSSALC].next = *yyypL;
667 if ((*yyypL = yyyNewSSALC++) == yyySSALspaceSize)
668 yyyHandleOverflow(yyySSALof);
669 }
670 else
671 {yyyiDum = yyySSALCfreeList;
672 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
673 yyySSALspace[yyyiDum].next = *yyypL;
674 *yyypL = yyyiDum;
675 }
676 yyySSALspace[*yyypL].attrbNum = yyywa;
677 }
678 }
679
680 } /* yyySolveAndSignal */
681
682
683
684
685
686
687 #define condStg unsigned int conds;
688 #define yyyClearConds {yyyTST->conds = 0;}
689 #define yyySetCond(n) {yyyTST->conds += (1<<(n));}
690 #define yyyCond(n) ((yyyTST->conds & (1<<(n)))?1:0)
691
692
693
694 struct yyyTravStackItem {yyyGNT *node;
695 char isReady;
696 condStg
697 };
698
699
700
yyyDoTraversals(yyyGNT * rootNode)701 void yyyDoTraversals(yyyGNT *rootNode)
702 {struct yyyTravStackItem *yyyTravStack,*yyyTST,*yyyAfterTravStack;
703 yyyGNT *yyyTSTn,**yyyCLptr2;
704 int yyyi,yyyRL,yyyPass;
705 int i;
706
707 if (!yyyYok) return;
708 if ((yyyTravStack =
709 ((struct yyyTravStackItem *)
710 calloc((size_t)yyyTravStackMaxSize,
711 (size_t)sizeof(struct yyyTravStackItem)
712 )
713 )
714 )
715 ==
716 (struct yyyTravStackItem *)NULL
717 )
718 {fputs("malloc error in traversal stack allocation\n",stderr);
719 exit(-1);
720 }
721
722 yyyAfterTravStack = yyyTravStack + yyyTravStackMaxSize;
723 yyyTravStack++;
724
725
726 for (yyyi=0; yyyi<2; yyyi++) {
727 yyyTST = yyyTravStack;
728 yyyTST->node = rootNode;
729 yyyTST->isReady = 0;
730 yyyClearConds
731
732 while(yyyTST >= yyyTravStack)
733 {yyyTSTn = yyyTST->node;
734 if (yyyTST->isReady)
735 {yyyPass = 1;
736 goto yyyTravSwitch;
737 yyyTpop:
738 yyyTST--;
739 }
740 else
741 {yyyPass = 0;
742 goto yyyTravSwitch;
743 yyyTpush:
744 yyyTST->isReady = 1;
745 if (yyyTSTn->prodNum)
746 {if (yyyRL)
747 {yyyCLptr2 = yyyTSTn->cL;
748 i = yyyTSTn->cLlen;
749 while (i--)
750 {if (++yyyTST == yyyAfterTravStack)
751 yyyHandleOverflow(yyyTSof);
752 else
753 {yyyTST->node = *yyyCLptr2;
754 yyyTST->isReady = 0;
755 yyyClearConds
756 }
757 yyyCLptr2++;
758 }
759 } /* right to left */
760 else /* left to right */
761 {i = yyyTSTn->cLlen;
762 yyyCLptr2 = yyyTSTn->cL + i;
763 while (i--)
764 {yyyCLptr2--;
765 if (++yyyTST == yyyAfterTravStack)
766 yyyHandleOverflow(yyyTSof);
767 else
768 {yyyTST->node = *yyyCLptr2;
769 yyyTST->isReady = 0;
770 yyyClearConds
771 }
772 }
773 } /* left to right */
774 }
775 } /* else */
776 continue;
777 yyyTravSwitch:
778 switch(yyyTSTn->prodNum) {
779 case 1:
780 switch(yyyi) {
781 case 0:
782 switch(yyyPass) {
783 case 0:
784 yyyRL = 0;yyySetCond(0)
785
786 if (!
787 #line 24 "expr.Y"
788 (1)
789 #line 444 "expr.oxout.y"
790 ) yyySetCond(1)
791 yyySetCond(2)
792
793 case 1:
794
795 if (yyyCond(0) != yyyPass) {
796 #line 24 "expr.Y"
797
798 #line 453 "expr.oxout.y"
799 }
800 if (yyyCond(1) != yyyPass) {
801 #line 24 "expr.Y"
802 printf("\n");
803
804 #line 459 "expr.oxout.y"
805 }
806 if (yyyCond(2) != yyyPass) {
807 #line 25 "expr.Y"
808 printf("prefix: ");
809
810 #line 465 "expr.oxout.y"
811 }
812 break;
813 }
814 break;
815 case 1:
816 switch(yyyPass) {
817 case 0:
818 yyyRL = 0;
819 if (
820 #line 23 "expr.Y"
821 (1)
822 #line 477 "expr.oxout.y"
823 ) yyySetCond(2)
824
825 case 1:
826
827 if (yyyCond(0) != yyyPass) {
828 #line 22 "expr.Y"
829 printf("\n");
830
831 #line 486 "expr.oxout.y"
832 }
833 if (yyyCond(1) != yyyPass) {
834 #line 23 "expr.Y"
835
836 #line 491 "expr.oxout.y"
837 }
838 if (yyyCond(2) != yyyPass) {
839 #line 23 "expr.Y"
840 printf("postfix: ")/* missing ; */
841
842 #line 497 "expr.oxout.y"
843 }
844 break;
845 }
846 break;
847 }
848
849 break;
850 case 2:
851 switch(yyyi) {
852 case 0:
853 switch(yyyPass) {
854 case 0:
855 yyyRL = 0;yyySetCond(0)
856
857 case 1:
858
859 if (yyyCond(0) != yyyPass) {
860 #line 29 "expr.Y"
861 printf(" * ");
862
863 #line 518 "expr.oxout.y"
864 }
865 break;
866 }
867 break;
868 case 1:
869 switch(yyyPass) {
870 case 0:
871 yyyRL = 0;
872 case 1:
873
874 if (yyyCond(0) != yyyPass) {
875 #line 28 "expr.Y"
876 printf(" * ");
877
878 #line 533 "expr.oxout.y"
879 }
880 break;
881 }
882 break;
883 }
884
885 break;
886 case 3:
887 switch(yyyi) {
888 case 0:
889 switch(yyyPass) {
890 case 0:
891 yyyRL = 0;yyySetCond(0)
892
893 case 1:
894
895 if (yyyCond(0) != yyyPass) {
896 #line 32 "expr.Y"
897 printf(" + ");
898
899 #line 554 "expr.oxout.y"
900 }
901 break;
902 }
903 break;
904 case 1:
905 switch(yyyPass) {
906 case 0:
907 yyyRL = 0;
908 case 1:
909
910 if (yyyCond(0) != yyyPass) {
911 #line 33 "expr.Y"
912 printf(" + ");
913
914 #line 569 "expr.oxout.y"
915 }
916 break;
917 }
918 break;
919 }
920
921 break;
922 case 4:
923 switch(yyyi) {
924 case 0:
925 switch(yyyPass) {
926 case 0:
927 yyyRL = 0;yyySetCond(0)
928
929 case 1:
930
931 if (yyyCond(0) != yyyPass) {
932 #line 37 "expr.Y"
933 printf(" / ");
934
935 #line 590 "expr.oxout.y"
936 }
937 break;
938 }
939 break;
940 case 1:
941 switch(yyyPass) {
942 case 0:
943 yyyRL = 0;
944 case 1:
945
946 if (yyyCond(0) != yyyPass) {
947 #line 36 "expr.Y"
948 printf(" / ");
949
950 #line 605 "expr.oxout.y"
951 }
952 break;
953 }
954 break;
955 }
956
957 break;
958 case 5:
959 switch(yyyi) {
960 case 0:
961 switch(yyyPass) {
962 case 0:
963 yyyRL = 0;yyySetCond(0)
964
965 case 1:
966
967 if (yyyCond(0) != yyyPass) {
968 #line 41 "expr.Y"
969 printf(" - ");
970
971 #line 626 "expr.oxout.y"
972 }
973 break;
974 }
975 break;
976 case 1:
977 switch(yyyPass) {
978 case 0:
979 yyyRL = 0;
980 case 1:
981
982 if (yyyCond(0) != yyyPass) {
983 #line 40 "expr.Y"
984 printf(" - ");
985
986 #line 641 "expr.oxout.y"
987 }
988 break;
989 }
990 break;
991 }
992
993 break;
994 case 6:
995 switch(yyyi) {
996 case 0:
997 switch(yyyPass) {
998 case 0:
999 yyyRL = 0;
1000 case 1:
1001
1002 break;
1003 }
1004 break;
1005 case 1:
1006 switch(yyyPass) {
1007 case 0:
1008 yyyRL = 0;
1009 case 1:
1010
1011 break;
1012 }
1013 break;
1014 }
1015
1016 break;
1017 case 7:
1018 switch(yyyi) {
1019 case 0:
1020 switch(yyyPass) {
1021 case 0:
1022 yyyRL = 0;yyySetCond(0)
1023
1024 case 1:
1025
1026 if (yyyCond(0) != yyyPass) {
1027 #line 46 "expr.Y"
1028 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1029
1030 #line 685 "expr.oxout.y"
1031 }
1032 break;
1033 }
1034 break;
1035 case 1:
1036 switch(yyyPass) {
1037 case 0:
1038 yyyRL = 0;
1039 case 1:
1040
1041 if (yyyCond(0) != yyyPass) {
1042 #line 45 "expr.Y"
1043 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1044
1045 #line 700 "expr.oxout.y"
1046 }
1047 break;
1048 }
1049 break;
1050 }
1051
1052 break;
1053 case 8:
1054 switch(yyyi) {
1055 case 0:
1056 switch(yyyPass) {
1057 case 0:
1058 yyyRL = 0;yyySetCond(0)
1059
1060 case 1:
1061
1062 if (yyyCond(0) != yyyPass) {
1063 #line 50 "expr.Y"
1064 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1065
1066 #line 721 "expr.oxout.y"
1067 }
1068 break;
1069 }
1070 break;
1071 case 1:
1072 switch(yyyPass) {
1073 case 0:
1074 yyyRL = 0;
1075 case 1:
1076
1077 if (yyyCond(0) != yyyPass) {
1078 #line 49 "expr.Y"
1079 printf(" %s ",yyyTSTn->cL[0]->yyyAttrbs.yyyAttrb1.lexeme);
1080
1081 #line 736 "expr.oxout.y"
1082 }
1083 break;
1084 }
1085 break;
1086 }
1087
1088 break;
1089 } /* switch */
1090 if (yyyPass) goto yyyTpop; else goto yyyTpush;
1091 } /* while */
1092 } /* for */
1093 } /* yyyDoTraversals */
1094
yyyExecuteRRsection(yyyGNT * rootNode)1095 void yyyExecuteRRsection(yyyGNT *rootNode) {
1096 int yyyi;
1097 long cycleSum = 0;
1098 long nNZrc = 0;
1099
1100 if (!yyyYok) return;
1101 yyyCheckUnsolvedInstTrav(rootNode,&nNZrc,&cycleSum);
1102 if (nNZrc)
1103 {
1104 fputs("\n\n\n**********\n",stderr);
1105 fputs("cycle detected in completed parse tree",stderr);
1106 fputs(" after decoration.\n",stderr);
1107 #if CYCLE_VERBOSE
1108 fprintf(stderr,
1109 "number of unsolved attribute instances == %ld.\n",
1110 nNZrc
1111 );
1112 fprintf(stderr,
1113 "total number of remaining dependencies == %ld.\n",
1114 cycleSum
1115 );
1116 fputs("average number of remaining dependencies\n",stderr);
1117 fprintf(stderr," per unsolved instance == %f.\n",
1118 ((float)(cycleSum)/(float)(nNZrc))
1119 );
1120 #endif
1121 fprintf(stderr,
1122 "searching parse tree for %ld unsolved instances:\n",
1123 nNZrc
1124 );
1125 yyyUnsolvedInstSearchTravAux(rootNode);
1126 }
1127 yyyDoTraversals(rootNode);
1128 } /* yyyExecuteRRsection */
1129
1130
1131
1132 yyyWAT yyyLRCIL[2] = {0,0,
1133 };
1134
1135
1136
yyyYoxInit(void)1137 void yyyYoxInit(void)
1138 {
1139 static int yyyInitDone = 0;
1140 if (yyyInitDone) return;
1141
1142 if ((yyyRS = (struct yyyRSitem *)
1143 calloc((size_t)(yyyRSmaxSize+1), (size_t)sizeof(struct yyyRSitem))
1144 )
1145 ==
1146 ((struct yyyRSitem *) NULL)
1147 )
1148 yyyfatal("malloc error in ox ready set space allocation\n");
1149 yyyRS++;
1150 yyyAfterRS = yyyRS + yyyRSmaxSize;
1151
1152
1153 if ((yyySSALspace = (struct yyySolvedSAlistCell *)
1154 calloc((size_t)(yyySSALspaceSize+1), (size_t)sizeof(struct yyySolvedSAlistCell))
1155 )
1156 ==
1157 ((struct yyySolvedSAlistCell *) NULL)
1158 )
1159 yyyfatal("malloc error in stack solved list space allocation\n");
1160 yyyInitDone = 1;
1161
1162 yyyRSTop = yyyRS - 1;
1163 } /* yyyYoxInit */
1164
1165
1166
yyyDecorate(void)1167 void yyyDecorate(void)
1168 {
1169 while (yyyRSTop >= yyyRS)
1170 yyySolveAndSignal();
1171 }
1172
1173
1174
yyyGenIntNode(long yyyProdNum,int yyyRHSlength,int yyyNattrbs,struct yyyOxAttrbs * yyval_OxAttrbs,...)1175 void yyyGenIntNode(long yyyProdNum, int yyyRHSlength, int yyyNattrbs, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1176 {yyyWST i;
1177 yyySIT **yyyOxStackItem = &yyval_OxAttrbs->yyyOxStackItem;
1178 yyyGNT *gnpDum;
1179 va_list ap;
1180
1181 *yyyOxStackItem = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1182 if (*yyyOxStackItem == (yyySIT *) NULL)
1183 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1184 (*yyyOxStackItem)->node =
1185 (yyyGNT *) malloc((size_t)sizeof(yyyGNT));
1186 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1187 yyyfatal("malloc error in ox node space allocation\n");
1188 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1189 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1190 (*yyyOxStackItem)->node->parentIsStack = 1;
1191 (*yyyOxStackItem)->node->cLlen = yyyRHSlength;
1192 (*yyyOxStackItem)->node->cL =
1193 (yyyGNT **) calloc((size_t)yyyRHSlength, (size_t)sizeof(yyyGNT *));
1194 if ((*yyyOxStackItem)->node->cL == (yyyGNT **) NULL)
1195 yyyfatal("malloc error in ox child list space allocation\n");
1196 (*yyyOxStackItem)->node->refCountListLen = yyyNattrbs;
1197 (*yyyOxStackItem)->node->refCountList =
1198 (yyyRCT *) calloc((size_t)yyyNattrbs, (size_t)sizeof(yyyRCT));
1199 if ((*yyyOxStackItem)->node->refCountList == (yyyRCT *) NULL)
1200 yyyfatal("malloc error in ox reference count list space allocation\n");
1201 (*yyyOxStackItem)->node->prodNum = yyyProdNum;
1202 va_start(ap, yyval_OxAttrbs);
1203 for (i=1;i<=yyyRHSlength;i++)
1204 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1205 gnpDum = (*yyyOxStackItem)->node->cL[i-1] = yaccStDum->node;
1206 gnpDum->whichSym = i;
1207 gnpDum->parent.noderef = (*yyyOxStackItem)->node;
1208 gnpDum->parentIsStack = 0;
1209 }
1210 va_end(ap);
1211 }
1212
1213
1214
1215 #define yyyDECORfREQ 50
1216
1217
1218
yyyAdjustINRC(long yyyProdNum,int yyyRHSlength,long startP,long stopP,struct yyyOxAttrbs * yyval_OxAttrbs,...)1219 void yyyAdjustINRC(long yyyProdNum, int yyyRHSlength, long startP, long stopP, struct yyyOxAttrbs *yyval_OxAttrbs, ...)
1220 {yyyWST i;
1221 yyySIT *yyyOxStackItem = yyval_OxAttrbs->yyyOxStackItem;
1222 long SSALptr,SSALptrHead,*cPtrPtr;
1223 long *pL;
1224 yyyGNT *gnpDum;
1225 long iTemp;
1226 long nextP;
1227 static unsigned short intNodeCount = yyyDECORfREQ;
1228 va_list ap;
1229
1230 nextP = startP;
1231 while (nextP < stopP)
1232 {if (yyyRCIL[nextP] == yyyR)
1233 {(yyyOxStackItem->node->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1234 }
1235 else
1236 {(((yyyOxStackItem->node->cL)[yyyRCIL[nextP]])->refCountList)[yyyRCIL[nextP+1]] = yyyRCIL[nextP+2];
1237 }
1238 nextP += 3;
1239 }
1240 pL = yyyIIEL + yyyIIIEL[yyyProdNum];
1241 va_start(ap, yyval_OxAttrbs);
1242 for (i=1;i<=yyyRHSlength;i++)
1243 {yyySIT *yaccStDum = va_arg(ap,struct yyyOxAttrbs *)->yyyOxStackItem;
1244 pL++;
1245 SSALptrHead = SSALptr = *(cPtrPtr = &(yaccStDum->solvedSAlist));
1246 if (SSALptr != yyyLambdaSSAL)
1247 {*cPtrPtr = yyyLambdaSSAL;
1248 do
1249 {
1250 iTemp = (*pL+yyySSALspace[SSALptr].attrbNum);
1251 yyySignalEnts(yyyOxStackItem->node,
1252 yyyIEL[iTemp],
1253 yyyIEL[iTemp+1]
1254 );
1255 SSALptr = *(cPtrPtr = &(yyySSALspace[SSALptr].next));
1256 }
1257 while (SSALptr != yyyLambdaSSAL);
1258 *cPtrPtr = yyySSALCfreeList;
1259 yyySSALCfreeList = SSALptrHead;
1260 }
1261 }
1262 va_end(ap);
1263 nextP = startP + 2;
1264 while (nextP < stopP)
1265 {if (!yyyRCIL[nextP])
1266 {if (yyyRCIL[nextP-2] == yyyR)
1267 {pL = &(yyyOxStackItem->solvedSAlist);
1268 if (yyySSALCfreeList == yyyLambdaSSAL)
1269 {yyySSALspace[yyyNewSSALC].next = *pL;
1270 if ((*pL = yyyNewSSALC++) == yyySSALspaceSize)
1271 yyyHandleOverflow(yyySSALof);
1272 }
1273 else
1274 {iTemp = yyySSALCfreeList;
1275 yyySSALCfreeList = yyySSALspace[yyySSALCfreeList].next;
1276 yyySSALspace[iTemp].next = *pL;
1277 *pL = iTemp;
1278 }
1279 yyySSALspace[*pL].attrbNum = yyyRCIL[nextP-1];
1280 }
1281 else
1282 {if ((gnpDum = (yyyOxStackItem->node->cL)[yyyRCIL[nextP-2]])->prodNum != 0)
1283 {
1284 iTemp = yyyIIEL[yyyIIIEL[gnpDum->prodNum]] + yyyRCIL[nextP-1];
1285 yyySignalEnts(gnpDum,
1286 yyyIEL[iTemp],
1287 yyyIEL[iTemp+1]
1288 );
1289 }
1290 }
1291 }
1292 nextP += 3;
1293 }
1294 if (!--intNodeCount)
1295 {intNodeCount = yyyDECORfREQ;
1296 yyyDecorate();
1297 }
1298 }
1299
1300
1301
yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE * yylval)1302 void yyyGenLeaf(int nAttrbs,int typeNum,long startP,long stopP,YYSTYPE *yylval)
1303 {yyyRCT *rcPdum;
1304 yyySIT **yyyOxStackItem = &yylval->yyyOxAttrbs.yyyOxStackItem;
1305 (*yyyOxStackItem) = (yyySIT *) malloc((size_t)sizeof(yyySIT));
1306 if ((*yyyOxStackItem) == (yyySIT *) NULL)
1307 yyyfatal("malloc error in ox yacc semantic stack space allocation\n");
1308 (*yyyOxStackItem)->node =
1309 (yyyGNT *) malloc((size_t)sizeof(yyyGNT))
1310 ;
1311 if ((*yyyOxStackItem)->node == (yyyGNT *) NULL)
1312 yyyfatal("malloc error in ox node space allocation\n");
1313 (*yyyOxStackItem)->solvedSAlist = yyyLambdaSSAL;
1314 (*yyyOxStackItem)->node->parent.stackref = *yyyOxStackItem;
1315 (*yyyOxStackItem)->node->parentIsStack = 1;
1316 (*yyyOxStackItem)->node->cLlen = 0;
1317 (*yyyOxStackItem)->node->cL = (yyyGNT **)NULL;
1318 (*yyyOxStackItem)->node->refCountListLen = nAttrbs;
1319 rcPdum = (*yyyOxStackItem)->node->refCountList =
1320 (yyyRCT *) calloc((size_t)nAttrbs, (size_t)sizeof(yyyRCT));
1321 if (rcPdum == (yyyRCT *) NULL)
1322 yyyfatal("malloc error in ox reference count list space allocation\n");
1323 while (startP < stopP) rcPdum[yyyLRCIL[startP++]] = 0;
1324 (*yyyOxStackItem)->node->prodNum = 0;
1325 (*yyyOxStackItem)->node->whichSym = 0;
1326 }
1327
1328
1329
yyyabort(void)1330 void yyyabort(void)
1331 {yyyYok = 0;
1332 }
1333
1334
1335
1336
1337
1338 #define yyyLastProdNum 8
1339
1340
1341 #define yyyNsorts 1
1342
1343
1344 int yyyProdsInd[] = {
1345 0,
1346 0, 2, 6, 10, 14, 18, 22, 24,
1347 26,
1348 };
1349
1350
1351 int yyyProds[][2] = {
1352 { 116, 0},{ 462, 0},{ 462, 0},{ 462, 0},{ 412, 0},
1353 { 462, 0},{ 462, 0},{ 462, 0},{ 420, 0},{ 462, 0},
1354 { 462, 0},{ 462, 0},{ 452, 0},{ 462, 0},{ 462, 0},
1355 { 462, 0},{ 436, 0},{ 462, 0},{ 462, 0},{ 396, 0},
1356 { 462, 0},{ 404, 0},{ 462, 0},{ 619, 1},{ 462, 0},
1357 { 567, 1},
1358 };
1359
1360
1361 int yyySortsInd[] = {
1362 0,
1363 0,
1364 1,
1365 };
1366
1367
1368 int yyySorts[] = {
1369 413,
1370 };
1371
1372
1373
1374 char *yyyStringTab[] = {
1375 0,0,0,0,0,
1376 0,0,0,0,0,
1377 0,0,0,0,0,
1378 0,0,0,0,0,
1379 0,0,0,0,0,
1380 0,0,0,0,0,
1381 0,0,0,0,0,
1382 0,0,0,0,0,
1383 0,0,0,0,0,
1384 0,0,0,0,0,
1385 0,0,0,0,0,
1386 0,0,0,0,0,
1387 0,0,0,0,0,
1388 0,0,0,0,0,
1389 0,0,0,0,0,
1390 0,0,0,0,0,
1391 0,0,0,0,0,
1392 0,0,0,0,0,
1393 0,0,0,0,0,
1394 0,0,0,0,0,
1395 0,0,0,0,0,
1396 0,0,0,0,0,
1397 0,0,0,0,0,
1398 0,"s",0,0,0,
1399 0,0,"y",0,0,
1400 0,0,0,0,0,
1401 0,0,0,0,0,
1402 0,0,0,0,0,
1403 0,0,0,0,0,
1404 0,0,0,0,0,
1405 0,0,0,0,0,
1406 0,0,0,0,0,
1407 0,0,0,0,0,
1408 0,0,0,0,0,
1409 0,0,0,0,0,
1410 0,0,0,0,0,
1411 0,0,0,0,0,
1412 0,0,0,0,0,
1413 0,0,0,0,0,
1414 0,0,0,0,0,
1415 0,0,0,0,0,
1416 0,0,0,0,0,
1417 0,0,0,0,0,
1418 0,0,0,0,0,
1419 0,0,0,0,0,
1420 0,0,0,0,0,
1421 0,0,0,0,0,
1422 0,0,0,0,0,
1423 0,0,0,0,0,
1424 0,0,0,0,0,
1425 0,0,0,0,0,
1426 0,0,0,0,0,
1427 0,0,0,0,0,
1428 0,0,0,0,0,
1429 0,0,0,0,0,
1430 0,0,0,0,0,
1431 0,0,0,0,0,
1432 0,0,0,0,0,
1433 0,0,0,0,0,
1434 0,0,0,0,0,
1435 0,0,0,0,0,
1436 0,0,0,0,0,
1437 0,0,0,0,0,
1438 0,0,0,0,0,
1439 0,0,0,0,0,
1440 0,"LRpre",0,0,0,
1441 0,0,0,0,0,
1442 0,0,0,0,0,
1443 0,0,0,0,0,
1444 0,0,0,0,0,
1445 0,0,0,0,0,
1446 0,0,0,0,0,
1447 0,0,0,0,0,
1448 0,0,0,0,0,
1449 0,0,0,0,0,
1450 0,0,0,0,0,
1451 0,0,0,0,0,
1452 0,0,0,0,0,
1453 0,0,0,0,0,
1454 0,"'('",0,0,0,
1455 0,0,0,0,"')'",
1456 0,0,0,0,0,
1457 0,0,"'*'","lexeme",0,
1458 0,0,0,0,0,
1459 "'+'",0,0,0,0,
1460 0,0,0,0,0,
1461 0,0,0,0,0,
1462 0,"'-'",0,0,0,
1463 0,0,0,0,0,
1464 0,0,0,0,0,
1465 0,0,"'/'",0,0,
1466 0,0,0,0,0,
1467 0,0,"expr",0,0,
1468 0,0,0,0,0,
1469 0,0,0,0,0,
1470 0,"printf",0,0,0,
1471 0,0,0,0,0,
1472 0,0,0,0,0,
1473 0,0,0,0,0,
1474 0,0,0,0,0,
1475 0,0,0,0,0,
1476 0,0,0,0,0,
1477 0,0,0,0,0,
1478 0,0,0,0,0,
1479 0,0,0,0,0,
1480 0,0,0,0,0,
1481 0,0,0,0,0,
1482 0,0,0,0,0,
1483 0,0,0,0,0,
1484 0,0,0,0,0,
1485 0,0,0,0,0,
1486 0,0,0,0,0,
1487 0,0,0,0,0,
1488 0,0,"CONST","LRpost",0,
1489 0,0,0,0,0,
1490 0,0,0,0,0,
1491 0,0,0,0,0,
1492 0,0,0,0,0,
1493 0,0,0,0,0,
1494 0,0,0,0,0,
1495 0,0,0,0,0,
1496 0,0,0,0,0,
1497 0,0,0,0,0,
1498 0,0,0,0,"ID",
1499 0,0,0,0,0,
1500 0,0,0,0,0,
1501 0,0,0,0,0,
1502 0,0,0,0,0,
1503 0,0,0,0,0,
1504 0,0,0,0,0,
1505 0,0,0,0,0,
1506 0,0,0,0,0,
1507 0,0,0,0,0,
1508 0,0,0,0,0,
1509 0,0,0,0,0,
1510 0,0,0,0,0,
1511 0,0,0,0,0,
1512 0,0,0,0,0,
1513 0,0,0,0,0,
1514 0,0,0,0,0,
1515 0,0,0,0,0,
1516 0,0,0,0,0,
1517 0,0,0,0,0,
1518 0,0,0,0,0,
1519 0,0,0,0,0,
1520 0,0,0,0,0,
1521 0,0,0,0,0,
1522 0,0,0,0,0,
1523 0,0,0,0,0,
1524 0,0,0,0,0,
1525 0,0,0,0,0,
1526 0,0,0,0,0,
1527 0,0,0,0,0,
1528 0,0,0,0,0,
1529 0,0,0,0,0,
1530 0,0,0,0,0,
1531 0,0,0,0,0,
1532 0,0,0,0,0,
1533 0,0,0,0,0,
1534 0,0,0,0,0,
1535 0,0,0,0,0,
1536 0,0,0,0,0,
1537 0,0,0,0,0,
1538 0,0,0,0,0,
1539 0,0,0,0,0,
1540 0,0,0,0,0,
1541 0,0,0,0,0,
1542 0,0,0,0,0,
1543 0,0,0,0,0,
1544 0,0,0,0,0,
1545 0,0,0,0,0,
1546 0,0,0,0,0,
1547 0,0,0,0,0,
1548 0,0,0,0,0,
1549 0,0,0,0,0,
1550 0,0,0,0,0,
1551 0,0,0,0,0,
1552 0,0,0,0,0,
1553 0,0,0,0,0,
1554 0,0,0,0,0,
1555 0,0,0,0,0,
1556 0,0,0,0,0,
1557 0,0,0,0,0,
1558 0,0,0,0,0,
1559 0,0,0,0,0,
1560 0,0,0,0,0,
1561 0,0,0,0,0,
1562 0,0,0,0,0,
1563 0,0,0,0,0,
1564 0,0,0,0,0,
1565 0,0,0,0,0,
1566 0,0,0,0,0,
1567 0,0,0,0,0,
1568 0,0,0,0,0,
1569 0,0,0,0,0,
1570 0,0,0,0,0,
1571 0,0,0,0,0,
1572 0,0,0,0,0,
1573 0,0,0,0,0,
1574 0,0,0,0,0,
1575 0,0,0,0,0,
1576 0,0,0,0,0,
1577 0,0,0,0,0,
1578 0,0,0,0,0,
1579 0,0,0,0,0,
1580 0,0,0,0,0,
1581 0,0,0,0,0,
1582 0,0,0,0,0,
1583 0,0,0,0,0,
1584 0,0,0,0,0,
1585 0,0,0,0,0,
1586 0,0,0,0,0,
1587 0,0,0,0,0,
1588 0,0,0,0,0,
1589 0,0,0,0,0,
1590 0,0,0,0,0,
1591 0,0,0,0,0,
1592 0,0,0,0,0,
1593 0,0,0,0,0,
1594 0,0,0,0,0,
1595 0,0,0,0,0,
1596 0,0,0,0,0,
1597 0,0,0,0,0,
1598 0,0,0,0,0,
1599 0,0,0,0,0,
1600 0,0,0,0,0,
1601 0,0,0,0,0,
1602 0,0,0,0,0,
1603 0,0,0,0,0,
1604 0,0,0,0,0,
1605 0,0,0,0,0,
1606 0,0,0,0,0,
1607 0,0,0,0,0,
1608 0,0,0,0,0,
1609 0,0,0,0,0,
1610 0,0,0,0,0,
1611 0,0,0,0,0,
1612 0,0,0,0,0,
1613 0,0,0,0,0,
1614 0,0,0,0,0,
1615 0,0,0,0,0,
1616 0,0,0,0,0,
1617 0,0,0,0,0,
1618 0,0,0,0,0,
1619 0,0,0,0,0,
1620 0,0,0,0,0,
1621 0,
1622 };
1623
1624
1625
1626 #define yyySizeofProd(num) (yyyProdsInd[(num)+1] - yyyProdsInd[(num)])
1627
1628 #define yyyGSoccurStr(prodNum,symPos) \
1629 (yyyStringTab[yyyProds[yyyProdsInd[(prodNum)] + (symPos)][0]])
1630
1631 #define yyySizeofSort(num) (yyySortsInd[(num)+1] - yyySortsInd[(num)])
1632
1633 #define yyySortOf(prodNum,symPos) \
1634 (yyyProds[yyyProdsInd[(prodNum)] + (symPos)][1])
1635
1636 #define yyyAttrbStr(prodNum,symPos,attrbNum) \
1637 (yyyStringTab[yyySorts[yyySortsInd[yyySortOf(prodNum,symPos)] + \
1638 (attrbNum) \
1639 ] \
1640 ] \
1641 )
1642
1643
1644
yyyShowProd(int i)1645 void yyyShowProd(int i)
1646 {int j,nSyms;
1647
1648 nSyms = yyySizeofProd(i);
1649 for (j=0; j<nSyms; j++)
1650 {
1651 fprintf(stderr,"%s",yyyGSoccurStr(i,j));
1652 if (j == 0) fputs(" : ",stderr); else putc(' ',stderr);
1653 }
1654 fputs(";\n",stderr);
1655 }
1656
1657
1658
yyyShowProds()1659 void yyyShowProds()
1660 {int i; for (i=1; i<=yyyLastProdNum; i++) yyyShowProd(i);}
1661
1662
1663
yyyShowSymsAndSorts()1664 void yyyShowSymsAndSorts()
1665 {int i;
1666
1667 for (i=1; i<=yyyLastProdNum; i++)
1668 {int j, nSyms;
1669
1670 fprintf(stderr,
1671 "\n\n\n---------------------------------- %3.1d\n",i);
1672 /* yyyShowProd(i); */
1673 nSyms = yyySizeofProd(i);
1674 for (j=0; j<nSyms; j++)
1675 {int k, sortSize;
1676
1677 fprintf(stderr,"%s\n",yyyGSoccurStr(i,j));
1678 sortSize = yyySizeofSort(yyySortOf(i,j));
1679 for (k=0; k<sortSize; k++)
1680 fprintf(stderr," %s\n",yyyAttrbStr(i,j,k));
1681 if (j == 0) fputs("->\n",stderr);
1682 else
1683 putc('\n',stderr);
1684 }
1685 }
1686 }
1687
1688
1689
yyyCheckNodeInstancesSolved(yyyGNT * np)1690 void yyyCheckNodeInstancesSolved(yyyGNT *np)
1691 {int mysort,sortSize,i,prodNum,symPos,inTerminalNode;
1692 int nUnsolvedInsts = 0;
1693
1694 if (np->prodNum != 0)
1695 {inTerminalNode = 0;
1696 prodNum = np->prodNum;
1697 symPos = 0;
1698 }
1699 else
1700 {inTerminalNode = 1;
1701 prodNum = np->parent.noderef->prodNum;
1702 symPos = np->whichSym;
1703 }
1704 mysort = yyySortOf(prodNum,symPos);
1705 sortSize = yyySizeofSort(mysort);
1706 for (i=0; i<sortSize; i++)
1707 if ((np->refCountList)[i] != 0) nUnsolvedInsts += 1;
1708 if (nUnsolvedInsts)
1709 {fprintf(stderr,
1710 "\nFound node that has %d unsolved attribute instance(s).\n",
1711 nUnsolvedInsts
1712 );
1713 fprintf(stderr,"Node is labeled \"%s\".\n",
1714 yyyGSoccurStr(prodNum,symPos));
1715 if (inTerminalNode)
1716 {fputs("Node is terminal. Its parent production is:\n ",stderr);
1717 yyyShowProd(prodNum);
1718 }
1719 else
1720 {fputs("Node is nonterminal. ",stderr);
1721 if (!(np->parentIsStack))
1722 {fprintf(stderr,
1723 "Node is %dth child in its parent production:\n ",
1724 np->whichSym
1725 );
1726 yyyShowProd(np->parent.noderef->prodNum);
1727 }
1728 fputs("Node is on left hand side of this production:\n ",stderr);
1729 yyyShowProd(np->prodNum);
1730 }
1731 fputs("The following instances are unsolved:\n",stderr);
1732 for (i=0; i<sortSize; i++)
1733 if ((np->refCountList)[i] != 0)
1734 fprintf(stderr," %-16s still has %1d dependencies.\n",
1735 yyyAttrbStr(prodNum,symPos,i),(np->refCountList)[i]);
1736 }
1737 }
1738
1739
1740
yyyCheckUnsolvedInstTrav(yyyGNT * pNode,long * nNZrc,long * cycleSum)1741 void yyyCheckUnsolvedInstTrav(yyyGNT *pNode,long *nNZrc,long *cycleSum)
1742 {yyyGNT **yyyCLpdum;
1743 yyyRCT *rcp;
1744 int i;
1745
1746 /* visit the refCountList of each node in the tree, and sum the non-zero refCounts */
1747 rcp = pNode->refCountList;
1748 i = pNode->refCountListLen;
1749 while (i--)
1750 if (*rcp++) {*cycleSum += *(rcp - 1); (*nNZrc)++;}
1751 yyyCLpdum = pNode->cL;
1752 i = pNode->cLlen;
1753 while (i--)
1754 {
1755 yyyCheckUnsolvedInstTrav(*yyyCLpdum,nNZrc,cycleSum);
1756 yyyCLpdum++;
1757 }
1758 }
1759
1760
1761
yyyUnsolvedInstSearchTravAux(yyyGNT * pNode)1762 void yyyUnsolvedInstSearchTravAux(yyyGNT *pNode)
1763 {yyyGNT **yyyCLpdum;
1764 int i;
1765
1766 yyyCheckNodeInstancesSolved(pNode);
1767 yyyCLpdum = pNode->cL;
1768 i = pNode->cLlen;
1769 while (i--)
1770 {
1771 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1772 yyyCLpdum++;
1773 }
1774 }
1775
1776
1777
yyyUnsolvedInstSearchTrav(yyyGNT * pNode)1778 void yyyUnsolvedInstSearchTrav(yyyGNT *pNode)
1779 {yyyGNT **yyyCLpdum;
1780 int i;
1781
1782 yyyCLpdum = pNode->cL;
1783 i = pNode->cLlen;
1784 while (i--)
1785 {
1786 yyyUnsolvedInstSearchTravAux(*yyyCLpdum);
1787 yyyCLpdum++;
1788 }
1789 }
1790
1791
1792
1793 #line 1794 "expr.oxout.tab.c"
1794
1795 /* For use in generated program */
1796 #define yydepth (int)(yystack.s_mark - yystack.s_base)
1797 #if YYBTYACC
1798 #define yytrial (yyps->save)
1799 #endif /* YYBTYACC */
1800
1801 #if YYDEBUG
1802 #include <stdio.h> /* needed for printf */
1803 #endif
1804
1805 #include <stdlib.h> /* needed for malloc, etc */
1806 #include <string.h> /* needed for memset */
1807
1808 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)1809 static int yygrowstack(YYSTACKDATA *data)
1810 {
1811 int i;
1812 unsigned newsize;
1813 YYINT *newss;
1814 YYSTYPE *newvs;
1815 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1816 YYLTYPE *newps;
1817 #endif
1818
1819 if ((newsize = data->stacksize) == 0)
1820 newsize = YYINITSTACKSIZE;
1821 else if (newsize >= YYMAXDEPTH)
1822 return YYENOMEM;
1823 else if ((newsize *= 2) > YYMAXDEPTH)
1824 newsize = YYMAXDEPTH;
1825
1826 i = (int) (data->s_mark - data->s_base);
1827 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1828 if (newss == 0)
1829 return YYENOMEM;
1830
1831 data->s_base = newss;
1832 data->s_mark = newss + i;
1833
1834 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1835 if (newvs == 0)
1836 return YYENOMEM;
1837
1838 data->l_base = newvs;
1839 data->l_mark = newvs + i;
1840
1841 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1842 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
1843 if (newps == 0)
1844 return YYENOMEM;
1845
1846 data->p_base = newps;
1847 data->p_mark = newps + i;
1848 #endif
1849
1850 data->stacksize = newsize;
1851 data->s_last = data->s_base + newsize - 1;
1852
1853 #if YYDEBUG
1854 if (yydebug)
1855 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
1856 #endif
1857 return 0;
1858 }
1859
1860 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)1861 static void yyfreestack(YYSTACKDATA *data)
1862 {
1863 free(data->s_base);
1864 free(data->l_base);
1865 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1866 free(data->p_base);
1867 #endif
1868 memset(data, 0, sizeof(*data));
1869 }
1870 #else
1871 #define yyfreestack(data) /* nothing */
1872 #endif /* YYPURE || defined(YY_NO_LEAKS) */
1873 #if YYBTYACC
1874
1875 static YYParseState *
yyNewState(unsigned size)1876 yyNewState(unsigned size)
1877 {
1878 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
1879 if (p == NULL) return NULL;
1880
1881 p->yystack.stacksize = size;
1882 if (size == 0)
1883 {
1884 p->yystack.s_base = NULL;
1885 p->yystack.l_base = NULL;
1886 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1887 p->yystack.p_base = NULL;
1888 #endif
1889 return p;
1890 }
1891 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
1892 if (p->yystack.s_base == NULL) return NULL;
1893 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
1894 if (p->yystack.l_base == NULL) return NULL;
1895 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
1896 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1897 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
1898 if (p->yystack.p_base == NULL) return NULL;
1899 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
1900 #endif
1901
1902 return p;
1903 }
1904
1905 static void
yyFreeState(YYParseState * p)1906 yyFreeState(YYParseState *p)
1907 {
1908 yyfreestack(&p->yystack);
1909 free(p);
1910 }
1911 #endif /* YYBTYACC */
1912
1913 #define YYABORT goto yyabort
1914 #define YYREJECT goto yyabort
1915 #define YYACCEPT goto yyaccept
1916 #define YYERROR goto yyerrlab
1917 #if YYBTYACC
1918 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
1919 #define YYVALID_NESTED do { if (yyps->save && \
1920 yyps->save->save == 0) goto yyvalid; } while(0)
1921 #endif /* YYBTYACC */
1922
1923 int
YYPARSE_DECL()1924 YYPARSE_DECL()
1925 {
1926 int yym, yyn, yystate, yyresult;
1927 #if YYBTYACC
1928 int yynewerrflag;
1929 YYParseState *yyerrctx = NULL;
1930 #endif /* YYBTYACC */
1931 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1932 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
1933 #endif
1934 #if YYDEBUG
1935 const char *yys;
1936
1937 if ((yys = getenv("YYDEBUG")) != 0)
1938 {
1939 yyn = *yys;
1940 if (yyn >= '0' && yyn <= '9')
1941 yydebug = yyn - '0';
1942 }
1943 if (yydebug)
1944 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
1945 #endif
1946 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1947 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
1948 #endif
1949
1950 #if YYBTYACC
1951 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
1952 yyps->save = 0;
1953 #endif /* YYBTYACC */
1954 yym = 0;
1955 yyn = 0;
1956 yynerrs = 0;
1957 yyerrflag = 0;
1958 yychar = YYEMPTY;
1959 yystate = 0;
1960
1961 #if YYPURE
1962 memset(&yystack, 0, sizeof(yystack));
1963 #endif
1964
1965 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1966 yystack.s_mark = yystack.s_base;
1967 yystack.l_mark = yystack.l_base;
1968 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1969 yystack.p_mark = yystack.p_base;
1970 #endif
1971 yystate = 0;
1972 *yystack.s_mark = 0;
1973
1974 yyloop:
1975 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1976 if (yychar < 0)
1977 {
1978 #if YYBTYACC
1979 do {
1980 if (yylvp < yylve)
1981 {
1982 /* we're currently re-reading tokens */
1983 yylval = *yylvp++;
1984 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1985 yylloc = *yylpp++;
1986 #endif
1987 yychar = *yylexp++;
1988 break;
1989 }
1990 if (yyps->save)
1991 {
1992 /* in trial mode; save scanner results for future parse attempts */
1993 if (yylvp == yylvlim)
1994 { /* Enlarge lexical value queue */
1995 size_t p = (size_t) (yylvp - yylvals);
1996 size_t s = (size_t) (yylvlim - yylvals);
1997
1998 s += YYLVQUEUEGROWTH;
1999 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
2000 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
2001 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2002 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
2003 #endif
2004 yylvp = yylve = yylvals + p;
2005 yylvlim = yylvals + s;
2006 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2007 yylpp = yylpe = yylpsns + p;
2008 yylplim = yylpsns + s;
2009 #endif
2010 yylexp = yylexemes + p;
2011 }
2012 *yylexp = (YYINT) YYLEX;
2013 *yylvp++ = yylval;
2014 yylve++;
2015 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2016 *yylpp++ = yylloc;
2017 yylpe++;
2018 #endif
2019 yychar = *yylexp++;
2020 break;
2021 }
2022 /* normal operation, no conflict encountered */
2023 #endif /* YYBTYACC */
2024 yychar = YYLEX;
2025 #if YYBTYACC
2026 } while (0);
2027 #endif /* YYBTYACC */
2028 if (yychar < 0) yychar = YYEOF;
2029 #if YYDEBUG
2030 if (yydebug)
2031 {
2032 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2033 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
2034 YYDEBUGSTR, yydepth, yystate, yychar, yys);
2035 #ifdef YYSTYPE_TOSTRING
2036 #if YYBTYACC
2037 if (!yytrial)
2038 #endif /* YYBTYACC */
2039 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
2040 #endif
2041 fputc('\n', stderr);
2042 }
2043 #endif
2044 }
2045 #if YYBTYACC
2046
2047 /* Do we have a conflict? */
2048 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2049 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2050 {
2051 YYINT ctry;
2052
2053 if (yypath)
2054 {
2055 YYParseState *save;
2056 #if YYDEBUG
2057 if (yydebug)
2058 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
2059 YYDEBUGSTR, yydepth, yystate);
2060 #endif
2061 /* Switch to the next conflict context */
2062 save = yypath;
2063 yypath = save->save;
2064 save->save = NULL;
2065 ctry = save->ctry;
2066 if (save->state != yystate) YYABORT;
2067 yyFreeState(save);
2068
2069 }
2070 else
2071 {
2072
2073 /* Unresolved conflict - start/continue trial parse */
2074 YYParseState *save;
2075 #if YYDEBUG
2076 if (yydebug)
2077 {
2078 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
2079 if (yyps->save)
2080 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
2081 else
2082 fputs("Starting trial parse.\n", stderr);
2083 }
2084 #endif
2085 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
2086 if (save == NULL) goto yyenomem;
2087 save->save = yyps->save;
2088 save->state = yystate;
2089 save->errflag = yyerrflag;
2090 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
2091 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2092 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
2093 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2094 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2095 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
2096 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2097 #endif
2098 ctry = yytable[yyn];
2099 if (yyctable[ctry] == -1)
2100 {
2101 #if YYDEBUG
2102 if (yydebug && yychar >= YYEOF)
2103 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
2104 #endif
2105 ctry++;
2106 }
2107 save->ctry = ctry;
2108 if (yyps->save == NULL)
2109 {
2110 /* If this is a first conflict in the stack, start saving lexemes */
2111 if (!yylexemes)
2112 {
2113 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
2114 if (yylexemes == NULL) goto yyenomem;
2115 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
2116 if (yylvals == NULL) goto yyenomem;
2117 yylvlim = yylvals + YYLVQUEUEGROWTH;
2118 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2119 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
2120 if (yylpsns == NULL) goto yyenomem;
2121 yylplim = yylpsns + YYLVQUEUEGROWTH;
2122 #endif
2123 }
2124 if (yylvp == yylve)
2125 {
2126 yylvp = yylve = yylvals;
2127 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2128 yylpp = yylpe = yylpsns;
2129 #endif
2130 yylexp = yylexemes;
2131 if (yychar >= YYEOF)
2132 {
2133 *yylve++ = yylval;
2134 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2135 *yylpe++ = yylloc;
2136 #endif
2137 *yylexp = (YYINT) yychar;
2138 yychar = YYEMPTY;
2139 }
2140 }
2141 }
2142 if (yychar >= YYEOF)
2143 {
2144 yylvp--;
2145 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2146 yylpp--;
2147 #endif
2148 yylexp--;
2149 yychar = YYEMPTY;
2150 }
2151 save->lexeme = (int) (yylvp - yylvals);
2152 yyps->save = save;
2153 }
2154 if (yytable[yyn] == ctry)
2155 {
2156 #if YYDEBUG
2157 if (yydebug)
2158 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
2159 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
2160 #endif
2161 if (yychar < 0)
2162 {
2163 yylvp++;
2164 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2165 yylpp++;
2166 #endif
2167 yylexp++;
2168 }
2169 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
2170 goto yyoverflow;
2171 yystate = yyctable[ctry];
2172 *++yystack.s_mark = (YYINT) yystate;
2173 *++yystack.l_mark = yylval;
2174 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2175 *++yystack.p_mark = yylloc;
2176 #endif
2177 yychar = YYEMPTY;
2178 if (yyerrflag > 0) --yyerrflag;
2179 goto yyloop;
2180 }
2181 else
2182 {
2183 yyn = yyctable[ctry];
2184 goto yyreduce;
2185 }
2186 } /* End of code dealing with conflicts */
2187 #endif /* YYBTYACC */
2188 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2189 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2190 {
2191 #if YYDEBUG
2192 if (yydebug)
2193 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
2194 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
2195 #endif
2196 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2197 yystate = yytable[yyn];
2198 *++yystack.s_mark = yytable[yyn];
2199 *++yystack.l_mark = yylval;
2200 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2201 *++yystack.p_mark = yylloc;
2202 #endif
2203 yychar = YYEMPTY;
2204 if (yyerrflag > 0) --yyerrflag;
2205 goto yyloop;
2206 }
2207 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
2208 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
2209 {
2210 yyn = yytable[yyn];
2211 goto yyreduce;
2212 }
2213 if (yyerrflag != 0) goto yyinrecovery;
2214 #if YYBTYACC
2215
2216 yynewerrflag = 1;
2217 goto yyerrhandler;
2218 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
2219
2220 yyerrlab:
2221 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
2222 * before looking for error recovery */
2223 yystack.s_mark -= yym;
2224 yystate = *yystack.s_mark;
2225 yystack.l_mark -= yym;
2226 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2227 yystack.p_mark -= yym;
2228 #endif
2229
2230 yynewerrflag = 0;
2231 yyerrhandler:
2232 while (yyps->save)
2233 {
2234 int ctry;
2235 YYParseState *save = yyps->save;
2236 #if YYDEBUG
2237 if (yydebug)
2238 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
2239 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
2240 (int)(yylvp - yylvals - yyps->save->lexeme));
2241 #endif
2242 /* Memorize most forward-looking error state in case it's really an error. */
2243 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
2244 {
2245 /* Free old saved error context state */
2246 if (yyerrctx) yyFreeState(yyerrctx);
2247 /* Create and fill out new saved error context state */
2248 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
2249 if (yyerrctx == NULL) goto yyenomem;
2250 yyerrctx->save = yyps->save;
2251 yyerrctx->state = yystate;
2252 yyerrctx->errflag = yyerrflag;
2253 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
2254 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2255 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
2256 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2257 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2258 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
2259 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2260 #endif
2261 yyerrctx->lexeme = (int) (yylvp - yylvals);
2262 }
2263 yylvp = yylvals + save->lexeme;
2264 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2265 yylpp = yylpsns + save->lexeme;
2266 #endif
2267 yylexp = yylexemes + save->lexeme;
2268 yychar = YYEMPTY;
2269 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
2270 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2271 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
2272 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2273 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2274 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
2275 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2276 #endif
2277 ctry = ++save->ctry;
2278 yystate = save->state;
2279 /* We tried shift, try reduce now */
2280 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
2281 yyps->save = save->save;
2282 save->save = NULL;
2283 yyFreeState(save);
2284
2285 /* Nothing left on the stack -- error */
2286 if (!yyps->save)
2287 {
2288 #if YYDEBUG
2289 if (yydebug)
2290 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
2291 YYPREFIX, yydepth);
2292 #endif
2293 /* Restore state as it was in the most forward-advanced error */
2294 yylvp = yylvals + yyerrctx->lexeme;
2295 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2296 yylpp = yylpsns + yyerrctx->lexeme;
2297 #endif
2298 yylexp = yylexemes + yyerrctx->lexeme;
2299 yychar = yylexp[-1];
2300 yylval = yylvp[-1];
2301 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2302 yylloc = yylpp[-1];
2303 #endif
2304 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
2305 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2306 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
2307 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2308 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2309 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
2310 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2311 #endif
2312 yystate = yyerrctx->state;
2313 yyFreeState(yyerrctx);
2314 yyerrctx = NULL;
2315 }
2316 yynewerrflag = 1;
2317 }
2318 if (yynewerrflag == 0) goto yyinrecovery;
2319 #endif /* YYBTYACC */
2320
2321 YYERROR_CALL("syntax error");
2322 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2323 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
2324 #endif
2325
2326 #if !YYBTYACC
2327 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
2328 yyerrlab:
2329 #endif
2330 ++yynerrs;
2331
2332 yyinrecovery:
2333 if (yyerrflag < 3)
2334 {
2335 yyerrflag = 3;
2336 for (;;)
2337 {
2338 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
2339 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
2340 {
2341 #if YYDEBUG
2342 if (yydebug)
2343 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
2344 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
2345 #endif
2346 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2347 yystate = yytable[yyn];
2348 *++yystack.s_mark = yytable[yyn];
2349 *++yystack.l_mark = yylval;
2350 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2351 /* lookahead position is error end position */
2352 yyerror_loc_range[1] = yylloc;
2353 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
2354 *++yystack.p_mark = yyloc;
2355 #endif
2356 goto yyloop;
2357 }
2358 else
2359 {
2360 #if YYDEBUG
2361 if (yydebug)
2362 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
2363 YYDEBUGSTR, yydepth, *yystack.s_mark);
2364 #endif
2365 if (yystack.s_mark <= yystack.s_base) goto yyabort;
2366 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2367 /* the current TOS position is the error start position */
2368 yyerror_loc_range[0] = *yystack.p_mark;
2369 #endif
2370 #if defined(YYDESTRUCT_CALL)
2371 #if YYBTYACC
2372 if (!yytrial)
2373 #endif /* YYBTYACC */
2374 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2375 YYDESTRUCT_CALL("error: discarding state",
2376 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
2377 #else
2378 YYDESTRUCT_CALL("error: discarding state",
2379 yystos[*yystack.s_mark], yystack.l_mark);
2380 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2381 #endif /* defined(YYDESTRUCT_CALL) */
2382 --yystack.s_mark;
2383 --yystack.l_mark;
2384 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2385 --yystack.p_mark;
2386 #endif
2387 }
2388 }
2389 }
2390 else
2391 {
2392 if (yychar == YYEOF) goto yyabort;
2393 #if YYDEBUG
2394 if (yydebug)
2395 {
2396 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2397 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
2398 YYDEBUGSTR, yydepth, yystate, yychar, yys);
2399 }
2400 #endif
2401 #if defined(YYDESTRUCT_CALL)
2402 #if YYBTYACC
2403 if (!yytrial)
2404 #endif /* YYBTYACC */
2405 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2406 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
2407 #else
2408 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
2409 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2410 #endif /* defined(YYDESTRUCT_CALL) */
2411 yychar = YYEMPTY;
2412 goto yyloop;
2413 }
2414
2415 yyreduce:
2416 yym = yylen[yyn];
2417 #if YYDEBUG
2418 if (yydebug)
2419 {
2420 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
2421 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
2422 #ifdef YYSTYPE_TOSTRING
2423 #if YYBTYACC
2424 if (!yytrial)
2425 #endif /* YYBTYACC */
2426 if (yym > 0)
2427 {
2428 int i;
2429 fputc('<', stderr);
2430 for (i = yym; i > 0; i--)
2431 {
2432 if (i != yym) fputs(", ", stderr);
2433 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
2434 yystack.l_mark[1-i]), stderr);
2435 }
2436 fputc('>', stderr);
2437 }
2438 #endif
2439 fputc('\n', stderr);
2440 }
2441 #endif
2442 if (yym > 0)
2443 yyval = yystack.l_mark[1-yym];
2444 else
2445 memset(&yyval, 0, sizeof yyval);
2446 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2447
2448 /* Perform position reduction */
2449 memset(&yyloc, 0, sizeof(yyloc));
2450 #if YYBTYACC
2451 if (!yytrial)
2452 #endif /* YYBTYACC */
2453 {
2454 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
2455 /* just in case YYERROR is invoked within the action, save
2456 the start of the rhs as the error start position */
2457 yyerror_loc_range[0] = yystack.p_mark[1-yym];
2458 }
2459 #endif
2460
2461 switch (yyn)
2462 {
2463 case 1:
2464 #line 64 "expr.oxout.y"
2465 {yyyYoxInit();}
2466 break;
2467 case 2:
2468 #line 66 "expr.oxout.y"
2469 {
2470 yyyDecorate(); yyyExecuteRRsection(yystack.l_mark[0].yyyOxAttrbs.yyyOxStackItem->node);
2471 }
2472 break;
2473 case 3:
2474 #line 73 "expr.oxout.y"
2475 {if(yyyYok){
2476 yyyGenIntNode(1,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2477 yyyAdjustINRC(1,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2478 break;
2479 case 4:
2480 #line 80 "expr.oxout.y"
2481 {if(yyyYok){
2482 yyyGenIntNode(2,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2483 yyyAdjustINRC(2,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2484 break;
2485 case 5:
2486 #line 87 "expr.oxout.y"
2487 {if(yyyYok){
2488 yyyGenIntNode(3,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2489 yyyAdjustINRC(3,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2490 break;
2491 case 6:
2492 #line 94 "expr.oxout.y"
2493 {if(yyyYok){
2494 yyyGenIntNode(4,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2495 yyyAdjustINRC(4,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2496 break;
2497 case 7:
2498 #line 101 "expr.oxout.y"
2499 {if(yyyYok){
2500 yyyGenIntNode(5,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2501 yyyAdjustINRC(5,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2502 break;
2503 case 8:
2504 #line 108 "expr.oxout.y"
2505 {if(yyyYok){
2506 yyyGenIntNode(6,3,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2507 yyyAdjustINRC(6,3,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[-2].yyyOxAttrbs,&yystack.l_mark[-1].yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2508 break;
2509 case 9:
2510 #line 114 "expr.oxout.y"
2511 {if(yyyYok){
2512 yyyGenIntNode(7,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2513 yyyAdjustINRC(7,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2514 break;
2515 case 10:
2516 #line 121 "expr.oxout.y"
2517 {if(yyyYok){
2518 yyyGenIntNode(8,1,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);
2519 yyyAdjustINRC(8,1,0,0,&yyval.yyyOxAttrbs,&yystack.l_mark[0].yyyOxAttrbs);}}
2520 break;
2521 #line 2522 "expr.oxout.tab.c"
2522 default:
2523 break;
2524 }
2525 yystack.s_mark -= yym;
2526 yystate = *yystack.s_mark;
2527 yystack.l_mark -= yym;
2528 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2529 yystack.p_mark -= yym;
2530 #endif
2531 yym = yylhs[yyn];
2532 if (yystate == 0 && yym == 0)
2533 {
2534 #if YYDEBUG
2535 if (yydebug)
2536 {
2537 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2538 #ifdef YYSTYPE_TOSTRING
2539 #if YYBTYACC
2540 if (!yytrial)
2541 #endif /* YYBTYACC */
2542 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
2543 #endif
2544 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
2545 }
2546 #endif
2547 yystate = YYFINAL;
2548 *++yystack.s_mark = YYFINAL;
2549 *++yystack.l_mark = yyval;
2550 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2551 *++yystack.p_mark = yyloc;
2552 #endif
2553 if (yychar < 0)
2554 {
2555 #if YYBTYACC
2556 do {
2557 if (yylvp < yylve)
2558 {
2559 /* we're currently re-reading tokens */
2560 yylval = *yylvp++;
2561 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2562 yylloc = *yylpp++;
2563 #endif
2564 yychar = *yylexp++;
2565 break;
2566 }
2567 if (yyps->save)
2568 {
2569 /* in trial mode; save scanner results for future parse attempts */
2570 if (yylvp == yylvlim)
2571 { /* Enlarge lexical value queue */
2572 size_t p = (size_t) (yylvp - yylvals);
2573 size_t s = (size_t) (yylvlim - yylvals);
2574
2575 s += YYLVQUEUEGROWTH;
2576 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
2577 goto yyenomem;
2578 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
2579 goto yyenomem;
2580 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2581 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
2582 goto yyenomem;
2583 #endif
2584 yylvp = yylve = yylvals + p;
2585 yylvlim = yylvals + s;
2586 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2587 yylpp = yylpe = yylpsns + p;
2588 yylplim = yylpsns + s;
2589 #endif
2590 yylexp = yylexemes + p;
2591 }
2592 *yylexp = (YYINT) YYLEX;
2593 *yylvp++ = yylval;
2594 yylve++;
2595 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2596 *yylpp++ = yylloc;
2597 yylpe++;
2598 #endif
2599 yychar = *yylexp++;
2600 break;
2601 }
2602 /* normal operation, no conflict encountered */
2603 #endif /* YYBTYACC */
2604 yychar = YYLEX;
2605 #if YYBTYACC
2606 } while (0);
2607 #endif /* YYBTYACC */
2608 if (yychar < 0) yychar = YYEOF;
2609 #if YYDEBUG
2610 if (yydebug)
2611 {
2612 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2613 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
2614 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
2615 }
2616 #endif
2617 }
2618 if (yychar == YYEOF) goto yyaccept;
2619 goto yyloop;
2620 }
2621 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
2622 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
2623 yystate = yytable[yyn];
2624 else
2625 yystate = yydgoto[yym];
2626 #if YYDEBUG
2627 if (yydebug)
2628 {
2629 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2630 #ifdef YYSTYPE_TOSTRING
2631 #if YYBTYACC
2632 if (!yytrial)
2633 #endif /* YYBTYACC */
2634 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
2635 #endif
2636 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
2637 }
2638 #endif
2639 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2640 *++yystack.s_mark = (YYINT) yystate;
2641 *++yystack.l_mark = yyval;
2642 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2643 *++yystack.p_mark = yyloc;
2644 #endif
2645 goto yyloop;
2646 #if YYBTYACC
2647
2648 /* Reduction declares that this path is valid. Set yypath and do a full parse */
2649 yyvalid:
2650 if (yypath) YYABORT;
2651 while (yyps->save)
2652 {
2653 YYParseState *save = yyps->save;
2654 yyps->save = save->save;
2655 save->save = yypath;
2656 yypath = save;
2657 }
2658 #if YYDEBUG
2659 if (yydebug)
2660 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
2661 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
2662 #endif
2663 if (yyerrctx)
2664 {
2665 yyFreeState(yyerrctx);
2666 yyerrctx = NULL;
2667 }
2668 yylvp = yylvals + yypath->lexeme;
2669 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2670 yylpp = yylpsns + yypath->lexeme;
2671 #endif
2672 yylexp = yylexemes + yypath->lexeme;
2673 yychar = YYEMPTY;
2674 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
2675 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2676 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
2677 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2678 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2679 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
2680 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2681 #endif
2682 yystate = yypath->state;
2683 goto yyloop;
2684 #endif /* YYBTYACC */
2685
2686 yyoverflow:
2687 YYERROR_CALL("yacc stack overflow");
2688 #if YYBTYACC
2689 goto yyabort_nomem;
2690 yyenomem:
2691 YYERROR_CALL("memory exhausted");
2692 yyabort_nomem:
2693 #endif /* YYBTYACC */
2694 yyresult = 2;
2695 goto yyreturn;
2696
2697 yyabort:
2698 yyresult = 1;
2699 goto yyreturn;
2700
2701 yyaccept:
2702 #if YYBTYACC
2703 if (yyps->save) goto yyvalid;
2704 #endif /* YYBTYACC */
2705 yyresult = 0;
2706
2707 yyreturn:
2708 #if defined(YYDESTRUCT_CALL)
2709 if (yychar != YYEOF && yychar != YYEMPTY)
2710 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2711 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
2712 #else
2713 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
2714 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2715
2716 {
2717 YYSTYPE *pv;
2718 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2719 YYLTYPE *pp;
2720
2721 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
2722 YYDESTRUCT_CALL("cleanup: discarding state",
2723 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
2724 #else
2725 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
2726 YYDESTRUCT_CALL("cleanup: discarding state",
2727 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
2728 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2729 }
2730 #endif /* defined(YYDESTRUCT_CALL) */
2731
2732 #if YYBTYACC
2733 if (yyerrctx)
2734 {
2735 yyFreeState(yyerrctx);
2736 yyerrctx = NULL;
2737 }
2738 while (yyps)
2739 {
2740 YYParseState *save = yyps;
2741 yyps = save->save;
2742 save->save = NULL;
2743 yyFreeState(save);
2744 }
2745 while (yypath)
2746 {
2747 YYParseState *save = yypath;
2748 yypath = save->save;
2749 save->save = NULL;
2750 yyFreeState(save);
2751 }
2752 #endif /* YYBTYACC */
2753 yyfreestack(&yystack);
2754 return (yyresult);
2755 }
2756