]>
Commit | Line | Data |
---|---|---|
08af01c2 | 1 | -*- C -*- |
a8289c62 | 2 | |
60491a94 | 3 | # Yacc compatible skeleton for Bison |
c7a65b99 | 4 | |
c932d613 | 5 | # Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, |
ea0a7676 | 6 | # Inc. |
60491a94 | 7 | |
f16b0819 | 8 | # This program is free software: you can redistribute it and/or modify |
60491a94 | 9 | # it under the terms of the GNU General Public License as published by |
f16b0819 | 10 | # the Free Software Foundation, either version 3 of the License, or |
60491a94 | 11 | # (at your option) any later version. |
f16b0819 | 12 | # |
60491a94 AD |
13 | # This program is distributed in the hope that it will be useful, |
14 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | # GNU General Public License for more details. | |
f16b0819 | 17 | # |
60491a94 | 18 | # You should have received a copy of the GNU General Public License |
f16b0819 | 19 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
60491a94 | 20 | |
812775a0 JD |
21 | # Check the value of %define api.push-pull. |
22 | b4_percent_define_default([[api.push-pull]], [[pull]]) | |
23 | b4_percent_define_check_values([[[[api.push-pull]], | |
93d0103d | 24 | [[pull]], [[push]], [[both]]]]) |
9ca7f077 JD |
25 | b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) |
26 | b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) | |
812775a0 | 27 | m4_case(b4_percent_define_get([[api.push-pull]]), |
9ca7f077 JD |
28 | [pull], [m4_define([b4_push_flag], [[0]])], |
29 | [push], [m4_define([b4_pull_flag], [[0]])]) | |
30 | ||
31 | # Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing | |
7e5ef706 PE |
32 | # tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the |
33 | # behavior of Bison at all when push parsing is already requested. | |
9ca7f077 JD |
34 | b4_define_flag_if([use_push_for_pull]) |
35 | b4_use_push_for_pull_if([ | |
36 | b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], | |
37 | [m4_define([b4_push_flag], [[1]])])]) | |
945e396c | 38 | |
723fe7d1 JD |
39 | # Check the value of %define parse.lac and friends, where LAC stands for |
40 | # lookahead correction. | |
ea13bea8 | 41 | b4_percent_define_default([[parse.lac]], [[none]]) |
723fe7d1 JD |
42 | b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]]) |
43 | b4_percent_define_default([[parse.lac.memory-trace]], [[failures]]) | |
44 | b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]], | |
45 | [[[[parse.lac.memory-trace]], | |
46 | [[failures]], [[full]]]]) | |
ea13bea8 JD |
47 | b4_define_flag_if([lac]) |
48 | m4_define([b4_lac_flag], | |
49 | [m4_if(b4_percent_define_get([[parse.lac]]), | |
50 | [none], [[0]], [[1]])]) | |
51 | ||
0a96ba81 | 52 | m4_include(b4_pkgdatadir/[c.m4]) |
7eb8a0bc | 53 | |
66d30cd4 AD |
54 | ## ---------------- ## |
55 | ## Default values. ## | |
56 | ## ---------------- ## | |
57 | ||
58 | # Stack parameters. | |
59 | m4_define_default([b4_stack_depth_max], [10000]) | |
60 | m4_define_default([b4_stack_depth_init], [200]) | |
61 | ||
2a8d363a AD |
62 | |
63 | ## ------------------------ ## | |
64 | ## Pure/impure interfaces. ## | |
65 | ## ------------------------ ## | |
66 | ||
d9df47b6 JD |
67 | b4_percent_define_default([[api.pure]], [[false]]) |
68 | b4_define_flag_if([pure]) | |
69 | m4_define([b4_pure_flag], | |
70 | [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])]) | |
2a8d363a | 71 | |
4b367315 AD |
72 | # b4_yacc_pure_if(IF-TRUE, IF-FALSE) |
73 | # ---------------------------------- | |
2a8d363a | 74 | # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise. |
4b367315 | 75 | m4_define([b4_yacc_pure_if], |
2a8d363a | 76 | [b4_pure_if([m4_ifset([b4_parse_param], |
02650b7f PE |
77 | [$1], [$2])], |
78 | [$2])]) | |
2a8d363a AD |
79 | |
80 | ||
93724f13 AD |
81 | # b4_yyerror_args |
82 | # --------------- | |
2a8d363a | 83 | # Arguments passed to yyerror: user args plus yylloc. |
93724f13 | 84 | m4_define([b4_yyerror_args], |
327afc7c | 85 | [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl |
93724f13 | 86 | m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) |
2a8d363a AD |
87 | |
88 | ||
89 | # b4_lex_param | |
90 | # ------------ | |
d42f69cd | 91 | # Accumulate in b4_lex_param all the yylex arguments. |
2a8d363a | 92 | # b4_lex_param arrives quoted twice, but we want to keep only one level. |
21964f43 AD |
93 | m4_define([b4_lex_param], |
94 | m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl | |
327afc7c | 95 | b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl |
68cdf747 | 96 | m4_ifdef([b4_lex_param], b4_lex_param))) |
66d30cd4 AD |
97 | |
98 | ||
f1886bb2 AD |
99 | ## ------------ ## |
100 | ## Data Types. ## | |
101 | ## ------------ ## | |
102 | ||
103 | # b4_int_type(MIN, MAX) | |
104 | # --------------------- | |
105 | # Return the smallest int type able to handle numbers ranging from | |
d42cf844 PE |
106 | # MIN to MAX (included). Overwrite the version from c.m4, which |
107 | # uses only C89 types, so that the user can override the shorter | |
108 | # types, and so that pre-C89 compilers are handled correctly. | |
f1886bb2 | 109 | m4_define([b4_int_type], |
d42cf844 PE |
110 | [m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8], |
111 | b4_ints_in($@, [-128], [127]), [1], [yytype_int8], | |
f1886bb2 | 112 | |
d42cf844 PE |
113 | b4_ints_in($@, [0], [65535]), [1], [yytype_uint16], |
114 | b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16], | |
f1886bb2 AD |
115 | |
116 | m4_eval([0 <= $1]), [1], [unsigned int], | |
117 | ||
02650b7f | 118 | [int])]) |
f1886bb2 AD |
119 | |
120 | ||
66d30cd4 AD |
121 | ## ----------------- ## |
122 | ## Semantic Values. ## | |
123 | ## ----------------- ## | |
124 | ||
125 | ||
82b6cb3f AD |
126 | # b4_lhs_value([TYPE]) |
127 | # -------------------- | |
128 | # Expansion of $<TYPE>$. | |
129 | m4_define([b4_lhs_value], | |
bc82c5a5 | 130 | [(yyval[]m4_ifval([$1], [.$1]))]) |
82b6cb3f AD |
131 | |
132 | ||
133 | # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) | |
134 | # -------------------------------------- | |
135 | # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH | |
136 | # symbols on RHS. | |
137 | m4_define([b4_rhs_value], | |
d1ff7a7c | 138 | [(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))]) |
82b6cb3f AD |
139 | |
140 | ||
58612f1d AD |
141 | |
142 | ## ----------- ## | |
143 | ## Locations. ## | |
144 | ## ----------- ## | |
145 | ||
82b6cb3f AD |
146 | # b4_lhs_location() |
147 | # ----------------- | |
148 | # Expansion of @$. | |
149 | m4_define([b4_lhs_location], | |
bc82c5a5 | 150 | [(yyloc)]) |
82b6cb3f AD |
151 | |
152 | ||
153 | # b4_rhs_location(RULE-LENGTH, NUM) | |
154 | # --------------------------------- | |
155 | # Expansion of @NUM, where the current rule has RULE-LENGTH symbols | |
156 | # on RHS. | |
157 | m4_define([b4_rhs_location], | |
d1ff7a7c | 158 | [(yylsp@{($2) - ($1)@})]) |
be2a1a68 | 159 | |
0d8bed56 | 160 | |
c0828abf AD |
161 | ## -------------- ## |
162 | ## Declarations. ## | |
163 | ## -------------- ## | |
93d0103d JD |
164 | |
165 | # b4_declare_scanner_communication_variables | |
166 | # ------------------------------------------ | |
167 | # Declare the variables that are global, or local to YYPARSE if | |
168 | # pure-parser. | |
169 | m4_define([b4_declare_scanner_communication_variables], [[ | |
170 | /* The lookahead symbol. */ | |
171 | int yychar; | |
172 | ||
173 | /* The semantic value of the lookahead symbol. */ | |
174 | YYSTYPE yylval;]b4_locations_if([[ | |
175 | ||
176 | /* Location data for the lookahead symbol. */ | |
177 | YYLTYPE yylloc;]])b4_pure_if([], [[ | |
178 | ||
179 | /* Number of syntax errors so far. */ | |
180 | int yynerrs;]])]) | |
181 | ||
182 | ||
183 | # b4_declare_parser_state_variables | |
184 | # --------------------------------- | |
185 | # Declare all the variables that are needed to maintain the parser state | |
186 | # between calls to yypush_parse. | |
187 | m4_define([b4_declare_parser_state_variables], [b4_pure_if([[ | |
188 | /* Number of syntax errors so far. */ | |
189 | int yynerrs; | |
190 | ]])[ | |
191 | int yystate; | |
192 | /* Number of tokens to shift before error messages enabled. */ | |
193 | int yyerrstatus; | |
194 | ||
195 | /* The stacks and their tools: | |
196 | `yyss': related to states. | |
197 | `yyvs': related to semantic values.]b4_locations_if([[ | |
198 | `yyls': related to locations.]])[ | |
199 | ||
cbdb6d91 | 200 | Refer to the stacks through separate pointers, to allow yyoverflow |
93d0103d JD |
201 | to reallocate them elsewhere. */ |
202 | ||
203 | /* The state stack. */ | |
204 | yytype_int16 yyssa[YYINITDEPTH]; | |
205 | yytype_int16 *yyss; | |
206 | yytype_int16 *yyssp; | |
207 | ||
208 | /* The semantic value stack. */ | |
209 | YYSTYPE yyvsa[YYINITDEPTH]; | |
210 | YYSTYPE *yyvs; | |
211 | YYSTYPE *yyvsp;]b4_locations_if([[ | |
212 | ||
213 | /* The location stack. */ | |
214 | YYLTYPE yylsa[YYINITDEPTH]; | |
215 | YYLTYPE *yyls; | |
216 | YYLTYPE *yylsp; | |
217 | ||
218 | /* The locations where the error started and ended. */ | |
a005dbcb | 219 | YYLTYPE yyerror_range[3];]])[ |
93d0103d | 220 | |
723fe7d1 JD |
221 | YYSIZE_T yystacksize;]b4_lac_if([[ |
222 | ||
223 | yytype_int16 yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@}; | |
224 | yytype_int16 *yyes; | |
225 | YYSIZE_T yyes_capacity;]])]) | |
93d0103d | 226 | |
ae6bdabb AD |
227 | |
228 | # b4_shared_declarations | |
229 | # ---------------------- | |
230 | # Declaration that might either go into the header (if --defines) | |
231 | # or open coded in the parser body. | |
232 | m4_define([b4_shared_declarations], | |
233 | [b4_percent_code_get([[requires]])[ | |
234 | ]b4_token_enums_defines(b4_tokens)[ | |
235 | ]b4_declare_yylstype[ | |
236 | ]b4_push_if([[ | |
237 | #ifndef YYPUSH_DECLS | |
238 | # define YYPUSH_DECLS | |
239 | typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; | |
240 | enum { YYPUSH_MORE = 4 }; | |
241 | ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param) | |
242 | ])b4_c_function_decl([b4_prefix[push_parse]], [[int]], | |
243 | [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([, | |
244 | [[[int yypushed_char]], [[yypushed_char]]], | |
245 | [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, | |
246 | [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, | |
247 | b4_parse_param])) | |
248 | b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]], | |
249 | [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, | |
250 | b4_parse_param]))]) | |
251 | b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]], | |
252 | [[[void]], []]) | |
253 | b4_c_function_decl([b4_prefix[pstate_delete]], [[void]], | |
254 | [[b4_prefix[pstate *yyps]], [[yyps]]])[ | |
255 | #endif | |
256 | ]]) | |
257 | b4_percent_code_get([[provides]])[]dnl | |
258 | ]) | |
259 | ||
c0828abf AD |
260 | ## -------------- ## |
261 | ## Output files. ## | |
262 | ## -------------- ## | |
1ae72863 | 263 | |
b526ee61 AD |
264 | # We do want M4 expansion after # for CPP macros. |
265 | m4_changecom() | |
08af01c2 | 266 | m4_divert_push(0)dnl |
0d2b2ab0 | 267 | @output(b4_parser_file_name@)@ |
448dc38b | 268 | b4_copyright([Bison implementation for Yacc-like parsers in C], |
681dda24 | 269 | [1984, 1989-1990, 2000-2012])[ |
af3412cd PE |
270 | |
271 | /* C LALR(1) parser skeleton written by Richard Stallman, by | |
272 | simplifying the original so-called "semantic" parser. */ | |
444fbf65 | 273 | |
cf44a9ae PE |
274 | /* All symbols defined below should begin with yy or YY, to avoid |
275 | infringing on user name space. This should be done even for local | |
276 | variables, as they might otherwise be expanded by user macros. | |
277 | There are some unavoidable exceptions within include files to | |
278 | define necessary library symbols; they are noted "INFRINGES ON | |
279 | USER NAME SPACE" below. */ | |
280 | ||
9c1e26bd | 281 | ]b4_identification |
a4e25e1d | 282 | b4_percent_code_get([[top]])[]dnl |
aa08666d | 283 | m4_if(b4_prefix, [yy], [], |
93d0103d JD |
284 | [[/* Substitute the variable and function names. */]b4_pull_if([[ |
285 | #define yyparse ]b4_prefix[parse]])b4_push_if([[ | |
286 | #define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[ | |
287 | #define yypull_parse ]b4_prefix[pull_parse]])[ | |
288 | #define yypstate_new ]b4_prefix[pstate_new | |
9ca7f077 | 289 | #define yypstate_delete ]b4_prefix[pstate_delete |
93d0103d JD |
290 | #define yypstate ]b4_prefix[pstate]])[ |
291 | #define yylex ]b4_prefix[lex | |
9ca7f077 JD |
292 | #define yyerror ]b4_prefix[error |
293 | #define yylval ]b4_prefix[lval | |
294 | #define yychar ]b4_prefix[char | |
295 | #define yydebug ]b4_prefix[debug | |
296 | #define yynerrs ]b4_prefix[nerrs | |
297 | ]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[ | |
17da6427 | 298 | |
0dd1580a | 299 | /* Copy the first part of user declarations. */ |
136a0f76 | 300 | ]b4_user_pre_prologue[ |
cce71710 | 301 | |
ef51bfa7 AD |
302 | ]b4_null_define[ |
303 | ||
d99361e6 AD |
304 | /* Enabling traces. */ |
305 | #ifndef YYDEBUG | |
327afc7c | 306 | # define YYDEBUG ]b4_debug_flag[ |
d99361e6 AD |
307 | #endif |
308 | ||
309 | /* Enabling verbose error messages. */ | |
310 | #ifdef YYERROR_VERBOSE | |
311 | # undef YYERROR_VERBOSE | |
312 | # define YYERROR_VERBOSE 1 | |
313 | #else | |
327afc7c | 314 | # define YYERROR_VERBOSE ]b4_error_verbose_flag[ |
d99361e6 AD |
315 | #endif |
316 | ||
141f5793 PE |
317 | /* Enabling the token table. */ |
318 | #ifndef YYTOKEN_TABLE | |
319 | # define YYTOKEN_TABLE ]b4_token_table[ | |
320 | #endif | |
321 | ||
0f11eec2 AD |
322 | ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]], |
323 | [b4_shared_declarations])[ | |
9bc0dd67 | 324 | |
ae6bdabb | 325 | /* Copy the second part of user declarations. */ |
8e0a5e9e | 326 | ]b4_user_post_prologue |
a4e25e1d | 327 | b4_percent_code_get[]dnl |
7093d0f5 | 328 | |
8e0a5e9e | 329 | [#ifdef short |
d42cf844 PE |
330 | # undef short |
331 | #endif | |
332 | ||
333 | #ifdef YYTYPE_UINT8 | |
334 | typedef YYTYPE_UINT8 yytype_uint8; | |
335 | #else | |
336 | typedef unsigned char yytype_uint8; | |
337 | #endif | |
338 | ||
339 | #ifdef YYTYPE_INT8 | |
340 | typedef YYTYPE_INT8 yytype_int8; | |
341 | #elif ]b4_c_modern[ | |
342 | typedef signed char yytype_int8; | |
343 | #else | |
344 | typedef short int yytype_int8; | |
345 | #endif | |
346 | ||
347 | #ifdef YYTYPE_UINT16 | |
348 | typedef YYTYPE_UINT16 yytype_uint16; | |
349 | #else | |
350 | typedef unsigned short int yytype_uint16; | |
351 | #endif | |
352 | ||
353 | #ifdef YYTYPE_INT16 | |
354 | typedef YYTYPE_INT16 yytype_int16; | |
355 | #else | |
356 | typedef short int yytype_int16; | |
357 | #endif | |
358 | ||
55289366 | 359 | #ifndef YYSIZE_T |
02650b7f | 360 | # ifdef __SIZE_TYPE__ |
55289366 | 361 | # define YYSIZE_T __SIZE_TYPE__ |
02650b7f | 362 | # elif defined size_t |
55289366 | 363 | # define YYSIZE_T size_t |
02650b7f | 364 | # elif ! defined YYSIZE_T && ]b4_c_modern[ |
55289366 PE |
365 | # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
366 | # define YYSIZE_T size_t | |
367 | # else | |
368 | # define YYSIZE_T unsigned int | |
369 | # endif | |
bedf57f5 | 370 | #endif |
7093d0f5 | 371 | |
b4c1f9d2 PE |
372 | #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
373 | ||
30757c8c | 374 | #ifndef YY_ |
06caf0e1 | 375 | # if defined YYENABLE_NLS && YYENABLE_NLS |
30757c8c PE |
376 | # if ENABLE_NLS |
377 | # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ | |
378 | # define YY_(msgid) dgettext ("bison-runtime", msgid) | |
379 | # endif | |
380 | # endif | |
381 | # ifndef YY_ | |
382 | # define YY_(msgid) msgid | |
383 | # endif | |
384 | #endif | |
385 | ||
2a4647a3 | 386 | /* Suppress unused-variable warnings by "using" E. */ |
02650b7f | 387 | #if ! defined lint || defined __GNUC__ |
12ce2df6 PE |
388 | # define YYUSE(e) ((void) (e)) |
389 | #else | |
390 | # define YYUSE(e) /* empty */ | |
391 | #endif | |
392 | ||
393 | /* Identity function, used to suppress warnings about constant conditions. */ | |
394 | #ifndef lint | |
395 | # define YYID(n) (n) | |
396 | #else | |
cd9e1ba2 | 397 | ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[ |
12ce2df6 | 398 | { |
cd9e1ba2 | 399 | return yyi; |
12ce2df6 PE |
400 | } |
401 | #endif | |
2a4647a3 | 402 | |
723fe7d1 | 403 | #if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[ |
2779e383 | 404 | |
723fe7d1 JD |
405 | /* The parser invokes alloca or malloc; define the necessary symbols. */]dnl |
406 | b4_push_if([], [b4_lac_if([], [[ | |
7093d0f5 | 407 | |
b929851a PE |
408 | # ifdef YYSTACK_USE_ALLOCA |
409 | # if YYSTACK_USE_ALLOCA | |
b929851a PE |
410 | # ifdef __GNUC__ |
411 | # define YYSTACK_ALLOC __builtin_alloca | |
02650b7f | 412 | # elif defined __BUILTIN_VA_ARG_INCR |
55289366 | 413 | # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ |
02650b7f | 414 | # elif defined _AIX |
55289366 | 415 | # define YYSTACK_ALLOC __alloca |
02650b7f | 416 | # elif defined _MSC_VER |
55289366 PE |
417 | # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ |
418 | # define alloca _alloca | |
d7e14fc0 PE |
419 | # else |
420 | # define YYSTACK_ALLOC alloca | |
ea6046b9 | 421 | # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && ]b4_c_modern[ |
bedf57f5 | 422 | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
43e9e2a1 | 423 | /* Use EXIT_SUCCESS as a witness for stdlib.h. */ |
ea6046b9 PE |
424 | # ifndef EXIT_SUCCESS |
425 | # define EXIT_SUCCESS 0 | |
55289366 | 426 | # endif |
bedf57f5 | 427 | # endif |
7093d0f5 AD |
428 | # endif |
429 | # endif | |
723fe7d1 | 430 | # endif]])])[ |
7093d0f5 | 431 | |
723fe7d1 | 432 | # ifdef YYSTACK_ALLOC |
9d9b8b70 | 433 | /* Pacify GCC's `empty if-body' warning. */ |
12ce2df6 | 434 | # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) |
506ffb1f | 435 | # ifndef YYSTACK_ALLOC_MAXIMUM |
b9c9f761 PE |
436 | /* The OS might guarantee only one guard page at the bottom of the stack, |
437 | and a page size can be as small as 4096 bytes. So we cannot safely | |
438 | invoke alloca (N) if N exceeds 4096. Use a slightly smaller number | |
439 | to allow for a few compiler-allocated temporary stack slots. */ | |
e2a21b6f | 440 | # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ |
506ffb1f | 441 | # endif |
7093d0f5 | 442 | # else |
2779e383 PE |
443 | # define YYSTACK_ALLOC YYMALLOC |
444 | # define YYSTACK_FREE YYFREE | |
506ffb1f | 445 | # ifndef YYSTACK_ALLOC_MAXIMUM |
b4c1f9d2 | 446 | # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
506ffb1f | 447 | # endif |
ea6046b9 | 448 | # if (defined __cplusplus && ! defined EXIT_SUCCESS \ |
fc3f467f PE |
449 | && ! ((defined YYMALLOC || defined malloc) \ |
450 | && (defined YYFREE || defined free))) | |
451 | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ | |
ea6046b9 PE |
452 | # ifndef EXIT_SUCCESS |
453 | # define EXIT_SUCCESS 0 | |
fc3f467f | 454 | # endif |
0925ebb4 | 455 | # endif |
bedf57f5 PE |
456 | # ifndef YYMALLOC |
457 | # define YYMALLOC malloc | |
ea6046b9 | 458 | # if ! defined malloc && ! defined EXIT_SUCCESS && ]b4_c_modern[ |
bedf57f5 PE |
459 | void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ |
460 | # endif | |
461 | # endif | |
462 | # ifndef YYFREE | |
463 | # define YYFREE free | |
ea6046b9 | 464 | # if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[ |
bedf57f5 PE |
465 | void free (void *); /* INFRINGES ON USER NAME SPACE */ |
466 | # endif | |
467 | # endif | |
723fe7d1 JD |
468 | # endif]b4_lac_if([[ |
469 | # define YYCOPY_NEEDED 1]])[ | |
470 | #endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[ | |
cf44a9ae PE |
471 | |
472 | ||
02650b7f PE |
473 | #if (! defined yyoverflow \ |
474 | && (! defined __cplusplus \ | |
327afc7c | 475 | || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ |
02650b7f | 476 | && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) |
7093d0f5 | 477 | |
600f9b0c PE |
478 | /* A type that is properly aligned for any stack member. */ |
479 | union yyalloc | |
480 | { | |
9ca7f077 JD |
481 | yytype_int16 yyss_alloc; |
482 | YYSTYPE yyvs_alloc;]b4_locations_if([ | |
483 | YYLTYPE yyls_alloc;])[ | |
484 | }; | |
600f9b0c PE |
485 | |
486 | /* The size of the maximum gap between one aligned stack and the next. */ | |
17836590 | 487 | # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
600f9b0c PE |
488 | |
489 | /* The size of an array large to enough to hold all stacks, each with | |
490 | N elements. */ | |
327afc7c | 491 | ]b4_locations_if( |
58612f1d | 492 | [# define YYSTACK_BYTES(N) \ |
d42cf844 | 493 | ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ |
17836590 | 494 | + 2 * YYSTACK_GAP_MAXIMUM)], |
58612f1d | 495 | [# define YYSTACK_BYTES(N) \ |
d42cf844 | 496 | ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ |
17836590 | 497 | + YYSTACK_GAP_MAXIMUM)])[ |
600f9b0c | 498 | |
723fe7d1 | 499 | # define YYCOPY_NEEDED 1 |
5b041382 PE |
500 | |
501 | /* Relocate STACK from its old location to the new one. The | |
7093d0f5 | 502 | local variables YYSIZE and YYSTACKSIZE give the old and new number of |
600f9b0c PE |
503 | elements in the stack, and YYPTR gives the new location of the |
504 | stack. Advance YYPTR to a properly aligned location for the next | |
505 | stack. */ | |
9ca7f077 | 506 | # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ |
7093d0f5 AD |
507 | do \ |
508 | { \ | |
509 | YYSIZE_T yynewbytes; \ | |
9ca7f077 JD |
510 | YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ |
511 | Stack = &yyptr->Stack_alloc; \ | |
17836590 | 512 | yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
2729e106 | 513 | yyptr += yynewbytes / sizeof (*yyptr); \ |
7093d0f5 | 514 | } \ |
12ce2df6 | 515 | while (YYID (0)) |
7093d0f5 | 516 | |
cf44a9ae | 517 | #endif |
8850be4b | 518 | |
723fe7d1 | 519 | #if defined YYCOPY_NEEDED && YYCOPY_NEEDED |
14f4455e | 520 | /* Copy COUNT objects from SRC to DST. The source and destination do |
723fe7d1 JD |
521 | not overlap. */ |
522 | # ifndef YYCOPY | |
523 | # if defined __GNUC__ && 1 < __GNUC__ | |
14f4455e AD |
524 | # define YYCOPY(Dst, Src, Count) \ |
525 | __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) | |
723fe7d1 | 526 | # else |
14f4455e AD |
527 | # define YYCOPY(Dst, Src, Count) \ |
528 | do \ | |
529 | { \ | |
530 | YYSIZE_T yyi; \ | |
531 | for (yyi = 0; yyi < (Count); yyi++) \ | |
532 | (Dst)[yyi] = (Src)[yyi]; \ | |
533 | } \ | |
723fe7d1 JD |
534 | while (YYID (0)) |
535 | # endif | |
536 | # endif | |
537 | #endif /* !YYCOPY_NEEDED */ | |
538 | ||
9d9b8b70 | 539 | /* YYFINAL -- State number of the termination state. */ |
9c1e26bd | 540 | #define YYFINAL ]b4_final_state_number[ |
39912f52 | 541 | /* YYLAST -- Last index in YYTABLE. */ |
9c1e26bd | 542 | #define YYLAST ]b4_last[ |
7742ddeb | 543 | |
9d9b8b70 | 544 | /* YYNTOKENS -- Number of terminals. */ |
9c1e26bd | 545 | #define YYNTOKENS ]b4_tokens_number[ |
9d9b8b70 | 546 | /* YYNNTS -- Number of nonterminals. */ |
9c1e26bd | 547 | #define YYNNTS ]b4_nterms_number[ |
9d9b8b70 | 548 | /* YYNRULES -- Number of rules. */ |
9c1e26bd | 549 | #define YYNRULES ]b4_rules_number[ |
9d9b8b70 | 550 | /* YYNRULES -- Number of states. */ |
9c1e26bd | 551 | #define YYNSTATES ]b4_states_number[ |
7742ddeb AD |
552 | |
553 | /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ | |
9c1e26bd AD |
554 | #define YYUNDEFTOK ]b4_undef_token_number[ |
555 | #define YYMAXUTOK ]b4_user_token_number_max[ | |
007a50a4 | 556 | |
04098407 | 557 | #define YYTRANSLATE(YYX) \ |
a20713a4 | 558 | ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
a8289c62 | 559 | |
b0400cc6 AD |
560 | /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
561 | static const ]b4_int_type_for([b4_translate])[ yytranslate[] = | |
a8289c62 | 562 | { |
c5e3e510 | 563 | ]b4_translate[ |
a8289c62 RA |
564 | }; |
565 | ||
566 | #if YYDEBUG | |
c5e3e510 | 567 | /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
7742ddeb | 568 | YYRHS. */ |
c5e3e510 | 569 | static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = |
a8289c62 | 570 | { |
c5e3e510 | 571 | ]b4_prhs[ |
a8289c62 RA |
572 | }; |
573 | ||
9d9b8b70 | 574 | /* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
c5e3e510 | 575 | static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = |
a8289c62 | 576 | { |
c5e3e510 | 577 | ]b4_rhs[ |
a8289c62 RA |
578 | }; |
579 | ||
c5e3e510 AD |
580 | /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
581 | static const ]b4_int_type_for([b4_rline])[ yyrline[] = | |
a8289c62 | 582 | { |
c5e3e510 | 583 | ]b4_rline[ |
a8289c62 RA |
584 | }; |
585 | #endif | |
586 | ||
141f5793 | 587 | #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
9e0876fb | 588 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
9d9b8b70 | 589 | First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
c5e3e510 | 590 | static const char *const yytname[] = |
a8289c62 | 591 | { |
c5e3e510 | 592 | ]b4_tname[ |
a8289c62 RA |
593 | }; |
594 | #endif | |
595 | ||
c0ad8bf3 | 596 | # ifdef YYPRINT |
c5e3e510 | 597 | /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
769b430f | 598 | token YYLEX-NUM. */ |
c5e3e510 | 599 | static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = |
a8289c62 | 600 | { |
c5e3e510 | 601 | ]b4_toknum[ |
a8289c62 | 602 | }; |
c0ad8bf3 | 603 | # endif |
a8289c62 | 604 | |
c5e3e510 AD |
605 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
606 | static const ]b4_int_type_for([b4_r1])[ yyr1[] = | |
a8289c62 | 607 | { |
c5e3e510 | 608 | ]b4_r1[ |
a8289c62 RA |
609 | }; |
610 | ||
c5e3e510 AD |
611 | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
612 | static const ]b4_int_type_for([b4_r2])[ yyr2[] = | |
a8289c62 | 613 | { |
c5e3e510 | 614 | ]b4_r2[ |
a8289c62 RA |
615 | }; |
616 | ||
620b5727 JD |
617 | /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM. |
618 | Performed when YYTABLE doesn't specify something else to do. Zero | |
5504898e | 619 | means the default is an error. */ |
c5e3e510 | 620 | static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
a8289c62 | 621 | { |
c5e3e510 | 622 | ]b4_defact[ |
a8289c62 RA |
623 | }; |
624 | ||
9d9b8b70 | 625 | /* YYDEFGOTO[NTERM-NUM]. */ |
c5e3e510 | 626 | static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = |
a8289c62 | 627 | { |
c5e3e510 | 628 | ]b4_defgoto[ |
a8289c62 RA |
629 | }; |
630 | ||
c5e3e510 | 631 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
7742ddeb | 632 | STATE-NUM. */ |
c5e3e510 AD |
633 | #define YYPACT_NINF ]b4_pact_ninf[ |
634 | static const ]b4_int_type_for([b4_pact])[ yypact[] = | |
a8289c62 | 635 | { |
c5e3e510 | 636 | ]b4_pact[ |
a8289c62 RA |
637 | }; |
638 | ||
c5e3e510 AD |
639 | /* YYPGOTO[NTERM-NUM]. */ |
640 | static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = | |
a8289c62 | 641 | { |
c5e3e510 | 642 | ]b4_pgoto[ |
a8289c62 RA |
643 | }; |
644 | ||
c5e3e510 | 645 | /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
7742ddeb | 646 | positive, shift that token. If negative, reduce the rule which |
e4bcae3c | 647 | number is the opposite. If YYTABLE_NINF, syntax error. */ |
c5e3e510 AD |
648 | #define YYTABLE_NINF ]b4_table_ninf[ |
649 | static const ]b4_int_type_for([b4_table])[ yytable[] = | |
a8289c62 | 650 | { |
c5e3e510 | 651 | ]b4_table[ |
a8289c62 RA |
652 | }; |
653 | ||
d5eb0826 | 654 | #define yypact_value_is_default(yystate) \ |
77373efa JD |
655 | ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[ |
656 | ||
d5eb0826 | 657 | #define yytable_value_is_error(yytable_value) \ |
e4bcae3c | 658 | ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[ |
77373efa | 659 | |
c5e3e510 | 660 | static const ]b4_int_type_for([b4_check])[ yycheck[] = |
a8289c62 | 661 | { |
c5e3e510 | 662 | ]b4_check[ |
a8289c62 RA |
663 | }; |
664 | ||
c5e3e510 | 665 | /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
5504898e | 666 | symbol of state STATE-NUM. */ |
c5e3e510 | 667 | static const ]b4_int_type_for([b4_stos])[ yystos[] = |
5504898e | 668 | { |
c5e3e510 | 669 | ]b4_stos[ |
5504898e | 670 | }; |
7093d0f5 | 671 | |
10fa2066 | 672 | #define yyerrok (yyerrstatus = 0) |
a20713a4 PE |
673 | #define yyclearin (yychar = YYEMPTY) |
674 | #define YYEMPTY (-2) | |
10fa2066 | 675 | #define YYEOF 0 |
a8289c62 | 676 | |
70ddf897 | 677 | #define YYACCEPT goto yyacceptlab |
a8289c62 | 678 | #define YYABORT goto yyabortlab |
a6b89bb2 | 679 | #define YYERROR goto yyerrorlab |
8a3eb3c8 | 680 | |
a8289c62 | 681 | |
71da9eea AD |
682 | /* Like YYERROR except do call yyerror. This remains here temporarily |
683 | to ease the transition to the new meaning of YYERROR, for GCC. | |
41d35e54 JD |
684 | Once GCC version 2 has supplanted version 1, this can go. However, |
685 | YYFAIL appears to be in use. Nevertheless, it is formally deprecated | |
686 | in Bison 2.4.2's NEWS entry, where a plan to phase it out is | |
687 | discussed. */ | |
a8289c62 | 688 | |
10fa2066 | 689 | #define YYFAIL goto yyerrlab |
41d35e54 JD |
690 | #if defined YYFAIL |
691 | /* This is here to suppress warnings from the GCC cpp's | |
692 | -Wunused-macros. Normally we don't worry about that warning, but | |
693 | some users do, and we want to make it easy for users to remove | |
694 | YYFAIL uses, which will produce warnings from Bison 2.5. */ | |
695 | #endif | |
a8289c62 | 696 | |
10fa2066 | 697 | #define YYRECOVERING() (!!yyerrstatus) |
a8289c62 | 698 | |
94556574 AD |
699 | #define YYBACKUP(Token, Value) \ |
700 | do \ | |
701 | if (yychar == YYEMPTY) \ | |
702 | { \ | |
703 | yychar = (Token); \ | |
704 | yylval = (Value); \ | |
705 | YYPOPSTACK (yylen); \ | |
706 | yystate = *yyssp; \]b4_lac_if([[ | |
707 | YY_LAC_DISCARD ("YYBACKUP"); \]])[ | |
708 | goto yybackup; \ | |
709 | } \ | |
710 | else \ | |
711 | { \ | |
30757c8c | 712 | yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ |
71da9eea AD |
713 | YYERROR; \ |
714 | } \ | |
12ce2df6 | 715 | while (YYID (0)) |
10fa2066 | 716 | |
3fc16193 | 717 | |
10fa2066 RS |
718 | #define YYTERROR 1 |
719 | #define YYERRCODE 256 | |
720 | ||
3fc16193 | 721 | |
b4a20338 AD |
722 | /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
723 | If N is 0, then set CURRENT to the empty location which ends | |
724 | the previous symbol: RHS[0] (always defined). */ | |
3abcd459 | 725 | |
24e0cbd0 | 726 | #define YYRHSLOC(Rhs, K) ((Rhs)[K]) |
3abcd459 | 727 | #ifndef YYLLOC_DEFAULT |
24e0cbd0 PE |
728 | # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
729 | do \ | |
d6cff4dc | 730 | if (YYID (N)) \ |
24e0cbd0 | 731 | { \ |
9bec482e PE |
732 | (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
733 | (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | |
734 | (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | |
735 | (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | |
24e0cbd0 PE |
736 | } \ |
737 | else \ | |
738 | { \ | |
739 | (Current).first_line = (Current).last_line = \ | |
9bec482e | 740 | YYRHSLOC (Rhs, 0).last_line; \ |
24e0cbd0 | 741 | (Current).first_column = (Current).last_column = \ |
9bec482e | 742 | YYRHSLOC (Rhs, 0).last_column; \ |
24e0cbd0 | 743 | } \ |
12ce2df6 | 744 | while (YYID (0)) |
3bba2dad JD |
745 | #endif]b4_locations_if([[ |
746 | ||
b8458aa5 | 747 | |
3fc16193 AD |
748 | /* YY_LOCATION_PRINT -- Print the location on the stream. |
749 | This macro was not mandated originally: define only if we know | |
750 | we won't break user code: when these are the locations we know. */ | |
751 | ||
3fc16193 | 752 | #ifndef YY_LOCATION_PRINT |
06caf0e1 | 753 | # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL |
b8458aa5 AD |
754 | # define YY_LOCATION_PRINT(File, Loc) \ |
755 | fprintf (File, "%d.%d-%d.%d", \ | |
02650b7f PE |
756 | (Loc).first_line, (Loc).first_column, \ |
757 | (Loc).last_line, (Loc).last_column) | |
0dcca5c2 AD |
758 | # else |
759 | # define YY_LOCATION_PRINT(File, Loc) ((void) 0) | |
b8458aa5 | 760 | # endif |
3bba2dad JD |
761 | #endif]], [[ |
762 | ||
763 | ||
874ac415 | 764 | /* This macro is provided for backward compatibility. */ |
3abcd459 | 765 | |
874ac415 JN |
766 | #ifndef YY_LOCATION_PRINT |
767 | # define YY_LOCATION_PRINT(File, Loc) ((void) 0) | |
3bba2dad JD |
768 | #endif]])[ |
769 | ||
3fc16193 | 770 | |
3abcd459 | 771 | /* YYLEX -- calling `yylex' with the right arguments. */ |
553e2b22 | 772 | |
ae7453f2 | 773 | #ifdef YYLEX_PARAM |
327afc7c | 774 | # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM) |
74310291 | 775 | #else |
9c1e26bd | 776 | # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ |
ae7453f2 | 777 | #endif |
553e2b22 | 778 | |
5a35a6cb | 779 | /* Enable debugging if requested. */ |
0d533154 | 780 | #if YYDEBUG |
b7575ffe | 781 | |
2f4f028d | 782 | # ifndef YYFPRINTF |
45119af1 PE |
783 | # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
784 | # define YYFPRINTF fprintf | |
b7575ffe PE |
785 | # endif |
786 | ||
5a35a6cb AD |
787 | # define YYDPRINTF(Args) \ |
788 | do { \ | |
17da6427 | 789 | if (yydebug) \ |
b7575ffe | 790 | YYFPRINTF Args; \ |
12ce2df6 | 791 | } while (YYID (0)) |
c5e3e510 | 792 | |
4b367315 AD |
793 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
794 | do { \ | |
795 | if (yydebug) \ | |
796 | { \ | |
797 | YYFPRINTF (stderr, "%s ", Title); \ | |
a0af42fc | 798 | yy_symbol_print (stderr, \ |
327afc7c | 799 | Type, Value]b4_locations_if([, Location])[]b4_user_args[); \ |
4b367315 AD |
800 | YYFPRINTF (stderr, "\n"); \ |
801 | } \ | |
12ce2df6 | 802 | } while (YYID (0)) |
9c1e26bd | 803 | |
a0af42fc | 804 | ]b4_yy_symbol_print_generate([b4_c_function_def])[ |
d1ff7a7c | 805 | |
b0937b22 AD |
806 | /*------------------------------------------------------------------. |
807 | | yy_stack_print -- Print the state stack from its BOTTOM up to its | | |
5348bfbe | 808 | | TOP (included). | |
b0937b22 AD |
809 | `------------------------------------------------------------------*/ |
810 | ||
811 | ]b4_c_function_def([yy_stack_print], [static void], | |
cd9e1ba2 PE |
812 | [[yytype_int16 *yybottom], [yybottom]], |
813 | [[yytype_int16 *yytop], [yytop]])[ | |
b0937b22 | 814 | { |
2f4f028d | 815 | YYFPRINTF (stderr, "Stack now"); |
cd9e1ba2 PE |
816 | for (; yybottom <= yytop; yybottom++) |
817 | { | |
818 | int yybot = *yybottom; | |
819 | YYFPRINTF (stderr, " %d", yybot); | |
820 | } | |
2f4f028d | 821 | YYFPRINTF (stderr, "\n"); |
b0937b22 AD |
822 | } |
823 | ||
824 | # define YY_STACK_PRINT(Bottom, Top) \ | |
825 | do { \ | |
826 | if (yydebug) \ | |
827 | yy_stack_print ((Bottom), (Top)); \ | |
12ce2df6 | 828 | } while (YYID (0)) |
b0937b22 AD |
829 | |
830 | ||
831 | /*------------------------------------------------. | |
832 | | Report that the YYRULE is going to be reduced. | | |
833 | `------------------------------------------------*/ | |
834 | ||
835 | ]b4_c_function_def([yy_reduce_print], [static void], | |
02650b7f | 836 | [[YYSTYPE *yyvsp], [yyvsp]], |
aefef0d6 PE |
837 | b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], |
838 | ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, | |
9ca7f077 | 839 | b4_parse_param]))[ |
b0937b22 | 840 | { |
d1ff7a7c | 841 | int yynrhs = yyr2[yyrule]; |
b0937b22 | 842 | int yyi; |
30757c8c | 843 | unsigned long int yylno = yyrline[yyrule]; |
d1ff7a7c | 844 | YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", |
02650b7f | 845 | yyrule - 1, yylno); |
d1ff7a7c AD |
846 | /* The symbols being reduced. */ |
847 | for (yyi = 0; yyi < yynrhs; yyi++) | |
848 | { | |
f57a7536 | 849 | YYFPRINTF (stderr, " $%d = ", yyi + 1); |
a0af42fc | 850 | yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
02650b7f | 851 | &]b4_rhs_value(yynrhs, yyi + 1)[ |
327afc7c | 852 | ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl |
02650b7f | 853 | b4_user_args[); |
f57a7536 | 854 | YYFPRINTF (stderr, "\n"); |
d1ff7a7c | 855 | } |
b0937b22 AD |
856 | } |
857 | ||
d9963c85 PE |
858 | # define YY_REDUCE_PRINT(Rule) \ |
859 | do { \ | |
860 | if (yydebug) \ | |
327afc7c | 861 | yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ |
12ce2df6 | 862 | } while (YYID (0)) |
b0937b22 | 863 | |
cf44a9ae PE |
864 | /* Nonzero means print parse trace. It is left uninitialized so that |
865 | multiple parsers can coexist. */ | |
17da6427 | 866 | int yydebug; |
5a35a6cb AD |
867 | #else /* !YYDEBUG */ |
868 | # define YYDPRINTF(Args) | |
284acc8b | 869 | # define YY_SYMBOL_PRINT(Title, Type, Value, Location) |
b0937b22 | 870 | # define YY_STACK_PRINT(Bottom, Top) |
d9963c85 | 871 | # define YY_REDUCE_PRINT(Rule) |
5a35a6cb AD |
872 | #endif /* !YYDEBUG */ |
873 | ||
b0937b22 | 874 | |
5a35a6cb | 875 | /* YYINITDEPTH -- initial size of the parser's stacks. */ |
10fa2066 | 876 | #ifndef YYINITDEPTH |
9c1e26bd | 877 | # define YYINITDEPTH ]b4_stack_depth_init[ |
10fa2066 RS |
878 | #endif |
879 | ||
5a35a6cb | 880 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
600f9b0c PE |
881 | if the built-in stack extension method is used). |
882 | ||
883 | Do not make this value too large; the results are undefined if | |
506ffb1f | 884 | YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) |
600f9b0c PE |
885 | evaluated with infinite-precision integer arithmetic. */ |
886 | ||
10fa2066 | 887 | #ifndef YYMAXDEPTH |
9c1e26bd | 888 | # define YYMAXDEPTH ]b4_stack_depth_max[ |
ea13bea8 JD |
889 | #endif]b4_lac_if([[ |
890 | ||
723fe7d1 JD |
891 | /* Given a state stack such that *YYBOTTOM is its bottom, such that |
892 | *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty | |
893 | stack, and such that *YYCAPACITY is the maximum number of elements it | |
894 | can hold without a reallocation, make sure there is enough room to | |
895 | store YYADD more elements. If not, allocate a new stack using | |
896 | YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM, | |
897 | *YYTOP, and *YYCAPACITY to reflect the new capacity and memory | |
898 | location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack | |
899 | using YYSTACK_FREE. Return 0 if successful or if no reallocation is | |
900 | required. Return 1 if memory is exhausted. */ | |
901 | static int | |
902 | yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd, | |
903 | #if YYDEBUG | |
904 | char const *yydebug_prefix, | |
905 | char const *yydebug_suffix, | |
906 | #endif | |
907 | yytype_int16 **yybottom, | |
908 | yytype_int16 *yybottom_no_free, | |
909 | yytype_int16 **yytop, yytype_int16 *yytop_empty) | |
910 | { | |
911 | YYSIZE_T yysize_old = | |
912 | *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1; | |
913 | YYSIZE_T yysize_new = yysize_old + yyadd; | |
914 | if (*yycapacity < yysize_new) | |
915 | { | |
916 | YYSIZE_T yyalloc = 2 * yysize_new; | |
917 | yytype_int16 *yybottom_new; | |
918 | /* Use YYMAXDEPTH for maximum stack size given that the stack | |
919 | should never need to grow larger than the main state stack | |
920 | needs to grow without LAC. */ | |
921 | if (YYMAXDEPTH < yysize_new) | |
922 | { | |
923 | YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix, | |
924 | yydebug_suffix)); | |
925 | return 1; | |
926 | } | |
927 | if (YYMAXDEPTH < yyalloc) | |
928 | yyalloc = YYMAXDEPTH; | |
929 | yybottom_new = | |
930 | (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new); | |
931 | if (!yybottom_new) | |
932 | { | |
933 | YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix, | |
934 | yydebug_suffix)); | |
935 | return 1; | |
936 | } | |
937 | if (*yytop != yytop_empty) | |
938 | { | |
939 | YYCOPY (yybottom_new, *yybottom, yysize_old); | |
940 | *yytop = yybottom_new + (yysize_old - 1); | |
941 | } | |
942 | if (*yybottom != yybottom_no_free) | |
943 | YYSTACK_FREE (*yybottom); | |
944 | *yybottom = yybottom_new; | |
945 | *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), | |
946 | [full], [[ | |
947 | YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix, | |
948 | (unsigned long int) yyalloc, yydebug_suffix));]])[ | |
949 | } | |
950 | return 0; | |
951 | } | |
952 | ||
ea13bea8 JD |
953 | /* Establish the initial context for the current lookahead if no initial |
954 | context is currently established. | |
955 | ||
956 | We define a context as a snapshot of the parser stacks. We define | |
957 | the initial context for a lookahead as the context in which the | |
958 | parser initially examines that lookahead in order to select a | |
959 | syntactic action. Thus, if the lookahead eventually proves | |
960 | syntactically unacceptable (possibly in a later context reached via a | |
961 | series of reductions), the initial context can be used to determine | |
962 | the exact set of tokens that would be syntactically acceptable in the | |
963 | lookahead's place. Moreover, it is the context after which any | |
964 | further semantic actions would be erroneous because they would be | |
965 | determined by a syntactically unacceptable token. | |
966 | ||
967 | YY_LAC_ESTABLISH should be invoked when a reduction is about to be | |
968 | performed in an inconsistent state (which, for the purposes of LAC, | |
969 | includes consistent states that don't know they're consistent because | |
970 | their default reductions have been disabled). Iff there is a | |
971 | lookahead token, it should also be invoked before reporting a syntax | |
972 | error. This latter case is for the sake of the debugging output. | |
973 | ||
974 | For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as | |
975 | follows. If no initial context is currently established for the | |
976 | current lookahead, then check if that lookahead can eventually be | |
977 | shifted if syntactic actions continue from the current context. | |
978 | Report a syntax error if it cannot. */ | |
723fe7d1 JD |
979 | #define YY_LAC_ESTABLISH \ |
980 | do { \ | |
981 | if (!yy_lac_established) \ | |
982 | { \ | |
983 | YYDPRINTF ((stderr, \ | |
984 | "LAC: initial context established for %s\n", \ | |
985 | yytname[yytoken])); \ | |
986 | yy_lac_established = 1; \ | |
987 | { \ | |
988 | int yy_lac_status = \ | |
989 | yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \ | |
990 | if (yy_lac_status == 2) \ | |
991 | goto yyexhaustedlab; \ | |
992 | if (yy_lac_status == 1) \ | |
993 | goto yyerrlab; \ | |
994 | } \ | |
995 | } \ | |
ea13bea8 JD |
996 | } while (YYID (0)) |
997 | ||
998 | /* Discard any previous initial lookahead context because of Event, | |
999 | which may be a lookahead change or an invalidation of the currently | |
1000 | established initial context for the current lookahead. | |
1001 | ||
1002 | The most common example of a lookahead change is a shift. An example | |
1003 | of both cases is syntax error recovery. That is, a syntax error | |
1004 | occurs when the lookahead is syntactically erroneous for the | |
1005 | currently established initial context, so error recovery manipulates | |
1006 | the parser stacks to try to find a new initial context in which the | |
1007 | current lookahead is syntactically acceptable. If it fails to find | |
1008 | such a context, it discards the lookahead. */ | |
1009 | #if YYDEBUG | |
1010 | # define YY_LAC_DISCARD(Event) \ | |
1011 | do { \ | |
1012 | if (yy_lac_established) \ | |
1013 | { \ | |
1014 | if (yydebug) \ | |
1015 | YYFPRINTF (stderr, "LAC: initial context discarded due to " \ | |
1016 | Event "\n"); \ | |
1017 | yy_lac_established = 0; \ | |
1018 | } \ | |
1019 | } while (YYID (0)) | |
1020 | #else | |
1021 | # define YY_LAC_DISCARD(Event) yy_lac_established = 0 | |
10fa2066 | 1022 | #endif |
a8289c62 | 1023 | |
ea13bea8 | 1024 | /* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can |
723fe7d1 JD |
1025 | eventually (after perhaps some reductions) be shifted, return 1 if |
1026 | not, or return 2 if memory is exhausted. As preconditions and | |
1027 | postconditions: *YYES_CAPACITY is the allocated size of the array to | |
1028 | which *YYES points, and either *YYES = YYESA or *YYES points to an | |
1029 | array allocated with YYSTACK_ALLOC. yy_lac may overwrite the | |
1030 | contents of either array, alter *YYES and *YYES_CAPACITY, and free | |
1031 | any old *YYES other than YYESA. */ | |
ea13bea8 | 1032 | static int |
723fe7d1 JD |
1033 | yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes, |
1034 | YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken) | |
ea13bea8 JD |
1035 | { |
1036 | yytype_int16 *yyes_prev = yyssp; | |
ea13bea8 JD |
1037 | yytype_int16 *yyesp = yyes_prev; |
1038 | YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken])); | |
1039 | if (yytoken == YYUNDEFTOK) | |
1040 | { | |
1041 | YYDPRINTF ((stderr, " Always Err\n")); | |
1042 | return 1; | |
1043 | } | |
1044 | while (1) | |
1045 | { | |
1046 | int yyrule = yypact[*yyesp]; | |
1047 | if (yypact_value_is_default (yyrule) | |
1048 | || (yyrule += yytoken) < 0 || YYLAST < yyrule | |
1049 | || yycheck[yyrule] != yytoken) | |
1050 | { | |
1051 | yyrule = yydefact[*yyesp]; | |
1052 | if (yyrule == 0) | |
1053 | { | |
1054 | YYDPRINTF ((stderr, " Err\n")); | |
1055 | return 1; | |
1056 | } | |
1057 | } | |
1058 | else | |
1059 | { | |
1060 | yyrule = yytable[yyrule]; | |
1061 | if (yytable_value_is_error (yyrule)) | |
1062 | { | |
1063 | YYDPRINTF ((stderr, " Err\n")); | |
1064 | return 1; | |
1065 | } | |
1066 | if (0 < yyrule) | |
1067 | { | |
1068 | YYDPRINTF ((stderr, " S%d\n", yyrule)); | |
1069 | return 0; | |
1070 | } | |
1071 | yyrule = -yyrule; | |
1072 | } | |
1073 | { | |
1074 | YYSIZE_T yylen = yyr2[yyrule]; | |
1075 | YYDPRINTF ((stderr, " R%d", yyrule - 1)); | |
1076 | if (yyesp != yyes_prev) | |
1077 | { | |
723fe7d1 | 1078 | YYSIZE_T yysize = yyesp - *yyes + 1; |
ea13bea8 JD |
1079 | if (yylen < yysize) |
1080 | { | |
1081 | yyesp -= yylen; | |
1082 | yylen = 0; | |
1083 | } | |
1084 | else | |
1085 | { | |
1086 | yylen -= yysize; | |
1087 | yyesp = yyes_prev; | |
1088 | } | |
1089 | } | |
1090 | if (yylen) | |
1091 | yyesp = yyes_prev -= yylen; | |
1092 | } | |
1093 | { | |
1094 | int yystate; | |
1095 | { | |
1096 | int yylhs = yyr1[yyrule] - YYNTOKENS; | |
1097 | yystate = yypgoto[yylhs] + *yyesp; | |
1098 | if (yystate < 0 || YYLAST < yystate | |
1099 | || yycheck[yystate] != *yyesp) | |
1100 | yystate = yydefgoto[yylhs]; | |
1101 | else | |
1102 | yystate = yytable[yystate]; | |
1103 | } | |
1104 | if (yyesp == yyes_prev) | |
1105 | { | |
723fe7d1 | 1106 | yyesp = *yyes; |
ea13bea8 JD |
1107 | *yyesp = yystate; |
1108 | } | |
1109 | else | |
1110 | { | |
723fe7d1 JD |
1111 | if (yy_lac_stack_realloc (yyes_capacity, 1, |
1112 | #if YYDEBUG | |
1113 | " (", ")", | |
1114 | #endif | |
1115 | yyes, yyesa, &yyesp, yyes_prev)) | |
ea13bea8 | 1116 | { |
723fe7d1 | 1117 | YYDPRINTF ((stderr, "\n")); |
ea13bea8 JD |
1118 | return 2; |
1119 | } | |
1120 | *++yyesp = yystate; | |
1121 | } | |
7e5ef706 | 1122 | YYDPRINTF ((stderr, " G%d", yystate)); |
ea13bea8 JD |
1123 | } |
1124 | } | |
1125 | }]])[ | |
1126 | ||
a8289c62 | 1127 | |
7093d0f5 AD |
1128 | #if YYERROR_VERBOSE |
1129 | ||
1130 | # ifndef yystrlen | |
02650b7f | 1131 | # if defined __GLIBC__ && defined _STRING_H |
7093d0f5 AD |
1132 | # define yystrlen strlen |
1133 | # else | |
1134 | /* Return the length of YYSTR. */ | |
1b9c21fb PE |
1135 | ]b4_c_function_def([yystrlen], [static YYSIZE_T], |
1136 | [[const char *yystr], [yystr]])[ | |
7093d0f5 | 1137 | { |
12ce2df6 PE |
1138 | YYSIZE_T yylen; |
1139 | for (yylen = 0; yystr[yylen]; yylen++) | |
7093d0f5 | 1140 | continue; |
12ce2df6 | 1141 | return yylen; |
7093d0f5 AD |
1142 | } |
1143 | # endif | |
1144 | # endif | |
1145 | ||
1146 | # ifndef yystpcpy | |
02650b7f | 1147 | # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE |
7093d0f5 AD |
1148 | # define yystpcpy stpcpy |
1149 | # else | |
1150 | /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in | |
1151 | YYDEST. */ | |
1b9c21fb PE |
1152 | ]b4_c_function_def([yystpcpy], [static char *], |
1153 | [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[ | |
7093d0f5 | 1154 | { |
cb530ce9 PE |
1155 | char *yyd = yydest; |
1156 | const char *yys = yysrc; | |
7093d0f5 AD |
1157 | |
1158 | while ((*yyd++ = *yys++) != '\0') | |
1159 | continue; | |
1160 | ||
1161 | return yyd - 1; | |
1162 | } | |
1163 | # endif | |
1164 | # endif | |
1165 | ||
9e0876fb PE |
1166 | # ifndef yytnamerr |
1167 | /* Copy to YYRES the contents of YYSTR after stripping away unnecessary | |
1168 | quotes and backslashes, so that it's suitable for yyerror. The | |
1169 | heuristic is that double-quoting is unnecessary unless the string | |
1170 | contains an apostrophe, a comma, or backslash (other than | |
1171 | backslash-backslash). YYSTR is taken from yytname. If YYRES is | |
1172 | null, do not copy; instead, return the length of what the result | |
1173 | would have been. */ | |
1174 | static YYSIZE_T | |
1175 | yytnamerr (char *yyres, const char *yystr) | |
1176 | { | |
1177 | if (*yystr == '"') | |
1178 | { | |
276f48df | 1179 | YYSIZE_T yyn = 0; |
9e0876fb PE |
1180 | char const *yyp = yystr; |
1181 | ||
1182 | for (;;) | |
1183 | switch (*++yyp) | |
1184 | { | |
1185 | case '\'': | |
1186 | case ',': | |
1187 | goto do_not_strip_quotes; | |
1188 | ||
1189 | case '\\': | |
1190 | if (*++yyp != '\\') | |
1191 | goto do_not_strip_quotes; | |
1192 | /* Fall through. */ | |
1193 | default: | |
1194 | if (yyres) | |
1195 | yyres[yyn] = *yyp; | |
1196 | yyn++; | |
1197 | break; | |
1198 | ||
1199 | case '"': | |
1200 | if (yyres) | |
1201 | yyres[yyn] = '\0'; | |
1202 | return yyn; | |
1203 | } | |
1204 | do_not_strip_quotes: ; | |
1205 | } | |
1206 | ||
1207 | if (! yyres) | |
1208 | return yystrlen (yystr); | |
1209 | ||
1210 | return yystpcpy (yyres, yystr) - yyres; | |
1211 | } | |
1212 | # endif | |
1213 | ||
69a2ab11 | 1214 | /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message |
ea13bea8 JD |
1215 | about the unexpected token YYTOKEN for the state stack whose top is |
1216 | YYSSP.]b4_lac_if([[ In order to see if a particular token T is a | |
723fe7d1 | 1217 | valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[ |
69a2ab11 | 1218 | |
095a1d11 JD |
1219 | Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is |
1220 | not large enough to hold the message. In that case, also set | |
1221 | *YYMSG_ALLOC to the required number of bytes. Return 2 if the | |
ea13bea8 JD |
1222 | required number of bytes is too large to store]b4_lac_if([[ or if |
1223 | yy_lac returned 2]])[. */ | |
69a2ab11 JD |
1224 | static int |
1225 | yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, | |
723fe7d1 JD |
1226 | ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes, |
1227 | YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken) | |
f953cb20 | 1228 | { |
6557bcce | 1229 | YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]); |
f953cb20 JD |
1230 | YYSIZE_T yysize = yysize0; |
1231 | YYSIZE_T yysize1; | |
1232 | enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; | |
1233 | /* Internationalized format string. */ | |
6557bcce | 1234 | const char *yyformat = YY_NULL; |
f953cb20 JD |
1235 | /* Arguments of yyformat. */ |
1236 | char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; | |
095a1d11 JD |
1237 | /* Number of reported tokens (one for the "unexpected", one per |
1238 | "expected"). */ | |
1239 | int yycount = 0; | |
f953cb20 | 1240 | |
095a1d11 JD |
1241 | /* There are many possibilities here to consider: |
1242 | - Assume YYFAIL is not used. It's too flawed to consider. See | |
1243 | <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html> | |
1244 | for details. YYERROR is fine as it does not invoke this | |
1245 | function. | |
1246 | - If this state is a consistent state with a default action, then | |
1247 | the only way this function was invoked is if the default action | |
1248 | is an error action. In that case, don't check for expected | |
1249 | tokens because there are none. | |
1250 | - The only way there can be no lookahead present (in yychar) is if | |
1251 | this state is a consistent state with a default action. Thus, | |
1252 | detecting the absence of a lookahead is sufficient to determine | |
1253 | that there is no unexpected or expected token to report. In that | |
1254 | case, just report a simple "syntax error". | |
1255 | - Don't assume there isn't a lookahead just because this state is a | |
1256 | consistent state with a default action. There might have been a | |
1257 | previous inconsistent state, consistent state with a non-default | |
ea13bea8 JD |
1258 | action, or user semantic action that manipulated yychar.]b4_lac_if([[ |
1259 | In the first two cases, it might appear that the current syntax | |
1260 | error should have been detected in the previous state when yy_lac | |
1261 | was invoked. However, at that time, there might have been a | |
1262 | different syntax error that discarded a different initial context | |
1263 | during error recovery, leaving behind the current lookahead.]], [[ | |
095a1d11 JD |
1264 | - Of course, the expected token list depends on states to have |
1265 | correct lookahead information, and it depends on the parser not | |
1266 | to perform extra reductions after fetching a lookahead from the | |
1267 | scanner and before detecting a syntax error. Thus, state merging | |
1268 | (from LALR or IELR) and default reductions corrupt the expected | |
1269 | token list. However, the list is correct for canonical LR with | |
1270 | one exception: it will still contain any token that will not be | |
ea13bea8 | 1271 | accepted due to an error action in a later state.]])[ |
095a1d11 JD |
1272 | */ |
1273 | if (yytoken != YYEMPTY) | |
1274 | { | |
ea13bea8 JD |
1275 | int yyn = yypact[*yyssp];]b4_lac_if([[ |
1276 | YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[ | |
095a1d11 JD |
1277 | yyarg[yycount++] = yytname[yytoken]; |
1278 | if (!yypact_value_is_default (yyn)) | |
ea13bea8 | 1279 | {]b4_lac_if([], [[ |
f953cb20 JD |
1280 | /* Start YYX at -YYN if negative to avoid negative indexes in |
1281 | YYCHECK. In other words, skip the first -YYN actions for | |
1282 | this state because they are default actions. */ | |
1283 | int yyxbegin = yyn < 0 ? -yyn : 0; | |
f953cb20 JD |
1284 | /* Stay within bounds of both yycheck and yytname. */ |
1285 | int yychecklim = YYLAST - yyn + 1; | |
ea13bea8 JD |
1286 | int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;]])[ |
1287 | int yyx;]b4_lac_if([[ | |
1288 | ||
1289 | for (yyx = 0; yyx < YYNTOKENS; ++yyx) | |
1290 | if (yyx != YYTERROR && yyx != YYUNDEFTOK) | |
1291 | { | |
1292 | { | |
723fe7d1 JD |
1293 | int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity, |
1294 | yyssp, yyx); | |
ea13bea8 JD |
1295 | if (yy_lac_status == 2) |
1296 | return 2; | |
1297 | if (yy_lac_status == 1) | |
1298 | continue; | |
1299 | }]], [[ | |
1300 | ||
f953cb20 JD |
1301 | for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
1302 | if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR | |
1303 | && !yytable_value_is_error (yytable[yyx + yyn])) | |
ea13bea8 | 1304 | {]])[ |
f953cb20 JD |
1305 | if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
1306 | { | |
1307 | yycount = 1; | |
1308 | yysize = yysize0; | |
1309 | break; | |
1310 | } | |
1311 | yyarg[yycount++] = yytname[yyx]; | |
6557bcce | 1312 | yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]); |
095a1d11 JD |
1313 | if (! (yysize <= yysize1 |
1314 | && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) | |
1315 | return 2; | |
f953cb20 JD |
1316 | yysize = yysize1; |
1317 | } | |
ea13bea8 JD |
1318 | }]b4_lac_if([[ |
1319 | # if YYDEBUG | |
1320 | else if (yydebug) | |
1321 | YYFPRINTF (stderr, "No expected tokens.\n"); | |
1322 | # endif]])[ | |
095a1d11 | 1323 | } |
f953cb20 JD |
1324 | |
1325 | switch (yycount) | |
b4c1f9d2 | 1326 | { |
ea13bea8 | 1327 | # define YYCASE_(N, S) \ |
f953cb20 JD |
1328 | case N: \ |
1329 | yyformat = S; \ | |
1330 | break | |
095a1d11 | 1331 | YYCASE_(0, YY_("syntax error")); |
f953cb20 JD |
1332 | YYCASE_(1, YY_("syntax error, unexpected %s")); |
1333 | YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); | |
1334 | YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); | |
1335 | YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); | |
1336 | YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); | |
ea13bea8 | 1337 | # undef YYCASE_ |
f953cb20 | 1338 | } |
d3d3628b | 1339 | |
f953cb20 JD |
1340 | yysize1 = yysize + yystrlen (yyformat); |
1341 | if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) | |
095a1d11 | 1342 | return 2; |
f953cb20 JD |
1343 | yysize = yysize1; |
1344 | ||
1345 | if (*yymsg_alloc < yysize) | |
1346 | { | |
1347 | *yymsg_alloc = 2 * yysize; | |
1348 | if (! (yysize <= *yymsg_alloc | |
1349 | && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) | |
1350 | *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; | |
095a1d11 | 1351 | return 1; |
f953cb20 JD |
1352 | } |
1353 | ||
1354 | /* Avoid sprintf, as that infringes on the user's name space. | |
1355 | Don't have undefined behavior even if the translation | |
1356 | produced a string with the wrong number of "%s"s. */ | |
1357 | { | |
1358 | char *yyp = *yymsg; | |
1359 | int yyi = 0; | |
1360 | while ((*yyp = *yyformat) != '\0') | |
1361 | if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) | |
69a2ab11 | 1362 | { |
f953cb20 JD |
1363 | yyp += yytnamerr (yyp, yyarg[yyi++]); |
1364 | yyformat += 2; | |
69a2ab11 | 1365 | } |
f953cb20 | 1366 | else |
69a2ab11 | 1367 | { |
f953cb20 JD |
1368 | yyp++; |
1369 | yyformat++; | |
69a2ab11 | 1370 | } |
f953cb20 JD |
1371 | } |
1372 | return 0; | |
1373 | } | |
b4c1f9d2 | 1374 | #endif /* YYERROR_VERBOSE */ |
a8289c62 | 1375 | |
93d0103d | 1376 | ]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[ |
4a2a22f4 | 1377 | |
93d0103d JD |
1378 | |
1379 | /* Prevent warnings from -Wmissing-prototypes. */ | |
4a2a22f4 | 1380 | #ifdef YYPARSE_PARAM |
1b9c21fb | 1381 | ]b4_c_function_decl([yyparse], [int], |
93d0103d | 1382 | [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ |
0245f82d | 1383 | #else /* ! YYPARSE_PARAM */ |
d1ff7a7c | 1384 | ]b4_c_function_decl([yyparse], [int], b4_parse_param)[ |
93d0103d | 1385 | #endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [ |
9ca7f077 | 1386 | |
93d0103d | 1387 | b4_declare_scanner_communication_variables])[]b4_push_if([[ |
9ca7f077 | 1388 | |
9ca7f077 | 1389 | |
93d0103d JD |
1390 | struct yypstate |
1391 | {]b4_declare_parser_state_variables[ | |
9ca7f077 JD |
1392 | /* Used to determine if this is the first time this instance has |
1393 | been used. */ | |
1394 | int yynew; | |
333e670c | 1395 | };]b4_pure_if([], [[ |
a35f64ea | 1396 | |
333e670c JD |
1397 | static char yypstate_allocated = 0;]])b4_pull_if([ |
1398 | ||
1399 | b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ | |
9ca7f077 | 1400 | { |
6557bcce | 1401 | return yypull_parse (YY_NULL]m4_ifset([b4_parse_param], |
9ca7f077 | 1402 | [[, ]b4_c_args(b4_parse_param)])[); |
333e670c | 1403 | } |
0245f82d | 1404 | |
9ca7f077 JD |
1405 | ]b4_c_function_def([[yypull_parse]], [[int]], |
1406 | [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, | |
1407 | b4_parse_param]))[ | |
1408 | { | |
1409 | int yystatus; | |
333e670c JD |
1410 | yypstate *yyps_local;]b4_pure_if([[ |
1411 | int yychar; | |
1412 | YYSTYPE yylval;]b4_locations_if([[ | |
1413 | YYLTYPE yylloc;]])])[ | |
6557bcce AD |
1414 | if (yyps) |
1415 | yyps_local = yyps; | |
1416 | else | |
9ca7f077 JD |
1417 | { |
1418 | yyps_local = yypstate_new (); | |
1419 | if (!yyps_local) | |
1420 | {]b4_pure_if([[ | |
1421 | yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[ | |
1422 | if (!yypstate_allocated) | |
1423 | yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[ | |
1424 | return 2; | |
1425 | } | |
1426 | } | |
9ca7f077 JD |
1427 | do { |
1428 | yychar = YYLEX; | |
1429 | yystatus = | |
1430 | yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[); | |
1431 | } while (yystatus == YYPUSH_MORE); | |
6557bcce | 1432 | if (!yyps) |
9ca7f077 JD |
1433 | yypstate_delete (yyps_local); |
1434 | return yystatus; | |
333e670c JD |
1435 | }]])[ |
1436 | ||
9ca7f077 JD |
1437 | /* Initialize the parser data structure. */ |
1438 | ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ | |
1439 | { | |
1440 | yypstate *yyps;]b4_pure_if([], [[ | |
1441 | if (yypstate_allocated) | |
6557bcce | 1442 | return YY_NULL;]])[ |
9ca7f077 JD |
1443 | yyps = (yypstate *) malloc (sizeof *yyps); |
1444 | if (!yyps) | |
6557bcce | 1445 | return YY_NULL; |
9ca7f077 JD |
1446 | yyps->yynew = 1;]b4_pure_if([], [[ |
1447 | yypstate_allocated = 1;]])[ | |
1448 | return yyps; | |
1449 | } | |
1450 | ||
1451 | ]b4_c_function_def([[yypstate_delete]], [[void]], | |
1452 | [[[yypstate *yyps]], [[yyps]]])[ | |
1453 | { | |
1454 | #ifndef yyoverflow | |
1455 | /* If the stack was reallocated but the parse did not complete, then the | |
1456 | stack still needs to be freed. */ | |
1457 | if (!yyps->yynew && yyps->yyss != yyps->yyssa) | |
1458 | YYSTACK_FREE (yyps->yyss); | |
723fe7d1 JD |
1459 | #endif]b4_lac_if([[ |
1460 | if (!yyps->yynew && yyps->yyes != yyps->yyesa) | |
1461 | YYSTACK_FREE (yyps->yyes);]])[ | |
9ca7f077 JD |
1462 | free (yyps);]b4_pure_if([], [[ |
1463 | yypstate_allocated = 0;]])[ | |
1464 | } | |
93d0103d JD |
1465 | ]b4_pure_if([[ |
1466 | #define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[ | |
1467 | #define yystate yyps->yystate | |
9ca7f077 JD |
1468 | #define yyerrstatus yyps->yyerrstatus |
1469 | #define yyssa yyps->yyssa | |
1470 | #define yyss yyps->yyss | |
1471 | #define yyssp yyps->yyssp | |
1472 | #define yyvsa yyps->yyvsa | |
1473 | #define yyvs yyps->yyvs | |
93d0103d JD |
1474 | #define yyvsp yyps->yyvsp]b4_locations_if([[ |
1475 | #define yylsa yyps->yylsa | |
9ca7f077 JD |
1476 | #define yyls yyps->yyls |
1477 | #define yylsp yyps->yylsp | |
93d0103d | 1478 | #define yyerror_range yyps->yyerror_range]])[ |
723fe7d1 JD |
1479 | #define yystacksize yyps->yystacksize]b4_lac_if([[ |
1480 | #define yyesa yyps->yyesa | |
1481 | #define yyes yyps->yyes | |
1482 | #define yyes_capacity yyps->yyes_capacity]])[ | |
93d0103d JD |
1483 | |
1484 | ||
1485 | /*---------------. | |
1486 | | yypush_parse. | | |
1487 | `---------------*/ | |
1488 | ||
1489 | ]b4_c_function_def([[yypush_parse]], [[int]], | |
9ca7f077 JD |
1490 | [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, |
1491 | [[[int yypushed_char]], [[yypushed_char]]], | |
1492 | [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, | |
1493 | [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [, | |
93d0103d JD |
1494 | b4_parse_param]))], [[ |
1495 | ||
1496 | ||
1497 | /*----------. | |
1498 | | yyparse. | | |
1499 | `----------*/ | |
1500 | ||
0245f82d | 1501 | #ifdef YYPARSE_PARAM |
93d0103d JD |
1502 | ]b4_c_function_def([yyparse], [int], |
1503 | [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ | |
0245f82d | 1504 | #else /* ! YYPARSE_PARAM */ |
93d0103d JD |
1505 | ]b4_c_function_def([yyparse], [int], b4_parse_param)[ |
1506 | #endif]])[ | |
1507 | {]b4_pure_if([b4_declare_scanner_communication_variables | |
1508 | ])b4_push_if([b4_pure_if([], [[ | |
1509 | int yypushed_char = yychar; | |
1510 | YYSTYPE yypushed_val = yylval;]b4_locations_if([[ | |
1511 | YYLTYPE yypushed_loc = yylloc;]]) | |
1512 | ])], | |
1513 | [b4_declare_parser_state_variables | |
ea13bea8 JD |
1514 | ])b4_lac_if([[ |
1515 | int yy_lac_established = 0;]])[ | |
cb530ce9 | 1516 | int yyn; |
600f9b0c | 1517 | int yyresult; |
742e4900 | 1518 | /* Lookahead token as an internal (translated) token number. */ |
9ca7f077 JD |
1519 | int yytoken; |
1520 | /* The variables used to return semantic value and location from the | |
1521 | action routines. */ | |
fa6aa7b3 JD |
1522 | YYSTYPE yyval;]b4_locations_if([[ |
1523 | YYLTYPE yyloc;]])[ | |
1524 | ||
b4c1f9d2 PE |
1525 | #if YYERROR_VERBOSE |
1526 | /* Buffer for error messages, and its allocated size. */ | |
1527 | char yymsgbuf[128]; | |
1528 | char *yymsg = yymsgbuf; | |
1529 | YYSIZE_T yymsg_alloc = sizeof yymsgbuf; | |
1530 | #endif | |
10fa2066 | 1531 | |
327afc7c | 1532 | #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[) |
10fa2066 | 1533 | |
a85284cf | 1534 | /* The number of symbols on the RHS of the reduced rule. |
9d9b8b70 | 1535 | Keep to zero when no symbol should be popped. */ |
fa6aa7b3 JD |
1536 | int yylen = 0;]b4_push_if([[ |
1537 | ||
9ca7f077 JD |
1538 | if (!yyps->yynew) |
1539 | { | |
1540 | yyn = yypact[yystate]; | |
1541 | goto yyread_pushed_token; | |
fa6aa7b3 JD |
1542 | }]])[ |
1543 | ||
9ca7f077 JD |
1544 | yytoken = 0; |
1545 | yyss = yyssa; | |
fa6aa7b3 JD |
1546 | yyvs = yyvsa;]b4_locations_if([[ |
1547 | yyls = yylsa;]])[ | |
723fe7d1 JD |
1548 | yystacksize = YYINITDEPTH;]b4_lac_if([[ |
1549 | ||
1550 | yyes = yyesa; | |
1551 | yyes_capacity = sizeof yyesa / sizeof *yyes; | |
1552 | if (YYMAXDEPTH < yyes_capacity) | |
1553 | yyes_capacity = YYMAXDEPTH;]])[ | |
10fa2066 | 1554 | |
2f4f028d | 1555 | YYDPRINTF ((stderr, "Starting parse\n")); |
10fa2066 RS |
1556 | |
1557 | yystate = 0; | |
1558 | yyerrstatus = 0; | |
17da6427 | 1559 | yynerrs = 0; |
9ca7f077 | 1560 | yychar = YYEMPTY; /* Cause a token to be read. */ |
10fa2066 RS |
1561 | |
1562 | /* Initialize stack pointers. | |
1563 | Waste one element of value and location stack | |
1564 | so that they stay on the same level as the state stack. | |
1565 | The wasted elements are never initialized. */ | |
cbd89906 | 1566 | yyssp = yyss; |
9ca7f077 JD |
1567 | yyvsp = yyvs;]b4_locations_if([[ |
1568 | yylsp = yyls; | |
1569 | ||
06caf0e1 | 1570 | #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL |
b8458aa5 | 1571 | /* Initialize the default location before parsing starts. */ |
cd48d21d AD |
1572 | yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[; |
1573 | yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[; | |
9ca7f077 JD |
1574 | #endif]]) |
1575 | m4_ifdef([b4_initial_action],[ | |
407d4a75 PE |
1576 | m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl |
1577 | m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl | |
9ca7f077 JD |
1578 | /* User initialization code. */ |
1579 | b4_user_initial_action | |
cd3684cf | 1580 | m4_popdef([b4_dollar_dollar])dnl |
8ec0a172 | 1581 | m4_popdef([b4_at_dollar])])dnl |
407d4a75 PE |
1582 | m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; |
1583 | ]])dnl | |
1584 | m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; | |
9ca7f077 JD |
1585 | ]])[ |
1586 | goto yysetstate; | |
10fa2066 | 1587 | |
71da9eea AD |
1588 | /*------------------------------------------------------------. |
1589 | | yynewstate -- Push a new state, which is found in yystate. | | |
1590 | `------------------------------------------------------------*/ | |
342b8b6e | 1591 | yynewstate: |
71da9eea | 1592 | /* In all cases, when you get here, the value and location stacks |
9d9b8b70 | 1593 | have just been pushed. So pushing a state here evens the stacks. */ |
cbd89906 PE |
1594 | yyssp++; |
1595 | ||
342b8b6e | 1596 | yysetstate: |
cbd89906 | 1597 | *yyssp = yystate; |
10fa2066 | 1598 | |
39912f52 | 1599 | if (yyss + yystacksize - 1 <= yyssp) |
10fa2066 | 1600 | { |
10fa2066 | 1601 | /* Get the current used size of the three stacks, in elements. */ |
7093d0f5 | 1602 | YYSIZE_T yysize = yyssp - yyss + 1; |
10fa2066 RS |
1603 | |
1604 | #ifdef yyoverflow | |
3d76b07d | 1605 | { |
9d9b8b70 | 1606 | /* Give user a chance to reallocate the stack. Use copies of |
3d76b07d AD |
1607 | these so that the &'s don't force the real ones into |
1608 | memory. */ | |
1609 | YYSTYPE *yyvs1 = yyvs; | |
9ca7f077 JD |
1610 | yytype_int16 *yyss1 = yyss;]b4_locations_if([ |
1611 | YYLTYPE *yyls1 = yyls;])[ | |
3d76b07d AD |
1612 | |
1613 | /* Each stack pointer address is followed by the size of the | |
58612f1d AD |
1614 | data in use in that stack, in bytes. This used to be a |
1615 | conditional around just the two extra args, but that might | |
1616 | be undefined if yyoverflow is a macro. */ | |
1a059451 | 1617 | yyoverflow (YY_("memory exhausted"), |
7093d0f5 | 1618 | &yyss1, yysize * sizeof (*yyssp), |
9ca7f077 JD |
1619 | &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([ |
1620 | &yyls1, yysize * sizeof (*yylsp),])[ | |
3d76b07d | 1621 | &yystacksize); |
9ca7f077 JD |
1622 | ]b4_locations_if([ |
1623 | yyls = yyls1;])[ | |
3d76b07d AD |
1624 | yyss = yyss1; |
1625 | yyvs = yyvs1; | |
1626 | } | |
10fa2066 | 1627 | #else /* no yyoverflow */ |
cf44a9ae | 1628 | # ifndef YYSTACK_RELOCATE |
1a059451 | 1629 | goto yyexhaustedlab; |
cf44a9ae | 1630 | # else |
10fa2066 | 1631 | /* Extend the stack our own way. */ |
39912f52 | 1632 | if (YYMAXDEPTH <= yystacksize) |
1a059451 | 1633 | goto yyexhaustedlab; |
10fa2066 | 1634 | yystacksize *= 2; |
39912f52 | 1635 | if (YYMAXDEPTH < yystacksize) |
10fa2066 | 1636 | yystacksize = YYMAXDEPTH; |
e9e4c321 | 1637 | |
600f9b0c | 1638 | { |
d42cf844 | 1639 | yytype_int16 *yyss1 = yyss; |
2729e106 PE |
1640 | union yyalloc *yyptr = |
1641 | (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); | |
600f9b0c | 1642 | if (! yyptr) |
1a059451 | 1643 | goto yyexhaustedlab; |
9ca7f077 JD |
1644 | YYSTACK_RELOCATE (yyss_alloc, yyss); |
1645 | YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([ | |
1646 | YYSTACK_RELOCATE (yyls_alloc, yyls);])[ | |
cf44a9ae | 1647 | # undef YYSTACK_RELOCATE |
600f9b0c PE |
1648 | if (yyss1 != yyssa) |
1649 | YYSTACK_FREE (yyss1); | |
1650 | } | |
cf44a9ae | 1651 | # endif |
10fa2066 RS |
1652 | #endif /* no yyoverflow */ |
1653 | ||
7093d0f5 | 1654 | yyssp = yyss + yysize - 1; |
9ca7f077 JD |
1655 | yyvsp = yyvs + yysize - 1;]b4_locations_if([ |
1656 | yylsp = yyls + yysize - 1;])[ | |
10fa2066 | 1657 | |
30757c8c | 1658 | YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
600f9b0c | 1659 | (unsigned long int) yystacksize)); |
10fa2066 | 1660 | |
39912f52 | 1661 | if (yyss + yystacksize - 1 <= yyssp) |
10fa2066 RS |
1662 | YYABORT; |
1663 | } | |
1664 | ||
30757c8c | 1665 | YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
10fa2066 | 1666 | |
868d2d96 JD |
1667 | if (yystate == YYFINAL) |
1668 | YYACCEPT; | |
1669 | ||
10fa2066 | 1670 | goto yybackup; |
71da9eea | 1671 | |
71da9eea AD |
1672 | /*-----------. |
1673 | | yybackup. | | |
1674 | `-----------*/ | |
1675 | yybackup: | |
10fa2066 | 1676 | |
a85284cf | 1677 | /* Do appropriate processing given the current state. Read a |
742e4900 | 1678 | lookahead token if we need one and don't already have one. */ |
10fa2066 | 1679 | |
742e4900 | 1680 | /* First try to decide what to do without reference to lookahead token. */ |
10fa2066 | 1681 | yyn = yypact[yystate]; |
d5eb0826 | 1682 | if (yypact_value_is_default (yyn)) |
10fa2066 RS |
1683 | goto yydefault; |
1684 | ||
742e4900 | 1685 | /* Not known => get a lookahead token if don't already have one. */ |
10fa2066 | 1686 | |
742e4900 | 1687 | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ |
a20713a4 | 1688 | if (yychar == YYEMPTY) |
fa6aa7b3 JD |
1689 | {]b4_push_if([[ |
1690 | if (!yyps->yynew) | |
1691 | {]b4_use_push_for_pull_if([], [[ | |
1692 | YYDPRINTF ((stderr, "Return for a new token:\n"));]])[ | |
1693 | yyresult = YYPUSH_MORE; | |
9ca7f077 JD |
1694 | goto yypushreturn; |
1695 | } | |
fa6aa7b3 | 1696 | yyps->yynew = 0;]b4_pure_if([], [[ |
9ca7f077 JD |
1697 | /* Restoring the pushed token is only necessary for the first |
1698 | yypush_parse invocation since subsequent invocations don't overwrite | |
1699 | it before jumping to yyread_pushed_token. */ | |
1700 | yychar = yypushed_char; | |
fa6aa7b3 JD |
1701 | yylval = yypushed_val;]b4_locations_if([[ |
1702 | yylloc = yypushed_loc;]])])[ | |
1703 | yyread_pushed_token:]])[ | |
1704 | YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[ | |
1705 | yychar = yypushed_char; | |
9ca7f077 | 1706 | if (yypushed_val) |
fa6aa7b3 JD |
1707 | yylval = *yypushed_val;]b4_locations_if([[ |
1708 | if (yypushed_loc) | |
1709 | yylloc = *yypushed_loc;]])])], [[ | |
1710 | yychar = YYLEX;]])[ | |
1711 | } | |
10fa2066 | 1712 | |
a20713a4 | 1713 | if (yychar <= YYEOF) |
10fa2066 | 1714 | { |
a20713a4 | 1715 | yychar = yytoken = YYEOF; |
2f4f028d | 1716 | YYDPRINTF ((stderr, "Now at end of input.\n")); |
10fa2066 RS |
1717 | } |
1718 | else | |
1719 | { | |
a20713a4 | 1720 | yytoken = YYTRANSLATE (yychar); |
30757c8c | 1721 | YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
10fa2066 RS |
1722 | } |
1723 | ||
b0400cc6 | 1724 | /* If the proper action on seeing token YYTOKEN is to reduce or to |
e5cfd9d8 | 1725 | detect an error, take that action. */ |
b0400cc6 | 1726 | yyn += yytoken; |
ea13bea8 JD |
1727 | if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[ |
1728 | { | |
1729 | YY_LAC_ESTABLISH; | |
1730 | goto yydefault; | |
1731 | }]], [[ | |
1732 | goto yydefault;]])[ | |
e5cfd9d8 PE |
1733 | yyn = yytable[yyn]; |
1734 | if (yyn <= 0) | |
10fa2066 | 1735 | { |
d5eb0826 | 1736 | if (yytable_value_is_error (yyn)) |
ea13bea8 JD |
1737 | goto yyerrlab;]b4_lac_if([[ |
1738 | YY_LAC_ESTABLISH;]])[ | |
10fa2066 RS |
1739 | yyn = -yyn; |
1740 | goto yyreduce; | |
1741 | } | |
10fa2066 | 1742 | |
a85284cf AD |
1743 | /* Count tokens shifted since error; after three, turn off error |
1744 | status. */ | |
1745 | if (yyerrstatus) | |
1746 | yyerrstatus--; | |
1747 | ||
742e4900 | 1748 | /* Shift the lookahead token. */ |
30757c8c | 1749 | YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
10fa2066 | 1750 | |
868d2d96 | 1751 | /* Discard the shifted token. */ |
ea13bea8 JD |
1752 | yychar = YYEMPTY;]b4_lac_if([[ |
1753 | YY_LAC_DISCARD ("shift");]])[ | |
10fa2066 | 1754 | |
a85284cf | 1755 | yystate = yyn; |
17da6427 | 1756 | *++yyvsp = yylval; |
327afc7c | 1757 | ]b4_locations_if([ *++yylsp = yylloc;])[ |
10fa2066 RS |
1758 | goto yynewstate; |
1759 | ||
10fa2066 | 1760 | |
71da9eea AD |
1761 | /*-----------------------------------------------------------. |
1762 | | yydefault -- do the default action for the current state. | | |
1763 | `-----------------------------------------------------------*/ | |
1764 | yydefault: | |
10fa2066 RS |
1765 | yyn = yydefact[yystate]; |
1766 | if (yyn == 0) | |
1767 | goto yyerrlab; | |
71da9eea | 1768 | goto yyreduce; |
10fa2066 | 1769 | |
71da9eea AD |
1770 | |
1771 | /*-----------------------------. | |
1772 | | yyreduce -- Do a reduction. | | |
1773 | `-----------------------------*/ | |
10fa2066 | 1774 | yyreduce: |
71da9eea | 1775 | /* yyn is the number of a rule to reduce with. */ |
10fa2066 | 1776 | yylen = yyr2[yyn]; |
da9abf43 AD |
1777 | |
1778 | /* If YYLEN is nonzero, implement the default value of the action: | |
573c1d9f | 1779 | `$$ = $1'. |
da9abf43 | 1780 | |
accea6db PE |
1781 | Otherwise, the following line sets YYVAL to garbage. |
1782 | This behavior is undocumented and Bison | |
da9abf43 AD |
1783 | users should not rely upon it. Assigning to YYVAL |
1784 | unconditionally makes the parser a bit smaller, and it avoids a | |
1785 | GCC warning that YYVAL may be used uninitialized. */ | |
1786 | yyval = yyvsp[1-yylen]; | |
3abcd459 | 1787 | |
327afc7c | 1788 | ]b4_locations_if( |
9d9b8b70 | 1789 | [[ /* Default location. */ |
401aace6 | 1790 | YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[ |
ea13bea8 JD |
1791 | YY_REDUCE_PRINT (yyn);]b4_lac_if([[ |
1792 | { | |
1793 | int yychar_backup = yychar; | |
1794 | switch (yyn) | |
1795 | { | |
1796 | ]b4_user_actions[ | |
1797 | default: break; | |
1798 | } | |
1799 | if (yychar_backup != yychar) | |
1800 | YY_LAC_DISCARD ("yychar change"); | |
1801 | }]], [[ | |
a8289c62 | 1802 | switch (yyn) |
d1ff7a7c | 1803 | { |
8ec0a172 | 1804 | ]b4_user_actions[ |
95f22ad2 | 1805 | default: break; |
ea13bea8 | 1806 | }]])[ |
abcc7c03 JD |
1807 | /* User semantic actions sometimes alter yychar, and that requires |
1808 | that yytoken be updated with the new translation. We take the | |
1809 | approach of translating immediately before every use of yytoken. | |
1810 | One alternative is translating here after every semantic action, | |
1811 | but that translation would be missed if the semantic action invokes | |
1812 | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or | |
1813 | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an | |
1814 | incorrect destructor might then be invoked immediately. In the | |
1815 | case of YYERROR or YYBACKUP, subsequent parser actions might lead | |
1816 | to an incorrect destructor call or verbose syntax error message | |
1817 | before the lookahead is translated. */ | |
d1ff7a7c | 1818 | YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); |
897668ee | 1819 | |
a85284cf AD |
1820 | YYPOPSTACK (yylen); |
1821 | yylen = 0; | |
b0937b22 | 1822 | YY_STACK_PRINT (yyss, yyssp); |
10fa2066 | 1823 | |
9ca7f077 JD |
1824 | *++yyvsp = yyval;]b4_locations_if([ |
1825 | *++yylsp = yyloc;])[ | |
10fa2066 | 1826 | |
41aca2e0 AD |
1827 | /* Now `shift' the result of the reduction. Determine what state |
1828 | that goes to, based on the state we popped back to and the rule | |
1829 | number reduced by. */ | |
10fa2066 RS |
1830 | |
1831 | yyn = yyr1[yyn]; | |
1832 | ||
7742ddeb | 1833 | yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; |
34ec3579 | 1834 | if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
10fa2066 RS |
1835 | yystate = yytable[yystate]; |
1836 | else | |
7742ddeb | 1837 | yystate = yydefgoto[yyn - YYNTOKENS]; |
10fa2066 RS |
1838 | |
1839 | goto yynewstate; | |
1840 | ||
10fa2066 | 1841 | |
71da9eea AD |
1842 | /*------------------------------------. |
1843 | | yyerrlab -- here on detecting error | | |
1844 | `------------------------------------*/ | |
1845 | yyerrlab: | |
abcc7c03 JD |
1846 | /* Make sure we have latest lookahead translation. See comments at |
1847 | user semantic actions for why this is necessary. */ | |
095a1d11 | 1848 | yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); |
abcc7c03 | 1849 | |
71da9eea AD |
1850 | /* If not already recovering from an error, report this error. */ |
1851 | if (!yyerrstatus) | |
10fa2066 | 1852 | { |
17da6427 | 1853 | ++yynerrs; |
b4c1f9d2 PE |
1854 | #if ! YYERROR_VERBOSE |
1855 | yyerror (]b4_yyerror_args[YY_("syntax error")); | |
1856 | #else | |
723fe7d1 JD |
1857 | # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[ |
1858 | yyesa, &yyes, &yyes_capacity, \]])[ | |
1859 | yyssp, yytoken) | |
0e0f066b JD |
1860 | { |
1861 | char const *yymsgp = YY_("syntax error"); | |
ea13bea8 JD |
1862 | int yysyntax_error_status;]b4_lac_if([[ |
1863 | if (yychar != YYEMPTY) | |
1864 | YY_LAC_ESTABLISH;]])[ | |
1865 | yysyntax_error_status = YYSYNTAX_ERROR; | |
0e0f066b JD |
1866 | if (yysyntax_error_status == 0) |
1867 | yymsgp = yymsg; | |
095a1d11 | 1868 | else if (yysyntax_error_status == 1) |
0e0f066b JD |
1869 | { |
1870 | if (yymsg != yymsgbuf) | |
1871 | YYSTACK_FREE (yymsg); | |
1872 | yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); | |
1873 | if (!yymsg) | |
1874 | { | |
1875 | yymsg = yymsgbuf; | |
1876 | yymsg_alloc = sizeof yymsgbuf; | |
095a1d11 | 1877 | yysyntax_error_status = 2; |
0e0f066b JD |
1878 | } |
1879 | else | |
1880 | { | |
1881 | yysyntax_error_status = YYSYNTAX_ERROR; | |
1882 | yymsgp = yymsg; | |
1883 | } | |
1884 | } | |
1885 | yyerror (]b4_yyerror_args[yymsgp); | |
1886 | if (yysyntax_error_status == 2) | |
1887 | goto yyexhaustedlab; | |
1888 | } | |
1889 | # undef YYSYNTAX_ERROR | |
b4c1f9d2 | 1890 | #endif |
10fa2066 | 1891 | } |
71da9eea | 1892 | |
a005dbcb | 1893 | ]b4_locations_if([[ yyerror_range[1] = yylloc;]])[ |
d42f69cd | 1894 | |
10fa2066 RS |
1895 | if (yyerrstatus == 3) |
1896 | { | |
742e4900 | 1897 | /* If just tried and failed to reuse lookahead token after an |
71da9eea | 1898 | error, discard it. */ |
10fa2066 | 1899 | |
a6b89bb2 | 1900 | if (yychar <= YYEOF) |
02650b7f | 1901 | { |
258b75ca | 1902 | /* Return failure if at end of input. */ |
a6b89bb2 | 1903 | if (yychar == YYEOF) |
80ce3401 | 1904 | YYABORT; |
02650b7f | 1905 | } |
a6b89bb2 PE |
1906 | else |
1907 | { | |
4b367315 | 1908 | yydestruct ("Error: discarding", |
327afc7c | 1909 | yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); |
a6b89bb2 | 1910 | yychar = YYEMPTY; |
a6b89bb2 | 1911 | } |
10fa2066 RS |
1912 | } |
1913 | ||
742e4900 | 1914 | /* Else will try to reuse lookahead token after shifting the error |
71da9eea | 1915 | token. */ |
8a3eb3c8 | 1916 | goto yyerrlab1; |
300a7966 | 1917 | |
10fa2066 | 1918 | |
a6b89bb2 PE |
1919 | /*---------------------------------------------------. |
1920 | | yyerrorlab -- error raised explicitly by YYERROR. | | |
1921 | `---------------------------------------------------*/ | |
1922 | yyerrorlab: | |
1923 | ||
c7a65b99 PE |
1924 | /* Pacify compilers like GCC when the user code never invokes |
1925 | YYERROR and the label yyerrorlab therefore never appears in user | |
1926 | code. */ | |
2a4647a3 | 1927 | if (/*CONSTCOND*/ 0) |
a6b89bb2 | 1928 | goto yyerrorlab; |
a6b89bb2 | 1929 | |
a005dbcb | 1930 | ]b4_locations_if([[ yyerror_range[1] = yylsp[1-yylen]; |
a85284cf | 1931 | ]])[ /* Do not reclaim the symbols of the rule which action triggered |
9d9b8b70 | 1932 | this YYERROR. */ |
a85284cf AD |
1933 | YYPOPSTACK (yylen); |
1934 | yylen = 0; | |
1935 | YY_STACK_PRINT (yyss, yyssp); | |
a6b89bb2 | 1936 | yystate = *yyssp; |
3fc16193 | 1937 | goto yyerrlab1; |
a6b89bb2 PE |
1938 | |
1939 | ||
1940 | /*-------------------------------------------------------------. | |
1941 | | yyerrlab1 -- common code for both syntax error and YYERROR. | | |
1942 | `-------------------------------------------------------------*/ | |
300a7966 | 1943 | yyerrlab1: |
cf44a9ae | 1944 | yyerrstatus = 3; /* Each real token shifted decrements this. */ |
10fa2066 | 1945 | |
660bc8dd PE |
1946 | for (;;) |
1947 | { | |
1948 | yyn = yypact[yystate]; | |
d5eb0826 | 1949 | if (!yypact_value_is_default (yyn)) |
660bc8dd PE |
1950 | { |
1951 | yyn += YYTERROR; | |
1952 | if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) | |
1953 | { | |
1954 | yyn = yytable[yyn]; | |
1955 | if (0 < yyn) | |
1956 | break; | |
1957 | } | |
1958 | } | |
10fa2066 | 1959 | |
660bc8dd PE |
1960 | /* Pop the current state because it cannot handle the error token. */ |
1961 | if (yyssp == yyss) | |
1962 | YYABORT; | |
5504898e | 1963 | |
a005dbcb | 1964 | ]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[ |
4b367315 | 1965 | yydestruct ("Error: popping", |
327afc7c | 1966 | yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); |
a85284cf | 1967 | YYPOPSTACK (1); |
a6b89bb2 | 1968 | yystate = *yyssp; |
b0937b22 | 1969 | YY_STACK_PRINT (yyss, yyssp); |
ea13bea8 JD |
1970 | }]b4_lac_if([[ |
1971 | ||
1972 | /* If the stack popping above didn't lose the initial context for the | |
1973 | current lookahead token, the shift below will for sure. */ | |
1974 | YY_LAC_DISCARD ("error recovery");]])[ | |
10fa2066 | 1975 | |
17da6427 | 1976 | *++yyvsp = yylval; |
327afc7c | 1977 | ]b4_locations_if([[ |
a005dbcb | 1978 | yyerror_range[2] = yylloc; |
3fc16193 | 1979 | /* Using YYLLOC is tempting, but would change the location of |
742e4900 | 1980 | the lookahead. YYLOC is available though. */ |
a005dbcb | 1981 | YYLLOC_DEFAULT (yyloc, yyerror_range, 2); |
3fc16193 | 1982 | *++yylsp = yyloc;]])[ |
10fa2066 | 1983 | |
9d9b8b70 | 1984 | /* Shift the error token. */ |
30757c8c | 1985 | YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); |
1576d44d | 1986 | |
10fa2066 RS |
1987 | yystate = yyn; |
1988 | goto yynewstate; | |
70ddf897 | 1989 | |
71da9eea AD |
1990 | |
1991 | /*-------------------------------------. | |
1992 | | yyacceptlab -- YYACCEPT comes here. | | |
1993 | `-------------------------------------*/ | |
1994 | yyacceptlab: | |
600f9b0c PE |
1995 | yyresult = 0; |
1996 | goto yyreturn; | |
71da9eea AD |
1997 | |
1998 | /*-----------------------------------. | |
1999 | | yyabortlab -- YYABORT comes here. | | |
2000 | `-----------------------------------*/ | |
2001 | yyabortlab: | |
600f9b0c PE |
2002 | yyresult = 1; |
2003 | goto yyreturn; | |
2004 | ||
24bb5f8f | 2005 | #if ]b4_lac_if([[1]], [[!defined yyoverflow || YYERROR_VERBOSE]])[ |
1a059451 PE |
2006 | /*-------------------------------------------------. |
2007 | | yyexhaustedlab -- memory exhaustion comes here. | | |
2008 | `-------------------------------------------------*/ | |
2009 | yyexhaustedlab: | |
2010 | yyerror (]b4_yyerror_args[YY_("memory exhausted")); | |
600f9b0c PE |
2011 | yyresult = 2; |
2012 | /* Fall through. */ | |
0bfb02ff | 2013 | #endif |
600f9b0c PE |
2014 | |
2015 | yyreturn: | |
868d2d96 | 2016 | if (yychar != YYEMPTY) |
abcc7c03 JD |
2017 | { |
2018 | /* Make sure we have latest lookahead translation. See comments at | |
2019 | user semantic actions for why this is necessary. */ | |
2020 | yytoken = YYTRANSLATE (yychar); | |
2021 | yydestruct ("Cleanup: discarding lookahead", | |
2022 | yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); | |
2023 | } | |
a85284cf | 2024 | /* Do not reclaim the symbols of the rule which action triggered |
9d9b8b70 | 2025 | this YYABORT or YYACCEPT. */ |
a85284cf AD |
2026 | YYPOPSTACK (yylen); |
2027 | YY_STACK_PRINT (yyss, yyssp); | |
258b75ca PE |
2028 | while (yyssp != yyss) |
2029 | { | |
dd5f2af2 | 2030 | yydestruct ("Cleanup: popping", |
327afc7c | 2031 | yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); |
a85284cf | 2032 | YYPOPSTACK (1); |
258b75ca | 2033 | } |
600f9b0c PE |
2034 | #ifndef yyoverflow |
2035 | if (yyss != yyssa) | |
2036 | YYSTACK_FREE (yyss); | |
723fe7d1 JD |
2037 | #endif]b4_lac_if([[ |
2038 | if (yyes != yyesa) | |
2039 | YYSTACK_FREE (yyes);]])b4_push_if([[ | |
93d0103d | 2040 | yyps->yynew = 1; |
9ca7f077 | 2041 | |
93d0103d JD |
2042 | yypushreturn:]])[ |
2043 | #if YYERROR_VERBOSE | |
b4c1f9d2 PE |
2044 | if (yymsg != yymsgbuf) |
2045 | YYSTACK_FREE (yymsg); | |
70ddf897 | 2046 | #endif |
7b5cdcbd JD |
2047 | /* Make sure YYID is used. */ |
2048 | return YYID (yyresult); | |
9ca7f077 | 2049 | } |
be2a1a68 | 2050 | |
24c0aad7 | 2051 | |
9ca7f077 | 2052 | ]b4_epilogue |
327afc7c | 2053 | b4_defines_if( |
0d2b2ab0 | 2054 | [@output(b4_spec_defines_file@)@ |
7e5ef706 | 2055 | b4_copyright([Bison interface for Yacc-like parsers in C], |
ae6bdabb AD |
2056 | [1984, 1989-1990, 2000-2012])[ |
2057 | ]b4_shared_declarations[ | |
c0828abf AD |
2058 | ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval; |
2059 | ]b4_locations_if([[extern YYLTYPE ]b4_prefix[lloc;]])])dnl | |
327afc7c | 2060 | ])dnl b4_defines_if |
08af01c2 | 2061 | m4_divert_pop(0) |