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