]>
Commit | Line | Data |
---|---|---|
720623af PH |
1 | m4_divert(-1) -*- C -*- |
2 | m4_include([c.m4]) | |
01241d47 | 3 | |
fb8135fa AD |
4 | # GLR skeleton for Bison |
5 | # Copyright (C) 2002 Free Software Foundation, Inc. | |
6 | ||
7 | # This program is free software; you can redistribute it and/or modify | |
8 | # it under the terms of the GNU General Public License as published by | |
9 | # the Free Software Foundation; either version 2 of the License, or | |
10 | # (at your option) any later version. | |
11 | ||
12 | # This program is distributed in the hope that it will be useful, | |
13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | # GNU General Public License for more details. | |
16 | ||
17 | # You should have received a copy of the GNU General Public License | |
18 | # along with this program; if not, write to the Free Software | |
19 | # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA | |
20 | # 02111-1307 USA | |
21 | ||
66d30cd4 AD |
22 | |
23 | ## ---------------- ## | |
24 | ## Default values. ## | |
25 | ## ---------------- ## | |
26 | ||
27 | # Stack parameters. | |
28 | m4_define_default([b4_stack_depth_max], [10000]) | |
29 | m4_define_default([b4_stack_depth_init], [200]) | |
30 | ||
31 | # Location type. | |
32 | m4_define_default([b4_location_type], [yyltype]) | |
33 | ||
2a8d363a AD |
34 | |
35 | ||
36 | ## ------------------------ ## | |
37 | ## Pure/impure interfaces. ## | |
38 | ## ------------------------ ## | |
39 | ||
40 | ||
41 | # b4_lex_param | |
42 | # ------------ | |
21964f43 AD |
43 | # Accumule in b4_lex_param all the yylex arguments. |
44 | # Yes, this is quite ugly... | |
45 | m4_define([b4_lex_param], | |
46 | m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[yylvalp]]][]dnl | |
47 | b4_location_if([, [[YYLTYPE *], [yyllocp]]])])dnl | |
48 | m4_ifdef([b4_lex_param], [, ]b4_lex_param))) | |
49 | ||
2a8d363a AD |
50 | |
51 | # b4_user_formals | |
52 | # --------------- | |
53 | m4_define([b4_user_formals], | |
54 | [m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])]) | |
55 | ||
56 | ||
93724f13 AD |
57 | # b4_yyerror_args |
58 | # --------------- | |
59 | # Arguments passed to yyerror: user args plus yylloc. | |
60 | m4_define([b4_yyerror_args], | |
61 | [b4_pure_if([b4_location_if([yylocp, ])])dnl | |
62 | m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) | |
63 | ||
64 | ||
65 | # b4_lyyerror_args | |
66 | # ---------------- | |
67 | # Same as above, but on the lookahead, hence yyllocp instead of yylocp. | |
68 | m4_define([b4_lyyerror_args], | |
69 | [b4_pure_if([b4_location_if([yyllocp, ])])dnl | |
70 | m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) | |
71 | ||
72 | ||
2a8d363a AD |
73 | # b4_pure_args |
74 | # ------------ | |
93724f13 | 75 | # Arguments needed by yyerror: user args plus yylloc. |
2a8d363a AD |
76 | m4_define([b4_pure_args], |
77 | [b4_pure_if([b4_location_if([, yylocp])])[]b4_user_args]) | |
78 | ||
79 | ||
80 | # b4_pure_formals | |
81 | # --------------- | |
82 | # Arguments passed to yyerror: user formals plus yyllocp. | |
83 | m4_define([b4_pure_formals], | |
84 | [b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals]) | |
85 | ||
86 | ||
87 | # b4_lpure_args | |
88 | # ------------- | |
89 | # Same as above, but on the lookahead, hence yyllocp instead of yylocp. | |
90 | m4_define([b4_lpure_args], | |
91 | [b4_pure_if([b4_location_if([, yyllocp])])[]b4_user_args]) | |
0245f82d | 92 | |
66d30cd4 | 93 | |
2a8d363a AD |
94 | # b4_lpure_formals |
95 | # ---------------- | |
96 | # Same as above, but on the lookahead, hence yyllocp instead of yylocp. | |
97 | m4_define([b4_lpure_formals], | |
98 | [b4_pure_if([b4_location_if([YYLTYPE *yyllocp])])[]b4_user_formals]) | |
99 | ||
66d30cd4 AD |
100 | |
101 | ## ----------------- ## | |
102 | ## Semantic Values. ## | |
103 | ## ----------------- ## | |
104 | ||
105 | ||
01241d47 PH |
106 | # b4_lhs_value([TYPE]) |
107 | # -------------------- | |
108 | # Expansion of $<TYPE>$. | |
109 | m4_define([b4_lhs_value], | |
110 | [(*yyvalp)[]m4_ifval([$1], [.$1])]) | |
111 | ||
112 | ||
113 | # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) | |
114 | # -------------------------------------- | |
115 | # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH | |
116 | # symbols on RHS. | |
117 | m4_define([b4_rhs_value], | |
947427ae | 118 | [yyvsp@{m4_eval([$2 - $1])@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3])]) |
01241d47 PH |
119 | |
120 | ||
121 | ||
122 | ## ----------- ## | |
123 | ## Locations. ## | |
124 | ## ----------- ## | |
125 | ||
01241d47 PH |
126 | # b4_lhs_location() |
127 | # ----------------- | |
128 | # Expansion of @$. | |
129 | m4_define([b4_lhs_location], | |
130 | [(*yylocp)]) | |
131 | ||
132 | ||
133 | # b4_rhs_location(RULE-LENGTH, NUM) | |
134 | # --------------------------------- | |
135 | # Expansion of @NUM, where the current rule has RULE-LENGTH symbols | |
136 | # on RHS. | |
137 | m4_define([b4_rhs_location], | |
947427ae | 138 | [yyvsp@{m4_eval([$2 - $1])@}.yystate.yyloc]) |
01241d47 PH |
139 | |
140 | ||
b526ee61 AD |
141 | # We do want M4 expansion after # for CPP macros. |
142 | m4_changecom() | |
01241d47 | 143 | m4_divert(0)dnl |
947427ae | 144 | @output @output_parser_name@ |
fb8135fa AD |
145 | b4_copyright([Skeleton parser for GLR parsing with Bison], [2002]) |
146 | [ | |
01241d47 PH |
147 | /* This is the parser code for GLR (Generalized LR) parser. */ |
148 | ||
cf126971 | 149 | #include <assert.h> |
cf126971 PE |
150 | #include <stdio.h> |
151 | #include <stdlib.h> | |
152 | #include <string.h> | |
2a8d363a AD |
153 | #include <stdarg.h> |
154 | #include <setjmp.h> | |
01241d47 | 155 | |
2a8d363a AD |
156 | ]b4_identification |
157 | m4_if(b4_prefix[], [yy], [], | |
01241d47 PH |
158 | [/* If NAME_PREFIX is specified substitute the variables and functions |
159 | names. */ | |
160 | #define yyparse b4_prefix[]parse | |
161 | #define yylex b4_prefix[]lex | |
162 | #define yyerror b4_prefix[]error | |
163 | #define yylval b4_prefix[]lval | |
164 | #define yychar b4_prefix[]char | |
165 | #define yydebug b4_prefix[]debug | |
166 | #define yynerrs b4_prefix[]nerrs | |
167 | b4_location_if([#define yylloc b4_prefix[]lloc])]) | |
168 | ||
17acead5 | 169 | b4_token_defines(b4_tokens) |
01241d47 | 170 | |
17acead5 PE |
171 | /* Copy the first part of user declarations. */ |
172 | b4_pre_prologue[ | |
01241d47 PH |
173 | |
174 | /* Enabling traces. */ | |
175 | #ifndef YYDEBUG | |
176 | # define YYDEBUG ]b4_debug[ | |
177 | #endif | |
178 | ||
179 | /* Enabling verbose error messages. */ | |
180 | #ifdef YYERROR_VERBOSE | |
181 | # undef YYERROR_VERBOSE | |
182 | # define YYERROR_VERBOSE 1 | |
183 | #else | |
184 | # define YYERROR_VERBOSE ]b4_error_verbose[ | |
185 | #endif | |
186 | ||
187 | #ifndef YYSTYPE | |
188 | ]m4_ifdef([b4_stype], | |
437c2d80 | 189 | [b4_syncline([b4_stype_line], [b4_filename]) |
01241d47 PH |
190 | typedef union b4_stype yystype; |
191 | /* Line __line__ of __file__. */ | |
947427ae | 192 | b4_syncline([@oline@], [@ofile@])], |
01241d47 PH |
193 | [typedef int yystype;])[ |
194 | # define YYSTYPE yystype | |
195 | # define YYSTYPE_IS_TRIVIAL 1 | |
196 | #endif | |
197 | ||
198 | #ifndef YYLTYPE | |
199 | typedef struct yyltype | |
200 | { | |
f50adbbd AD |
201 | int first_line; |
202 | int first_column; | |
203 | int last_line; | |
ffa4c58a | 204 | int last_column; |
01241d47 | 205 | } yyltype; |
66d30cd4 | 206 | # define YYLTYPE ]b4_location_type[ |
01241d47 PH |
207 | # define YYLTYPE_IS_TRIVIAL 1 |
208 | #endif | |
209 | ||
210 | /* Default (constant) values used for initialization for null | |
fb8135fa | 211 | right-hand sides. Unlike the standard bison.simple template, |
947427ae | 212 | here we set the default values of $$ and $@@ to zeroed-out |
01241d47 PH |
213 | values. Since the default value of these quantities is undefined, |
214 | this behavior is technically correct. */ | |
215 | static YYSTYPE yyval_default; | |
216 | static YYLTYPE yyloc_default; | |
217 | ||
218 | /* Copy the second part of user declarations. */ | |
219 | ]b4_post_prologue[ | |
220 | ||
221 | ]/* Line __line__ of __file__. */ | |
947427ae | 222 | b4_syncline([@oline@], [@ofile@]) |
01241d47 PH |
223 | [ |
224 | #if ! defined (__cplusplus) | |
225 | typedef char bool; | |
226 | # define yytrue 1 | |
227 | # define yyfalse 0 | |
228 | #endif | |
229 | ||
1154cced AD |
230 | /*-----------------. |
231 | | GCC extensions. | | |
232 | `-----------------*/ | |
233 | ||
234 | #ifndef __attribute__ | |
235 | /* This feature is available in gcc versions 2.5 and later. */ | |
236 | # if !defined (__GNUC__) || __GNUC__ < 2 || \ | |
237 | (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__ | |
238 | # define __attribute__(Spec) /* empty */ | |
239 | # endif | |
240 | #endif | |
241 | ||
242 | #ifndef ATTRIBUTE_UNUSED | |
243 | # define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) | |
244 | #endif | |
245 | ||
01241d47 | 246 | /* YYFINAL -- State number of the termination state. */ |
7db2ed2d | 247 | #define YYFINAL ]b4_final_state_number[ |
39912f52 | 248 | /* YYLAST -- Last index in YYTABLE. */ |
01241d47 PH |
249 | #define YYLAST ]b4_last[ |
250 | ||
251 | /* YYNTOKENS -- Number of terminals. */ | |
7db2ed2d | 252 | #define YYNTOKENS ]b4_tokens_number[ |
01241d47 | 253 | /* YYNNTS -- Number of nonterminals. */ |
7db2ed2d | 254 | #define YYNNTS ]b4_nterms_number[ |
01241d47 | 255 | /* YYNRULES -- Number of rules. */ |
7db2ed2d | 256 | #define YYNRULES ]b4_rules_number[ |
01241d47 | 257 | /* YYNRULES -- Number of states. */ |
7db2ed2d | 258 | #define YYNSTATES ]b4_states_number[ |
01241d47 PH |
259 | /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ |
260 | #define YYMAXRHS ]b4_r2_max[ | |
261 | ||
262 | /* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */ | |
263 | #define YYUNDEFTOK ]b4_undef_token_number[ | |
264 | #define YYMAXUTOK ]b4_user_token_number_max[ | |
265 | ||
b0400cc6 AD |
266 | #define YYTRANSLATE(YYX) \ |
267 | ((YYX <= 0) ? YYEOF : \ | |
268 | (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | |
01241d47 PH |
269 | |
270 | /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ | |
a762e609 | 271 | static const ]b4_int_type_for([b4_translate])[ yytranslate[] = |
01241d47 PH |
272 | { |
273 | ]b4_translate[ | |
274 | }; | |
275 | ||
276 | #if YYDEBUG | |
277 | /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in | |
278 | YYRHS. */ | |
a762e609 | 279 | static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = |
01241d47 PH |
280 | { |
281 | ]b4_prhs[ | |
282 | }; | |
283 | ||
284 | /* YYRHS -- A `-1'-separated list of the rules' RHS. */ | |
a762e609 | 285 | static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = |
01241d47 PH |
286 | { |
287 | ]b4_rhs[ | |
288 | }; | |
289 | ||
290 | /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ | |
a762e609 | 291 | static const ]b4_int_type_for([b4_rline])[ yyrline[] = |
01241d47 PH |
292 | { |
293 | ]b4_rline[ | |
294 | }; | |
295 | #endif | |
296 | ||
297 | #if (YYDEBUG) || YYERROR_VERBOSE | |
298 | /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. | |
299 | First, the terminals, then, starting at YYNTOKENS, nonterminals. */ | |
300 | static const char *const yytname[] = | |
301 | { | |
302 | ]b4_tname[ | |
303 | }; | |
304 | ||
1154cced | 305 | #define yytname_size ((int) (sizeof (yytname) / sizeof (yytname[0]))) |
01241d47 PH |
306 | #endif |
307 | ||
308 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ | |
a762e609 | 309 | static const ]b4_int_type_for([b4_r1])[ yyr1[] = |
01241d47 PH |
310 | { |
311 | ]b4_r1[ | |
312 | }; | |
313 | ||
314 | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ | |
a762e609 | 315 | static const ]b4_int_type_for([b4_r2])[ yyr2[] = |
01241d47 PH |
316 | { |
317 | ]b4_r2[ | |
318 | }; | |
319 | ||
320 | /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ | |
a762e609 | 321 | static const ]b4_int_type_for([b4_dprec])[ yydprec[] = |
01241d47 PH |
322 | { |
323 | ]b4_dprec[ | |
324 | }; | |
325 | ||
326 | /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ | |
a762e609 | 327 | static const ]b4_int_type_for([b4_merger])[ yymerger[] = |
01241d47 PH |
328 | { |
329 | ]b4_merger[ | |
330 | }; | |
331 | ||
332 | /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE | |
333 | doesn't specify something else to do. Zero means the default is an | |
334 | error. */ | |
a762e609 | 335 | static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
01241d47 PH |
336 | { |
337 | ]b4_defact[ | |
338 | }; | |
339 | ||
12b0043a | 340 | /* YYPDEFGOTO[NTERM-NUM]. */ |
a762e609 | 341 | static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = |
01241d47 PH |
342 | { |
343 | ]b4_defgoto[ | |
344 | }; | |
345 | ||
346 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing | |
347 | STATE-NUM. */ | |
12b0043a | 348 | #define YYPACT_NINF ]b4_pact_ninf[ |
a762e609 | 349 | static const ]b4_int_type_for([b4_pact])[ yypact[] = |
01241d47 PH |
350 | { |
351 | ]b4_pact[ | |
352 | }; | |
353 | ||
354 | /* YYPGOTO[NTERM-NUM]. */ | |
a762e609 | 355 | static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = |
01241d47 PH |
356 | { |
357 | ]b4_pgoto[ | |
358 | }; | |
359 | ||
360 | /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If | |
361 | positive, shift that token. If negative, reduce the rule which | |
f50adbbd | 362 | number is the opposite. If zero, do what YYDEFACT says. |
6e649e65 | 363 | If YYTABLE_NINF, syntax error. */ |
12b0043a | 364 | #define YYTABLE_NINF ]b4_table_ninf[ |
a762e609 | 365 | static const ]b4_int_type_for([b4_table])[ yytable[] = |
01241d47 PH |
366 | { |
367 | ]b4_table[ | |
368 | }; | |
369 | ||
ea99527d AD |
370 | /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of |
371 | list of conflicting reductions corresponding to action entry for | |
372 | state STATE-NUM in yytable. 0 means no conflicts. The list in | |
373 | yyconfl is terminated by a rule number of 0. */ | |
a762e609 | 374 | static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = |
01241d47 PH |
375 | { |
376 | ]b4_conflict_list_heads[ | |
377 | }; | |
378 | ||
ea99527d AD |
379 | /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by |
380 | 0, pointed into by YYCONFLP. */ | |
a762e609 AD |
381 | ]dnl Do not use b4_int_type_for here, since there are places where |
382 | dnl pointers onto yyconfl are taken, which type is "short *". | |
383 | dnl We probably ought to introduce a type for confl. | |
384 | [static const short yyconfl[] = | |
01241d47 PH |
385 | { |
386 | ]b4_conflicting_rules[ | |
387 | }; | |
388 | ||
a762e609 | 389 | static const ]b4_int_type_for([b4_check])[ yycheck[] = |
01241d47 PH |
390 | { |
391 | ]b4_check[ | |
392 | }; | |
393 | ||
7bd6c77e AD |
394 | /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
395 | symbol of state STATE-NUM. */ | |
396 | static const ]b4_int_type_for([b4_stos])[ yystos[] = | |
397 | { | |
398 | ]b4_stos[ | |
399 | }; | |
400 | ||
01241d47 | 401 | \f |
0245f82d | 402 | /* Prevent warning if -Wmissing-prototypes. */ |
2a8d363a | 403 | ]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[ |
e7cb57c0 | 404 | |
2a8d363a | 405 | /* Error token number */ |
01241d47 PH |
406 | #define YYTERROR 1 |
407 | ||
408 | /* YYLLOC_DEFAULT -- Compute the default location (before the actions | |
409 | are run). */ | |
410 | ||
411 | #define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc) | |
412 | ||
413 | #ifndef YYLLOC_DEFAULT | |
12b0043a | 414 | # define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) \ |
f50adbbd AD |
415 | yyCurrent.first_line = YYRHSLOC(yyRhs,1).first_line; \ |
416 | yyCurrent.first_column = YYRHSLOC(yyRhs,1).first_column; \ | |
417 | yyCurrent.last_line = YYRHSLOC(yyRhs,YYN).last_line; \ | |
418 | yyCurrent.last_column = YYRHSLOC(yyRhs,YYN).last_column; | |
01241d47 PH |
419 | #endif |
420 | ||
421 | /* YYLEX -- calling `yylex' with the right arguments. */ | |
21964f43 | 422 | #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ |
01241d47 PH |
423 | |
424 | ]b4_pure_if( | |
425 | [ | |
01241d47 PH |
426 | #undef yynerrs |
427 | #define yynerrs (yystack->yyerrcnt) | |
428 | #undef yychar | |
429 | #define yychar (yystack->yyrawchar)], | |
430 | [YYSTYPE yylval; | |
431 | ||
432 | YYLTYPE yylloc; | |
433 | ||
434 | int yynerrs; | |
435 | int yychar;])[ | |
436 | ||
437 | static const int YYEOF = 0; | |
438 | static const int YYEMPTY = -2; | |
439 | ||
440 | typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; | |
441 | ||
442 | #define YYCHK(YYE) \ | |
443 | do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \ | |
444 | while (0) | |
445 | ||
446 | #if YYDEBUG | |
447 | ||
448 | #if ! defined (YYFPRINTF) | |
449 | # define YYFPRINTF fprintf | |
450 | #endif | |
451 | ||
452 | # define YYDPRINTF(Args) \ | |
453 | do { \ | |
454 | if (yydebug) \ | |
455 | YYFPRINTF Args; \ | |
456 | } while (0) | |
7bd6c77e AD |
457 | |
458 | ]b4_yysymprint_generate([b4_c_ansi_function_def])[ | |
459 | ||
460 | # define YYDSYMPRINT(Args) \ | |
461 | do { \ | |
462 | if (yydebug) \ | |
463 | yysymprint Args; \ | |
464 | } while (0) | |
465 | ||
9c1e26bd AD |
466 | # define YYDSYMPRINTF(Title, Token, Value, Location) \ |
467 | do { \ | |
468 | if (yydebug) \ | |
469 | { \ | |
470 | YYFPRINTF (stderr, "%s ", Title); \ | |
471 | yysymprint (stderr, \ | |
472 | Token, Value]b4_location_if([, Location])[); \ | |
473 | YYFPRINTF (stderr, "\n"); \ | |
474 | } \ | |
475 | } while (0) | |
476 | ||
01241d47 PH |
477 | /* Nonzero means print parse trace. It is left uninitialized so that |
478 | multiple parsers can coexist. */ | |
479 | int yydebug; | |
7bd6c77e | 480 | |
01241d47 | 481 | #else /* !YYDEBUG */ |
7bd6c77e | 482 | |
1154cced | 483 | /* Avoid empty `if' bodies. */ |
7bd6c77e AD |
484 | # define YYDPRINTF(Args) {} |
485 | # define YYDSYMPRINT(Args) {} | |
9c1e26bd | 486 | # define YYDSYMPRINTF(Title, Token, Value, Location) {} |
7bd6c77e | 487 | |
01241d47 PH |
488 | #endif /* !YYDEBUG */ |
489 | ||
490 | /* YYINITDEPTH -- initial size of the parser's stacks. */ | |
491 | #ifndef YYINITDEPTH | |
66d30cd4 | 492 | # define YYINITDEPTH ]b4_stack_depth_init[ |
01241d47 PH |
493 | #endif |
494 | ||
495 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only | |
496 | if the built-in stack extension method is used). | |
497 | ||
498 | Do not make this value too large; the results are undefined if | |
fb8135fa | 499 | SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) |
01241d47 PH |
500 | evaluated with infinite-precision integer arithmetic. */ |
501 | ||
502 | #if YYMAXDEPTH == 0 | |
503 | # undef YYMAXDEPTH | |
504 | #endif | |
505 | ||
506 | #ifndef YYMAXDEPTH | |
66d30cd4 | 507 | # define YYMAXDEPTH ]b4_stack_depth_max[ |
01241d47 PH |
508 | #endif |
509 | ||
510 | /* Minimum number of free items on the stack allowed after an | |
fb8135fa AD |
511 | allocation. This is to allow allocation and initialization |
512 | to be completed by functions that call expandGLRStack before the | |
513 | stack is expanded, thus insuring that all necessary pointers get | |
01241d47 PH |
514 | properly redirected to new data. */ |
515 | #define YYHEADROOM 2 | |
516 | ||
517 | #if ! defined (YYSTACKEXPANDABLE) \ | |
518 | && (! defined (__cplusplus) || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)) | |
519 | #define YYSTACKEXPANDABLE 1 | |
520 | #else | |
521 | #define YYSTACKEXPANDABLE 0 | |
522 | #endif | |
523 | ||
524 | /** State numbers, as in LALR(1) machine */ | |
525 | typedef int yyStateNum; | |
526 | ||
527 | /** Rule numbers, as in LALR(1) machine */ | |
528 | typedef int yyRuleNum; | |
529 | ||
530 | /** Grammar symbol */ | |
531 | typedef short yySymbol; | |
532 | ||
533 | /** Item references, as in LALR(1) machine */ | |
534 | typedef short yyItemNum; | |
535 | ||
536 | typedef struct yyGLRState yyGLRState; | |
537 | typedef struct yySemanticOption yySemanticOption; | |
538 | typedef union yyGLRStackItem yyGLRStackItem; | |
539 | typedef struct yyGLRStack yyGLRStack; | |
540 | typedef struct yyGLRStateSet yyGLRStateSet; | |
541 | ||
542 | struct yyGLRState { | |
fb8135fa | 543 | bool yyisState; |
01241d47 PH |
544 | bool yyresolved; |
545 | yyStateNum yylrState; | |
546 | yyGLRState* yypred; | |
547 | size_t yyposn; | |
548 | union { | |
549 | yySemanticOption* yyfirstVal; | |
550 | YYSTYPE yysval; | |
551 | } yysemantics; | |
552 | YYLTYPE yyloc; | |
553 | }; | |
554 | ||
555 | struct yyGLRStateSet { | |
556 | yyGLRState** yystates; | |
557 | size_t yysize, yycapacity; | |
558 | }; | |
559 | ||
560 | struct yySemanticOption { | |
561 | bool yyisState; | |
562 | yyRuleNum yyrule; | |
563 | yyGLRState* yystate; | |
564 | yySemanticOption* yynext; | |
565 | }; | |
566 | ||
567 | union yyGLRStackItem { | |
568 | yyGLRState yystate; | |
569 | yySemanticOption yyoption; | |
570 | }; | |
571 | ||
572 | struct yyGLRStack { | |
573 | int yyerrflag; | |
574 | int yyerrState; | |
575 | ]b4_pure_if( | |
576 | [ | |
577 | int yyerrcnt; | |
578 | int yyrawchar; | |
579 | ])[ | |
580 | yySymbol* yytokenp; | |
581 | jmp_buf yyexception_buffer; | |
582 | yyGLRStackItem* yyitems; | |
583 | yyGLRStackItem* yynextFree; | |
584 | int yyspaceLeft; | |
585 | yyGLRState* yysplitPoint; | |
586 | yyGLRState* yylastDeleted; | |
587 | yyGLRStateSet yytops; | |
588 | }; | |
589 | ||
590 | static void yyinitGLRStack (yyGLRStack* yystack, size_t yysize); | |
2a8d363a | 591 | static void yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[); |
01241d47 PH |
592 | static void yyfreeGLRStack (yyGLRStack* yystack); |
593 | ||
594 | static void | |
2a8d363a | 595 | yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yyformat, ...) |
01241d47 | 596 | { |
970785f1 | 597 | yystack->yyerrflag = 1; |
01241d47 PH |
598 | if (yyformat != NULL) |
599 | { | |
600 | char yymsg[256]; | |
601 | va_list yyap; | |
602 | va_start (yyap, yyformat); | |
01241d47 | 603 | vsprintf (yymsg, yyformat, yyap); |
93724f13 | 604 | yyerror (]b4_yyerror_args[yymsg); |
01241d47 PH |
605 | } |
606 | longjmp (yystack->yyexception_buffer, 1); | |
607 | } | |
608 | ||
609 | #if YYDEBUG || YYERROR_VERBOSE | |
610 | /** A printable representation of TOKEN. Valid until next call to | |
611 | * tokenName. */ | |
fb8135fa AD |
612 | static inline const char* |
613 | yytokenName (yySymbol yytoken) | |
01241d47 PH |
614 | { |
615 | return yytname[yytoken]; | |
616 | } | |
617 | #endif | |
618 | ||
619 | /** Perform user action for rule number YYN, with RHS length YYRHSLEN, | |
620 | * and top stack item YYVSP. YYLVALP points to place to put semantic | |
621 | * value ($$), and yylocp points to place for location information | |
947427ae | 622 | * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, |
01241d47 PH |
623 | * yyerr for YYERROR, yyabort for YYABORT. */ |
624 | static YYRESULTTAG | |
fb8135fa | 625 | yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, |
e7cb57c0 | 626 | YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack |
2a8d363a | 627 | ]b4_user_formals[) |
01241d47 | 628 | { |
1154cced AD |
629 | /* Avoid `unused' warnings in there are no $n. */ |
630 | (void) yystack; | |
631 | ||
fb8135fa | 632 | if (yyrhslen == 0) |
01241d47 PH |
633 | { |
634 | *yyvalp = yyval_default; | |
635 | *yylocp = yyloc_default; | |
636 | } | |
fb8135fa | 637 | else |
01241d47 PH |
638 | { |
639 | *yyvalp = yyvsp[1-yyrhslen].yystate.yysemantics.yysval; | |
640 | *yylocp = yyvsp[1-yyrhslen].yystate.yyloc; | |
641 | } | |
01241d47 PH |
642 | # undef yyerrok |
643 | # define yyerrok (yystack->yyerrState = 0) | |
644 | # undef YYACCEPT | |
645 | # define YYACCEPT return yyaccept | |
646 | # undef YYABORT | |
647 | # define YYABORT return yyabort | |
648 | # undef YYERROR | |
649 | # define YYERROR return yyerr | |
650 | # undef YYRECOVERING | |
651 | # define YYRECOVERING (yystack->yyerrState != 0) | |
652 | # undef yyclearin | |
653 | # define yyclearin (yychar = *(yystack->yytokenp) = YYEMPTY) | |
654 | # undef YYBACKUP | |
655 | # define YYBACKUP(Token, Value) \ | |
656 | do { \ | |
93724f13 | 657 | yyerror (]b4_yyerror_args["syntax error: cannot back up"); \ |
01241d47 PH |
658 | YYERROR; \ |
659 | } while (0) | |
660 | ||
661 | ] | |
fb8135fa | 662 | switch (yyn) |
01241d47 PH |
663 | { |
664 | b4_actions | |
665 | } | |
666 | ||
667 | return yyok; | |
01241d47 PH |
668 | # undef yyerrok |
669 | # undef YYABORT | |
670 | # undef YYACCEPT | |
671 | # undef YYERROR | |
672 | # undef YYBACKUP | |
673 | # undef yyclearin | |
674 | # undef YYRECOVERING | |
675 | /* Line __line__ of __file__. */ | |
947427ae | 676 | b4_syncline([@oline@], [@ofile@]) |
01241d47 PH |
677 | } |
678 | \f | |
679 | ||
680 | static YYSTYPE | |
681 | yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) | |
682 | { | |
683 | YYSTYPE yyval = *yy0; | |
2a8d363a | 684 | /* `Use' the arguments. */ |
1154cced AD |
685 | (void) yy0; |
686 | (void) yy1; | |
687 | ||
fb8135fa | 688 | switch (yyn) |
01241d47 PH |
689 | { |
690 | b4_mergers | |
691 | } | |
692 | return yyval; | |
693 | } | |
694 | [ | |
2a8d363a | 695 | /* Bison grammar-table manipulation. */ |
01241d47 | 696 | |
7bd6c77e AD |
697 | ]b4_yydestruct_generate([b4_c_ansi_function_def])[ |
698 | ||
01241d47 PH |
699 | /** Number of symbols composing the right hand side of rule #RULE. */ |
700 | static inline int | |
fb8135fa | 701 | yyrhsLength (yyRuleNum yyrule) |
01241d47 PH |
702 | { |
703 | return yyr2[yyrule]; | |
704 | } | |
705 | ||
706 | /** Left-hand-side symbol for rule #RULE. */ | |
707 | static inline yySymbol | |
fb8135fa | 708 | yylhsNonterm (yyRuleNum yyrule) |
01241d47 PH |
709 | { |
710 | return yyr1[yyrule]; | |
711 | } | |
712 | ||
944ed9f4 PE |
713 | #define yyis_pact_ninf(yystate) \ |
714 | ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), 1, | |
715 | 0, | |
716 | ((yystate) == YYPACT_NINF))[ | |
717 | ||
01241d47 PH |
718 | /** True iff LR state STATE has only a default reduction (regardless |
719 | * of token). */ | |
720 | static inline bool | |
721 | yyisDefaultedState (yyStateNum yystate) | |
722 | { | |
944ed9f4 | 723 | return yyis_pact_ninf (yypact[yystate]); |
01241d47 | 724 | } |
fb8135fa | 725 | |
01241d47 PH |
726 | /** The default reduction for STATE, assuming it has one. */ |
727 | static inline yyRuleNum | |
728 | yydefaultAction (yyStateNum yystate) | |
729 | { | |
730 | return yydefact[yystate]; | |
731 | } | |
732 | ||
944ed9f4 PE |
733 | #define yyis_table_ninf(yyindex) \ |
734 | ]m4_if(m4_eval(b4_table_ninf < b4_table_min), 1, | |
735 | 0, | |
736 | ((yyindex) == YYTABLE_NINF))[ | |
737 | ||
2a1fe6ed | 738 | /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. |
01241d47 PH |
739 | * Result R means |
740 | * R < 0: Reduce on rule -R. | |
741 | * R = 0: Error. | |
fb8135fa AD |
742 | * R > 0: Shift to state R. |
743 | * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of | |
01241d47 PH |
744 | * conflicting reductions. |
745 | */ | |
746 | static inline void | |
fb8135fa | 747 | yygetLRActions (yyStateNum yystate, int yytoken, |
01241d47 PH |
748 | int* yyaction, const short** yyconflicts) |
749 | { | |
750 | int yyindex = yypact[yystate] + yytoken; | |
f50adbbd | 751 | if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) |
01241d47 PH |
752 | { |
753 | *yyaction = -yydefact[yystate]; | |
754 | *yyconflicts = yyconfl; | |
755 | } | |
944ed9f4 | 756 | else if (! yyis_table_ninf (yyindex)) |
01241d47 PH |
757 | { |
758 | *yyaction = yytable[yyindex]; | |
759 | *yyconflicts = yyconfl + yyconflp[yyindex]; | |
760 | } | |
f50adbbd AD |
761 | else |
762 | { | |
763 | *yyaction = 0; | |
764 | *yyconflicts = yyconfl + yyconflp[yyindex]; | |
765 | } | |
01241d47 PH |
766 | } |
767 | ||
768 | static inline yyStateNum | |
769 | yyLRgotoState (yyStateNum yystate, yySymbol yylhs) | |
770 | { | |
771 | int yyr; | |
772 | yyr = yypgoto[yylhs - YYNTOKENS] + yystate; | |
f50adbbd | 773 | if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) |
01241d47 PH |
774 | return yytable[yyr]; |
775 | else | |
776 | return yydefgoto[yylhs - YYNTOKENS]; | |
777 | } | |
778 | ||
779 | static inline bool | |
fb8135fa | 780 | yyisShiftAction (int yyaction) |
01241d47 | 781 | { |
39912f52 | 782 | return 0 < yyaction; |
01241d47 PH |
783 | } |
784 | ||
785 | static inline bool | |
fb8135fa | 786 | yyisErrorAction (int yyaction) |
01241d47 | 787 | { |
f50adbbd | 788 | return yyaction == 0; |
01241d47 PH |
789 | } |
790 | ||
791 | /* GLRStates */ | |
792 | ||
793 | /** True iff the semantic value of the edge leading to STATE is | |
794 | * resolved. */ | |
795 | static inline bool | |
fb8135fa | 796 | yyhasResolvedValue (yyGLRState* yystate) |
01241d47 PH |
797 | { |
798 | return yystate->yyresolved; | |
799 | } | |
800 | ||
1154cced AD |
801 | static void |
802 | yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate, | |
2a8d363a | 803 | yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[) |
01241d47 PH |
804 | { |
805 | yySemanticOption* yynewItem; | |
806 | yynewItem = &yystack->yynextFree->yyoption; | |
807 | yystack->yyspaceLeft -= 1; | |
808 | yystack->yynextFree += 1; | |
809 | yynewItem->yyisState = yyfalse; | |
6fed0802 | 810 | yynewItem->yystate = rhs; |
fb8135fa | 811 | yynewItem->yyrule = yyrule; |
01241d47 PH |
812 | yynewItem->yynext = yystate->yysemantics.yyfirstVal; |
813 | yystate->yysemantics.yyfirstVal = yynewItem; | |
814 | if (yystack->yyspaceLeft < YYHEADROOM) | |
2a8d363a | 815 | yyexpandGLRStack (yystack]b4_pure_args[); |
01241d47 PH |
816 | } |
817 | ||
818 | /* GLRStacks */ | |
819 | ||
820 | /** Initialize SET to a singleton set containing an empty stack. */ | |
821 | static void | |
822 | yyinitStateSet (yyGLRStateSet* yyset) | |
823 | { | |
824 | yyset->yysize = 1; | |
825 | yyset->yycapacity = 16; | |
826 | yyset->yystates = (yyGLRState**) malloc (16 * sizeof (yyset->yystates[0])); | |
827 | yyset->yystates[0] = NULL; | |
828 | } | |
829 | ||
fb8135fa | 830 | static void yyfreeStateSet (yyGLRStateSet* yyset) |
01241d47 PH |
831 | { |
832 | free (yyset->yystates); | |
833 | } | |
834 | ||
835 | /** Initialize STACK to a single empty stack, with total maximum | |
836 | * capacity for all stacks of SIZE. */ | |
837 | static void | |
838 | yyinitGLRStack (yyGLRStack* yystack, size_t yysize) | |
839 | { | |
840 | yystack->yyerrflag = 0; | |
841 | yystack->yyerrState = 0; | |
842 | yynerrs = 0; | |
843 | yystack->yyspaceLeft = yysize; | |
fb8135fa | 844 | yystack->yynextFree = yystack->yyitems = |
01241d47 PH |
845 | (yyGLRStackItem*) malloc (yysize * sizeof (yystack->yynextFree[0])); |
846 | yystack->yysplitPoint = NULL; | |
847 | yystack->yylastDeleted = NULL; | |
848 | yyinitStateSet (&yystack->yytops); | |
849 | } | |
850 | ||
851 | #define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ | |
852 | &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE | |
853 | ||
854 | /** If STACK is expandable, extend it. WARNING: Pointers into the | |
855 | stack from outside should be considered invalid after this call. | |
856 | We always expand when there are 1 or fewer items left AFTER an | |
857 | allocation, so that we can avoid having external pointers exist | |
858 | across an allocation. */ | |
859 | static void | |
2a8d363a | 860 | yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[) |
01241d47 PH |
861 | { |
862 | #if YYSTACKEXPANDABLE | |
863 | yyGLRStack yynewStack; | |
864 | yyGLRStackItem* yyp0, *yyp1; | |
865 | size_t yysize, yynewSize; | |
866 | size_t yyn; | |
867 | yysize = yystack->yynextFree - yystack->yyitems; | |
39912f52 | 868 | if (YYMAXDEPTH <= yysize) |
6e649e65 | 869 | yyFail (yystack][]b4_pure_args[, "parser stack overflow"); |
01241d47 | 870 | yynewSize = 2*yysize; |
39912f52 | 871 | if (YYMAXDEPTH < yynewSize) |
01241d47 PH |
872 | yynewSize = YYMAXDEPTH; |
873 | yyinitGLRStack (&yynewStack, yynewSize); | |
fb8135fa | 874 | for (yyp0 = yystack->yyitems, yyp1 = yynewStack.yyitems, yyn = yysize; |
39912f52 | 875 | 0 < yyn; |
fb8135fa | 876 | yyn -= 1, yyp0 += 1, yyp1 += 1) |
01241d47 PH |
877 | { |
878 | *yyp1 = *yyp0; | |
fb8135fa AD |
879 | if (*(bool*) yyp0) |
880 | { | |
01241d47 PH |
881 | yyGLRState* yys0 = &yyp0->yystate; |
882 | yyGLRState* yys1 = &yyp1->yystate; | |
fb8135fa AD |
883 | if (yys0->yypred != NULL) |
884 | yys1->yypred = | |
01241d47 PH |
885 | YYRELOC (yyp0, yyp1, yys0->yypred, yystate); |
886 | if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) | |
fb8135fa | 887 | yys1->yysemantics.yyfirstVal = |
01241d47 PH |
888 | YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); |
889 | } | |
fb8135fa | 890 | else |
01241d47 PH |
891 | { |
892 | yySemanticOption* yyv0 = &yyp0->yyoption; | |
893 | yySemanticOption* yyv1 = &yyp1->yyoption; | |
894 | if (yyv0->yystate != NULL) | |
895 | yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); | |
896 | if (yyv0->yynext != NULL) | |
897 | yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); | |
898 | } | |
899 | } | |
900 | if (yystack->yysplitPoint != NULL) | |
fb8135fa | 901 | yystack->yysplitPoint = YYRELOC (yystack->yyitems, yynewStack.yyitems, |
01241d47 | 902 | yystack->yysplitPoint, yystate); |
fb8135fa AD |
903 | |
904 | for (yyn = 0; yyn < yystack->yytops.yysize; yyn += 1) | |
01241d47 | 905 | if (yystack->yytops.yystates[yyn] != NULL) |
fb8135fa AD |
906 | yystack->yytops.yystates[yyn] = |
907 | YYRELOC (yystack->yyitems, yynewStack.yyitems, | |
01241d47 PH |
908 | yystack->yytops.yystates[yyn], yystate); |
909 | free (yystack->yyitems); | |
910 | yystack->yyitems = yynewStack.yyitems; | |
911 | yystack->yynextFree = yynewStack.yynextFree + yysize; | |
912 | yystack->yyspaceLeft = yynewStack.yyspaceLeft - yysize; | |
913 | ||
914 | #else | |
fb8135fa | 915 | |
6e649e65 | 916 | yyFail (yystack][]b4_lpure_args[, "parser stack overflow"); |
fb8135fa | 917 | #endif |
01241d47 PH |
918 | } |
919 | ||
920 | static void | |
fb8135fa | 921 | yyfreeGLRStack (yyGLRStack* yystack) |
01241d47 PH |
922 | { |
923 | free (yystack->yyitems); | |
924 | yyfreeStateSet (&yystack->yytops); | |
925 | } | |
926 | ||
927 | /** Assuming that S is a GLRState somewhere on STACK, update the | |
fb8135fa | 928 | * splitpoint of STACK, if needed, so that it is at least as deep as |
01241d47 PH |
929 | * S. */ |
930 | static inline void | |
fb8135fa | 931 | yyupdateSplit (yyGLRStack* yystack, yyGLRState* yys) |
01241d47 | 932 | { |
fb8135fa | 933 | if (yystack->yysplitPoint != NULL && yystack->yysplitPoint > yys) |
01241d47 PH |
934 | yystack->yysplitPoint = yys; |
935 | } | |
936 | ||
937 | /** Invalidate stack #K in STACK. */ | |
938 | static inline void | |
fb8135fa | 939 | yymarkStackDeleted (yyGLRStack* yystack, int yyk) |
01241d47 PH |
940 | { |
941 | if (yystack->yytops.yystates[yyk] != NULL) | |
942 | yystack->yylastDeleted = yystack->yytops.yystates[yyk]; | |
943 | yystack->yytops.yystates[yyk] = NULL; | |
944 | } | |
945 | ||
fb8135fa | 946 | /** Undelete the last stack that was marked as deleted. Can only be |
01241d47 PH |
947 | done once after a deletion, and only when all other stacks have |
948 | been deleted. */ | |
949 | static void | |
950 | yyundeleteLastStack (yyGLRStack* yystack) | |
951 | { | |
952 | if (yystack->yylastDeleted == NULL || yystack->yytops.yysize != 0) | |
953 | return; | |
fb8135fa | 954 | yystack->yytops.yystates[0] = yystack->yylastDeleted; |
01241d47 PH |
955 | yystack->yytops.yysize = 1; |
956 | YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); | |
957 | yystack->yylastDeleted = NULL; | |
958 | } | |
959 | ||
960 | static inline void | |
961 | yyremoveDeletes (yyGLRStack* yystack) | |
962 | { | |
1154cced | 963 | size_t yyi, yyj; |
01241d47 | 964 | yyi = yyj = 0; |
fb8135fa | 965 | while (yyj < yystack->yytops.yysize) |
01241d47 PH |
966 | { |
967 | if (yystack->yytops.yystates[yyi] == NULL) | |
968 | { | |
1154cced | 969 | if (yyi == yyj) |
01241d47 PH |
970 | YYDPRINTF ((stderr, "Removing dead stacks.\n")); |
971 | yystack->yytops.yysize -= 1; | |
972 | } | |
fb8135fa | 973 | else |
01241d47 PH |
974 | { |
975 | yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi]; | |
976 | if (yyj != yyi) | |
977 | YYDPRINTF ((stderr, "Rename stack %d -> %d.\n", yyi, yyj)); | |
978 | yyj += 1; | |
979 | } | |
980 | yyi += 1; | |
981 | } | |
982 | } | |
983 | ||
fb8135fa | 984 | /** Shift to a new state on stack #K of STACK, corresponding to LR state |
01241d47 PH |
985 | * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ |
986 | static inline void | |
fb8135fa | 987 | yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn, |
2a8d363a | 988 | YYSTYPE yysval, YYLTYPE* yylocp]b4_user_formals[) |
01241d47 PH |
989 | { |
990 | yyGLRStackItem* yynewItem; | |
991 | ||
992 | yynewItem = yystack->yynextFree; | |
993 | yystack->yynextFree += 1; | |
994 | yystack->yyspaceLeft -= 1; | |
995 | yynewItem->yystate.yyisState = yytrue; | |
996 | yynewItem->yystate.yylrState = yylrState; | |
997 | yynewItem->yystate.yyposn = yyposn; | |
998 | yynewItem->yystate.yyresolved = yytrue; | |
999 | yynewItem->yystate.yypred = yystack->yytops.yystates[yyk]; | |
1000 | yystack->yytops.yystates[yyk] = &yynewItem->yystate; | |
1001 | yynewItem->yystate.yysemantics.yysval = yysval; | |
1002 | yynewItem->yystate.yyloc = *yylocp; | |
1003 | if (yystack->yyspaceLeft < YYHEADROOM) | |
2a8d363a | 1004 | yyexpandGLRStack (yystack]b4_pure_args[); |
01241d47 PH |
1005 | } |
1006 | ||
1007 | /** Shift to a new state on stack #K of STACK, to a new state | |
1008 | * corresponding to LR state LRSTATE, at input position POSN, with | |
1009 | * the (unresolved) semantic value of RHS under the action for RULE. */ | |
1010 | static inline void | |
fb8135fa | 1011 | yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState, |
2a8d363a | 1012 | size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[) |
01241d47 PH |
1013 | { |
1014 | yyGLRStackItem* yynewItem; | |
1015 | ||
1016 | yynewItem = yystack->yynextFree; | |
1017 | yynewItem->yystate.yyisState = yytrue; | |
1018 | yynewItem->yystate.yylrState = yylrState; | |
1019 | yynewItem->yystate.yyposn = yyposn; | |
1020 | yynewItem->yystate.yyresolved = yyfalse; | |
1021 | yynewItem->yystate.yypred = yystack->yytops.yystates[yyk]; | |
1022 | yynewItem->yystate.yysemantics.yyfirstVal = NULL; | |
1023 | yystack->yytops.yystates[yyk] = &yynewItem->yystate; | |
1024 | yystack->yynextFree += 1; | |
1025 | yystack->yyspaceLeft -= 1; | |
2a8d363a | 1026 | yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule]b4_pure_args[); |
01241d47 PH |
1027 | } |
1028 | ||
1029 | /** Pop the symbols consumed by reduction #RULE from the top of stack | |
fb8135fa AD |
1030 | * #K of STACK, and perform the appropriate semantic action on their |
1031 | * semantic values. Assumes that all ambiguities in semantic values | |
01241d47 PH |
1032 | * have been previously resolved. Set *VALP to the resulting value, |
1033 | * and *LOCP to the computed location (if any). Return value is as | |
1034 | * for userAction. */ | |
ff032592 | 1035 | static inline YYRESULTTAG |
01241d47 | 1036 | yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, |
2a8d363a | 1037 | YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
01241d47 PH |
1038 | { |
1039 | int yynrhs = yyrhsLength (yyrule); | |
1040 | ||
fb8135fa | 1041 | if (yystack->yysplitPoint == NULL) |
01241d47 PH |
1042 | { |
1043 | /* Standard special case: single stack. */ | |
6fed0802 | 1044 | yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk]; |
01241d47 PH |
1045 | assert (yyk == 0); |
1046 | yystack->yynextFree -= yynrhs; | |
1047 | yystack->yyspaceLeft += yynrhs; | |
1048 | yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate; | |
fb8135fa | 1049 | if (yynrhs == 0) |
01241d47 PH |
1050 | { |
1051 | *yyvalp = yyval_default; | |
1052 | *yylocp = yyloc_default; | |
1053 | } | |
fb8135fa | 1054 | else |
01241d47 | 1055 | { |
6fed0802 AD |
1056 | *yyvalp = rhs[1-yynrhs].yystate.yysemantics.yysval; |
1057 | *yylocp = rhs[1-yynrhs].yystate.yyloc; | |
01241d47 | 1058 | } |
e7cb57c0 | 1059 | return yyuserAction (yyrule, yynrhs, rhs, |
2a8d363a | 1060 | yyvalp, yylocp, yystack]b4_user_args[); |
01241d47 | 1061 | } |
fb8135fa | 1062 | else |
01241d47 PH |
1063 | { |
1064 | int yyi; | |
1065 | yyGLRState* yys; | |
1066 | yyGLRStackItem yyrhsVals[YYMAXRHS]; | |
39912f52 | 1067 | for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; 0 <= yyi; |
fb8135fa | 1068 | yyi -= 1, yys = yys->yypred) |
01241d47 PH |
1069 | { |
1070 | assert (yys->yypred != NULL); | |
1071 | yyrhsVals[yyi].yystate.yyresolved = yytrue; | |
1072 | yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval; | |
1073 | yyrhsVals[yyi].yystate.yyloc = yys->yyloc; | |
1074 | } | |
1075 | yyupdateSplit (yystack, yys); | |
1076 | yystack->yytops.yystates[yyk] = yys; | |
fb8135fa | 1077 | if (yynrhs == 0) |
01241d47 PH |
1078 | { |
1079 | *yyvalp = yyval_default; | |
1080 | *yylocp = yyloc_default; | |
1081 | } | |
fb8135fa | 1082 | else |
01241d47 PH |
1083 | { |
1084 | *yyvalp = yyrhsVals[0].yystate.yysemantics.yysval; | |
1085 | *yylocp = yyrhsVals[0].yystate.yyloc; | |
1086 | } | |
fb8135fa | 1087 | return yyuserAction (yyrule, yynrhs, yyrhsVals + (yynrhs-1), |
2a8d363a | 1088 | yyvalp, yylocp, yystack]b4_user_args[); |
01241d47 PH |
1089 | } |
1090 | } | |
1091 | ||
e7cb57c0 AD |
1092 | #if !YYDEBUG |
1093 | # define YY_REDUCE_PRINT(K, Rule) | |
1094 | #else | |
1095 | # define YY_REDUCE_PRINT(K, Rule) \ | |
1096 | do { \ | |
1097 | if (yydebug) \ | |
1098 | yy_reduce_print (K, Rule); \ | |
1099 | } while (0) | |
1100 | ||
1101 | /*----------------------------------------------------------. | |
1102 | | Report that the RULE is going to be reduced on stack #K. | | |
1103 | `----------------------------------------------------------*/ | |
1104 | ||
1105 | static inline void | |
1106 | yy_reduce_print (size_t yyk, yyRuleNum yyrule) | |
1107 | { | |
1108 | int yyi; | |
b0937b22 AD |
1109 | YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %d), ", |
1110 | yyk, yyrule - 1, yyrline[yyrule]); | |
e7cb57c0 AD |
1111 | /* Print the symbols being reduced, and their result. */ |
1112 | for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) | |
1113 | YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi])); | |
9c1e26bd | 1114 | YYFPRINTF (stderr, "-> %s\n", yytokenName (yyr1[yyrule])); |
e7cb57c0 AD |
1115 | } |
1116 | #endif | |
1117 | ||
01241d47 PH |
1118 | /** Pop items off stack #K of STACK according to grammar rule RULE, |
1119 | * and push back on the resulting nonterminal symbol. Perform the | |
fb8135fa | 1120 | * semantic action associated with RULE and store its value with the |
01241d47 PH |
1121 | * newly pushed state, if FORCEEVAL or if STACK is currently |
1122 | * unambiguous. Otherwise, store the deferred semantic action with | |
1123 | * the new state. If the new state would have an identical input | |
1124 | * position, LR state, and predecessor to an existing state on the stack, | |
fb8135fa AD |
1125 | * it is identified with that existing state, eliminating stack #K from |
1126 | * the STACK. In this case, the (necessarily deferred) semantic value is | |
1127 | * added to the options for the existing state's semantic value. | |
01241d47 PH |
1128 | */ |
1129 | static inline YYRESULTTAG | |
1154cced | 1130 | yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, |
2a8d363a | 1131 | bool yyforceEval]b4_pure_formals[) |
01241d47 | 1132 | { |
1154cced | 1133 | size_t yyposn = yystack->yytops.yystates[yyk]->yyposn; |
01241d47 | 1134 | |
fb8135fa | 1135 | if (yyforceEval || yystack->yysplitPoint == NULL) |
01241d47 PH |
1136 | { |
1137 | YYSTYPE yysval; | |
1138 | YYLTYPE yyloc; | |
fb8135fa | 1139 | |
e7cb57c0 | 1140 | YY_REDUCE_PRINT (yyk, yyrule); |
2a8d363a | 1141 | YYCHK (yydoAction (yystack, yyk, yyrule, &yysval, &yyloc]b4_user_args[)); |
fb8135fa AD |
1142 | yyglrShift (yystack, yyk, |
1143 | yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState, | |
01241d47 | 1144 | yylhsNonterm (yyrule)), |
2a8d363a | 1145 | yyposn, yysval, &yyloc]b4_user_args[); |
01241d47 | 1146 | } |
fb8135fa | 1147 | else |
01241d47 | 1148 | { |
1154cced AD |
1149 | size_t yyi; |
1150 | int yyn; | |
01241d47 PH |
1151 | yyGLRState* yys, *yys0 = yystack->yytops.yystates[yyk]; |
1152 | yyStateNum yynewLRState; | |
1153 | ||
fb8135fa | 1154 | for (yys = yystack->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); |
39912f52 | 1155 | 0 < yyn; yyn -= 1) |
01241d47 PH |
1156 | { |
1157 | yys = yys->yypred; | |
1158 | assert (yys != NULL); | |
1159 | } | |
1160 | yyupdateSplit (yystack, yys); | |
1161 | yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); | |
fb8135fa | 1162 | YYDPRINTF ((stderr, |
01241d47 PH |
1163 | "Reduced stack %d by rule #%d; action deferred. " |
1164 | "Now in state %d.\n", | |
1165 | yyk, yyrule-1, yynewLRState)); | |
1166 | for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1) | |
fb8135fa | 1167 | if (yyi != yyk && yystack->yytops.yystates[yyi] != NULL) |
01241d47 PH |
1168 | { |
1169 | yyGLRState* yyp, *yysplit = yystack->yysplitPoint; | |
1170 | yyp = yystack->yytops.yystates[yyi]; | |
fb8135fa | 1171 | while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) |
01241d47 | 1172 | { |
fb8135fa | 1173 | if (yyp->yylrState == yynewLRState && yyp->yypred == yys) |
01241d47 | 1174 | { |
2a8d363a | 1175 | yyaddDeferredAction (yystack, yyp, yys0, yyrule]b4_pure_args[); |
01241d47 PH |
1176 | yymarkStackDeleted (yystack, yyk); |
1177 | YYDPRINTF ((stderr, "Merging stack %d into stack %d.\n", | |
1178 | yyk, yyi)); | |
ff032592 | 1179 | return yyok; |
01241d47 PH |
1180 | } |
1181 | yyp = yyp->yypred; | |
1182 | } | |
1183 | } | |
1184 | yystack->yytops.yystates[yyk] = yys; | |
2a8d363a | 1185 | yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule]b4_pure_args[); |
fb8135fa | 1186 | } |
ff032592 | 1187 | return yyok; |
01241d47 PH |
1188 | } |
1189 | ||
1190 | static int | |
1191 | yysplitStack (yyGLRStack* yystack, int yyk) | |
1192 | { | |
fb8135fa | 1193 | if (yystack->yysplitPoint == NULL) |
01241d47 PH |
1194 | { |
1195 | assert (yyk == 0); | |
1196 | yystack->yysplitPoint = yystack->yytops.yystates[yyk]; | |
1197 | } | |
fb8135fa | 1198 | if (yystack->yytops.yysize >= yystack->yytops.yycapacity) |
01241d47 PH |
1199 | { |
1200 | yystack->yytops.yycapacity *= 2; | |
fb8135fa AD |
1201 | yystack->yytops.yystates = |
1202 | (yyGLRState**) realloc (yystack->yytops.yystates, | |
1203 | yystack->yytops.yycapacity | |
01241d47 PH |
1204 | * sizeof (yyGLRState*)); |
1205 | } | |
fb8135fa | 1206 | yystack->yytops.yystates[yystack->yytops.yysize] |
01241d47 PH |
1207 | = yystack->yytops.yystates[yyk]; |
1208 | yystack->yytops.yysize += 1; | |
1209 | return yystack->yytops.yysize-1; | |
1210 | } | |
1211 | ||
1212 | /** True iff Y0 and Y1 represent identical options at the top level. | |
1213 | * That is, they represent the same rule applied to RHS symbols | |
1214 | * that produce the same terminal symbols. */ | |
1215 | static bool | |
1216 | yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) | |
1217 | { | |
fb8135fa | 1218 | if (yyy0->yyrule == yyy1->yyrule) |
01241d47 PH |
1219 | { |
1220 | yyGLRState *yys0, *yys1; | |
1221 | int yyn; | |
fb8135fa | 1222 | for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, |
01241d47 PH |
1223 | yyn = yyrhsLength (yyy0->yyrule); |
1224 | yyn > 0; | |
1225 | yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) | |
1226 | if (yys0->yyposn != yys1->yyposn) | |
1227 | return yyfalse; | |
1228 | return yytrue; | |
1229 | } | |
1230 | else | |
1231 | return yyfalse; | |
1232 | } | |
1233 | ||
1234 | /** Assuming identicalOptions (Y0,Y1), (destructively) merge the | |
fb8135fa | 1235 | * alternative semantic values for the RHS-symbols of Y1 into the |
01241d47 PH |
1236 | * corresponding semantic value sets of the symbols of Y0. */ |
1237 | static void | |
1238 | yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) | |
1239 | { | |
1240 | yyGLRState *yys0, *yys1; | |
1241 | int yyn; | |
fb8135fa | 1242 | for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, |
01241d47 PH |
1243 | yyn = yyrhsLength (yyy0->yyrule); |
1244 | yyn > 0; | |
1245 | yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) | |
1246 | if (yys0 == yys1) | |
1247 | break; | |
fb8135fa | 1248 | else if (! yys0->yyresolved && ! yys1->yyresolved) |
01241d47 PH |
1249 | { |
1250 | yySemanticOption* yyz; | |
fb8135fa | 1251 | for (yyz = yys0->yysemantics.yyfirstVal; yyz->yynext != NULL; |
01241d47 PH |
1252 | yyz = yyz->yynext) |
1253 | ; | |
1254 | yyz->yynext = yys1->yysemantics.yyfirstVal; | |
1255 | } | |
1256 | } | |
1257 | ||
1258 | /** Y0 and Y1 represent two possible actions to take in a given | |
1259 | * parsing state; return 0 if no combination is possible, | |
1260 | * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ | |
1261 | static int | |
1154cced | 1262 | yypreference (yySemanticOption* y0, yySemanticOption* y1) |
01241d47 | 1263 | { |
1154cced AD |
1264 | yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; |
1265 | int p0 = yydprec[r0], p1 = yydprec[r1]; | |
01241d47 | 1266 | |
1154cced | 1267 | if (p0 == p1) |
01241d47 | 1268 | { |
1154cced | 1269 | if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) |
01241d47 PH |
1270 | return 0; |
1271 | else | |
1272 | return 1; | |
1273 | } | |
1154cced | 1274 | if (p0 == 0 || p1 == 0) |
01241d47 | 1275 | return 0; |
1154cced | 1276 | if (p0 < p1) |
01241d47 | 1277 | return 3; |
39912f52 | 1278 | if (p1 < p0) |
01241d47 PH |
1279 | return 2; |
1280 | return 0; | |
1281 | } | |
1282 | ||
fb8135fa AD |
1283 | static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList, |
1284 | yyGLRStack* yystack, YYSTYPE* yyvalp, | |
2a8d363a | 1285 | YYLTYPE* yylocp]b4_user_formals[); |
01241d47 PH |
1286 | |
1287 | static YYRESULTTAG | |
2a8d363a | 1288 | yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack]b4_user_formals[) |
01241d47 PH |
1289 | { |
1290 | YYRESULTTAG yyflag; | |
39912f52 | 1291 | if (0 < yyn) |
01241d47 PH |
1292 | { |
1293 | assert (yys->yypred != NULL); | |
2a8d363a | 1294 | yyflag = yyresolveStates (yys->yypred, yyn-1, yystack]b4_user_args[); |
01241d47 PH |
1295 | if (yyflag != yyok) |
1296 | return yyflag; | |
fb8135fa | 1297 | if (! yys->yyresolved) |
01241d47 PH |
1298 | { |
1299 | yyflag = yyresolveValue (yys->yysemantics.yyfirstVal, yystack, | |
e7cb57c0 | 1300 | &yys->yysemantics.yysval, &yys->yyloc |
2a8d363a | 1301 | ]b4_user_args[); |
01241d47 PH |
1302 | if (yyflag != yyok) |
1303 | return yyflag; | |
1304 | yys->yyresolved = yytrue; | |
1305 | } | |
1306 | } | |
1307 | return yyok; | |
1308 | } | |
1309 | ||
1310 | static YYRESULTTAG | |
fb8135fa | 1311 | yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack, |
2a8d363a | 1312 | YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
01241d47 PH |
1313 | { |
1314 | yyGLRStackItem yyrhsVals[YYMAXRHS]; | |
1315 | int yynrhs, yyi; | |
1316 | yyGLRState* yys; | |
1317 | ||
1318 | yynrhs = yyrhsLength (yyopt->yyrule); | |
2a8d363a | 1319 | YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[)); |
39912f52 | 1320 | for (yyi = yynrhs-1, yys = yyopt->yystate; 0 <= yyi; |
01241d47 PH |
1321 | yyi -= 1, yys = yys->yypred) |
1322 | { | |
1323 | assert (yys->yypred != NULL); | |
1324 | yyrhsVals[yyi].yystate.yyresolved = yytrue; | |
1325 | yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval; | |
1326 | yyrhsVals[yyi].yystate.yyloc = yys->yyloc; | |
fb8135fa AD |
1327 | } |
1328 | return yyuserAction (yyopt->yyrule, yynrhs, yyrhsVals + (yynrhs-1), | |
2a8d363a | 1329 | yyvalp, yylocp, yystack]b4_user_args[); |
01241d47 PH |
1330 | } |
1331 | ||
1332 | #if YYDEBUG | |
e7cb57c0 AD |
1333 | static void |
1334 | yyreportTree (yySemanticOption* yyx, int yyindent) | |
01241d47 PH |
1335 | { |
1336 | int yynrhs = yyrhsLength (yyx->yyrule); | |
1337 | int yyi; | |
1338 | yyGLRState* yys; | |
1339 | yyGLRState* yystates[YYMAXRHS]; | |
782a05f9 | 1340 | yyGLRState yyleftmost_state; |
01241d47 | 1341 | |
39912f52 | 1342 | for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) |
01241d47 PH |
1343 | yystates[yyi] = yys; |
1344 | if (yys == NULL) | |
782a05f9 PE |
1345 | { |
1346 | yyleftmost_state.yyposn = 0; | |
1347 | yystates[0] = &yyleftmost_state; | |
1348 | } | |
01241d47 PH |
1349 | else |
1350 | yystates[0] = yys; | |
1351 | ||
39912f52 | 1352 | if (yyx->yystate->yyposn < yys->yyposn + 1) |
01241d47 | 1353 | YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n", |
fb8135fa | 1354 | yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), |
01241d47 PH |
1355 | yyx->yyrule); |
1356 | else | |
fb8135fa | 1357 | YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %d .. %d>\n", |
01241d47 PH |
1358 | yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), |
1359 | yyx->yyrule, yys->yyposn+1, yyx->yystate->yyposn); | |
fb8135fa | 1360 | for (yyi = 1; yyi <= yynrhs; yyi += 1) |
01241d47 | 1361 | { |
fb8135fa | 1362 | if (yystates[yyi]->yyresolved) |
01241d47 PH |
1363 | { |
1364 | if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) | |
1365 | YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "", | |
1366 | yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); | |
1367 | else | |
1368 | YYFPRINTF (stderr, "%*s%s <tokens %d .. %d>\n", yyindent+2, "", | |
1369 | yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), | |
1370 | yystates[yyi-1]->yyposn+1, yystates[yyi]->yyposn); | |
1371 | } | |
fb8135fa | 1372 | else |
01241d47 PH |
1373 | yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); |
1374 | } | |
1375 | } | |
fb8135fa | 1376 | #endif |
01241d47 PH |
1377 | |
1378 | static void | |
1379 | yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, | |
2a8d363a | 1380 | yyGLRStack* yystack]b4_pure_formals[) |
01241d47 | 1381 | { |
1154cced AD |
1382 | /* `Unused' warnings. */ |
1383 | (void) yyx0; | |
1384 | (void) yyx1; | |
1385 | ||
01241d47 PH |
1386 | #if YYDEBUG |
1387 | YYFPRINTF (stderr, "Ambiguity detected.\n"); | |
1388 | YYFPRINTF (stderr, "Option 1,\n"); | |
1389 | yyreportTree (yyx0, 2); | |
1390 | YYFPRINTF (stderr, "\nOption 2,\n"); | |
1391 | yyreportTree (yyx1, 2); | |
1392 | YYFPRINTF (stderr, "\n"); | |
1393 | #endif | |
2a8d363a | 1394 | yyFail (yystack][]b4_pure_args[, "ambiguity detected"); |
01241d47 PH |
1395 | } |
1396 | ||
1397 | ||
1398 | /** Resolve the ambiguity represented by OPTIONLIST, perform the indicated | |
1399 | * actions, and return the result. */ | |
1400 | static YYRESULTTAG | |
fb8135fa | 1401 | yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack, |
2a8d363a | 1402 | YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) |
01241d47 PH |
1403 | { |
1404 | yySemanticOption* yybest; | |
1405 | yySemanticOption* yyp; | |
1406 | int yymerge; | |
1407 | ||
fb8135fa | 1408 | yybest = yyoptionList; |
01241d47 | 1409 | yymerge = 0; |
fb8135fa | 1410 | for (yyp = yyoptionList->yynext; yyp != NULL; yyp = yyp->yynext) |
01241d47 PH |
1411 | { |
1412 | if (yyidenticalOptions (yybest, yyp)) | |
1413 | yymergeOptionSets (yybest, yyp); | |
1414 | else | |
fb8135fa | 1415 | switch (yypreference (yybest, yyp)) |
01241d47 PH |
1416 | { |
1417 | case 0: | |
2a8d363a | 1418 | yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[); |
01241d47 PH |
1419 | break; |
1420 | case 1: | |
1421 | yymerge = 1; | |
1422 | break; | |
1423 | case 2: | |
1424 | break; | |
1425 | case 3: | |
1426 | yybest = yyp; | |
1427 | yymerge = 0; | |
1428 | break; | |
1429 | } | |
1430 | } | |
1431 | ||
fb8135fa | 1432 | if (yymerge) |
01241d47 PH |
1433 | { |
1434 | int yyprec = yydprec[yybest->yyrule]; | |
2a8d363a | 1435 | YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp]b4_user_args[)); |
fb8135fa | 1436 | for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) |
01241d47 | 1437 | { |
fb8135fa | 1438 | if (yyprec == yydprec[yyp->yyrule]) |
01241d47 PH |
1439 | { |
1440 | YYSTYPE yyval1; | |
1441 | YYLTYPE yydummy; | |
2a8d363a | 1442 | YYCHK (yyresolveAction (yyp, yystack, &yyval1, &yydummy]b4_user_args[)); |
01241d47 PH |
1443 | *yyvalp = yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1); |
1444 | } | |
1445 | } | |
1446 | return yyok; | |
1447 | } | |
1448 | else | |
2a8d363a | 1449 | return yyresolveAction (yybest, yystack, yyvalp, yylocp]b4_user_args[); |
01241d47 PH |
1450 | } |
1451 | ||
1452 | static YYRESULTTAG | |
2a8d363a | 1453 | yyresolveStack (yyGLRStack* yystack]b4_user_formals[) |
01241d47 | 1454 | { |
fb8135fa | 1455 | if (yystack->yysplitPoint != NULL) |
01241d47 PH |
1456 | { |
1457 | yyGLRState* yys; | |
1458 | int yyn; | |
1459 | ||
fb8135fa AD |
1460 | for (yyn = 0, yys = yystack->yytops.yystates[0]; |
1461 | yys != yystack->yysplitPoint; | |
01241d47 PH |
1462 | yys = yys->yypred, yyn += 1) |
1463 | ; | |
e7cb57c0 | 1464 | YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack |
2a8d363a | 1465 | ]b4_user_args[)); |
01241d47 PH |
1466 | } |
1467 | return yyok; | |
1468 | } | |
1469 | ||
1470 | static void | |
fb8135fa | 1471 | yycompressStack (yyGLRStack* yystack) |
01241d47 PH |
1472 | { |
1473 | yyGLRState* yyp, *yyq, *yyr; | |
1474 | ||
1475 | if (yystack->yytops.yysize != 1 || yystack->yysplitPoint == NULL) | |
1476 | return; | |
1477 | ||
fb8135fa AD |
1478 | for (yyp = yystack->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL; |
1479 | yyp != yystack->yysplitPoint; | |
01241d47 PH |
1480 | yyr = yyp, yyp = yyq, yyq = yyp->yypred) |
1481 | yyp->yypred = yyr; | |
fb8135fa | 1482 | |
01241d47 PH |
1483 | yystack->yyspaceLeft += yystack->yynextFree - yystack->yyitems; |
1484 | yystack->yynextFree = ((yyGLRStackItem*) yystack->yysplitPoint) + 1; | |
1485 | yystack->yyspaceLeft -= yystack->yynextFree - yystack->yyitems; | |
1486 | yystack->yysplitPoint = NULL; | |
1487 | yystack->yylastDeleted = NULL; | |
fb8135fa AD |
1488 | |
1489 | while (yyr != NULL) | |
1490 | { | |
01241d47 PH |
1491 | yystack->yynextFree->yystate = *yyr; |
1492 | yyr = yyr->yypred; | |
1493 | yystack->yynextFree->yystate.yypred = & yystack->yynextFree[-1].yystate; | |
1494 | yystack->yytops.yystates[0] = &yystack->yynextFree->yystate; | |
1495 | yystack->yynextFree += 1; | |
1496 | yystack->yyspaceLeft -= 1; | |
1497 | } | |
1498 | } | |
1499 | ||
1500 | static YYRESULTTAG | |
fb8135fa | 1501 | yyprocessOneStack (yyGLRStack* yystack, int yyk, |
e7cb57c0 | 1502 | size_t yyposn, YYSTYPE* yylvalp, YYLTYPE* yyllocp |
2a8d363a | 1503 | ]b4_user_formals[) |
01241d47 PH |
1504 | { |
1505 | int yyaction; | |
1506 | const short* yyconflicts; | |
1507 | yyRuleNum yyrule; | |
1508 | yySymbol* const yytokenp = yystack->yytokenp; | |
1509 | ||
fb8135fa | 1510 | while (yystack->yytops.yystates[yyk] != NULL) |
01241d47 PH |
1511 | { |
1512 | yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState; | |
b0937b22 | 1513 | YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate)); |
01241d47 PH |
1514 | |
1515 | assert (yystate != YYFINAL); | |
fb8135fa | 1516 | if (yyisDefaultedState (yystate)) |
01241d47 PH |
1517 | { |
1518 | yyrule = yydefaultAction (yystate); | |
fb8135fa | 1519 | if (yyrule == 0) |
01241d47 PH |
1520 | { |
1521 | YYDPRINTF ((stderr, "Stack %d dies.\n", yyk)); | |
1522 | yymarkStackDeleted (yystack, yyk); | |
1523 | return yyok; | |
1524 | } | |
2a8d363a | 1525 | YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse]b4_lpure_args[)); |
01241d47 | 1526 | } |
fb8135fa | 1527 | else |
01241d47 | 1528 | { |
fb8135fa | 1529 | if (*yytokenp == YYEMPTY) |
01241d47 | 1530 | { |
2a1fe6ed | 1531 | YYDPRINTF ((stderr, "Reading a token: ")); |
01241d47 | 1532 | yychar = YYLEX; |
b0400cc6 | 1533 | *yytokenp = YYTRANSLATE (yychar); |
9c1e26bd | 1534 | YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp); |
01241d47 PH |
1535 | } |
1536 | yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts); | |
1537 | ||
fb8135fa | 1538 | while (*yyconflicts != 0) |
01241d47 PH |
1539 | { |
1540 | int yynewStack = yysplitStack (yystack, yyk); | |
1541 | YYDPRINTF ((stderr, "Splitting off stack %d from %d.\n", | |
1542 | yynewStack, yyk)); | |
e7cb57c0 | 1543 | YYCHK (yyglrReduce (yystack, yynewStack, |
2a8d363a | 1544 | *yyconflicts, yyfalse]b4_lpure_args[)); |
fb8135fa | 1545 | YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn, |
2a8d363a | 1546 | yylvalp, yyllocp]b4_user_args[)); |
01241d47 PH |
1547 | yyconflicts += 1; |
1548 | } | |
fb8135fa AD |
1549 | |
1550 | if (yyisShiftAction (yyaction)) | |
01241d47 | 1551 | { |
2a1fe6ed | 1552 | YYDPRINTF ((stderr, "Shifting token %s on stack %d, ", |
01241d47 | 1553 | yytokenName (*yytokenp), yyk)); |
2a8d363a AD |
1554 | yyglrShift (yystack, yyk, yyaction, yyposn+1, |
1555 | *yylvalp, yyllocp]b4_user_args[); | |
fb8135fa | 1556 | YYDPRINTF ((stderr, "which is now in state #%d\n", |
01241d47 PH |
1557 | yystack->yytops.yystates[yyk]->yylrState)); |
1558 | break; | |
1559 | } | |
fb8135fa | 1560 | else if (yyisErrorAction (yyaction)) |
01241d47 PH |
1561 | { |
1562 | YYDPRINTF ((stderr, "Stack %d dies.\n", yyk)); | |
1563 | yymarkStackDeleted (yystack, yyk); | |
1564 | break; | |
1565 | } | |
1566 | else | |
2a8d363a | 1567 | YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse]b4_lpure_args[)); |
01241d47 PH |
1568 | } |
1569 | } | |
1570 | return yyok; | |
1571 | } | |
1572 | ||
1573 | static void | |
2a8d363a AD |
1574 | yyreportParseError (yyGLRStack* yystack, |
1575 | YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[) | |
01241d47 | 1576 | { |
1154cced AD |
1577 | /* `Unused' warnings. */ |
1578 | (void) yylvalp; | |
1579 | (void) yyllocp; | |
01241d47 PH |
1580 | |
1581 | if (yystack->yyerrState == 0) | |
1582 | { | |
fb8135fa | 1583 | #if YYERROR_VERBOSE |
1154cced | 1584 | yySymbol* const yytokenp = yystack->yytokenp; |
cf126971 PE |
1585 | int yyn, yyx, yycount; |
1586 | size_t yysize; | |
1154cced | 1587 | const char* yyprefix; |
01241d47 PH |
1588 | char* yyp; |
1589 | char* yymsg; | |
1590 | yyn = yypact[yystack->yytops.yystates[0]->yylrState]; | |
12b0043a | 1591 | if (YYPACT_NINF < yyn && yyn < YYLAST) |
01241d47 PH |
1592 | { |
1593 | yycount = 0; | |
1594 | /* Start YYX at -YYN if negative to avoid negative indexes in | |
1595 | YYCHECK. */ | |
6e649e65 | 1596 | yysize = sizeof ("syntax error, unexpected ") |
01241d47 PH |
1597 | + strlen (yytokenName (*yytokenp)); |
1598 | yyprefix = ", expecting "; | |
fb8135fa | 1599 | for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5; |
01241d47 | 1600 | yyx += 1) |
217598da | 1601 | if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
01241d47 PH |
1602 | yysize += strlen (yytokenName (yyx)) + strlen (yyprefix), |
1603 | yycount += 1, yyprefix = " or "; | |
1604 | yymsg = yyp = (char*) malloc (yysize); | |
6e649e65 PE |
1605 | sprintf (yyp, "syntax error, unexpected %s", |
1606 | yytokenName (*yytokenp)); | |
3eb49163 | 1607 | yyp += strlen (yyp); |
01241d47 PH |
1608 | if (yycount < 5) |
1609 | { | |
1610 | yyprefix = ", expecting "; | |
1611 | for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size; yyx += 1) | |
f50adbbd | 1612 | if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
01241d47 | 1613 | { |
3eb49163 PE |
1614 | sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx)); |
1615 | yyp += strlen (yyp); | |
01241d47 PH |
1616 | yyprefix = " or "; |
1617 | } | |
1618 | } | |
93724f13 | 1619 | yyerror (]b4_lyyerror_args[yymsg); |
01241d47 PH |
1620 | free (yymsg); |
1621 | } | |
1622 | else | |
1623 | #endif | |
6e649e65 | 1624 | yyerror (]b4_lyyerror_args["syntax error"); |
01241d47 PH |
1625 | yynerrs += 1; |
1626 | } | |
1627 | } | |
1628 | ||
f50adbbd | 1629 | /* Recover from a syntax error on YYSTACK, assuming that YYTOKENP, |
01241d47 | 1630 | YYLVALP, and YYLLOCP point to the syntactic category, semantic |
f50adbbd | 1631 | value, and location of the lookahead. */ |
fb8135fa | 1632 | static void |
2a8d363a AD |
1633 | yyrecoverParseError (yyGLRStack* yystack, |
1634 | YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[) | |
01241d47 PH |
1635 | { |
1636 | yySymbol* const yytokenp = yystack->yytokenp; | |
1154cced AD |
1637 | size_t yyk; |
1638 | int yyj; | |
01241d47 | 1639 | |
fb8135fa | 1640 | if (yystack->yyerrState == 0) |
01241d47 | 1641 | yystack->yyerrState = 3; |
fb8135fa | 1642 | else if (yystack->yyerrState == 3) |
2a1fe6ed AD |
1643 | /* We just shifted the error token and (perhaps) took some |
1644 | reductions. Skip tokens until we can proceed. */ | |
1645 | while (yytrue) | |
1646 | { | |
01241d47 | 1647 | if (*yytokenp == YYEOF) |
7bd6c77e AD |
1648 | { |
1649 | /* Now pop stack until we find a state that shifts the | |
1650 | error token. */ | |
1651 | while (yystack->yytops.yystates[0] != NULL) | |
1652 | { | |
1653 | yyGLRState *yys = yystack->yytops.yystates[0]; | |
9c1e26bd | 1654 | YYDSYMPRINTF ("Error: popping", |
7bd6c77e | 1655 | yystos[yys->yylrState], |
9c1e26bd | 1656 | &yys->yysemantics.yysval, &yys->yyloc); |
7bd6c77e AD |
1657 | yydestruct (yystos[yys->yylrState], |
1658 | &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[); | |
1659 | yystack->yytops.yystates[0] = yys->yypred; | |
1660 | yystack->yynextFree -= 1; | |
1661 | yystack->yyspaceLeft += 1; | |
1662 | } | |
1663 | yyFail (yystack][]b4_lpure_args[, NULL); | |
1664 | } | |
01241d47 | 1665 | if (*yytokenp != YYEMPTY) |
7bd6c77e | 1666 | { |
9c1e26bd | 1667 | YYDSYMPRINTF ("Error: discarding", *yytokenp, yylvalp, yyllocp); |
7bd6c77e AD |
1668 | yydestruct (*yytokenp, yylvalp]b4_location_if([, yyllocp])[); |
1669 | } | |
2a1fe6ed | 1670 | YYDPRINTF ((stderr, "Reading a token: ")); |
01241d47 PH |
1671 | yychar = YYLEX; |
1672 | *yytokenp = YYTRANSLATE (yychar); | |
9c1e26bd | 1673 | YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp); |
01241d47 | 1674 | yyj = yypact[yystack->yytops.yystates[0]->yylrState]; |
944ed9f4 | 1675 | if (yyis_pact_ninf (yyj)) |
2a1fe6ed | 1676 | /* Something's not right; we shouldn't be here. */ |
2a8d363a | 1677 | yyFail (yystack][]b4_lpure_args[, NULL); |
01241d47 | 1678 | yyj += *yytokenp; |
ea99527d | 1679 | if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp) |
01241d47 PH |
1680 | { |
1681 | if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0) | |
1682 | return; | |
1683 | } | |
944ed9f4 | 1684 | else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj])) |
01241d47 | 1685 | return; |
2a1fe6ed | 1686 | } |
fb8135fa | 1687 | |
2a1fe6ed | 1688 | /* Reduce to one stack. */ |
01241d47 PH |
1689 | for (yyk = 0; yyk < yystack->yytops.yysize; yyk += 1) |
1690 | if (yystack->yytops.yystates[yyk] != NULL) | |
1691 | break; | |
1692 | if (yyk >= yystack->yytops.yysize) | |
2a8d363a | 1693 | yyFail (yystack][]b4_lpure_args[, NULL); |
01241d47 PH |
1694 | for (yyk += 1; yyk < yystack->yytops.yysize; yyk += 1) |
1695 | yymarkStackDeleted (yystack, yyk); | |
1696 | yyremoveDeletes (yystack); | |
1697 | yycompressStack (yystack); | |
1698 | ||
1699 | /* Now pop stack until we find a state that shifts the error token. */ | |
fb8135fa | 1700 | while (yystack->yytops.yystates[0] != NULL) |
01241d47 | 1701 | { |
7bd6c77e AD |
1702 | yyGLRState *yys = yystack->yytops.yystates[0]; |
1703 | yyj = yypact[yys->yylrState]; | |
944ed9f4 | 1704 | if (! yyis_pact_ninf (yyj)) |
01241d47 | 1705 | { |
944ed9f4 PE |
1706 | yyj += YYTERROR; |
1707 | if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR | |
1708 | && yyisShiftAction (yytable[yyj])) | |
1709 | { | |
7bd6c77e | 1710 | YYDPRINTF ((stderr, "Shifting error token, ")); |
944ed9f4 | 1711 | yyglrShift (yystack, 0, yytable[yyj], |
7bd6c77e | 1712 | yys->yyposn, *yylvalp, yyllocp]b4_user_args[); |
944ed9f4 PE |
1713 | break; |
1714 | } | |
01241d47 | 1715 | } |
9c1e26bd | 1716 | YYDSYMPRINTF ("Error: popping", |
7bd6c77e | 1717 | yystos[yys->yylrState], |
9c1e26bd | 1718 | &yys->yysemantics.yysval, &yys->yyloc); |
7bd6c77e AD |
1719 | yydestruct (yystos[yys->yylrState], |
1720 | &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[); | |
1721 | yystack->yytops.yystates[0] = yys->yypred; | |
01241d47 PH |
1722 | yystack->yynextFree -= 1; |
1723 | yystack->yyspaceLeft += 1; | |
1724 | } | |
1725 | if (yystack->yytops.yystates[0] == NULL) | |
2a8d363a | 1726 | yyFail (yystack][]b4_lpure_args[, NULL); |
fb8135fa AD |
1727 | } |
1728 | ||
01241d47 PH |
1729 | #define YYCHK1(YYE) \ |
1730 | do { \ | |
1731 | switch (YYE) { \ | |
1732 | default: \ | |
1733 | break; \ | |
1734 | case yyabort: \ | |
1735 | yystack.yyerrflag = 1; \ | |
1736 | goto yyDone; \ | |
1737 | case yyaccept: \ | |
1738 | yystack.yyerrflag = 0; \ | |
1739 | goto yyDone; \ | |
1740 | case yyerr: \ | |
1741 | goto yyuser_error; \ | |
1742 | } \ | |
fb8135fa | 1743 | } while (0) |
01241d47 | 1744 | |
0245f82d AD |
1745 | |
1746 | /*----------. | |
1747 | | yyparse. | | |
1748 | `----------*/ | |
1749 | ||
1750 | ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ | |
01241d47 PH |
1751 | { |
1752 | yySymbol yytoken; | |
1753 | yyGLRStack yystack; | |
1754 | size_t yyposn; | |
1755 | ]b4_pure_if( | |
1756 | [ | |
1757 | YYSTYPE yylval; | |
1758 | YYLTYPE yylloc; | |
1759 | #undef yychar | |
1760 | #define yychar (yystack.yyrawchar) | |
1761 | ])[ | |
1762 | ||
1763 | YYSTYPE* const yylvalp = &yylval; | |
1764 | YYLTYPE* const yyllocp = &yylloc; | |
fb8135fa | 1765 | |
01241d47 PH |
1766 | yyinitGLRStack (&yystack, YYINITDEPTH); |
1767 | yystack.yytokenp = &yytoken; | |
1768 | ||
2a1fe6ed AD |
1769 | YYDPRINTF ((stderr, "Starting parse\n")); |
1770 | ||
01241d47 PH |
1771 | if (setjmp (yystack.yyexception_buffer) != 0) |
1772 | goto yyDone; | |
1773 | ||
2a8d363a | 1774 | yyglrShift (&yystack, 0, 0, 0, yyval_default, &yyloc_default]b4_user_args[); |
01241d47 PH |
1775 | yytoken = YYEMPTY; |
1776 | yyposn = 0; | |
1777 | ||
fb8135fa | 1778 | while (yytrue) |
01241d47 | 1779 | { |
21964f43 AD |
1780 | /* For efficiency, we have two loops, the first of which is |
1781 | specialized to deterministic operation (single stack, no | |
1782 | potential ambiguity). */ | |
01241d47 | 1783 | /* Standard mode */ |
fb8135fa | 1784 | while (yytrue) |
01241d47 PH |
1785 | { |
1786 | yyRuleNum yyrule; | |
1787 | int yyaction; | |
1788 | const short* yyconflicts; | |
1789 | ||
1790 | yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; | |
b0937b22 | 1791 | YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
01241d47 PH |
1792 | if (yystate == YYFINAL) |
1793 | goto yyDone; | |
fb8135fa | 1794 | if (yyisDefaultedState (yystate)) |
01241d47 PH |
1795 | { |
1796 | yyrule = yydefaultAction (yystate); | |
fb8135fa | 1797 | if (yyrule == 0) |
01241d47 | 1798 | { |
2a8d363a | 1799 | yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[); |
01241d47 PH |
1800 | goto yyuser_error; |
1801 | } | |
2a8d363a | 1802 | YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_lpure_args[)); |
01241d47 | 1803 | } |
fb8135fa | 1804 | else |
01241d47 | 1805 | { |
fb8135fa | 1806 | if (yytoken == YYEMPTY) |
01241d47 | 1807 | { |
2a1fe6ed | 1808 | YYDPRINTF ((stderr, "Reading a token: ")); |
01241d47 PH |
1809 | yychar = YYLEX; |
1810 | yytoken = YYTRANSLATE (yychar); | |
9c1e26bd | 1811 | YYDSYMPRINTF ("Next token is", yytoken, yylvalp, yyllocp); |
01241d47 PH |
1812 | } |
1813 | yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); | |
1814 | if (*yyconflicts != 0) | |
1815 | break; | |
fb8135fa | 1816 | if (yyisShiftAction (yyaction)) |
01241d47 | 1817 | { |
2a1fe6ed | 1818 | YYDPRINTF ((stderr, "Shifting token %s, ", |
01241d47 PH |
1819 | yytokenName (yytoken))); |
1820 | if (yytoken != YYEOF) | |
1821 | yytoken = YYEMPTY; | |
1822 | yyposn += 1; | |
2a8d363a AD |
1823 | yyglrShift (&yystack, 0, yyaction, yyposn, |
1824 | yylval, yyllocp]b4_user_args[); | |
39912f52 | 1825 | if (0 < yystack.yyerrState) |
01241d47 | 1826 | yystack.yyerrState -= 1; |
01241d47 PH |
1827 | } |
1828 | else if (yyisErrorAction (yyaction)) | |
1829 | { | |
2a8d363a | 1830 | yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[); |
01241d47 PH |
1831 | goto yyuser_error; |
1832 | } | |
1833 | else | |
2a8d363a | 1834 | YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_lpure_args[)); |
01241d47 PH |
1835 | } |
1836 | } | |
1837 | ||
fb8135fa | 1838 | while (yytrue) |
01241d47 PH |
1839 | { |
1840 | int yys; | |
1841 | int yyn = yystack.yytops.yysize; | |
1842 | for (yys = 0; yys < yyn; yys += 1) | |
1843 | YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn, | |
2a8d363a | 1844 | yylvalp, yyllocp]b4_user_args[)); |
01241d47 PH |
1845 | yytoken = YYEMPTY; |
1846 | yyposn += 1; | |
1847 | yyremoveDeletes (&yystack); | |
1848 | if (yystack.yytops.yysize == 0) | |
1849 | { | |
1850 | yyundeleteLastStack (&yystack); | |
1851 | if (yystack.yytops.yysize == 0) | |
6e649e65 | 1852 | yyFail (&yystack][]b4_lpure_args[, "syntax error"); |
2a8d363a | 1853 | YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); |
01241d47 | 1854 | YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); |
2a8d363a | 1855 | yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[); |
01241d47 PH |
1856 | goto yyuser_error; |
1857 | } | |
fb8135fa | 1858 | else if (yystack.yytops.yysize == 1) |
01241d47 | 1859 | { |
2a8d363a | 1860 | YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); |
01241d47 PH |
1861 | YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); |
1862 | yycompressStack (&yystack); | |
1863 | break; | |
1864 | } | |
1865 | } | |
1866 | continue; | |
1867 | yyuser_error: | |
2a8d363a | 1868 | yyrecoverParseError (&yystack, yylvalp, yyllocp]b4_user_args[); |
01241d47 PH |
1869 | yyposn = yystack.yytops.yystates[0]->yyposn; |
1870 | } | |
1871 | yyDone: | |
1872 | ; | |
1873 | ||
1874 | yyfreeGLRStack (&yystack); | |
1875 | return yystack.yyerrflag; | |
1876 | } | |
1877 | ||
1878 | /* DEBUGGING ONLY */ | |
1154cced AD |
1879 | static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED; |
1880 | static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED; | |
01241d47 | 1881 | |
1154cced | 1882 | static void |
cf126971 | 1883 | yy_yypstack (yyGLRState* yys) |
01241d47 | 1884 | { |
cf126971 | 1885 | if (yys->yypred) |
01241d47 | 1886 | { |
cf126971 PE |
1887 | yy_yypstack (yys->yypred); |
1888 | fprintf (stderr, " -> "); | |
01241d47 | 1889 | } |
947427ae | 1890 | fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long) yys->yyposn); |
cf126971 | 1891 | } |
01241d47 | 1892 | |
cf126971 PE |
1893 | static void |
1894 | yypstates (yyGLRState* yyst) | |
1895 | { | |
fb8135fa | 1896 | if (yyst == NULL) |
01241d47 | 1897 | fprintf (stderr, "<null>"); |
fb8135fa | 1898 | else |
01241d47 PH |
1899 | yy_yypstack (yyst); |
1900 | fprintf (stderr, "\n"); | |
1901 | } | |
1902 | ||
1154cced | 1903 | static void |
fb8135fa | 1904 | yypstack (yyGLRStack* yystack, int yyk) |
01241d47 PH |
1905 | { |
1906 | yypstates (yystack->yytops.yystates[yyk]); | |
1907 | } | |
1908 | ||
1909 | #define YYINDEX(YYX) \ | |
1910 | ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems) | |
1911 | ||
1912 | ||
1154cced | 1913 | static void |
fb8135fa | 1914 | yypdumpstack (yyGLRStack* yystack) |
01241d47 PH |
1915 | { |
1916 | yyGLRStackItem* yyp; | |
1154cced | 1917 | size_t yyi; |
fb8135fa | 1918 | for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1) |
01241d47 | 1919 | { |
cf126971 | 1920 | fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems)); |
fb8135fa | 1921 | if (*(bool*) yyp) |
01241d47 | 1922 | { |
cf126971 | 1923 | fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", |
fb8135fa | 1924 | yyp->yystate.yyresolved, yyp->yystate.yylrState, |
cf126971 PE |
1925 | (unsigned long) yyp->yystate.yyposn, |
1926 | (long) YYINDEX (yyp->yystate.yypred)); | |
fb8135fa | 1927 | if (! yyp->yystate.yyresolved) |
cf126971 PE |
1928 | fprintf (stderr, ", firstVal: %ld", |
1929 | (long) YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); | |
01241d47 | 1930 | } |
fb8135fa | 1931 | else |
01241d47 | 1932 | { |
cf126971 PE |
1933 | fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld", |
1934 | yyp->yyoption.yyrule, | |
1935 | (long) YYINDEX (yyp->yyoption.yystate), | |
1936 | (long) YYINDEX (yyp->yyoption.yynext)); | |
01241d47 PH |
1937 | } |
1938 | fprintf (stderr, "\n"); | |
1939 | } | |
1940 | fprintf (stderr, "Tops:"); | |
1941 | for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1) | |
cf126971 PE |
1942 | fprintf (stderr, "%lu: %ld; ", (unsigned long) yyi, |
1943 | (long) YYINDEX (yystack->yytops.yystates[yyi])); | |
01241d47 PH |
1944 | fprintf (stderr, "\n"); |
1945 | } | |
01241d47 PH |
1946 | ] |
1947 | ||
1948 | b4_epilogue | |
1949 | m4_if(b4_defines_flag, 0, [], | |
947427ae | 1950 | [@output @output_header_name@ |
fb8135fa | 1951 | b4_copyright([Skeleton parser for GLR parsing with Bison], [2002]) |
01241d47 PH |
1952 | |
1953 | b4_token_defines(b4_tokens) | |
1954 | ||
1955 | #ifndef YYSTYPE | |
1956 | m4_ifdef([b4_stype], | |
437c2d80 | 1957 | [b4_syncline([b4_stype_line], [b4_filename]) |
01241d47 PH |
1958 | typedef union b4_stype yystype; |
1959 | /* Line __line__ of __file__. */ | |
947427ae | 1960 | b4_syncline([@oline@], [@ofile@])], |
01241d47 PH |
1961 | [typedef int yystype;]) |
1962 | # define YYSTYPE yystype | |
947427ae | 1963 | # define YYSTYPE_IS_TRIVIAL 1 |
01241d47 PH |
1964 | #endif |
1965 | ||
1966 | b4_pure_if([], | |
1967 | [extern YYSTYPE b4_prefix[]lval;]) | |
1968 | ||
1969 | b4_location_if( | |
1970 | [#ifndef YYLTYPE | |
1971 | typedef struct yyltype | |
1972 | { | |
f50adbbd AD |
1973 | int first_line; |
1974 | int first_column; | |
1975 | int last_line; | |
1976 | int last_column; | |
01241d47 PH |
1977 | } yyltype; |
1978 | # define YYLTYPE yyltype | |
1979 | #endif | |
1980 | ||
1981 | m4_if(b4_pure, [0], | |
1982 | [extern YYLTYPE b4_prefix[]lloc;]) | |
1983 | ]) | |
01241d47 | 1984 | ]) |