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 2
7 #define YYMINOR 0
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 1
18 #define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug")
19
20 #ifndef yyparse
21 #define yyparse demo_parse
22 #endif /* yyparse */
23
24 #ifndef yylex
25 #define yylex demo_lex
26 #endif /* yylex */
27
28 #ifndef yyerror
29 #define yyerror demo_error
30 #endif /* yyerror */
31
32 #ifndef yychar
33 #define yychar demo_char
34 #endif /* yychar */
35
36 #ifndef yyval
37 #define yyval demo_val
38 #endif /* yyval */
39
40 #ifndef yylval
41 #define yylval demo_lval
42 #endif /* yylval */
43
44 #ifndef yydebug
45 #define yydebug demo_debug
46 #endif /* yydebug */
47
48 #ifndef yynerrs
49 #define yynerrs demo_nerrs
50 #endif /* yynerrs */
51
52 #ifndef yyerrflag
53 #define yyerrflag demo_errflag
54 #endif /* yyerrflag */
55
56 #ifndef yylhs
57 #define yylhs demo_lhs
58 #endif /* yylhs */
59
60 #ifndef yylen
61 #define yylen demo_len
62 #endif /* yylen */
63
64 #ifndef yydefred
65 #define yydefred demo_defred
66 #endif /* yydefred */
67
68 #ifndef yystos
69 #define yystos demo_stos
70 #endif /* yystos */
71
72 #ifndef yydgoto
73 #define yydgoto demo_dgoto
74 #endif /* yydgoto */
75
76 #ifndef yysindex
77 #define yysindex demo_sindex
78 #endif /* yysindex */
79
80 #ifndef yyrindex
81 #define yyrindex demo_rindex
82 #endif /* yyrindex */
83
84 #ifndef yygindex
85 #define yygindex demo_gindex
86 #endif /* yygindex */
87
88 #ifndef yytable
89 #define yytable demo_table
90 #endif /* yytable */
91
92 #ifndef yycheck
93 #define yycheck demo_check
94 #endif /* yycheck */
95
96 #ifndef yyname
97 #define yyname demo_name
98 #endif /* yyname */
99
100 #ifndef yyrule
101 #define yyrule demo_rule
102 #endif /* yyrule */
103
104 #ifndef yyloc
105 #define yyloc demo_loc
106 #endif /* yyloc */
107
108 #ifndef yylloc
109 #define yylloc demo_lloc
110 #endif /* yylloc */
111
112 #if YYBTYACC
113
114 #ifndef yycindex
115 #define yycindex demo_cindex
116 #endif /* yycindex */
117
118 #ifndef yyctable
119 #define yyctable demo_ctable
120 #endif /* yyctable */
121
122 #endif /* YYBTYACC */
123
124 #define YYPREFIX "demo_"
125
126 #define YYPURE 0
127
128 #line 15 "btyacc_demo.y"
129 /* dummy types just for compile check */
130 typedef int Code;
131 typedef int Decl_List;
132 typedef int Expr;
133 typedef int Expr_List;
134 typedef int Scope;
135 typedef int Type;
136 enum Operator { ADD, SUB, MUL, MOD, DIV, DEREF };
137
138 typedef unsigned char bool;
139 typedef struct Decl {
140 Scope *scope;
141 Type *type;
142 bool (*istype)(void);
143 } Decl;
144
145 #include "btyacc_demo.tab.h"
146 #include <stdlib.h>
147 #include <stdio.h>
148 #ifdef YYSTYPE
149 #undef YYSTYPE_IS_DECLARED
150 #define YYSTYPE_IS_DECLARED 1
151 #endif
152 #ifndef YYSTYPE_IS_DECLARED
153 #define YYSTYPE_IS_DECLARED 1
154 #line 36 "btyacc_demo.y"
155 typedef union YYSTYPE {
156 Scope *scope;
157 Expr *expr;
158 Expr_List *elist;
159 Type *type;
160 Decl *decl;
161 Decl_List *dlist;
162 Code *code;
163 char *id;
164 } YYSTYPE;
165 #endif /* !YYSTYPE_IS_DECLARED */
166 #line 167 "btyacc_demo.tab.c"
167
168 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
169 /* Default: YYLTYPE is the text position type. */
170 typedef struct YYLTYPE
171 {
172 int first_line;
173 int first_column;
174 int last_line;
175 int last_column;
176 unsigned source;
177 } YYLTYPE;
178 #define YYLTYPE_IS_DECLARED 1
179 #endif
180 #define YYRHSLOC(rhs, k) ((rhs)[k])
181
182 /* compatibility with bison */
183 #ifdef YYPARSE_PARAM
184 /* compatibility with FreeBSD */
185 # ifdef YYPARSE_PARAM_TYPE
186 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
187 # else
188 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
189 # endif
190 #else
191 # define YYPARSE_DECL() yyparse(void)
192 #endif
193
194 /* Parameters sent to lex. */
195 #ifdef YYLEX_PARAM
196 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
197 # define YYLEX yylex(YYLEX_PARAM)
198 #else
199 # define YYLEX_DECL() yylex(void)
200 # define YYLEX yylex()
201 #endif
202
203 /* Parameters sent to yyerror. */
204 #ifndef YYERROR_DECL
205 #define YYERROR_DECL() yyerror(YYLTYPE *loc, const char *s)
206 #endif
207 #ifndef YYERROR_CALL
208 #define YYERROR_CALL(msg) yyerror(&yylloc, msg)
209 #endif
210
211 #ifndef YYDESTRUCT_DECL
212 #define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, YYLTYPE *loc)
213 #endif
214 #ifndef YYDESTRUCT_CALL
215 #define YYDESTRUCT_CALL(msg, psymb, val, loc) yydestruct(msg, psymb, val, loc)
216 #endif
217
218 extern int YYPARSE_DECL();
219
220 #define PREFIX 257
221 #define POSTFIX 258
222 #define ID 259
223 #define CONSTANT 260
224 #define EXTERN 261
225 #define REGISTER 262
226 #define STATIC 263
227 #define CONST 264
228 #define VOLATILE 265
229 #define IF 266
230 #define THEN 267
231 #define ELSE 268
232 #define CLCL 269
233 #define YYERRCODE 256
234 typedef int YYINT;
235 static const YYINT demo_lhs[] = { -1,
236 15, 15, 15, 12, 18, 0, 4, 19, 4, 2,
237 20, 2, 10, 10, 13, 13, 11, 11, 11, 11,
238 11, 14, 14, 21, 22, 3, 3, 8, 8, 23,
239 24, 8, 8, 8, 8, 16, 16, 17, 17, 9,
240 1, 1, 1, 1, 1, 1, 1, 1, 5, 5,
241 25, 26, 5, 5, 27, 5, 6, 6, 7,
242 };
243 static const YYINT demo_len[] = { 2,
244 0, 1, 3, 2, 0, 2, 0, 0, 3, 3,
245 0, 4, 1, 3, 0, 2, 1, 1, 1, 1,
246 1, 1, 1, 0, 0, 5, 1, 0, 1, 0,
247 0, 5, 5, 5, 6, 0, 1, 4, 1, 2,
248 4, 4, 4, 4, 4, 3, 1, 1, 1, 2,
249 0, 0, 11, 8, 0, 2, 0, 3, 4,
250 };
251 static const YYINT demo_defred[] = { 5,
252 0, 7, 0, 0, 19, 20, 21, 22, 23, 2,
253 9, 0, 13, 18, 17, 0, 15, 30, 29, 0,
254 0, 0, 0, 0, 31, 10, 24, 24, 24, 0,
255 14, 3, 16, 25, 0, 25, 0, 0, 8, 12,
256 0, 0, 0, 39, 0, 0, 0, 8, 47, 48,
257 0, 57, 0, 32, 0, 0, 15, 30, 0, 30,
258 30, 30, 30, 30, 34, 0, 0, 0, 46, 0,
259 0, 0, 0, 0, 59, 0, 38, 0, 0, 43,
260 45, 44, 0, 0, 49, 58, 0, 30, 50, 56,
261 0, 0, 0, 51, 0, 0, 52, 0, 53,
262 };
263 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
264 static const YYINT demo_stos[] = { 0,
265 271, 289, 275, 290, 261, 262, 263, 264, 265, 269,
266 273, 281, 282, 283, 285, 286, 42, 40, 259, 274,
267 279, 290, 259, 284, 294, 59, 44, 40, 91, 291,
268 282, 269, 285, 292, 295, 292, 292, 292, 123, 278,
269 293, 279, 293, 280, 281, 287, 288, 42, 259, 260,
270 272, 290, 279, 41, 279, 279, 41, 44, 290, 43,
271 45, 42, 47, 37, 93, 277, 284, 294, 272, 294,
272 294, 294, 294, 294, 125, 290, 280, 272, 272, 272,
273 272, 272, 266, 272, 273, 276, 298, 40, 59, 278,
274 294, 272, 41, 267, 296, 276, 268, 297, 276,
275 };
276 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
277 static const YYINT demo_dgoto[] = { 1,
278 84, 85, 20, 3, 86, 66, 40, 21, 44, 12,
279 13, 14, 24, 15, 16, 46, 47, 2, 22, 30,
280 34, 41, 25, 35, 95, 98, 87,
281 };
282 static const YYINT demo_sindex[] = { 0,
283 0, 0, 0, -103, 0, 0, 0, 0, 0, 0,
284 0, -31, 0, 0, 0, -238, 0, 0, 0, 4,
285 -36, -103, 0, -133, 0, 0, 0, 0, 0, -94,
286 0, 0, 0, 0, -40, 0, -103, -33, 0, 0,
287 -40, -25, -40, 0, -31, 8, 15, 0, 0, 0,
288 -2, 0, -36, 0, -36, -36, 0, 0, -33, 0,
289 0, 0, 0, 0, 0, -92, -133, -103, 0, -33,
290 -33, -33, -33, -33, 0, -8, 0, 23, 23, 0,
291 0, 0, 11, 75, 0, 0, -94, 0, 0, 0,
292 -33, 96, -194, 0, -8, 0, 0, -8, 0,
293 };
294 static const YYINT demo_rindex[] = { 0,
295 0, 0, 1, -181, 0, 0, 0, 0, 0, 0,
296 0, 17, 0, 0, 0, 0, 0, 0, 0, 0,
297 -39, -181, 12, -34, 0, 0, 0, 0, 0, 0,
298 0, 0, 0, 0, -5, 0, -11, 0, 0, 0,
299 -17, 0, 28, 0, -41, 0, 47, 0, 0, 0,
300 0, 0, -13, 0, 18, 70, 0, 0, 0, 0,
301 0, 0, 0, 0, 0, -19, -27, -181, 0, 0,
302 0, 0, 0, 0, 0, -29, 0, 56, 64, 0,
303 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
304 0, 0, 0, 0, -29, -30, 0, -29, 0,
305 };
306 #if YYBTYACC
307 static const YYINT demo_cindex[] = { 0,
308 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
309 0, -22, 0, 0, 0, 0, 0, 0, 0, 0,
310 0, 0, -179, 0, 0, 0, 0, 0, 0, 0,
311 0, 0, 0, 0, 52, 0, 0, 0, 0, 0,
312 58, 0, 62, 0, -21, 0, 0, 0, 0, 0,
313 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
314 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
315 0, 0, 0, 0, 0, -146, 0, 0, 0, 0,
316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
317 0, 0, 0, 0, -143, -147, 0, -134, 0,
318 };
319 #endif
320 static const YYINT demo_gindex[] = { 0,
321 9, 143, 0, 0, 50, 0, 63, 101, 83, 7,
322 130, 0, 98, 2, 0, 0, 0, 0, 19, 0,
323 10, 117, 66, 0, 0, 0, 0,
324 };
325 #define YYTABLESIZE 286
326 static const YYINT demo_table[] = { 28,
327 6, 17, 28, 28, 27, 24, 24, 24, 48, 24,
328 17, 54, 35, 35, 28, 54, 35, 0, 0, 27,
329 23, 4, 8, 28, 24, 33, 28, 33, 39, 36,
330 33, 35, 75, 48, 64, 28, 36, 37, 38, 62,
331 60, 28, 61, 45, 63, 33, 51, 27, 57, 28,
332 88, 4, 4, 4, 29, 4, 24, 52, 58, 64,
333 28, 26, 26, 35, 62, 29, 59, 69, 33, 63,
334 4, 28, 94, 28, 45, 28, 26, 1, 78, 79,
335 80, 81, 82, 11, 76, 28, 28, 37, 24, 6,
336 65, 0, 54, 55, 54, 35, 41, 0, 41, 92,
337 41, 0, 4, 8, 42, 28, 42, 28, 42, 33,
338 40, 64, 9, 40, 41, 9, 62, 60, 28, 61,
339 12, 63, 42, 68, 9, 70, 71, 72, 73, 74,
340 8, 9, 64, 89, 4, 42, 93, 62, 60, 28,
341 61, 53, 63, 55, 96, 56, 11, 99, 41, 90,
342 77, 31, 43, 91, 67, 0, 42, 5, 6, 7,
343 8, 9, 0, 0, 0, 10, 0, 0, 0, 0,
344 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
345 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
346 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
347 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
348 0, 0, 0, 0, 0, 0, 0, 0, 19, 8,
349 8, 8, 8, 8, 24, 49, 50, 8, 54, 54,
350 54, 54, 54, 54, 54, 54, 3, 3, 54, 8,
351 8, 8, 8, 8, 8, 8, 8, 1, 0, 8,
352 0, 50, 5, 6, 7, 8, 9, 83, 0, 8,
353 10, 8, 8, 8, 8, 8, 0, 0, 0, 8,
354 4, 0, 4, 4, 4, 4, 4, 8, 8, 8,
355 8, 8, 0, 0, 0, 8,
356 };
357 static const YYINT demo_check[] = { 41,
358 0, 42, 44, 40, 44, 40, 41, 42, 42, 44,
359 42, 42, 40, 41, 40, 41, 44, 40, 40, 59,
360 259, 3, 42, 41, 59, 24, 44, 41, 123, 41,
361 44, 59, 125, 42, 37, 41, 27, 28, 29, 42,
362 43, 59, 45, 37, 47, 59, 38, 44, 41, 91,
363 40, 40, 41, 42, 91, 44, 91, 39, 44, 37,
364 44, 44, 59, 91, 42, 91, 48, 59, 67, 47,
365 59, 44, 267, 91, 68, 59, 59, 259, 70, 71,
366 72, 73, 74, 123, 66, 91, 59, 41, 123, 269,
367 93, 40, 123, 123, 125, 123, 41, 40, 43, 91,
368 45, 40, 91, 123, 41, 123, 43, 91, 45, 123,
369 41, 37, 259, 44, 59, 259, 42, 43, 91, 45,
370 268, 47, 59, 58, 259, 60, 61, 62, 63, 64,
371 264, 265, 37, 59, 123, 35, 41, 42, 43, 123,
372 45, 41, 47, 43, 95, 45, 4, 98, 93, 87,
373 68, 22, 36, 88, 57, -1, 93, 261, 262, 263,
374 264, 265, -1, -1, -1, 269, -1, -1, -1, -1,
375 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
376 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
377 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
378 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
379 -1, -1, -1, -1, -1, -1, -1, -1, 259, 261,
380 262, 263, 264, 265, 259, 259, 260, 269, 259, 260,
381 261, 262, 263, 264, 265, 266, 259, 259, 269, 259,
382 260, 261, 262, 263, 264, 265, 266, 259, -1, 269,
383 -1, 260, 261, 262, 263, 264, 265, 266, -1, 259,
384 269, 261, 262, 263, 264, 265, -1, -1, -1, 269,
385 259, -1, 261, 262, 263, 264, 265, 261, 262, 263,
386 264, 265, -1, -1, -1, 269,
387 };
388 #if YYBTYACC
389 static const YYINT demo_ctable[] = { 18,
390 28, -1, 19, 8, -1, 32, 4, -1, 49, 1,
391 -1, 97, 54, -1, -1, -1, -1, -1, -1, -1,
392 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
393 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
394 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
395 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
396 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
397 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
398 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
399 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
400 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
401 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
402 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
403 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
404 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
405 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
406 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
407 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
408 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
409 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
410 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
411 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
412 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
413 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
414 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
415 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
416 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
417 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
418 -1, -1, -1, -1, -1,
419 };
420 #endif
421 #define YYFINAL 1
422 #ifndef YYDEBUG
423 #define YYDEBUG 0
424 #endif
425 #define YYMAXTOKEN 269
426 #define YYUNDFTOKEN 299
427 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
428 #if YYDEBUG
429 static const char *const demo_name[] = {
430
431 "$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,
432 "'%'",0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,0,0,0,0,0,0,0,0,0,
433 "';'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'['",0,
434 "']'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,
435 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
436 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
437 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
438 0,0,0,0,0,0,0,0,0,"error","PREFIX","POSTFIX","ID","CONSTANT","EXTERN",
439 "REGISTER","STATIC","CONST","VOLATILE","IF","THEN","ELSE","CLCL","$accept",
440 "input","expr","decl","declarator_list","decl_list","statement",
441 "statement_list","block_statement","declarator","formal_arg","decl_specs",
442 "decl_spec","typename","cv_quals","cv_qual","opt_scope","formal_arg_list",
443 "nonempty_formal_arg_list","$$1","$$2","$$3","$$4","$$5","$$6","$$7","$$8",
444 "$$9","$$10","illegal-symbol",
445 };
446 static const char *const demo_rule[] = {
447 "$accept : input",
448 "opt_scope :",
449 "opt_scope : CLCL",
450 "opt_scope : opt_scope ID CLCL",
451 "typename : opt_scope ID",
452 "$$1 :",
453 "input : $$1 decl_list",
454 "decl_list :",
455 "$$2 :",
456 "decl_list : decl_list $$2 decl",
457 "decl : decl_specs declarator_list ';'",
458 "$$3 :",
459 "decl : decl_specs declarator $$3 block_statement",
460 "decl_specs : decl_spec",
461 "decl_specs : decl_specs $$2 decl_spec",
462 "cv_quals :",
463 "cv_quals : cv_quals cv_qual",
464 "decl_spec : cv_qual",
465 "decl_spec : typename",
466 "decl_spec : EXTERN",
467 "decl_spec : REGISTER",
468 "decl_spec : STATIC",
469 "cv_qual : CONST",
470 "cv_qual : VOLATILE",
471 "$$4 :",
472 "$$5 :",
473 "declarator_list : declarator_list ',' $$4 $$5 declarator",
474 "declarator_list : declarator",
475 "declarator :",
476 "declarator : ID",
477 "$$6 :",
478 "$$7 :",
479 "declarator : '(' $$6 $$7 declarator ')'",
480 "declarator : '*' cv_quals $$4 $$5 declarator",
481 "declarator : declarator '[' $$4 expr ']'",
482 "declarator : declarator '(' $$4 formal_arg_list ')' cv_quals",
483 "formal_arg_list :",
484 "formal_arg_list : nonempty_formal_arg_list",
485 "nonempty_formal_arg_list : nonempty_formal_arg_list ',' $$6 formal_arg",
486 "nonempty_formal_arg_list : formal_arg",
487 "formal_arg : decl_specs declarator",
488 "expr : expr '+' $$6 expr",
489 "expr : expr '-' $$6 expr",
490 "expr : expr '*' $$6 expr",
491 "expr : expr '%' $$6 expr",
492 "expr : expr '/' $$6 expr",
493 "expr : '*' $$2 expr",
494 "expr : ID",
495 "expr : CONSTANT",
496 "statement : decl",
497 "statement : expr ';'",
498 "$$8 :",
499 "$$9 :",
500 "statement : IF '(' $$6 expr ')' THEN $$8 statement ELSE $$9 statement",
501 "statement : IF '(' $$6 expr ')' THEN $$8 statement",
502 "$$10 :",
503 "statement : $$10 block_statement",
504 "statement_list :",
505 "statement_list : statement_list $$2 statement",
506 "block_statement : '{' $$2 statement_list '}'",
507
508 };
509 #endif
510
511 #if YYDEBUG
512 int yydebug;
513 #endif
514
515 int yyerrflag;
516 int yychar;
517 YYSTYPE yyval;
518 YYSTYPE yylval;
519 int yynerrs;
520
521 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
522 YYLTYPE yyloc; /* position returned by actions */
523 YYLTYPE yylloc; /* position from the lexer */
524 #endif
525
526 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
527 #ifndef YYLLOC_DEFAULT
528 #define YYLLOC_DEFAULT(loc, rhs, n) \
529 do \
530 { \
531 if (n == 0) \
532 { \
533 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
534 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
535 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
536 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
537 } \
538 else \
539 { \
540 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
541 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
542 (loc).last_line = YYRHSLOC(rhs, n).last_line; \
543 (loc).last_column = YYRHSLOC(rhs, n).last_column; \
544 } \
545 } while (0)
546 #endif /* YYLLOC_DEFAULT */
547 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
548 #if YYBTYACC
549
550 #ifndef YYLVQUEUEGROWTH
551 #define YYLVQUEUEGROWTH 32
552 #endif
553 #endif /* YYBTYACC */
554
555 /* define the initial stack-sizes */
556 #ifdef YYSTACKSIZE
557 #undef YYMAXDEPTH
558 #define YYMAXDEPTH YYSTACKSIZE
559 #else
560 #ifdef YYMAXDEPTH
561 #define YYSTACKSIZE YYMAXDEPTH
562 #else
563 #define YYSTACKSIZE 10000
564 #define YYMAXDEPTH 10000
565 #endif
566 #endif
567
568 #ifndef YYINITSTACKSIZE
569 #define YYINITSTACKSIZE 200
570 #endif
571
572 typedef struct {
573 unsigned stacksize;
574 YYINT *s_base;
575 YYINT *s_mark;
576 YYINT *s_last;
577 YYSTYPE *l_base;
578 YYSTYPE *l_mark;
579 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
580 YYLTYPE *p_base;
581 YYLTYPE *p_mark;
582 #endif
583 } YYSTACKDATA;
584 #if YYBTYACC
585
586 struct YYParseState_s
587 {
588 struct YYParseState_s *save; /* Previously saved parser state */
589 YYSTACKDATA yystack; /* saved parser stack */
590 int state; /* saved parser state */
591 int errflag; /* saved error recovery status */
592 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
593 YYINT ctry; /* saved index in yyctable[] for this conflict */
594 };
595 typedef struct YYParseState_s YYParseState;
596 #endif /* YYBTYACC */
597 /* variables for the parser stack */
598 static YYSTACKDATA yystack;
599 #if YYBTYACC
600
601 /* Current parser state */
602 static YYParseState *yyps = 0;
603
604 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
605 static YYParseState *yypath = 0;
606
607 /* Base of the lexical value queue */
608 static YYSTYPE *yylvals = 0;
609
610 /* Current position at lexical value queue */
611 static YYSTYPE *yylvp = 0;
612
613 /* End position of lexical value queue */
614 static YYSTYPE *yylve = 0;
615
616 /* The last allocated position at the lexical value queue */
617 static YYSTYPE *yylvlim = 0;
618
619 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
620 /* Base of the lexical position queue */
621 static YYLTYPE *yylpsns = 0;
622
623 /* Current position at lexical position queue */
624 static YYLTYPE *yylpp = 0;
625
626 /* End position of lexical position queue */
627 static YYLTYPE *yylpe = 0;
628
629 /* The last allocated position at the lexical position queue */
630 static YYLTYPE *yylplim = 0;
631 #endif
632
633 /* Current position at lexical token queue */
634 static YYINT *yylexp = 0;
635
636 static YYINT *yylexemes = 0;
637 #endif /* YYBTYACC */
638 #line 200 "btyacc_demo.y"
639
640 extern int YYLEX_DECL();
641 extern void YYERROR_DECL();
642
643 extern Scope *global_scope;
644
645 extern Decl * lookup(Scope *scope, char *id);
646 extern Scope * new_scope(Scope *outer_scope);
647 extern Scope * start_fn_def(Scope *scope, Decl *fn_decl);
648 extern void finish_fn_def(Decl *fn_decl, Code *block);
649 extern Type * type_combine(Type *specs, Type *spec);
650 extern Type * bare_extern(void);
651 extern Type * bare_register(void);
652 extern Type * bare_static(void);
653 extern Type * bare_const(void);
654 extern Type * bare_volatile(void);
655 extern Decl * declare(Scope *scope, char *id, Type *type);
656 extern Decl * make_pointer(Decl *decl, Type *type);
657 extern Decl * make_array(Type *type, Expr *expr);
658 extern Decl * build_function(Decl *decl, Decl_List *dlist, Type *type);
659 extern Decl_List * append_dlist(Decl_List *dlist, Decl *decl);
660 extern Decl_List * build_dlist(Decl *decl);
661 extern Expr * build_expr(Expr *left, enum Operator op, Expr *right);
662 extern Expr * var_expr(Scope *scope, char *id);
663 extern Code * build_expr_code(Expr *expr);
664 extern Code * build_if(Expr *cond_expr, Code *then_stmt, Code *else_stmt);
665 extern Code * code_append(Code *stmt_list, Code *stmt);
666 #line 667 "btyacc_demo.tab.c"
667
668 /* Release memory associated with symbol. */
669 #if ! defined YYDESTRUCT_IS_DECLARED
670 static void
YYDESTRUCT_DECL()671 YYDESTRUCT_DECL()
672 {
673 switch (psymb)
674 {
675 case 43:
676 #line 83 "btyacc_demo.y"
677 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
678 msg,
679 (*loc).first_line, (*loc).first_column,
680 (*loc).last_line, (*loc).last_column);
681 /* in this example, we don't know what to do here */ }
682 #line 683 "btyacc_demo.tab.c"
683 break;
684 case 45:
685 #line 83 "btyacc_demo.y"
686 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
687 msg,
688 (*loc).first_line, (*loc).first_column,
689 (*loc).last_line, (*loc).last_column);
690 /* in this example, we don't know what to do here */ }
691 #line 692 "btyacc_demo.tab.c"
692 break;
693 case 42:
694 #line 83 "btyacc_demo.y"
695 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
696 msg,
697 (*loc).first_line, (*loc).first_column,
698 (*loc).last_line, (*loc).last_column);
699 /* in this example, we don't know what to do here */ }
700 #line 701 "btyacc_demo.tab.c"
701 break;
702 case 47:
703 #line 83 "btyacc_demo.y"
704 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
705 msg,
706 (*loc).first_line, (*loc).first_column,
707 (*loc).last_line, (*loc).last_column);
708 /* in this example, we don't know what to do here */ }
709 #line 710 "btyacc_demo.tab.c"
710 break;
711 case 37:
712 #line 83 "btyacc_demo.y"
713 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
714 msg,
715 (*loc).first_line, (*loc).first_column,
716 (*loc).last_line, (*loc).last_column);
717 /* in this example, we don't know what to do here */ }
718 #line 719 "btyacc_demo.tab.c"
719 break;
720 case 257:
721 #line 83 "btyacc_demo.y"
722 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
723 msg,
724 (*loc).first_line, (*loc).first_column,
725 (*loc).last_line, (*loc).last_column);
726 /* in this example, we don't know what to do here */ }
727 #line 728 "btyacc_demo.tab.c"
728 break;
729 case 258:
730 #line 83 "btyacc_demo.y"
731 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
732 msg,
733 (*loc).first_line, (*loc).first_column,
734 (*loc).last_line, (*loc).last_column);
735 /* in this example, we don't know what to do here */ }
736 #line 737 "btyacc_demo.tab.c"
737 break;
738 case 40:
739 #line 83 "btyacc_demo.y"
740 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
741 msg,
742 (*loc).first_line, (*loc).first_column,
743 (*loc).last_line, (*loc).last_column);
744 /* in this example, we don't know what to do here */ }
745 #line 746 "btyacc_demo.tab.c"
746 break;
747 case 91:
748 #line 83 "btyacc_demo.y"
749 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
750 msg,
751 (*loc).first_line, (*loc).first_column,
752 (*loc).last_line, (*loc).last_column);
753 /* in this example, we don't know what to do here */ }
754 #line 755 "btyacc_demo.tab.c"
755 break;
756 case 46:
757 #line 83 "btyacc_demo.y"
758 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
759 msg,
760 (*loc).first_line, (*loc).first_column,
761 (*loc).last_line, (*loc).last_column);
762 /* in this example, we don't know what to do here */ }
763 #line 764 "btyacc_demo.tab.c"
764 break;
765 case 259:
766 #line 78 "btyacc_demo.y"
767 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
768 msg,
769 (*loc).first_line, (*loc).first_column,
770 (*loc).last_line, (*loc).last_column);
771 free((*val).id); }
772 #line 773 "btyacc_demo.tab.c"
773 break;
774 case 260:
775 #line 78 "btyacc_demo.y"
776 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
777 msg,
778 (*loc).first_line, (*loc).first_column,
779 (*loc).last_line, (*loc).last_column);
780 free((*val).expr); }
781 #line 782 "btyacc_demo.tab.c"
782 break;
783 case 261:
784 #line 83 "btyacc_demo.y"
785 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
786 msg,
787 (*loc).first_line, (*loc).first_column,
788 (*loc).last_line, (*loc).last_column);
789 /* in this example, we don't know what to do here */ }
790 #line 791 "btyacc_demo.tab.c"
791 break;
792 case 262:
793 #line 83 "btyacc_demo.y"
794 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
795 msg,
796 (*loc).first_line, (*loc).first_column,
797 (*loc).last_line, (*loc).last_column);
798 /* in this example, we don't know what to do here */ }
799 #line 800 "btyacc_demo.tab.c"
800 break;
801 case 263:
802 #line 83 "btyacc_demo.y"
803 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
804 msg,
805 (*loc).first_line, (*loc).first_column,
806 (*loc).last_line, (*loc).last_column);
807 /* in this example, we don't know what to do here */ }
808 #line 809 "btyacc_demo.tab.c"
809 break;
810 case 264:
811 #line 83 "btyacc_demo.y"
812 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
813 msg,
814 (*loc).first_line, (*loc).first_column,
815 (*loc).last_line, (*loc).last_column);
816 /* in this example, we don't know what to do here */ }
817 #line 818 "btyacc_demo.tab.c"
818 break;
819 case 265:
820 #line 83 "btyacc_demo.y"
821 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
822 msg,
823 (*loc).first_line, (*loc).first_column,
824 (*loc).last_line, (*loc).last_column);
825 /* in this example, we don't know what to do here */ }
826 #line 827 "btyacc_demo.tab.c"
827 break;
828 case 266:
829 #line 83 "btyacc_demo.y"
830 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
831 msg,
832 (*loc).first_line, (*loc).first_column,
833 (*loc).last_line, (*loc).last_column);
834 /* in this example, we don't know what to do here */ }
835 #line 836 "btyacc_demo.tab.c"
836 break;
837 case 267:
838 #line 83 "btyacc_demo.y"
839 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
840 msg,
841 (*loc).first_line, (*loc).first_column,
842 (*loc).last_line, (*loc).last_column);
843 /* in this example, we don't know what to do here */ }
844 #line 845 "btyacc_demo.tab.c"
845 break;
846 case 268:
847 #line 83 "btyacc_demo.y"
848 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
849 msg,
850 (*loc).first_line, (*loc).first_column,
851 (*loc).last_line, (*loc).last_column);
852 /* in this example, we don't know what to do here */ }
853 #line 854 "btyacc_demo.tab.c"
854 break;
855 case 269:
856 #line 83 "btyacc_demo.y"
857 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
858 msg,
859 (*loc).first_line, (*loc).first_column,
860 (*loc).last_line, (*loc).last_column);
861 /* in this example, we don't know what to do here */ }
862 #line 863 "btyacc_demo.tab.c"
863 break;
864 case 59:
865 #line 83 "btyacc_demo.y"
866 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
867 msg,
868 (*loc).first_line, (*loc).first_column,
869 (*loc).last_line, (*loc).last_column);
870 /* in this example, we don't know what to do here */ }
871 #line 872 "btyacc_demo.tab.c"
872 break;
873 case 44:
874 #line 83 "btyacc_demo.y"
875 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
876 msg,
877 (*loc).first_line, (*loc).first_column,
878 (*loc).last_line, (*loc).last_column);
879 /* in this example, we don't know what to do here */ }
880 #line 881 "btyacc_demo.tab.c"
881 break;
882 case 41:
883 #line 83 "btyacc_demo.y"
884 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
885 msg,
886 (*loc).first_line, (*loc).first_column,
887 (*loc).last_line, (*loc).last_column);
888 /* in this example, we don't know what to do here */ }
889 #line 890 "btyacc_demo.tab.c"
890 break;
891 case 93:
892 #line 83 "btyacc_demo.y"
893 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
894 msg,
895 (*loc).first_line, (*loc).first_column,
896 (*loc).last_line, (*loc).last_column);
897 /* in this example, we don't know what to do here */ }
898 #line 899 "btyacc_demo.tab.c"
899 break;
900 case 123:
901 #line 83 "btyacc_demo.y"
902 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
903 msg,
904 (*loc).first_line, (*loc).first_column,
905 (*loc).last_line, (*loc).last_column);
906 /* in this example, we don't know what to do here */ }
907 #line 908 "btyacc_demo.tab.c"
908 break;
909 case 125:
910 #line 83 "btyacc_demo.y"
911 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
912 msg,
913 (*loc).first_line, (*loc).first_column,
914 (*loc).last_line, (*loc).last_column);
915 /* in this example, we don't know what to do here */ }
916 #line 917 "btyacc_demo.tab.c"
917 break;
918 case 270:
919 #line 83 "btyacc_demo.y"
920 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
921 msg,
922 (*loc).first_line, (*loc).first_column,
923 (*loc).last_line, (*loc).last_column);
924 /* in this example, we don't know what to do here */ }
925 #line 926 "btyacc_demo.tab.c"
926 break;
927 case 271:
928 #line 83 "btyacc_demo.y"
929 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
930 msg,
931 (*loc).first_line, (*loc).first_column,
932 (*loc).last_line, (*loc).last_column);
933 /* in this example, we don't know what to do here */ }
934 #line 935 "btyacc_demo.tab.c"
935 break;
936 case 272:
937 #line 78 "btyacc_demo.y"
938 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
939 msg,
940 (*loc).first_line, (*loc).first_column,
941 (*loc).last_line, (*loc).last_column);
942 free((*val).expr); }
943 #line 944 "btyacc_demo.tab.c"
944 break;
945 case 273:
946 #line 67 "btyacc_demo.y"
947 { /* 'msg' is a 'char *' indicating the context of destructor invocation*/
948 printf("%s accessed by symbol \"decl\" (case s.b. 273) @ position[%d,%d..%d,%d]\n",
949 msg,
950 (*loc).first_line, (*loc).first_column,
951 (*loc).last_line, (*loc).last_column);
952 free((*val).decl->scope); free((*val).decl->type); }
953 #line 954 "btyacc_demo.tab.c"
954 break;
955 case 274:
956 #line 83 "btyacc_demo.y"
957 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
958 msg,
959 (*loc).first_line, (*loc).first_column,
960 (*loc).last_line, (*loc).last_column);
961 /* in this example, we don't know what to do here */ }
962 #line 963 "btyacc_demo.tab.c"
963 break;
964 case 275:
965 #line 83 "btyacc_demo.y"
966 { printf("%s accessed by symbol with no type @ position[%d,%d..%d,%d]\n",
967 msg,
968 (*loc).first_line, (*loc).first_column,
969 (*loc).last_line, (*loc).last_column);
970 /* in this example, we don't know what to do here */ }
971 #line 972 "btyacc_demo.tab.c"
972 break;
973 case 276:
974 #line 78 "btyacc_demo.y"
975 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
976 msg,
977 (*loc).first_line, (*loc).first_column,
978 (*loc).last_line, (*loc).last_column);
979 free((*val).code); }
980 #line 981 "btyacc_demo.tab.c"
981 break;
982 case 277:
983 #line 78 "btyacc_demo.y"
984 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
985 msg,
986 (*loc).first_line, (*loc).first_column,
987 (*loc).last_line, (*loc).last_column);
988 free((*val).code); }
989 #line 990 "btyacc_demo.tab.c"
990 break;
991 case 278:
992 #line 78 "btyacc_demo.y"
993 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
994 msg,
995 (*loc).first_line, (*loc).first_column,
996 (*loc).last_line, (*loc).last_column);
997 free((*val).code); }
998 #line 999 "btyacc_demo.tab.c"
999 break;
1000 case 279:
1001 #line 73 "btyacc_demo.y"
1002 { printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n",
1003 msg,
1004 (*loc).first_line, (*loc).first_column,
1005 (*loc).last_line, (*loc).last_column);
1006 free((*val).decl); }
1007 #line 1008 "btyacc_demo.tab.c"
1008 break;
1009 case 280:
1010 #line 73 "btyacc_demo.y"
1011 { printf("%s accessed by symbol with type <decl> (case s.b. 279 & 280) @ position[%d,%d..%d,%d]\n",
1012 msg,
1013 (*loc).first_line, (*loc).first_column,
1014 (*loc).last_line, (*loc).last_column);
1015 free((*val).decl); }
1016 #line 1017 "btyacc_demo.tab.c"
1017 break;
1018 case 281:
1019 #line 78 "btyacc_demo.y"
1020 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1021 msg,
1022 (*loc).first_line, (*loc).first_column,
1023 (*loc).last_line, (*loc).last_column);
1024 free((*val).type); }
1025 #line 1026 "btyacc_demo.tab.c"
1026 break;
1027 case 282:
1028 #line 78 "btyacc_demo.y"
1029 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1030 msg,
1031 (*loc).first_line, (*loc).first_column,
1032 (*loc).last_line, (*loc).last_column);
1033 free((*val).type); }
1034 #line 1035 "btyacc_demo.tab.c"
1035 break;
1036 case 283:
1037 #line 78 "btyacc_demo.y"
1038 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1039 msg,
1040 (*loc).first_line, (*loc).first_column,
1041 (*loc).last_line, (*loc).last_column);
1042 free((*val).type); }
1043 #line 1044 "btyacc_demo.tab.c"
1044 break;
1045 case 284:
1046 #line 78 "btyacc_demo.y"
1047 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1048 msg,
1049 (*loc).first_line, (*loc).first_column,
1050 (*loc).last_line, (*loc).last_column);
1051 free((*val).type); }
1052 #line 1053 "btyacc_demo.tab.c"
1053 break;
1054 case 285:
1055 #line 78 "btyacc_demo.y"
1056 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1057 msg,
1058 (*loc).first_line, (*loc).first_column,
1059 (*loc).last_line, (*loc).last_column);
1060 free((*val).type); }
1061 #line 1062 "btyacc_demo.tab.c"
1062 break;
1063 case 286:
1064 #line 78 "btyacc_demo.y"
1065 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1066 msg,
1067 (*loc).first_line, (*loc).first_column,
1068 (*loc).last_line, (*loc).last_column);
1069 free((*val).scope); }
1070 #line 1071 "btyacc_demo.tab.c"
1071 break;
1072 case 287:
1073 #line 78 "btyacc_demo.y"
1074 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1075 msg,
1076 (*loc).first_line, (*loc).first_column,
1077 (*loc).last_line, (*loc).last_column);
1078 free((*val).dlist); }
1079 #line 1080 "btyacc_demo.tab.c"
1080 break;
1081 case 288:
1082 #line 78 "btyacc_demo.y"
1083 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1084 msg,
1085 (*loc).first_line, (*loc).first_column,
1086 (*loc).last_line, (*loc).last_column);
1087 free((*val).dlist); }
1088 #line 1089 "btyacc_demo.tab.c"
1089 break;
1090 case 289:
1091 #line 78 "btyacc_demo.y"
1092 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1093 msg,
1094 (*loc).first_line, (*loc).first_column,
1095 (*loc).last_line, (*loc).last_column);
1096 free((*val).scope); }
1097 #line 1098 "btyacc_demo.tab.c"
1098 break;
1099 case 290:
1100 #line 78 "btyacc_demo.y"
1101 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1102 msg,
1103 (*loc).first_line, (*loc).first_column,
1104 (*loc).last_line, (*loc).last_column);
1105 free((*val).scope); }
1106 #line 1107 "btyacc_demo.tab.c"
1107 break;
1108 case 291:
1109 #line 78 "btyacc_demo.y"
1110 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1111 msg,
1112 (*loc).first_line, (*loc).first_column,
1113 (*loc).last_line, (*loc).last_column);
1114 free((*val).scope); }
1115 #line 1116 "btyacc_demo.tab.c"
1116 break;
1117 case 292:
1118 #line 78 "btyacc_demo.y"
1119 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1120 msg,
1121 (*loc).first_line, (*loc).first_column,
1122 (*loc).last_line, (*loc).last_column);
1123 free((*val).scope); }
1124 #line 1125 "btyacc_demo.tab.c"
1125 break;
1126 case 293:
1127 #line 78 "btyacc_demo.y"
1128 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1129 msg,
1130 (*loc).first_line, (*loc).first_column,
1131 (*loc).last_line, (*loc).last_column);
1132 free((*val).type); }
1133 #line 1134 "btyacc_demo.tab.c"
1134 break;
1135 case 294:
1136 #line 78 "btyacc_demo.y"
1137 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1138 msg,
1139 (*loc).first_line, (*loc).first_column,
1140 (*loc).last_line, (*loc).last_column);
1141 free((*val).scope); }
1142 #line 1143 "btyacc_demo.tab.c"
1143 break;
1144 case 295:
1145 #line 78 "btyacc_demo.y"
1146 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1147 msg,
1148 (*loc).first_line, (*loc).first_column,
1149 (*loc).last_line, (*loc).last_column);
1150 free((*val).type); }
1151 #line 1152 "btyacc_demo.tab.c"
1152 break;
1153 case 296:
1154 #line 78 "btyacc_demo.y"
1155 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1156 msg,
1157 (*loc).first_line, (*loc).first_column,
1158 (*loc).last_line, (*loc).last_column);
1159 free((*val).scope); }
1160 #line 1161 "btyacc_demo.tab.c"
1161 break;
1162 case 297:
1163 #line 78 "btyacc_demo.y"
1164 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1165 msg,
1166 (*loc).first_line, (*loc).first_column,
1167 (*loc).last_line, (*loc).last_column);
1168 free((*val).scope); }
1169 #line 1170 "btyacc_demo.tab.c"
1170 break;
1171 case 298:
1172 #line 78 "btyacc_demo.y"
1173 { printf("%s accessed by symbol of any type other than <decl> @ position[%d,%d..%d,%d]\n",
1174 msg,
1175 (*loc).first_line, (*loc).first_column,
1176 (*loc).last_line, (*loc).last_column);
1177 free((*val).scope); }
1178 #line 1179 "btyacc_demo.tab.c"
1179 break;
1180 }
1181 }
1182 #define YYDESTRUCT_IS_DECLARED 1
1183 #endif
1184
1185 /* For use in generated program */
1186 #define yydepth (int)(yystack.s_mark - yystack.s_base)
1187 #if YYBTYACC
1188 #define yytrial (yyps->save)
1189 #endif /* YYBTYACC */
1190
1191 #if YYDEBUG
1192 #include <stdio.h> /* needed for printf */
1193 #endif
1194
1195 #include <stdlib.h> /* needed for malloc, etc */
1196 #include <string.h> /* needed for memset */
1197
1198 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)1199 static int yygrowstack(YYSTACKDATA *data)
1200 {
1201 int i;
1202 unsigned newsize;
1203 YYINT *newss;
1204 YYSTYPE *newvs;
1205 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1206 YYLTYPE *newps;
1207 #endif
1208
1209 if ((newsize = data->stacksize) == 0)
1210 newsize = YYINITSTACKSIZE;
1211 else if (newsize >= YYMAXDEPTH)
1212 return YYENOMEM;
1213 else if ((newsize *= 2) > YYMAXDEPTH)
1214 newsize = YYMAXDEPTH;
1215
1216 i = (int) (data->s_mark - data->s_base);
1217 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1218 if (newss == NULL)
1219 return YYENOMEM;
1220
1221 data->s_base = newss;
1222 data->s_mark = newss + i;
1223
1224 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1225 if (newvs == NULL)
1226 return YYENOMEM;
1227
1228 data->l_base = newvs;
1229 data->l_mark = newvs + i;
1230
1231 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1232 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
1233 if (newps == NULL)
1234 return YYENOMEM;
1235
1236 data->p_base = newps;
1237 data->p_mark = newps + i;
1238 #endif
1239
1240 data->stacksize = newsize;
1241 data->s_last = data->s_base + newsize - 1;
1242
1243 #if YYDEBUG
1244 if (yydebug)
1245 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
1246 #endif
1247 return 0;
1248 }
1249
1250 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)1251 static void yyfreestack(YYSTACKDATA *data)
1252 {
1253 free(data->s_base);
1254 free(data->l_base);
1255 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1256 free(data->p_base);
1257 #endif
1258 memset(data, 0, sizeof(*data));
1259 }
1260 #else
1261 #define yyfreestack(data) /* nothing */
1262 #endif /* YYPURE || defined(YY_NO_LEAKS) */
1263 #if YYBTYACC
1264
1265 static YYParseState *
yyNewState(unsigned size)1266 yyNewState(unsigned size)
1267 {
1268 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
1269 if (p == NULL) return NULL;
1270
1271 p->yystack.stacksize = size;
1272 if (size == 0)
1273 {
1274 p->yystack.s_base = NULL;
1275 p->yystack.l_base = NULL;
1276 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1277 p->yystack.p_base = NULL;
1278 #endif
1279 return p;
1280 }
1281 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
1282 if (p->yystack.s_base == NULL) return NULL;
1283 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
1284 if (p->yystack.l_base == NULL) return NULL;
1285 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
1286 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1287 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
1288 if (p->yystack.p_base == NULL) return NULL;
1289 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
1290 #endif
1291
1292 return p;
1293 }
1294
1295 static void
yyFreeState(YYParseState * p)1296 yyFreeState(YYParseState *p)
1297 {
1298 yyfreestack(&p->yystack);
1299 free(p);
1300 }
1301 #endif /* YYBTYACC */
1302
1303 #define YYABORT goto yyabort
1304 #define YYREJECT goto yyabort
1305 #define YYACCEPT goto yyaccept
1306 #define YYERROR goto yyerrlab
1307 #if YYBTYACC
1308 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
1309 #define YYVALID_NESTED do { if (yyps->save && \
1310 yyps->save->save == 0) goto yyvalid; } while(0)
1311 #endif /* YYBTYACC */
1312
1313 int
YYPARSE_DECL()1314 YYPARSE_DECL()
1315 {
1316 int yym, yyn, yystate, yyresult;
1317 #if YYBTYACC
1318 int yynewerrflag;
1319 YYParseState *yyerrctx = NULL;
1320 #endif /* YYBTYACC */
1321 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1322 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
1323 #endif
1324 #if YYDEBUG
1325 const char *yys;
1326
1327 if ((yys = getenv("YYDEBUG")) != NULL)
1328 {
1329 yyn = *yys;
1330 if (yyn >= '0' && yyn <= '9')
1331 yydebug = yyn - '0';
1332 }
1333 if (yydebug)
1334 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
1335 #endif
1336 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1337 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
1338 #endif
1339
1340 #if YYBTYACC
1341 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
1342 yyps->save = 0;
1343 #endif /* YYBTYACC */
1344 yym = 0;
1345 /* yyn is set below */
1346 yynerrs = 0;
1347 yyerrflag = 0;
1348 yychar = YYEMPTY;
1349 yystate = 0;
1350
1351 #if YYPURE
1352 memset(&yystack, 0, sizeof(yystack));
1353 #endif
1354
1355 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1356 yystack.s_mark = yystack.s_base;
1357 yystack.l_mark = yystack.l_base;
1358 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1359 yystack.p_mark = yystack.p_base;
1360 #endif
1361 yystate = 0;
1362 *yystack.s_mark = 0;
1363
1364 yyloop:
1365 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1366 if (yychar < 0)
1367 {
1368 #if YYBTYACC
1369 do {
1370 if (yylvp < yylve)
1371 {
1372 /* we're currently re-reading tokens */
1373 yylval = *yylvp++;
1374 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1375 yylloc = *yylpp++;
1376 #endif
1377 yychar = *yylexp++;
1378 break;
1379 }
1380 if (yyps->save)
1381 {
1382 /* in trial mode; save scanner results for future parse attempts */
1383 if (yylvp == yylvlim)
1384 { /* Enlarge lexical value queue */
1385 size_t p = (size_t) (yylvp - yylvals);
1386 size_t s = (size_t) (yylvlim - yylvals);
1387
1388 s += YYLVQUEUEGROWTH;
1389 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
1390 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
1391 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1392 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
1393 #endif
1394 yylvp = yylve = yylvals + p;
1395 yylvlim = yylvals + s;
1396 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1397 yylpp = yylpe = yylpsns + p;
1398 yylplim = yylpsns + s;
1399 #endif
1400 yylexp = yylexemes + p;
1401 }
1402 *yylexp = (YYINT) YYLEX;
1403 *yylvp++ = yylval;
1404 yylve++;
1405 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1406 *yylpp++ = yylloc;
1407 yylpe++;
1408 #endif
1409 yychar = *yylexp++;
1410 break;
1411 }
1412 /* normal operation, no conflict encountered */
1413 #endif /* YYBTYACC */
1414 yychar = YYLEX;
1415 #if YYBTYACC
1416 } while (0);
1417 #endif /* YYBTYACC */
1418 if (yychar < 0) yychar = YYEOF;
1419 #if YYDEBUG
1420 if (yydebug)
1421 {
1422 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1423 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
1424 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1425 #ifdef YYSTYPE_TOSTRING
1426 #if YYBTYACC
1427 if (!yytrial)
1428 #endif /* YYBTYACC */
1429 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
1430 #endif
1431 fputc('\n', stderr);
1432 }
1433 #endif
1434 }
1435 #if YYBTYACC
1436
1437 /* Do we have a conflict? */
1438 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1439 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1440 {
1441 YYINT ctry;
1442
1443 if (yypath)
1444 {
1445 YYParseState *save;
1446 #if YYDEBUG
1447 if (yydebug)
1448 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
1449 YYDEBUGSTR, yydepth, yystate);
1450 #endif
1451 /* Switch to the next conflict context */
1452 save = yypath;
1453 yypath = save->save;
1454 save->save = NULL;
1455 ctry = save->ctry;
1456 if (save->state != yystate) YYABORT;
1457 yyFreeState(save);
1458
1459 }
1460 else
1461 {
1462
1463 /* Unresolved conflict - start/continue trial parse */
1464 YYParseState *save;
1465 #if YYDEBUG
1466 if (yydebug)
1467 {
1468 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
1469 if (yyps->save)
1470 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
1471 else
1472 fputs("Starting trial parse.\n", stderr);
1473 }
1474 #endif
1475 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1476 if (save == NULL) goto yyenomem;
1477 save->save = yyps->save;
1478 save->state = yystate;
1479 save->errflag = yyerrflag;
1480 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
1481 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1482 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
1483 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1484 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1485 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
1486 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1487 #endif
1488 ctry = yytable[yyn];
1489 if (yyctable[ctry] == -1)
1490 {
1491 #if YYDEBUG
1492 if (yydebug && yychar >= YYEOF)
1493 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
1494 #endif
1495 ctry++;
1496 }
1497 save->ctry = ctry;
1498 if (yyps->save == NULL)
1499 {
1500 /* If this is a first conflict in the stack, start saving lexemes */
1501 if (!yylexemes)
1502 {
1503 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
1504 if (yylexemes == NULL) goto yyenomem;
1505 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
1506 if (yylvals == NULL) goto yyenomem;
1507 yylvlim = yylvals + YYLVQUEUEGROWTH;
1508 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1509 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
1510 if (yylpsns == NULL) goto yyenomem;
1511 yylplim = yylpsns + YYLVQUEUEGROWTH;
1512 #endif
1513 }
1514 if (yylvp == yylve)
1515 {
1516 yylvp = yylve = yylvals;
1517 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1518 yylpp = yylpe = yylpsns;
1519 #endif
1520 yylexp = yylexemes;
1521 if (yychar >= YYEOF)
1522 {
1523 *yylve++ = yylval;
1524 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1525 *yylpe++ = yylloc;
1526 #endif
1527 *yylexp = (YYINT) yychar;
1528 yychar = YYEMPTY;
1529 }
1530 }
1531 }
1532 if (yychar >= YYEOF)
1533 {
1534 yylvp--;
1535 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1536 yylpp--;
1537 #endif
1538 yylexp--;
1539 yychar = YYEMPTY;
1540 }
1541 save->lexeme = (int) (yylvp - yylvals);
1542 yyps->save = save;
1543 }
1544 if (yytable[yyn] == ctry)
1545 {
1546 #if YYDEBUG
1547 if (yydebug)
1548 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1549 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1550 #endif
1551 if (yychar < 0)
1552 {
1553 yylvp++;
1554 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1555 yylpp++;
1556 #endif
1557 yylexp++;
1558 }
1559 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1560 goto yyoverflow;
1561 yystate = yyctable[ctry];
1562 *++yystack.s_mark = (YYINT) yystate;
1563 *++yystack.l_mark = yylval;
1564 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1565 *++yystack.p_mark = yylloc;
1566 #endif
1567 yychar = YYEMPTY;
1568 if (yyerrflag > 0) --yyerrflag;
1569 goto yyloop;
1570 }
1571 else
1572 {
1573 yyn = yyctable[ctry];
1574 goto yyreduce;
1575 }
1576 } /* End of code dealing with conflicts */
1577 #endif /* YYBTYACC */
1578 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1579 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1580 {
1581 #if YYDEBUG
1582 if (yydebug)
1583 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1584 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1585 #endif
1586 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1587 yystate = yytable[yyn];
1588 *++yystack.s_mark = yytable[yyn];
1589 *++yystack.l_mark = yylval;
1590 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1591 *++yystack.p_mark = yylloc;
1592 #endif
1593 yychar = YYEMPTY;
1594 if (yyerrflag > 0) --yyerrflag;
1595 goto yyloop;
1596 }
1597 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1598 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1599 {
1600 yyn = yytable[yyn];
1601 goto yyreduce;
1602 }
1603 if (yyerrflag != 0) goto yyinrecovery;
1604 #if YYBTYACC
1605
1606 yynewerrflag = 1;
1607 goto yyerrhandler;
1608 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1609
1610 yyerrlab:
1611 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
1612 * before looking for error recovery */
1613 yystack.s_mark -= yym;
1614 yystate = *yystack.s_mark;
1615 yystack.l_mark -= yym;
1616 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1617 yystack.p_mark -= yym;
1618 #endif
1619
1620 yynewerrflag = 0;
1621 yyerrhandler:
1622 while (yyps->save)
1623 {
1624 int ctry;
1625 YYParseState *save = yyps->save;
1626 #if YYDEBUG
1627 if (yydebug)
1628 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1629 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1630 (int)(yylvp - yylvals - yyps->save->lexeme));
1631 #endif
1632 /* Memorize most forward-looking error state in case it's really an error. */
1633 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1634 {
1635 /* Free old saved error context state */
1636 if (yyerrctx) yyFreeState(yyerrctx);
1637 /* Create and fill out new saved error context state */
1638 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1639 if (yyerrctx == NULL) goto yyenomem;
1640 yyerrctx->save = yyps->save;
1641 yyerrctx->state = yystate;
1642 yyerrctx->errflag = yyerrflag;
1643 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1644 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1645 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1646 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1647 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1648 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1649 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1650 #endif
1651 yyerrctx->lexeme = (int) (yylvp - yylvals);
1652 }
1653 yylvp = yylvals + save->lexeme;
1654 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1655 yylpp = yylpsns + save->lexeme;
1656 #endif
1657 yylexp = yylexemes + save->lexeme;
1658 yychar = YYEMPTY;
1659 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1660 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1661 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1662 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1663 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1664 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1665 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1666 #endif
1667 ctry = ++save->ctry;
1668 yystate = save->state;
1669 /* We tried shift, try reduce now */
1670 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1671 yyps->save = save->save;
1672 save->save = NULL;
1673 yyFreeState(save);
1674
1675 /* Nothing left on the stack -- error */
1676 if (!yyps->save)
1677 {
1678 #if YYDEBUG
1679 if (yydebug)
1680 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1681 YYPREFIX, yydepth);
1682 #endif
1683 /* Restore state as it was in the most forward-advanced error */
1684 yylvp = yylvals + yyerrctx->lexeme;
1685 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1686 yylpp = yylpsns + yyerrctx->lexeme;
1687 #endif
1688 yylexp = yylexemes + yyerrctx->lexeme;
1689 yychar = yylexp[-1];
1690 yylval = yylvp[-1];
1691 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1692 yylloc = yylpp[-1];
1693 #endif
1694 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1695 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1696 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1697 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1698 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1699 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1700 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1701 #endif
1702 yystate = yyerrctx->state;
1703 yyFreeState(yyerrctx);
1704 yyerrctx = NULL;
1705 }
1706 yynewerrflag = 1;
1707 }
1708 if (yynewerrflag == 0) goto yyinrecovery;
1709 #endif /* YYBTYACC */
1710
1711 YYERROR_CALL("syntax error");
1712 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1713 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1714 #endif
1715
1716 #if !YYBTYACC
1717 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1718 yyerrlab:
1719 #endif
1720 ++yynerrs;
1721
1722 yyinrecovery:
1723 if (yyerrflag < 3)
1724 {
1725 yyerrflag = 3;
1726 for (;;)
1727 {
1728 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1729 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1730 {
1731 #if YYDEBUG
1732 if (yydebug)
1733 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1734 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1735 #endif
1736 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1737 yystate = yytable[yyn];
1738 *++yystack.s_mark = yytable[yyn];
1739 *++yystack.l_mark = yylval;
1740 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1741 /* lookahead position is error end position */
1742 yyerror_loc_range[2] = yylloc;
1743 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1744 *++yystack.p_mark = yyloc;
1745 #endif
1746 goto yyloop;
1747 }
1748 else
1749 {
1750 #if YYDEBUG
1751 if (yydebug)
1752 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1753 YYDEBUGSTR, yydepth, *yystack.s_mark);
1754 #endif
1755 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1756 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1757 /* the current TOS position is the error start position */
1758 yyerror_loc_range[1] = *yystack.p_mark;
1759 #endif
1760 #if defined(YYDESTRUCT_CALL)
1761 #if YYBTYACC
1762 if (!yytrial)
1763 #endif /* YYBTYACC */
1764 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1765 YYDESTRUCT_CALL("error: discarding state",
1766 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1767 #else
1768 YYDESTRUCT_CALL("error: discarding state",
1769 yystos[*yystack.s_mark], yystack.l_mark);
1770 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1771 #endif /* defined(YYDESTRUCT_CALL) */
1772 --yystack.s_mark;
1773 --yystack.l_mark;
1774 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1775 --yystack.p_mark;
1776 #endif
1777 }
1778 }
1779 }
1780 else
1781 {
1782 if (yychar == YYEOF) goto yyabort;
1783 #if YYDEBUG
1784 if (yydebug)
1785 {
1786 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1787 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1788 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1789 }
1790 #endif
1791 #if defined(YYDESTRUCT_CALL)
1792 #if YYBTYACC
1793 if (!yytrial)
1794 #endif /* YYBTYACC */
1795 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1796 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1797 #else
1798 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1799 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1800 #endif /* defined(YYDESTRUCT_CALL) */
1801 yychar = YYEMPTY;
1802 goto yyloop;
1803 }
1804
1805 yyreduce:
1806 yym = yylen[yyn];
1807 #if YYDEBUG
1808 if (yydebug)
1809 {
1810 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1811 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1812 #ifdef YYSTYPE_TOSTRING
1813 #if YYBTYACC
1814 if (!yytrial)
1815 #endif /* YYBTYACC */
1816 if (yym > 0)
1817 {
1818 int i;
1819 fputc('<', stderr);
1820 for (i = yym; i > 0; i--)
1821 {
1822 if (i != yym) fputs(", ", stderr);
1823 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1824 yystack.l_mark[1-i]), stderr);
1825 }
1826 fputc('>', stderr);
1827 }
1828 #endif
1829 fputc('\n', stderr);
1830 }
1831 #endif
1832 if (yym > 0)
1833 yyval = yystack.l_mark[1-yym];
1834 else
1835 memset(&yyval, 0, sizeof yyval);
1836 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1837
1838 /* Perform position reduction */
1839 memset(&yyloc, 0, sizeof(yyloc));
1840 #if YYBTYACC
1841 if (!yytrial)
1842 #endif /* YYBTYACC */
1843 {
1844 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1845 /* just in case YYERROR is invoked within the action, save
1846 the start of the rhs as the error start position */
1847 yyerror_loc_range[1] = yystack.p_mark[1-yym];
1848 }
1849 #endif
1850
1851 switch (yyn)
1852 {
1853 case 1:
1854 #line 93 "btyacc_demo.y"
1855 { yyval.scope = yystack.l_mark[0].scope; }
1856 #line 1857 "btyacc_demo.tab.c"
1857 break;
1858 case 2:
1859 #line 94 "btyacc_demo.y"
1860 { yyval.scope = global_scope; }
1861 #line 1862 "btyacc_demo.tab.c"
1862 break;
1863 case 3:
1864 #line 95 "btyacc_demo.y"
1865 { Decl *d = lookup(yystack.l_mark[-2].scope, yystack.l_mark[-1].id);
1866 if (!d || !d->scope) YYERROR;
1867 yyval.scope = d->scope; }
1868 #line 1869 "btyacc_demo.tab.c"
1869 break;
1870 case 4:
1871 #line 101 "btyacc_demo.y"
1872 { Decl *d = lookup(yystack.l_mark[-1].scope, yystack.l_mark[0].id);
1873 if (d == NULL || d->istype() == 0) YYERROR;
1874 yyval.type = d->type; }
1875 #line 1876 "btyacc_demo.tab.c"
1876 break;
1877 case 5:
1878 #line 106 "btyacc_demo.y"
1879 yyval.scope = global_scope = new_scope(0);
1880 #line 1881 "btyacc_demo.tab.c"
1881 break;
1882 case 8:
1883 #line 107 "btyacc_demo.y"
1884 yyval.scope = yystack.l_mark[-1].scope;
1885 #line 1886 "btyacc_demo.tab.c"
1886 break;
1887 case 10:
1888 #line 109 "btyacc_demo.y"
1889 {YYVALID;}
1890 #line 1891 "btyacc_demo.tab.c"
1891 break;
1892 case 11:
1893 #line 110 "btyacc_demo.y"
1894 yyval.scope = start_fn_def(yystack.l_mark[-2].scope, yystack.l_mark[0].decl);
1895 #line 1896 "btyacc_demo.tab.c"
1896 break;
1897 case 12:
1898 if (!yytrial)
1899 #line 111 "btyacc_demo.y"
1900 { /* demonstrate use of @$ & @N, although this is just the
1901 default computation and so is not necessary */
1902 yyloc.first_line = yystack.p_mark[-3].first_line;
1903 yyloc.first_column = yystack.p_mark[-3].first_column;
1904 yyloc.last_line = yystack.p_mark[0].last_line;
1905 yyloc.last_column = yystack.p_mark[0].last_column;
1906 finish_fn_def(yystack.l_mark[-2].decl, yystack.l_mark[0].code); }
1907 #line 1908 "btyacc_demo.tab.c"
1908 break;
1909 case 13:
1910 #line 121 "btyacc_demo.y"
1911 { yyval.type = yystack.l_mark[0].type; }
1912 #line 1913 "btyacc_demo.tab.c"
1913 break;
1914 case 14:
1915 #line 122 "btyacc_demo.y"
1916 { yyval.type = type_combine(yystack.l_mark[-2].type, yystack.l_mark[0].type); }
1917 #line 1918 "btyacc_demo.tab.c"
1918 break;
1919 case 15:
1920 #line 125 "btyacc_demo.y"
1921 { yyval.type = 0; }
1922 #line 1923 "btyacc_demo.tab.c"
1923 break;
1924 case 16:
1925 #line 126 "btyacc_demo.y"
1926 { yyval.type = type_combine(yystack.l_mark[-1].type, yystack.l_mark[0].type); }
1927 #line 1928 "btyacc_demo.tab.c"
1928 break;
1929 case 17:
1930 #line 130 "btyacc_demo.y"
1931 { yyval.type = yystack.l_mark[0].type; }
1932 #line 1933 "btyacc_demo.tab.c"
1933 break;
1934 case 18:
1935 #line 131 "btyacc_demo.y"
1936 { yyval.type = yystack.l_mark[0].type; }
1937 #line 1938 "btyacc_demo.tab.c"
1938 break;
1939 case 19:
1940 #line 132 "btyacc_demo.y"
1941 { yyval.type = bare_extern(); }
1942 #line 1943 "btyacc_demo.tab.c"
1943 break;
1944 case 20:
1945 #line 133 "btyacc_demo.y"
1946 { yyval.type = bare_register(); }
1947 #line 1948 "btyacc_demo.tab.c"
1948 break;
1949 case 21:
1950 #line 134 "btyacc_demo.y"
1951 { yyval.type = bare_static(); }
1952 #line 1953 "btyacc_demo.tab.c"
1953 break;
1954 case 22:
1955 #line 138 "btyacc_demo.y"
1956 { yyval.type = bare_const(); }
1957 #line 1958 "btyacc_demo.tab.c"
1958 break;
1959 case 23:
1960 #line 139 "btyacc_demo.y"
1961 { yyval.type = bare_volatile(); }
1962 #line 1963 "btyacc_demo.tab.c"
1963 break;
1964 case 24:
1965 #line 143 "btyacc_demo.y"
1966 yyval.scope = yystack.l_mark[-3].scope;
1967 #line 1968 "btyacc_demo.tab.c"
1968 break;
1969 case 25:
1970 #line 143 "btyacc_demo.y"
1971 yyval.type = yystack.l_mark[-3].type;
1972 #line 1973 "btyacc_demo.tab.c"
1973 break;
1974 case 28:
1975 #line 148 "btyacc_demo.y"
1976 { if (!yystack.l_mark[0].type) YYERROR; } if (!yytrial)
1977 #line 149 "btyacc_demo.y"
1978 { yyval.decl = declare(yystack.l_mark[-1].scope, 0, yystack.l_mark[0].type); }
1979 #line 1980 "btyacc_demo.tab.c"
1980 break;
1981 case 29:
1982 if (!yytrial)
1983 #line 150 "btyacc_demo.y"
1984 { yyval.decl = declare(yystack.l_mark[-2].scope, yystack.l_mark[0].id, yystack.l_mark[-1].type); }
1985 #line 1986 "btyacc_demo.tab.c"
1986 break;
1987 case 30:
1988 #line 151 "btyacc_demo.y"
1989 yyval.scope = yystack.l_mark[-2].scope;
1990 #line 1991 "btyacc_demo.tab.c"
1991 break;
1992 case 31:
1993 #line 151 "btyacc_demo.y"
1994 yyval.type = yystack.l_mark[-2].type;
1995 #line 1996 "btyacc_demo.tab.c"
1996 break;
1997 case 32:
1998 if (!yytrial)
1999 #line 151 "btyacc_demo.y"
2000 { yyval.decl = yystack.l_mark[-1].decl; }
2001 #line 2002 "btyacc_demo.tab.c"
2002 break;
2003 case 33:
2004 if (!yytrial)
2005 #line 153 "btyacc_demo.y"
2006 { yyval.decl = make_pointer(yystack.l_mark[0].decl, yystack.l_mark[-3].type); }
2007 #line 2008 "btyacc_demo.tab.c"
2008 break;
2009 case 34:
2010 if (!yytrial)
2011 #line 155 "btyacc_demo.y"
2012 { yyval.decl = make_array(yystack.l_mark[-4].decl->type, yystack.l_mark[-1].expr); }
2013 #line 2014 "btyacc_demo.tab.c"
2014 break;
2015 case 35:
2016 if (!yytrial)
2017 #line 157 "btyacc_demo.y"
2018 { yyval.decl = build_function(yystack.l_mark[-5].decl, yystack.l_mark[-2].dlist, yystack.l_mark[0].type); }
2019 #line 2020 "btyacc_demo.tab.c"
2020 break;
2021 case 36:
2022 if (!yytrial)
2023 #line 160 "btyacc_demo.y"
2024 { yyval.dlist = 0; }
2025 #line 2026 "btyacc_demo.tab.c"
2026 break;
2027 case 37:
2028 if (!yytrial)
2029 #line 161 "btyacc_demo.y"
2030 { yyval.dlist = yystack.l_mark[0].dlist; }
2031 #line 2032 "btyacc_demo.tab.c"
2032 break;
2033 case 38:
2034 if (!yytrial)
2035 #line 164 "btyacc_demo.y"
2036 { yyval.dlist = append_dlist(yystack.l_mark[-3].dlist, yystack.l_mark[0].decl); }
2037 #line 2038 "btyacc_demo.tab.c"
2038 break;
2039 case 39:
2040 if (!yytrial)
2041 #line 165 "btyacc_demo.y"
2042 { yyval.dlist = build_dlist(yystack.l_mark[0].decl); }
2043 #line 2044 "btyacc_demo.tab.c"
2044 break;
2045 case 40:
2046 if (!yytrial)
2047 #line 168 "btyacc_demo.y"
2048 { yyval.decl = yystack.l_mark[0].decl; }
2049 #line 2050 "btyacc_demo.tab.c"
2050 break;
2051 case 41:
2052 if (!yytrial)
2053 #line 172 "btyacc_demo.y"
2054 { yyval.expr = build_expr(yystack.l_mark[-3].expr, ADD, yystack.l_mark[0].expr); }
2055 #line 2056 "btyacc_demo.tab.c"
2056 break;
2057 case 42:
2058 if (!yytrial)
2059 #line 173 "btyacc_demo.y"
2060 { yyval.expr = build_expr(yystack.l_mark[-3].expr, SUB, yystack.l_mark[0].expr); }
2061 #line 2062 "btyacc_demo.tab.c"
2062 break;
2063 case 43:
2064 if (!yytrial)
2065 #line 174 "btyacc_demo.y"
2066 { yyval.expr = build_expr(yystack.l_mark[-3].expr, MUL, yystack.l_mark[0].expr); }
2067 #line 2068 "btyacc_demo.tab.c"
2068 break;
2069 case 44:
2070 if (!yytrial)
2071 #line 175 "btyacc_demo.y"
2072 { yyval.expr = build_expr(yystack.l_mark[-3].expr, MOD, yystack.l_mark[0].expr); }
2073 #line 2074 "btyacc_demo.tab.c"
2074 break;
2075 case 45:
2076 if (!yytrial)
2077 #line 176 "btyacc_demo.y"
2078 { yyval.expr = build_expr(yystack.l_mark[-3].expr, DIV, yystack.l_mark[0].expr); }
2079 #line 2080 "btyacc_demo.tab.c"
2080 break;
2081 case 46:
2082 if (!yytrial)
2083 #line 177 "btyacc_demo.y"
2084 { yyval.expr = build_expr(0, DEREF, yystack.l_mark[0].expr); }
2085 #line 2086 "btyacc_demo.tab.c"
2086 break;
2087 case 47:
2088 if (!yytrial)
2089 #line 178 "btyacc_demo.y"
2090 { yyval.expr = var_expr(yystack.l_mark[-1].scope, yystack.l_mark[0].id); }
2091 #line 2092 "btyacc_demo.tab.c"
2092 break;
2093 case 48:
2094 if (!yytrial)
2095 #line 179 "btyacc_demo.y"
2096 { yyval.expr = yystack.l_mark[0].expr; }
2097 #line 2098 "btyacc_demo.tab.c"
2098 break;
2099 case 49:
2100 if (!yytrial)
2101 #line 183 "btyacc_demo.y"
2102 { yyval.code = 0; }
2103 #line 2104 "btyacc_demo.tab.c"
2104 break;
2105 case 50:
2106 #line 184 "btyacc_demo.y"
2107 {YYVALID;} if (!yytrial)
2108 #line 184 "btyacc_demo.y"
2109 { yyval.code = build_expr_code(yystack.l_mark[-1].expr); }
2110 #line 2111 "btyacc_demo.tab.c"
2111 break;
2112 case 51:
2113 #line 185 "btyacc_demo.y"
2114 yyval.scope = yystack.l_mark[-6].scope;
2115 #line 2116 "btyacc_demo.tab.c"
2116 break;
2117 case 52:
2118 #line 185 "btyacc_demo.y"
2119 yyval.scope = yystack.l_mark[-9].scope;
2120 #line 2121 "btyacc_demo.tab.c"
2121 break;
2122 case 53:
2123 #line 185 "btyacc_demo.y"
2124 {YYVALID;} if (!yytrial)
2125 #line 186 "btyacc_demo.y"
2126 { yyval.code = build_if(yystack.l_mark[-7].expr, yystack.l_mark[-3].code, yystack.l_mark[0].code); }
2127 #line 2128 "btyacc_demo.tab.c"
2128 break;
2129 case 54:
2130 #line 187 "btyacc_demo.y"
2131 {YYVALID;} if (!yytrial)
2132 #line 188 "btyacc_demo.y"
2133 { yyval.code = build_if(yystack.l_mark[-4].expr, yystack.l_mark[0].code, 0); }
2134 #line 2135 "btyacc_demo.tab.c"
2135 break;
2136 case 55:
2137 #line 189 "btyacc_demo.y"
2138 yyval.scope = new_scope(yystack.l_mark[0].scope);
2139 #line 2140 "btyacc_demo.tab.c"
2140 break;
2141 case 56:
2142 #line 189 "btyacc_demo.y"
2143 {YYVALID;} if (!yytrial)
2144 #line 189 "btyacc_demo.y"
2145 { yyval.code = yystack.l_mark[0].code; }
2146 #line 2147 "btyacc_demo.tab.c"
2147 break;
2148 case 57:
2149 if (!yytrial)
2150 #line 192 "btyacc_demo.y"
2151 { yyval.code = 0; }
2152 #line 2153 "btyacc_demo.tab.c"
2153 break;
2154 case 58:
2155 if (!yytrial)
2156 #line 193 "btyacc_demo.y"
2157 { yyval.code = code_append(yystack.l_mark[-2].code, yystack.l_mark[0].code); }
2158 #line 2159 "btyacc_demo.tab.c"
2159 break;
2160 case 59:
2161 if (!yytrial)
2162 #line 197 "btyacc_demo.y"
2163 { yyval.code = yystack.l_mark[-1].code; }
2164 #line 2165 "btyacc_demo.tab.c"
2165 break;
2166 #line 2167 "btyacc_demo.tab.c"
2167 default:
2168 break;
2169 }
2170 yystack.s_mark -= yym;
2171 yystate = *yystack.s_mark;
2172 yystack.l_mark -= yym;
2173 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2174 yystack.p_mark -= yym;
2175 #endif
2176 yym = yylhs[yyn];
2177 if (yystate == 0 && yym == 0)
2178 {
2179 #if YYDEBUG
2180 if (yydebug)
2181 {
2182 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2183 #ifdef YYSTYPE_TOSTRING
2184 #if YYBTYACC
2185 if (!yytrial)
2186 #endif /* YYBTYACC */
2187 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
2188 #endif
2189 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
2190 }
2191 #endif
2192 yystate = YYFINAL;
2193 *++yystack.s_mark = YYFINAL;
2194 *++yystack.l_mark = yyval;
2195 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2196 *++yystack.p_mark = yyloc;
2197 #endif
2198 if (yychar < 0)
2199 {
2200 #if YYBTYACC
2201 do {
2202 if (yylvp < yylve)
2203 {
2204 /* we're currently re-reading tokens */
2205 yylval = *yylvp++;
2206 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2207 yylloc = *yylpp++;
2208 #endif
2209 yychar = *yylexp++;
2210 break;
2211 }
2212 if (yyps->save)
2213 {
2214 /* in trial mode; save scanner results for future parse attempts */
2215 if (yylvp == yylvlim)
2216 { /* Enlarge lexical value queue */
2217 size_t p = (size_t) (yylvp - yylvals);
2218 size_t s = (size_t) (yylvlim - yylvals);
2219
2220 s += YYLVQUEUEGROWTH;
2221 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
2222 goto yyenomem;
2223 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
2224 goto yyenomem;
2225 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2226 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
2227 goto yyenomem;
2228 #endif
2229 yylvp = yylve = yylvals + p;
2230 yylvlim = yylvals + s;
2231 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2232 yylpp = yylpe = yylpsns + p;
2233 yylplim = yylpsns + s;
2234 #endif
2235 yylexp = yylexemes + p;
2236 }
2237 *yylexp = (YYINT) YYLEX;
2238 *yylvp++ = yylval;
2239 yylve++;
2240 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2241 *yylpp++ = yylloc;
2242 yylpe++;
2243 #endif
2244 yychar = *yylexp++;
2245 break;
2246 }
2247 /* normal operation, no conflict encountered */
2248 #endif /* YYBTYACC */
2249 yychar = YYLEX;
2250 #if YYBTYACC
2251 } while (0);
2252 #endif /* YYBTYACC */
2253 if (yychar < 0) yychar = YYEOF;
2254 #if YYDEBUG
2255 if (yydebug)
2256 {
2257 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2258 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
2259 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
2260 }
2261 #endif
2262 }
2263 if (yychar == YYEOF) goto yyaccept;
2264 goto yyloop;
2265 }
2266 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
2267 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
2268 yystate = yytable[yyn];
2269 else
2270 yystate = yydgoto[yym];
2271 #if YYDEBUG
2272 if (yydebug)
2273 {
2274 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2275 #ifdef YYSTYPE_TOSTRING
2276 #if YYBTYACC
2277 if (!yytrial)
2278 #endif /* YYBTYACC */
2279 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
2280 #endif
2281 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
2282 }
2283 #endif
2284 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2285 *++yystack.s_mark = (YYINT) yystate;
2286 *++yystack.l_mark = yyval;
2287 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2288 *++yystack.p_mark = yyloc;
2289 #endif
2290 goto yyloop;
2291 #if YYBTYACC
2292
2293 /* Reduction declares that this path is valid. Set yypath and do a full parse */
2294 yyvalid:
2295 if (yypath) YYABORT;
2296 while (yyps->save)
2297 {
2298 YYParseState *save = yyps->save;
2299 yyps->save = save->save;
2300 save->save = yypath;
2301 yypath = save;
2302 }
2303 #if YYDEBUG
2304 if (yydebug)
2305 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
2306 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
2307 #endif
2308 if (yyerrctx)
2309 {
2310 yyFreeState(yyerrctx);
2311 yyerrctx = NULL;
2312 }
2313 yylvp = yylvals + yypath->lexeme;
2314 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2315 yylpp = yylpsns + yypath->lexeme;
2316 #endif
2317 yylexp = yylexemes + yypath->lexeme;
2318 yychar = YYEMPTY;
2319 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
2320 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2321 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
2322 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2323 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2324 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
2325 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2326 #endif
2327 yystate = yypath->state;
2328 goto yyloop;
2329 #endif /* YYBTYACC */
2330
2331 yyoverflow:
2332 YYERROR_CALL("yacc stack overflow");
2333 #if YYBTYACC
2334 goto yyabort_nomem;
2335 yyenomem:
2336 YYERROR_CALL("memory exhausted");
2337 yyabort_nomem:
2338 #endif /* YYBTYACC */
2339 yyresult = 2;
2340 goto yyreturn;
2341
2342 yyabort:
2343 yyresult = 1;
2344 goto yyreturn;
2345
2346 yyaccept:
2347 #if YYBTYACC
2348 if (yyps->save) goto yyvalid;
2349 #endif /* YYBTYACC */
2350 yyresult = 0;
2351
2352 yyreturn:
2353 #if defined(YYDESTRUCT_CALL)
2354 if (yychar != YYEOF && yychar != YYEMPTY)
2355 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2356 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
2357 #else
2358 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
2359 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2360
2361 {
2362 YYSTYPE *pv;
2363 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2364 YYLTYPE *pp;
2365
2366 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
2367 YYDESTRUCT_CALL("cleanup: discarding state",
2368 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
2369 #else
2370 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
2371 YYDESTRUCT_CALL("cleanup: discarding state",
2372 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
2373 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2374 }
2375 #endif /* defined(YYDESTRUCT_CALL) */
2376
2377 #if YYBTYACC
2378 if (yyerrctx)
2379 {
2380 yyFreeState(yyerrctx);
2381 yyerrctx = NULL;
2382 }
2383 while (yyps)
2384 {
2385 YYParseState *save = yyps;
2386 yyps = save->save;
2387 save->save = NULL;
2388 yyFreeState(save);
2389 }
2390 while (yypath)
2391 {
2392 YYParseState *save = yypath;
2393 yypath = save->save;
2394 save->save = NULL;
2395 yyFreeState(save);
2396 }
2397 #endif /* YYBTYACC */
2398 yyfreestack(&yystack);
2399 return (yyresult);
2400 }
2401