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