source: trunk/contrib/bison-2.4.2/share/bison/yacc.c @ 1933

Last change on this file since 1933 was 1933, checked in by sam, 11 years ago

contrib: add Bison and Flex executables for Windows.
File size: 49.0 KB
Line 
1                                                             -*- C -*-
2
3# Yacc compatible skeleton for Bison
4
5# Copyright (C) 1984, 1989-1990, 2000-2010 Free Software Foundation,
6# Inc.
7
8# This program is free software: you can redistribute it and/or modify
9# it under the terms of the GNU General Public License as published by
10# the Free Software Foundation, either version 3 of the License, or
11# (at your option) any later version.
12#
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.
17#
18# You should have received a copy of the GNU General Public License
19# along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
21# Check the value of %define api.push_pull.
22b4_percent_define_default([[api.push_pull]], [[pull]])
23b4_percent_define_check_values([[[[api.push_pull]],
24                               [[pull]], [[push]], [[both]]]])
25b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
26b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
27m4_case(b4_percent_define_get([[api.push_pull]]),
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
32# tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's
33# behavior at all when push parsing is already requested.
34b4_define_flag_if([use_push_for_pull])
35b4_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]])])])
38
39m4_include(b4_pkgdatadir/[c.m4])
40
41## ---------------- ##
42## Default values.  ##
43## ---------------- ##
44
45# Stack parameters.
46m4_define_default([b4_stack_depth_max], [10000])
47m4_define_default([b4_stack_depth_init],  [200])
48
49
50## ------------------------ ##
51## Pure/impure interfaces.  ##
52## ------------------------ ##
53
54b4_percent_define_default([[api.pure]], [[false]])
55b4_define_flag_if([pure])
56m4_define([b4_pure_flag],
57          [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])
58
59# b4_yacc_pure_if(IF-TRUE, IF-FALSE)
60# ----------------------------------
61# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
62m4_define([b4_yacc_pure_if],
63[b4_pure_if([m4_ifset([b4_parse_param],
64                      [$1], [$2])],
65            [$2])])
66
67
68# b4_yyerror_args
69# ---------------
70# Arguments passed to yyerror: user args plus yylloc.
71m4_define([b4_yyerror_args],
72[b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
73m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
74
75
76# b4_lex_param
77# ------------
78# Accumulate in b4_lex_param all the yylex arguments.
79# b4_lex_param arrives quoted twice, but we want to keep only one level.
80m4_define([b4_lex_param],
81m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
82b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
83m4_ifdef([b4_lex_param], b4_lex_param)))
84
85
86## ------------ ##
87## Data Types.  ##
88## ------------ ##
89
90# b4_int_type(MIN, MAX)
91# ---------------------
92# Return the smallest int type able to handle numbers ranging from
93# MIN to MAX (included).  Overwrite the version from c.m4, which
94# uses only C89 types, so that the user can override the shorter
95# types, and so that pre-C89 compilers are handled correctly.
96m4_define([b4_int_type],
97[m4_if(b4_ints_in($@,      [0],   [255]), [1], [yytype_uint8],
98       b4_ints_in($@,   [-128],   [127]), [1], [yytype_int8],
99
100       b4_ints_in($@,      [0], [65535]), [1], [yytype_uint16],
101       b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
102
103       m4_eval([0 <= $1]),                [1], [unsigned int],
104
105                                               [int])])
106
107
108## ----------------- ##
109## Semantic Values.  ##
110## ----------------- ##
111
112
113# b4_lhs_value([TYPE])
114# --------------------
115# Expansion of $<TYPE>$.
116m4_define([b4_lhs_value],
117[(yyval[]m4_ifval([$1], [.$1]))])
118
119
120# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
121# --------------------------------------
122# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
123# symbols on RHS.
124m4_define([b4_rhs_value],
125[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
126
127
128
129## ----------- ##
130## Locations.  ##
131## ----------- ##
132
133# b4_lhs_location()
134# -----------------
135# Expansion of @$.
136m4_define([b4_lhs_location],
137[(yyloc)])
138
139
140# b4_rhs_location(RULE-LENGTH, NUM)
141# ---------------------------------
142# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
143# on RHS.
144m4_define([b4_rhs_location],
145[(yylsp@{($2) - ($1)@})])
146
147
148
149## --------------------------------------------------------- ##
150## Defining symbol actions, e.g., printers and destructors.  ##
151## --------------------------------------------------------- ##
152
153# We do want M4 expansion after # for CPP macros.
154m4_changecom()
155m4_divert_push(0)dnl
156@output(b4_parser_file_name@)@
157b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],
158             [1984, 1989-1990, 2000-2006, 2009-2010])[
159
160/* C LALR(1) parser skeleton written by Richard Stallman, by
161   simplifying the original so-called "semantic" parser.  */
162
163/* All symbols defined below should begin with yy or YY, to avoid
164   infringing on user name space.  This should be done even for local
165   variables, as they might otherwise be expanded by user macros.
166   There are some unavoidable exceptions within include files to
167   define necessary library symbols; they are noted "INFRINGES ON
168   USER NAME SPACE" below.  */
169
170]b4_identification
171b4_percent_code_get([[top]])[]dnl
172m4_if(b4_prefix, [yy], [],
173[[/* Substitute the variable and function names.  */
174]b4_pull_if([[#define yyparse         ]b4_prefix[parse
175]])b4_push_if([[#define yypush_parse    ]b4_prefix[push_parse
176]b4_pull_if([[#define yypull_parse    ]b4_prefix[pull_parse
177]])[#define yypstate_new    ]b4_prefix[pstate_new
178#define yypstate_delete ]b4_prefix[pstate_delete
179#define yypstate        ]b4_prefix[pstate
180]])[#define yylex           ]b4_prefix[lex
181#define yyerror         ]b4_prefix[error
182#define yylval          ]b4_prefix[lval
183#define yychar          ]b4_prefix[char
184#define yydebug         ]b4_prefix[debug
185#define yynerrs         ]b4_prefix[nerrs
186]b4_locations_if([[#define yylloc          ]b4_prefix[lloc]])])[
187
188/* Copy the first part of user declarations.  */
189]b4_user_pre_prologue[
190
191/* Enabling traces.  */
192#ifndef YYDEBUG
193# define YYDEBUG ]b4_debug_flag[
194#endif
195
196/* Enabling verbose error messages.  */
197#ifdef YYERROR_VERBOSE
198# undef YYERROR_VERBOSE
199# define YYERROR_VERBOSE 1
200#else
201# define YYERROR_VERBOSE ]b4_error_verbose_flag[
202#endif
203
204/* Enabling the token table.  */
205#ifndef YYTOKEN_TABLE
206# define YYTOKEN_TABLE ]b4_token_table[
207#endif
208
209]b4_percent_code_get([[requires]])[]dnl
210
211b4_token_enums_defines(b4_tokens)[
212
213#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
214]m4_ifdef([b4_stype],
215[[typedef union ]b4_union_name[
216{
217]b4_user_stype[
218} YYSTYPE;
219# define YYSTYPE_IS_TRIVIAL 1]],
220[m4_if(b4_tag_seen_flag, 0,
221[[typedef int YYSTYPE;
222# define YYSTYPE_IS_TRIVIAL 1]])])[
223# define yystype YYSTYPE /* obsolescent; will be withdrawn */
224# define YYSTYPE_IS_DECLARED 1
225#endif]b4_locations_if([[
226
227#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
228typedef struct YYLTYPE
229{
230  int first_line;
231  int first_column;
232  int last_line;
233  int last_column;
234} YYLTYPE;
235# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
236# define YYLTYPE_IS_DECLARED 1
237# define YYLTYPE_IS_TRIVIAL 1
238#endif]])b4_push_if([[
239
240#ifndef YYPUSH_DECLS
241#  define YYPUSH_DECLS
242struct yypstate;
243typedef struct yypstate yypstate;
244enum { YYPUSH_MORE = 4 };
245
246]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param)
247])b4_c_function_decl([[yypush_parse]], [[int]],
248  [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
249  [[[int yypushed_char]], [[yypushed_char]]],
250  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
251  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
252  b4_parse_param]))
253b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
254  [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
255  b4_parse_param]))])
256b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
257b4_c_function_decl([[yypstate_delete]], [[void]],
258                   [[[yypstate *yyps]], [[yyps]]])[
259#endif]])
260
261b4_percent_code_get([[provides]])[]dnl
262
263[/* Copy the second part of user declarations.  */
264]b4_user_post_prologue
265b4_percent_code_get[]dnl
266
267[#ifdef short
268# undef short
269#endif
270
271#ifdef YYTYPE_UINT8
272typedef YYTYPE_UINT8 yytype_uint8;
273#else
274typedef unsigned char yytype_uint8;
275#endif
276
277#ifdef YYTYPE_INT8
278typedef YYTYPE_INT8 yytype_int8;
279#elif ]b4_c_modern[
280typedef signed char yytype_int8;
281#else
282typedef short int yytype_int8;
283#endif
284
285#ifdef YYTYPE_UINT16
286typedef YYTYPE_UINT16 yytype_uint16;
287#else
288typedef unsigned short int yytype_uint16;
289#endif
290
291#ifdef YYTYPE_INT16
292typedef YYTYPE_INT16 yytype_int16;
293#else
294typedef short int yytype_int16;
295#endif
296
297#ifndef YYSIZE_T
298# ifdef __SIZE_TYPE__
299#  define YYSIZE_T __SIZE_TYPE__
300# elif defined size_t
301#  define YYSIZE_T size_t
302# elif ! defined YYSIZE_T && ]b4_c_modern[
303#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
304#  define YYSIZE_T size_t
305# else
306#  define YYSIZE_T unsigned int
307# endif
308#endif
309
310#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
311
312#ifndef YY_
313# if defined YYENABLE_NLS && YYENABLE_NLS
314#  if ENABLE_NLS
315#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
316#   define YY_(msgid) dgettext ("bison-runtime", msgid)
317#  endif
318# endif
319# ifndef YY_
320#  define YY_(msgid) msgid
321# endif
322#endif
323
324/* Suppress unused-variable warnings by "using" E.  */
325#if ! defined lint || defined __GNUC__
326# define YYUSE(e) ((void) (e))
327#else
328# define YYUSE(e) /* empty */
329#endif
330
331/* Identity function, used to suppress warnings about constant conditions.  */
332#ifndef lint
333# define YYID(n) (n)
334#else
335]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
336{
337  return yyi;
338}
339#endif
340
341#if ! defined yyoverflow || YYERROR_VERBOSE
342
343]b4_push_if([],
344[[/* The parser invokes alloca or malloc; define the necessary symbols.  */
345
346# ifdef YYSTACK_USE_ALLOCA
347#  if YYSTACK_USE_ALLOCA
348#   ifdef __GNUC__
349#    define YYSTACK_ALLOC __builtin_alloca
350#   elif defined __BUILTIN_VA_ARG_INCR
351#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
352#   elif defined _AIX
353#    define YYSTACK_ALLOC __alloca
354#   elif defined _MSC_VER
355#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
356#    define alloca _alloca
357#   else
358#    define YYSTACK_ALLOC alloca
359#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[
360#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
361#     ifndef _STDLIB_H
362#      define _STDLIB_H 1
363#     endif
364#    endif
365#   endif
366#  endif
367# endif
368
369]])dnl
370[# ifdef YYSTACK_ALLOC
371   /* Pacify GCC's `empty if-body' warning.  */
372#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
373#  ifndef YYSTACK_ALLOC_MAXIMUM
374    /* The OS might guarantee only one guard page at the bottom of the stack,
375       and a page size can be as small as 4096 bytes.  So we cannot safely
376       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
377       to allow for a few compiler-allocated temporary stack slots.  */
378#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
379#  endif
380# else
381#  define YYSTACK_ALLOC YYMALLOC
382#  define YYSTACK_FREE YYFREE
383#  ifndef YYSTACK_ALLOC_MAXIMUM
384#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
385#  endif
386#  if (defined __cplusplus && ! defined _STDLIB_H \
387       && ! ((defined YYMALLOC || defined malloc) \
388             && (defined YYFREE || defined free)))
389#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
390#   ifndef _STDLIB_H
391#    define _STDLIB_H 1
392#   endif
393#  endif
394#  ifndef YYMALLOC
395#   define YYMALLOC malloc
396#   if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[
397void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
398#   endif
399#  endif
400#  ifndef YYFREE
401#   define YYFREE free
402#   if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[
403void free (void *); /* INFRINGES ON USER NAME SPACE */
404#   endif
405#  endif
406# endif
407#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
408
409
410#if (! defined yyoverflow \
411     && (! defined __cplusplus \
412         || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
413             && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
414
415/* A type that is properly aligned for any stack member.  */
416union yyalloc
417{
418  yytype_int16 yyss_alloc;
419  YYSTYPE yyvs_alloc;]b4_locations_if([
420  YYLTYPE yyls_alloc;])[
421};
422
423/* The size of the maximum gap between one aligned stack and the next.  */
424# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
425
426/* The size of an array large to enough to hold all stacks, each with
427   N elements.  */
428]b4_locations_if(
429[# define YYSTACK_BYTES(N) \
430     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
431      + 2 * YYSTACK_GAP_MAXIMUM)],
432[# define YYSTACK_BYTES(N) \
433     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
434      + YYSTACK_GAP_MAXIMUM)])[
435
436/* Copy COUNT objects from FROM to TO.  The source and destination do
437   not overlap.  */
438# ifndef YYCOPY
439#  if defined __GNUC__ && 1 < __GNUC__
440#   define YYCOPY(To, From, Count) \
441      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
442#  else
443#   define YYCOPY(To, From, Count)              \
444      do                                        \
445        {                                       \
446          YYSIZE_T yyi;                         \
447          for (yyi = 0; yyi < (Count); yyi++)   \
448            (To)[yyi] = (From)[yyi];            \
449        }                                       \
450      while (YYID (0))
451#  endif
452# endif
453
454/* Relocate STACK from its old location to the new one.  The
455   local variables YYSIZE and YYSTACKSIZE give the old and new number of
456   elements in the stack, and YYPTR gives the new location of the
457   stack.  Advance YYPTR to a properly aligned location for the next
458   stack.  */
459# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
460    do                                                                  \
461      {                                                                 \
462        YYSIZE_T yynewbytes;                                            \
463        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
464        Stack = &yyptr->Stack_alloc;                                    \
465        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
466        yyptr += yynewbytes / sizeof (*yyptr);                          \
467      }                                                                 \
468    while (YYID (0))
469
470#endif
471
472/* YYFINAL -- State number of the termination state.  */
473#define YYFINAL  ]b4_final_state_number[
474/* YYLAST -- Last index in YYTABLE.  */
475#define YYLAST   ]b4_last[
476
477/* YYNTOKENS -- Number of terminals.  */
478#define YYNTOKENS  ]b4_tokens_number[
479/* YYNNTS -- Number of nonterminals.  */
480#define YYNNTS  ]b4_nterms_number[
481/* YYNRULES -- Number of rules.  */
482#define YYNRULES  ]b4_rules_number[
483/* YYNRULES -- Number of states.  */
484#define YYNSTATES  ]b4_states_number[
485
486/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
487#define YYUNDEFTOK  ]b4_undef_token_number[
488#define YYMAXUTOK   ]b4_user_token_number_max[
489
490#define YYTRANSLATE(YYX)                                                \
491  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
492
493/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
494static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
495{
496  ]b4_translate[
497};
498
499#if YYDEBUG
500/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
501   YYRHS.  */
502static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
503{
504  ]b4_prhs[
505};
506
507/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
508static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
509{
510  ]b4_rhs[
511};
512
513/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
514static const ]b4_int_type_for([b4_rline])[ yyrline[] =
515{
516  ]b4_rline[
517};
518#endif
519
520#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
521/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
522   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
523static const char *const yytname[] =
524{
525  ]b4_tname[
526};
527#endif
528
529# ifdef YYPRINT
530/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
531   token YYLEX-NUM.  */
532static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
533{
534  ]b4_toknum[
535};
536# endif
537
538/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
539static const ]b4_int_type_for([b4_r1])[ yyr1[] =
540{
541  ]b4_r1[
542};
543
544/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
545static const ]b4_int_type_for([b4_r2])[ yyr2[] =
546{
547  ]b4_r2[
548};
549
550/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
551   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
552   means the default is an error.  */
553static const ]b4_int_type_for([b4_defact])[ yydefact[] =
554{
555  ]b4_defact[
556};
557
558/* YYDEFGOTO[NTERM-NUM].  */
559static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
560{
561  ]b4_defgoto[
562};
563
564/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
565   STATE-NUM.  */
566#define YYPACT_NINF ]b4_pact_ninf[
567static const ]b4_int_type_for([b4_pact])[ yypact[] =
568{
569  ]b4_pact[
570};
571
572/* YYPGOTO[NTERM-NUM].  */
573static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
574{
575  ]b4_pgoto[
576};
577
578/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
579   positive, shift that token.  If negative, reduce the rule which
580   number is the opposite.  If zero, do what YYDEFACT says.
581   If YYTABLE_NINF, syntax error.  */
582#define YYTABLE_NINF ]b4_table_ninf[
583static const ]b4_int_type_for([b4_table])[ yytable[] =
584{
585  ]b4_table[
586};
587
588static const ]b4_int_type_for([b4_check])[ yycheck[] =
589{
590  ]b4_check[
591};
592
593/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
594   symbol of state STATE-NUM.  */
595static const ]b4_int_type_for([b4_stos])[ yystos[] =
596{
597  ]b4_stos[
598};
599
600#define yyerrok         (yyerrstatus = 0)
601#define yyclearin       (yychar = YYEMPTY)
602#define YYEMPTY         (-2)
603#define YYEOF           0
604
605#define YYACCEPT        goto yyacceptlab
606#define YYABORT         goto yyabortlab
607#define YYERROR         goto yyerrorlab
608
609
610/* Like YYERROR except do call yyerror.  This remains here temporarily
611   to ease the transition to the new meaning of YYERROR, for GCC.
612   Once GCC version 2 has supplanted version 1, this can go.  However,
613   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
614   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
615   discussed.  */
616
617#define YYFAIL          goto yyerrlab
618#if defined YYFAIL
619  /* This is here to suppress warnings from the GCC cpp's
620     -Wunused-macros.  Normally we don't worry about that warning, but
621     some users do, and we want to make it easy for users to remove
622     YYFAIL uses, which will produce warnings from Bison 2.5.  */
623#endif
624
625#define YYRECOVERING()  (!!yyerrstatus)
626
627#define YYBACKUP(Token, Value)                                  \
628do                                                              \
629  if (yychar == YYEMPTY && yylen == 1)                          \
630    {                                                           \
631      yychar = (Token);                                         \
632      yylval = (Value);                                         \
633      yytoken = YYTRANSLATE (yychar);                           \
634      YYPOPSTACK (1);                                           \
635      goto yybackup;                                            \
636    }                                                           \
637  else                                                          \
638    {                                                           \
639      yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
640      YYERROR;                                                  \
641    }                                                           \
642while (YYID (0))
643
644
645#define YYTERROR        1
646#define YYERRCODE       256
647
648
649/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
650   If N is 0, then set CURRENT to the empty location which ends
651   the previous symbol: RHS[0] (always defined).  */
652
653#define YYRHSLOC(Rhs, K) ((Rhs)[K])
654#ifndef YYLLOC_DEFAULT
655# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
656    do                                                                  \
657      if (YYID (N))                                                    \
658        {                                                               \
659          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
660          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
661          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
662          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
663        }                                                               \
664      else                                                              \
665        {                                                               \
666          (Current).first_line   = (Current).last_line   =              \
667            YYRHSLOC (Rhs, 0).last_line;                                \
668          (Current).first_column = (Current).last_column =              \
669            YYRHSLOC (Rhs, 0).last_column;                              \
670        }                                                               \
671    while (YYID (0))
672#endif
673
674
675/* YY_LOCATION_PRINT -- Print the location on the stream.
676   This macro was not mandated originally: define only if we know
677   we won't break user code: when these are the locations we know.  */
678
679#ifndef YY_LOCATION_PRINT
680# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
681#  define YY_LOCATION_PRINT(File, Loc)                  \
682     fprintf (File, "%d.%d-%d.%d",                      \
683              (Loc).first_line, (Loc).first_column,     \
684              (Loc).last_line,  (Loc).last_column)
685# else
686#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
687# endif
688#endif
689
690
691/* YYLEX -- calling `yylex' with the right arguments.  */
692
693#ifdef YYLEX_PARAM
694# define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
695#else
696# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
697#endif
698
699/* Enable debugging if requested.  */
700#if YYDEBUG
701
702# ifndef YYFPRINTF
703#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
704#  define YYFPRINTF fprintf
705# endif
706
707# define YYDPRINTF(Args)                        \
708do {                                            \
709  if (yydebug)                                  \
710    YYFPRINTF Args;                             \
711} while (YYID (0))
712
713# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
714do {                                                                      \
715  if (yydebug)                                                            \
716    {                                                                     \
717      YYFPRINTF (stderr, "%s ", Title);                                   \
718      yy_symbol_print (stderr,                                            \
719                  Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
720      YYFPRINTF (stderr, "\n");                                           \
721    }                                                                     \
722} while (YYID (0))
723
724]b4_yy_symbol_print_generate([b4_c_function_def])[
725
726/*------------------------------------------------------------------.
727| yy_stack_print -- Print the state stack from its BOTTOM up to its |
728| TOP (included).                                                   |
729`------------------------------------------------------------------*/
730
731]b4_c_function_def([yy_stack_print], [static void],
732                   [[yytype_int16 *yybottom], [yybottom]],
733                   [[yytype_int16 *yytop],    [yytop]])[
734{
735  YYFPRINTF (stderr, "Stack now");
736  for (; yybottom <= yytop; yybottom++)
737    {
738      int yybot = *yybottom;
739      YYFPRINTF (stderr, " %d", yybot);
740    }
741  YYFPRINTF (stderr, "\n");
742}
743
744# define YY_STACK_PRINT(Bottom, Top)                            \
745do {                                                            \
746  if (yydebug)                                                  \
747    yy_stack_print ((Bottom), (Top));                           \
748} while (YYID (0))
749
750
751/*------------------------------------------------.
752| Report that the YYRULE is going to be reduced.  |
753`------------------------------------------------*/
754
755]b4_c_function_def([yy_reduce_print], [static void],
756                   [[YYSTYPE *yyvsp], [yyvsp]],
757    b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
758                   ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
759                   b4_parse_param]))[
760{
761  int yynrhs = yyr2[yyrule];
762  int yyi;
763  unsigned long int yylno = yyrline[yyrule];
764  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
765             yyrule - 1, yylno);
766  /* The symbols being reduced.  */
767  for (yyi = 0; yyi < yynrhs; yyi++)
768    {
769      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
770      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
771                       &]b4_rhs_value(yynrhs, yyi + 1)[
772                       ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
773                       b4_user_args[);
774      YYFPRINTF (stderr, "\n");
775    }
776}
777
778# define YY_REDUCE_PRINT(Rule)          \
779do {                                    \
780  if (yydebug)                          \
781    yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
782} while (YYID (0))
783
784/* Nonzero means print parse trace.  It is left uninitialized so that
785   multiple parsers can coexist.  */
786int yydebug;
787#else /* !YYDEBUG */
788# define YYDPRINTF(Args)
789# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
790# define YY_STACK_PRINT(Bottom, Top)
791# define YY_REDUCE_PRINT(Rule)
792#endif /* !YYDEBUG */
793
794
795/* YYINITDEPTH -- initial size of the parser's stacks.  */
796#ifndef YYINITDEPTH
797# define YYINITDEPTH ]b4_stack_depth_init[
798#endif
799
800/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
801   if the built-in stack extension method is used).
802
803   Do not make this value too large; the results are undefined if
804   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
805   evaluated with infinite-precision integer arithmetic.  */
806
807#ifndef YYMAXDEPTH
808# define YYMAXDEPTH ]b4_stack_depth_max[
809#endif
810
811
812
813#if YYERROR_VERBOSE
814
815# ifndef yystrlen
816#  if defined __GLIBC__ && defined _STRING_H
817#   define yystrlen strlen
818#  else
819/* Return the length of YYSTR.  */
820]b4_c_function_def([yystrlen], [static YYSIZE_T],
821   [[const char *yystr], [yystr]])[
822{
823  YYSIZE_T yylen;
824  for (yylen = 0; yystr[yylen]; yylen++)
825    continue;
826  return yylen;
827}
828#  endif
829# endif
830
831# ifndef yystpcpy
832#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
833#   define yystpcpy stpcpy
834#  else
835/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
836   YYDEST.  */
837]b4_c_function_def([yystpcpy], [static char *],
838   [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
839{
840  char *yyd = yydest;
841  const char *yys = yysrc;
842
843  while ((*yyd++ = *yys++) != '\0')
844    continue;
845
846  return yyd - 1;
847}
848#  endif
849# endif
850
851# ifndef yytnamerr
852/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
853   quotes and backslashes, so that it's suitable for yyerror.  The
854   heuristic is that double-quoting is unnecessary unless the string
855   contains an apostrophe, a comma, or backslash (other than
856   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
857   null, do not copy; instead, return the length of what the result
858   would have been.  */
859static YYSIZE_T
860yytnamerr (char *yyres, const char *yystr)
861{
862  if (*yystr == '"')
863    {
864      YYSIZE_T yyn = 0;
865      char const *yyp = yystr;
866
867      for (;;)
868        switch (*++yyp)
869          {
870          case '\'':
871          case ',':
872            goto do_not_strip_quotes;
873
874          case '\\':
875            if (*++yyp != '\\')
876              goto do_not_strip_quotes;
877            /* Fall through.  */
878          default:
879            if (yyres)
880              yyres[yyn] = *yyp;
881            yyn++;
882            break;
883
884          case '"':
885            if (yyres)
886              yyres[yyn] = '\0';
887            return yyn;
888          }
889    do_not_strip_quotes: ;
890    }
891
892  if (! yyres)
893    return yystrlen (yystr);
894
895  return yystpcpy (yyres, yystr) - yyres;
896}
897# endif
898
899/* Copy into YYRESULT an error message about the unexpected token
900   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
901   including the terminating null byte.  If YYRESULT is null, do not
902   copy anything; just return the number of bytes that would be
903   copied.  As a special case, return 0 if an ordinary "syntax error"
904   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
905   size calculation.  */
906static YYSIZE_T
907yysyntax_error (char *yyresult, int yystate, int yychar)
908{
909  int yyn = yypact[yystate];
910
911  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
912    return 0;
913  else
914    {
915      int yytype = YYTRANSLATE (yychar);
916      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
917      YYSIZE_T yysize = yysize0;
918      YYSIZE_T yysize1;
919      int yysize_overflow = 0;
920      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
921      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
922      int yyx;
923
924# if 0
925      /* This is so xgettext sees the translatable formats that are
926         constructed on the fly.  */
927      YY_("syntax error, unexpected %s");
928      YY_("syntax error, unexpected %s, expecting %s");
929      YY_("syntax error, unexpected %s, expecting %s or %s");
930      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
931      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
932# endif
933      char *yyfmt;
934      char const *yyf;
935      static char const yyunexpected[] = "syntax error, unexpected %s";
936      static char const yyexpecting[] = ", expecting %s";
937      static char const yyor[] = " or %s";
938      char yyformat[sizeof yyunexpected
939                    + sizeof yyexpecting - 1
940                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
941                       * (sizeof yyor - 1))];
942      char const *yyprefix = yyexpecting;
943
944      /* Start YYX at -YYN if negative to avoid negative indexes in
945         YYCHECK.  */
946      int yyxbegin = yyn < 0 ? -yyn : 0;
947
948      /* Stay within bounds of both yycheck and yytname.  */
949      int yychecklim = YYLAST - yyn + 1;
950      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
951      int yycount = 1;
952
953      yyarg[0] = yytname[yytype];
954      yyfmt = yystpcpy (yyformat, yyunexpected);
955
956      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
957        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
958          {
959            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
960              {
961                yycount = 1;
962                yysize = yysize0;
963                yyformat[sizeof yyunexpected - 1] = '\0';
964                break;
965              }
966            yyarg[yycount++] = yytname[yyx];
967            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
968            yysize_overflow |= (yysize1 < yysize);
969            yysize = yysize1;
970            yyfmt = yystpcpy (yyfmt, yyprefix);
971            yyprefix = yyor;
972          }
973
974      yyf = YY_(yyformat);
975      yysize1 = yysize + yystrlen (yyf);
976      yysize_overflow |= (yysize1 < yysize);
977      yysize = yysize1;
978
979      if (yysize_overflow)
980        return YYSIZE_MAXIMUM;
981
982      if (yyresult)
983        {
984          /* Avoid sprintf, as that infringes on the user's name space.
985             Don't have undefined behavior even if the translation
986             produced a string with the wrong number of "%s"s.  */
987          char *yyp = yyresult;
988          int yyi = 0;
989          while ((*yyp = *yyf) != '\0')
990            {
991              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
992                {
993                  yyp += yytnamerr (yyp, yyarg[yyi++]);
994                  yyf += 2;
995                }
996              else
997                {
998                  yyp++;
999                  yyf++;
1000                }
1001            }
1002        }
1003      return yysize;
1004    }
1005}
1006#endif /* YYERROR_VERBOSE */
1007
1008
1009]b4_yydestruct_generate([b4_c_function_def])[
1010
1011]b4_push_if([],
1012[[/* Prevent warnings from -Wmissing-prototypes.  */
1013#ifdef YYPARSE_PARAM
1014]b4_c_function_decl([yyparse], [int],
1015   [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1016#else /* ! YYPARSE_PARAM */
1017]b4_c_function_decl([yyparse], [int], b4_parse_param)[
1018#endif /* ! YYPARSE_PARAM */]])
1019
1020m4_divert_push([KILL])# ======================== M4 code.
1021# b4_declare_scanner_communication_variables
1022# ------------------------------------------
1023# Declare the variables that are global, or local to YYPARSE if
1024# pure-parser.
1025m4_define([b4_declare_scanner_communication_variables],
1026[[/* The lookahead symbol.  */
1027int yychar;
1028
1029/* The semantic value of the lookahead symbol.  */
1030YYSTYPE yylval;
1031]b4_locations_if([[
1032/* Location data for the lookahead symbol.  */
1033YYLTYPE yylloc;
1034]])b4_pure_if([], [[
1035/* Number of syntax errors so far.  */
1036int yynerrs;
1037]])])
1038
1039# b4_declare_parser_state_variables
1040# ---------------------------------
1041# Declare all the variables that are needed to maintain the parser state
1042# between calls to yypush_parse.
1043m4_define([b4_declare_parser_state_variables],
1044[b4_pure_if([[    /* Number of syntax errors so far.  */
1045    int yynerrs;
1046]])[
1047    int yystate;
1048    /* Number of tokens to shift before error messages enabled.  */
1049    int yyerrstatus;
1050
1051    /* The stacks and their tools:
1052       `yyss': related to states.
1053       `yyvs': related to semantic values.]b4_locations_if([[
1054       `yyls': related to locations.]])[
1055
1056       Refer to the stacks thru separate pointers, to allow yyoverflow
1057       to reallocate them elsewhere.  */
1058
1059    /* The state stack.  */
1060    yytype_int16 yyssa[YYINITDEPTH];
1061    yytype_int16 *yyss;
1062    yytype_int16 *yyssp;
1063
1064    /* The semantic value stack.  */
1065    YYSTYPE yyvsa[YYINITDEPTH];
1066    YYSTYPE *yyvs;
1067    YYSTYPE *yyvsp;
1068]b4_locations_if([[
1069    /* The location stack.  */
1070    YYLTYPE yylsa[YYINITDEPTH];
1071    YYLTYPE *yyls;
1072    YYLTYPE *yylsp;
1073
1074    /* The locations where the error started and ended.  */
1075    YYLTYPE yyerror_range[2];
1076]])[
1077    YYSIZE_T yystacksize;
1078]])
1079
1080m4_divert_pop([KILL])dnl# ====================== End of M4 code.
1081
1082b4_pure_if([], [b4_declare_scanner_communication_variables])
1083
1084b4_push_if(
1085[[struct yypstate
1086  {
1087    ]b4_declare_parser_state_variables[
1088    /* Used to determine if this is the first time this instance has
1089       been used.  */
1090    int yynew;
1091  };]b4_pure_if([], [[
1092
1093static char yypstate_allocated = 0;]])b4_pull_if([
1094
1095b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1096{
1097  return yypull_parse (0]m4_ifset([b4_parse_param],
1098                                  [[, ]b4_c_args(b4_parse_param)])[);
1099}
1100
1101]b4_c_function_def([[yypull_parse]], [[int]],
1102  [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1103  b4_parse_param]))[
1104{
1105  int yystatus;
1106  yypstate *yyps_local;]b4_pure_if([[
1107  int yychar;
1108  YYSTYPE yylval;]b4_locations_if([[
1109  YYLTYPE yylloc;]])])[
1110  if (yyps == 0)
1111    {
1112      yyps_local = yypstate_new ();
1113      if (!yyps_local)
1114        {]b4_pure_if([[
1115          yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1116          if (!yypstate_allocated)
1117            yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1118          return 2;
1119        }
1120    }
1121  else
1122    yyps_local = yyps;
1123  do {
1124    yychar = YYLEX;
1125    yystatus =
1126      yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1127  } while (yystatus == YYPUSH_MORE);
1128  if (yyps == 0)
1129    yypstate_delete (yyps_local);
1130  return yystatus;
1131}]])[
1132
1133/* Initialize the parser data structure.  */
1134]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1135{
1136  yypstate *yyps;]b4_pure_if([], [[
1137  if (yypstate_allocated)
1138    return 0;]])[
1139  yyps = (yypstate *) malloc (sizeof *yyps);
1140  if (!yyps)
1141    return 0;
1142  yyps->yynew = 1;]b4_pure_if([], [[
1143  yypstate_allocated = 1;]])[
1144  return yyps;
1145}
1146
1147]b4_c_function_def([[yypstate_delete]], [[void]],
1148                   [[[yypstate *yyps]], [[yyps]]])[
1149{
1150#ifndef yyoverflow
1151  /* If the stack was reallocated but the parse did not complete, then the
1152     stack still needs to be freed.  */
1153  if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1154    YYSTACK_FREE (yyps->yyss);
1155#endif
1156  free (yyps);]b4_pure_if([], [[
1157  yypstate_allocated = 0;]])[
1158}
1159
1160]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs
1161]])[#define yystate yyps->yystate
1162#define yyerrstatus yyps->yyerrstatus
1163#define yyssa yyps->yyssa
1164#define yyss yyps->yyss
1165#define yyssp yyps->yyssp
1166#define yyvsa yyps->yyvsa
1167#define yyvs yyps->yyvs
1168#define yyvsp yyps->yyvsp
1169]b4_locations_if([[#define yylsa yyps->yylsa
1170#define yyls yyps->yyls
1171#define yylsp yyps->yylsp
1172#define yyerror_range yyps->yyerror_range
1173]])[#define yystacksize yyps->yystacksize
1174]])[
1175/*-------------------------.
1176| yyparse or yypush_parse.  |
1177`-------------------------*/
1178]b4_push_if([
1179b4_c_function_def([[yypush_parse]], [[int]],
1180  [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1181  [[[int yypushed_char]], [[yypushed_char]]],
1182  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1183  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1184  b4_parse_param]))], [
1185#ifdef YYPARSE_PARAM
1186b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1187#else /* ! YYPARSE_PARAM */
1188b4_c_function_def([yyparse], [int], b4_parse_param)
1189#endif])[
1190{
1191]b4_pure_if([b4_declare_scanner_communication_variables])
1192b4_push_if([b4_pure_if([], [[  int yypushed_char = yychar;
1193  YYSTYPE yypushed_val = yylval;
1194  ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc;
1195]])])],
1196  [b4_declare_parser_state_variables])[
1197  int yyn;
1198  int yyresult;
1199  /* Lookahead token as an internal (translated) token number.  */
1200  int yytoken;
1201  /* The variables used to return semantic value and location from the
1202     action routines.  */
1203  YYSTYPE yyval;]b4_locations_if([[
1204  YYLTYPE yyloc;]])[
1205
1206#if YYERROR_VERBOSE
1207  /* Buffer for error messages, and its allocated size.  */
1208  char yymsgbuf[128];
1209  char *yymsg = yymsgbuf;
1210  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1211#endif
1212
1213#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1214
1215  /* The number of symbols on the RHS of the reduced rule.
1216     Keep to zero when no symbol should be popped.  */
1217  int yylen = 0;]b4_push_if([[
1218
1219  if (!yyps->yynew)
1220    {
1221      yyn = yypact[yystate];
1222      goto yyread_pushed_token;
1223    }]])[
1224
1225  yytoken = 0;
1226  yyss = yyssa;
1227  yyvs = yyvsa;]b4_locations_if([[
1228  yyls = yylsa;]])[
1229  yystacksize = YYINITDEPTH;
1230
1231  YYDPRINTF ((stderr, "Starting parse\n"));
1232
1233  yystate = 0;
1234  yyerrstatus = 0;
1235  yynerrs = 0;
1236  yychar = YYEMPTY; /* Cause a token to be read.  */
1237
1238  /* Initialize stack pointers.
1239     Waste one element of value and location stack
1240     so that they stay on the same level as the state stack.
1241     The wasted elements are never initialized.  */
1242  yyssp = yyss;
1243  yyvsp = yyvs;]b4_locations_if([[
1244  yylsp = yyls;
1245
1246#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1247  /* Initialize the default location before parsing starts.  */
1248  yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
1249  yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1250#endif]])
1251m4_ifdef([b4_initial_action],[
1252m4_pushdef([b4_at_dollar],     [m4_define([b4_at_dollar_used])yylloc])dnl
1253m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1254/* User initialization code.  */
1255b4_user_initial_action
1256m4_popdef([b4_dollar_dollar])dnl
1257m4_popdef([b4_at_dollar])])dnl
1258m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
1259]])dnl
1260m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
1261]])[
1262  goto yysetstate;
1263
1264/*------------------------------------------------------------.
1265| yynewstate -- Push a new state, which is found in yystate.  |
1266`------------------------------------------------------------*/
1267 yynewstate:
1268  /* In all cases, when you get here, the value and location stacks
1269     have just been pushed.  So pushing a state here evens the stacks.  */
1270  yyssp++;
1271
1272 yysetstate:
1273  *yyssp = yystate;
1274
1275  if (yyss + yystacksize - 1 <= yyssp)
1276    {
1277      /* Get the current used size of the three stacks, in elements.  */
1278      YYSIZE_T yysize = yyssp - yyss + 1;
1279
1280#ifdef yyoverflow
1281      {
1282        /* Give user a chance to reallocate the stack.  Use copies of
1283           these so that the &'s don't force the real ones into
1284           memory.  */
1285        YYSTYPE *yyvs1 = yyvs;
1286        yytype_int16 *yyss1 = yyss;]b4_locations_if([
1287        YYLTYPE *yyls1 = yyls;])[
1288
1289        /* Each stack pointer address is followed by the size of the
1290           data in use in that stack, in bytes.  This used to be a
1291           conditional around just the two extra args, but that might
1292           be undefined if yyoverflow is a macro.  */
1293        yyoverflow (YY_("memory exhausted"),
1294                    &yyss1, yysize * sizeof (*yyssp),
1295                    &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1296                    &yyls1, yysize * sizeof (*yylsp),])[
1297                    &yystacksize);
1298]b4_locations_if([
1299        yyls = yyls1;])[
1300        yyss = yyss1;
1301        yyvs = yyvs1;
1302      }
1303#else /* no yyoverflow */
1304# ifndef YYSTACK_RELOCATE
1305      goto yyexhaustedlab;
1306# else
1307      /* Extend the stack our own way.  */
1308      if (YYMAXDEPTH <= yystacksize)
1309        goto yyexhaustedlab;
1310      yystacksize *= 2;
1311      if (YYMAXDEPTH < yystacksize)
1312        yystacksize = YYMAXDEPTH;
1313
1314      {
1315        yytype_int16 *yyss1 = yyss;
1316        union yyalloc *yyptr =
1317          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1318        if (! yyptr)
1319          goto yyexhaustedlab;
1320        YYSTACK_RELOCATE (yyss_alloc, yyss);
1321        YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1322        YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1323#  undef YYSTACK_RELOCATE
1324        if (yyss1 != yyssa)
1325          YYSTACK_FREE (yyss1);
1326      }
1327# endif
1328#endif /* no yyoverflow */
1329
1330      yyssp = yyss + yysize - 1;
1331      yyvsp = yyvs + yysize - 1;]b4_locations_if([
1332      yylsp = yyls + yysize - 1;])[
1333
1334      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1335                  (unsigned long int) yystacksize));
1336
1337      if (yyss + yystacksize - 1 <= yyssp)
1338        YYABORT;
1339    }
1340
1341  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1342
1343  if (yystate == YYFINAL)
1344    YYACCEPT;
1345
1346  goto yybackup;
1347
1348/*-----------.
1349| yybackup.  |
1350`-----------*/
1351yybackup:
1352
1353  /* Do appropriate processing given the current state.  Read a
1354     lookahead token if we need one and don't already have one.  */
1355
1356  /* First try to decide what to do without reference to lookahead token.  */
1357  yyn = yypact[yystate];
1358  if (yyn == YYPACT_NINF)
1359    goto yydefault;
1360
1361  /* Not known => get a lookahead token if don't already have one.  */
1362
1363  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1364  if (yychar == YYEMPTY)
1365    {]b4_push_if([[
1366      if (!yyps->yynew)
1367        {]b4_use_push_for_pull_if([], [[
1368          YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1369          yyresult = YYPUSH_MORE;
1370          goto yypushreturn;
1371        }
1372      yyps->yynew = 0;]b4_pure_if([], [[
1373      /* Restoring the pushed token is only necessary for the first
1374         yypush_parse invocation since subsequent invocations don't overwrite
1375         it before jumping to yyread_pushed_token.  */
1376      yychar = yypushed_char;
1377      yylval = yypushed_val;]b4_locations_if([[
1378      yylloc = yypushed_loc;]])])[
1379yyread_pushed_token:]])[
1380      YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1381      yychar = yypushed_char;
1382      if (yypushed_val)
1383        yylval = *yypushed_val;]b4_locations_if([[
1384      if (yypushed_loc)
1385        yylloc = *yypushed_loc;]])])], [[
1386      yychar = YYLEX;]])[
1387    }
1388
1389  if (yychar <= YYEOF)
1390    {
1391      yychar = yytoken = YYEOF;
1392      YYDPRINTF ((stderr, "Now at end of input.\n"));
1393    }
1394  else
1395    {
1396      yytoken = YYTRANSLATE (yychar);
1397      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1398    }
1399
1400  /* If the proper action on seeing token YYTOKEN is to reduce or to
1401     detect an error, take that action.  */
1402  yyn += yytoken;
1403  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1404    goto yydefault;
1405  yyn = yytable[yyn];
1406  if (yyn <= 0)
1407    {
1408      if (yyn == 0 || yyn == YYTABLE_NINF)
1409        goto yyerrlab;
1410      yyn = -yyn;
1411      goto yyreduce;
1412    }
1413
1414  /* Count tokens shifted since error; after three, turn off error
1415     status.  */
1416  if (yyerrstatus)
1417    yyerrstatus--;
1418
1419  /* Shift the lookahead token.  */
1420  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1421
1422  /* Discard the shifted token.  */
1423  yychar = YYEMPTY;
1424
1425  yystate = yyn;
1426  *++yyvsp = yylval;
1427]b4_locations_if([  *++yylsp = yylloc;])[
1428  goto yynewstate;
1429
1430
1431/*-----------------------------------------------------------.
1432| yydefault -- do the default action for the current state.  |
1433`-----------------------------------------------------------*/
1434yydefault:
1435  yyn = yydefact[yystate];
1436  if (yyn == 0)
1437    goto yyerrlab;
1438  goto yyreduce;
1439
1440
1441/*-----------------------------.
1442| yyreduce -- Do a reduction.  |
1443`-----------------------------*/
1444yyreduce:
1445  /* yyn is the number of a rule to reduce with.  */
1446  yylen = yyr2[yyn];
1447
1448  /* If YYLEN is nonzero, implement the default value of the action:
1449     `$$ = $1'.
1450
1451     Otherwise, the following line sets YYVAL to garbage.
1452     This behavior is undocumented and Bison
1453     users should not rely upon it.  Assigning to YYVAL
1454     unconditionally makes the parser a bit smaller, and it avoids a
1455     GCC warning that YYVAL may be used uninitialized.  */
1456  yyval = yyvsp[1-yylen];
1457
1458]b4_locations_if(
1459[[  /* Default location.  */
1460  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1461  YY_REDUCE_PRINT (yyn);
1462  switch (yyn)
1463    {
1464      ]b4_user_actions[
1465      default: break;
1466    }
1467  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1468
1469  YYPOPSTACK (yylen);
1470  yylen = 0;
1471  YY_STACK_PRINT (yyss, yyssp);
1472
1473  *++yyvsp = yyval;]b4_locations_if([
1474  *++yylsp = yyloc;])[
1475
1476  /* Now `shift' the result of the reduction.  Determine what state
1477     that goes to, based on the state we popped back to and the rule
1478     number reduced by.  */
1479
1480  yyn = yyr1[yyn];
1481
1482  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1483  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1484    yystate = yytable[yystate];
1485  else
1486    yystate = yydefgoto[yyn - YYNTOKENS];
1487
1488  goto yynewstate;
1489
1490
1491/*------------------------------------.
1492| yyerrlab -- here on detecting error |
1493`------------------------------------*/
1494yyerrlab:
1495  /* If not already recovering from an error, report this error.  */
1496  if (!yyerrstatus)
1497    {
1498      ++yynerrs;
1499#if ! YYERROR_VERBOSE
1500      yyerror (]b4_yyerror_args[YY_("syntax error"));
1501#else
1502      {
1503        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1504        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1505          {
1506            YYSIZE_T yyalloc = 2 * yysize;
1507            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1508              yyalloc = YYSTACK_ALLOC_MAXIMUM;
1509            if (yymsg != yymsgbuf)
1510              YYSTACK_FREE (yymsg);
1511            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1512            if (yymsg)
1513              yymsg_alloc = yyalloc;
1514            else
1515              {
1516                yymsg = yymsgbuf;
1517                yymsg_alloc = sizeof yymsgbuf;
1518              }
1519          }
1520
1521        if (0 < yysize && yysize <= yymsg_alloc)
1522          {
1523            (void) yysyntax_error (yymsg, yystate, yychar);
1524            yyerror (]b4_yyerror_args[yymsg);
1525          }
1526        else
1527          {
1528            yyerror (]b4_yyerror_args[YY_("syntax error"));
1529            if (yysize != 0)
1530              goto yyexhaustedlab;
1531          }
1532      }
1533#endif
1534    }
1535
1536]b4_locations_if([[  yyerror_range[0] = yylloc;]])[
1537
1538  if (yyerrstatus == 3)
1539    {
1540      /* If just tried and failed to reuse lookahead token after an
1541         error, discard it.  */
1542
1543      if (yychar <= YYEOF)
1544        {
1545          /* Return failure if at end of input.  */
1546          if (yychar == YYEOF)
1547            YYABORT;
1548        }
1549      else
1550        {
1551          yydestruct ("Error: discarding",
1552                      yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1553          yychar = YYEMPTY;
1554        }
1555    }
1556
1557  /* Else will try to reuse lookahead token after shifting the error
1558     token.  */
1559  goto yyerrlab1;
1560
1561
1562/*---------------------------------------------------.
1563| yyerrorlab -- error raised explicitly by YYERROR.  |
1564`---------------------------------------------------*/
1565yyerrorlab:
1566
1567  /* Pacify compilers like GCC when the user code never invokes
1568     YYERROR and the label yyerrorlab therefore never appears in user
1569     code.  */
1570  if (/*CONSTCOND*/ 0)
1571     goto yyerrorlab;
1572
1573]b4_locations_if([[  yyerror_range[0] = yylsp[1-yylen];
1574]])[  /* Do not reclaim the symbols of the rule which action triggered
1575     this YYERROR.  */
1576  YYPOPSTACK (yylen);
1577  yylen = 0;
1578  YY_STACK_PRINT (yyss, yyssp);
1579  yystate = *yyssp;
1580  goto yyerrlab1;
1581
1582
1583/*-------------------------------------------------------------.
1584| yyerrlab1 -- common code for both syntax error and YYERROR.  |
1585`-------------------------------------------------------------*/
1586yyerrlab1:
1587  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1588
1589  for (;;)
1590    {
1591      yyn = yypact[yystate];
1592      if (yyn != YYPACT_NINF)
1593        {
1594          yyn += YYTERROR;
1595          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1596            {
1597              yyn = yytable[yyn];
1598              if (0 < yyn)
1599                break;
1600            }
1601        }
1602
1603      /* Pop the current state because it cannot handle the error token.  */
1604      if (yyssp == yyss)
1605        YYABORT;
1606
1607]b4_locations_if([[      yyerror_range[0] = *yylsp;]])[
1608      yydestruct ("Error: popping",
1609                  yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1610      YYPOPSTACK (1);
1611      yystate = *yyssp;
1612      YY_STACK_PRINT (yyss, yyssp);
1613    }
1614
1615  *++yyvsp = yylval;
1616]b4_locations_if([[
1617  yyerror_range[1] = yylloc;
1618  /* Using YYLLOC is tempting, but would change the location of
1619     the lookahead.  YYLOC is available though.  */
1620  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1621  *++yylsp = yyloc;]])[
1622
1623  /* Shift the error token.  */
1624  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1625
1626  yystate = yyn;
1627  goto yynewstate;
1628
1629
1630/*-------------------------------------.
1631| yyacceptlab -- YYACCEPT comes here.  |
1632`-------------------------------------*/
1633yyacceptlab:
1634  yyresult = 0;
1635  goto yyreturn;
1636
1637/*-----------------------------------.
1638| yyabortlab -- YYABORT comes here.  |
1639`-----------------------------------*/
1640yyabortlab:
1641  yyresult = 1;
1642  goto yyreturn;
1643
1644#if !defined(yyoverflow) || YYERROR_VERBOSE
1645/*-------------------------------------------------.
1646| yyexhaustedlab -- memory exhaustion comes here.  |
1647`-------------------------------------------------*/
1648yyexhaustedlab:
1649  yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1650  yyresult = 2;
1651  /* Fall through.  */
1652#endif
1653
1654yyreturn:
1655  if (yychar != YYEMPTY)
1656     yydestruct ("Cleanup: discarding lookahead",
1657                 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1658  /* Do not reclaim the symbols of the rule which action triggered
1659     this YYABORT or YYACCEPT.  */
1660  YYPOPSTACK (yylen);
1661  YY_STACK_PRINT (yyss, yyssp);
1662  while (yyssp != yyss)
1663    {
1664      yydestruct ("Cleanup: popping",
1665                  yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1666      YYPOPSTACK (1);
1667    }
1668#ifndef yyoverflow
1669  if (yyss != yyssa)
1670    YYSTACK_FREE (yyss);
1671#endif
1672]b4_push_if([[  yyps->yynew = 1;
1673
1674yypushreturn:
1675]])[#if YYERROR_VERBOSE
1676  if (yymsg != yymsgbuf)
1677    YYSTACK_FREE (yymsg);
1678#endif
1679  /* Make sure YYID is used.  */
1680  return YYID (yyresult);
1681}
1682
1683
1684]b4_epilogue
1685b4_defines_if(
1686[@output(b4_spec_defines_file@)@
1687b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],
1688             [1984, 1989-1990, 2000-2006, 2009-2010])
1689
1690b4_percent_code_get([[requires]])[]dnl
1691
1692b4_token_enums_defines(b4_tokens)
1693
1694[#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1695]m4_ifdef([b4_stype],
1696[[typedef union ]b4_union_name[
1697{
1698]b4_user_stype[
1699} YYSTYPE;
1700# define YYSTYPE_IS_TRIVIAL 1]],
1701[m4_if(b4_tag_seen_flag, 0,
1702[[typedef int YYSTYPE;
1703# define YYSTYPE_IS_TRIVIAL 1]])])[
1704# define yystype YYSTYPE /* obsolescent; will be withdrawn */
1705# define YYSTYPE_IS_DECLARED 1
1706#endif
1707
1708]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1709
1710b4_locations_if(
1711[#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1712typedef struct YYLTYPE
1713{
1714  int first_line;
1715  int first_column;
1716  int last_line;
1717  int last_column;
1718} YYLTYPE;
1719# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1720# define YYLTYPE_IS_DECLARED 1
1721# define YYLTYPE_IS_TRIVIAL 1
1722#endif
1723
1724]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1725)dnl b4_locations_if
1726b4_push_if([[
1727#ifndef YYPUSH_DECLS
1728#  define YYPUSH_DECLS
1729struct ]b4_prefix[pstate;
1730typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1731enum { YYPUSH_MORE = 4 };
1732]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1733])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1734  [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1735  [[[int yypushed_char]], [[yypushed_char]]],
1736  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1737  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1738  b4_parse_param]))
1739b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1740  [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1741  b4_parse_param]))])
1742b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1743                    [[[void]], []])
1744b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1745                   [[b4_prefix[pstate *yyps]], [[yyps]]])[
1746#endif
1747]])
1748b4_percent_code_get([[provides]])[]dnl
1749])dnl b4_defines_if
1750m4_divert_pop(0)
Note: See TracBrowser for help on using the repository browser.