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