(state_number): Renamed from state_number_t.

[bison.git] / data / yacc.c

diff --git a/data/yacc.c b/data/yacc.c
index 31ee8436c85111bbd88ea622c91ad34208ec8ebf..4cf0b05f0ca9cfa34f69cc96036244bc9845c21f 100644 (file)
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -20,6 +20,79 @@ m4_include([c.m4])
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 # 02111-1307  USA
 
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 # 02111-1307  USA
 

+
+
+## ---------------- ##
+## Default values.  ##
+## ---------------- ##
+
+# Stack parameters.
+m4_define_default([b4_stack_depth_max], [10000])
+m4_define_default([b4_stack_depth_init],  [200])
+
+# Location type.
+m4_define_default([b4_location_type], [yyltype])
+
+
+## ------------------------ ##
+## Pure/impure interfaces.  ##
+## ------------------------ ##
+
+
+# b4_pure_if(IF-TRUE, IF-FALSE)
+# -----------------------------
+# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
+m4_define([b4_Pure_if],
+[b4_pure_if([m4_ifset([b4_parse_param],
+                      [$1], [$2])],
+            [$2])])
+
+
+# b4_yyerror_args
+# ---------------
+# Arguments passed to yyerror: user args plus yylloc.
+m4_define([b4_yyerror_args],
+[b4_Pure_if([b4_location_if([&yylloc, ])])dnl
+m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
+
+
+# b4_lex_param
+# ------------
+# Accumule in b4_lex_param all the yylex arguments.
+# b4_lex_param arrives quoted twice, but we want to keep only one level.
+m4_define([b4_lex_param],
+m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
+b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl
+m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
+
+
+
+## ------------ ##
+## Data Types.  ##
+## ------------ ##
+
+# b4_int_type(MIN, MAX)
+# ---------------------
+# Return the smallest int type able to handle numbers ranging from
+# MIN to MAX (included).  We overwrite the version from c.m4 which relies
+# on "signed char" which is not portable to old K&R compilers.
+m4_define([b4_int_type],
+[m4_if(b4_ints_in($@,      [0],   [255]), [1], [unsigned char],
+       b4_ints_in($@,   [-128],   [127]), [1], [yysigned_char],
+
+       b4_ints_in($@,      [0], [65535]), [1], [unsigned short],
+       b4_ints_in($@, [-32768], [32767]), [1], [short],
+
+       m4_eval([0 <= $1]),                [1], [unsigned int],
+
+                                              [int])])
+
+
+## ----------------- ##
+## Semantic Values.  ##
+## ----------------- ##
+
+

 # b4_lhs_value([TYPE])
 # --------------------
 # Expansion of $<TYPE>$.
 # b4_lhs_value([TYPE])
 # --------------------
 # Expansion of $<TYPE>$.


@@ -32,7 +105,7 @@ m4_define([b4_lhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],

-[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
+[yyvsp@{m4_eval([$2 - $1])@}m4_ifval([$3], [.$3])])

 
 
 
 
 
 


@@ -40,15 +113,6 @@ m4_define([b4_rhs_value],
 ## Locations.  ##
 ## ----------- ##
 
 ## Locations.  ##
 ## ----------- ##
 

-# b4_location_if(IF-TRUE, IF-FALSE)
-# ---------------------------------
-# Expand IF-TRUE, if locations are used, IF-FALSE otherwise.
-m4_define([b4_location_if],
-[m4_if(b4_locations_flag, [1],
-       [$1],
-       [$2])])
-
-

 # b4_lhs_location()
 # -----------------
 # Expansion of @$.
 # b4_lhs_location()
 # -----------------
 # Expansion of @$.


@@ -61,45 +125,7 @@ m4_define([b4_lhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],

-[yylsp@<:@m4_eval([$2 - $1])@:>@])
-
-
-
-## -------------- ##
-## %pure-parser.  ##
-## -------------- ##
-
-# b4_pure_if(IF-TRUE, IF-FALSE)
-# -----------------------------
-# Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise.
-m4_define([b4_pure_if],
-[m4_if(b4_pure, [1],
-       [$1],
-       [$2])])
-
-
-## ------------------- ##
-## Output file names.  ##
-## ------------------- ##
-
-m4_define_default([b4_input_suffix], [.y])
-
-m4_define_default([b4_output_parser_suffix],
-[m4_translit(b4_input_suffix, [yY], [cC])])
-
-m4_define_default([b4_output_parser_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
-
-
-m4_define_default([b4_output_header_suffix],
-[m4_translit(b4_input_suffix, [yY], [hH])])
-
-m4_define_default([b4_output_header_name],
-[b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
-
-m4_define_default([b4_header_guard],
-                  [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
-                                [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
+[yylsp@{m4_eval([$2 - $1])@}])

 
 
 
 
 
 


@@ -107,28 +133,12 @@ m4_define_default([b4_header_guard],
 ## Defining symbol actions, e.g., printers and destructors.  ##
 ## --------------------------------------------------------- ##
 
 ## Defining symbol actions, e.g., printers and destructors.  ##
 ## --------------------------------------------------------- ##
 

-# b4_symbol_actions(FILENAME, LINENO,
-#                   SYMBOL-TAG, SYMBOL-NUM,
-#                   SYMBOL-ACTION, SYMBOL-TYPENAME)
-# -------------------------------------------------
-m4_define([b4_symbol_actions],
-[m4_pushdef([b4_dollar_dollar], [yyvalue.$6])dnl
-m4_pushdef([b4_at_dollar], [yylocation])dnl
-      case $4: /* $3 */
-#line $2 "$1"
-        $5;
-#line __oline__ "__ofile__"
-        break;
-m4_popdef([b4_at_dollar])dnl
-m4_popdef([b4_dollar_dollar])dnl
-])
-
-
-
+# We do want M4 expansion after # for CPP macros.
+m4_changecom()

 m4_divert(0)dnl
 m4_divert(0)dnl

-#output "b4_output_parser_name"
+@output @output_parser_name@

 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],

-             [1984, 1989, 1990, 2000, 2001, 2002])
+             [1984, 1989, 1990, 2000, 2001, 2002])[

 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.


@@ -145,15 +155,7 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 

-/* Identify Bison output.  */
-#define YYBISON        1
-
-/* Pure parsers.  */
-#define YYPURE b4_pure
-
-/* Using locations.  */
-#define YYLSP_NEEDED b4_locations_flag
-
+]b4_identification

 m4_if(b4_prefix[], [yy], [],
 [/* If NAME_PREFIX is specified substitute the variables and functions
    names.  */
 m4_if(b4_prefix[], [yy], [],
 [/* If NAME_PREFIX is specified substitute the variables and functions
    names.  */


@@ -164,16 +166,16 @@ m4_if(b4_prefix[], [yy], [],
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs

-b4_location_if([#define yylloc b4_prefix[]lloc])])
+b4_location_if([#define yylloc b4_prefix[]lloc])])[

 
 

-b4_token_defines(b4_tokens)
+]b4_token_defines(b4_tokens)[

 
 /* Copy the first part of user declarations.  */
 
 /* Copy the first part of user declarations.  */

-b4_pre_prologue
+]b4_pre_prologue[

 
 /* Enabling traces.  */
 #ifndef YYDEBUG
 
 /* Enabling traces.  */
 #ifndef YYDEBUG

-# define YYDEBUG b4_debug
+# define YYDEBUG ]b4_debug[

 #endif
 
 /* Enabling verbose error messages.  */
 #endif
 
 /* Enabling verbose error messages.  */


@@ -181,16 +183,16 @@ b4_pre_prologue
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else

-# define YYERROR_VERBOSE b4_error_verbose
+# define YYERROR_VERBOSE ]b4_error_verbose[

 #endif
 
 #ifndef YYSTYPE
 #endif
 
 #ifndef YYSTYPE

-m4_ifdef([b4_stype],
-[#line b4_stype_line "b4_filename"
+]m4_ifdef([b4_stype],
+[b4_syncline([b4_stype_line], [b4_filename])

 typedef union b4_stype yystype;
 typedef union b4_stype yystype;

-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"],
-[typedef int yystype;])
+/* Line __line__ of yacc.c.  */
+b4_syncline([@oline@], [@ofile@])],
+[typedef int yystype;])[

 # define YYSTYPE yystype
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 # define YYSTYPE yystype
 # define YYSTYPE_IS_TRIVIAL 1
 #endif


@@ -203,15 +205,15 @@ typedef struct yyltype
   int last_line;
   int last_column;
 } yyltype;
   int last_line;
   int last_column;
 } yyltype;

-# define YYLTYPE b4_ltype
+# define YYLTYPE ]b4_location_type[

 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 /* Copy the second part of user declarations.  */
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 /* Copy the second part of user declarations.  */

-b4_post_prologue
+]b4_post_prologue

 
 

-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"
+/* Line __line__ of yacc.c.  */
+b4_syncline([@oline@], [@ofile@])[

 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 


@@ -254,22 +256,22 @@ union yyalloc
 {
   short yyss;
   YYSTYPE yyvs;
 {
   short yyss;
   YYSTYPE yyvs;

-  b4_location_if([  YYLTYPE yyls;
+  ]b4_location_if([  YYLTYPE yyls;

 ])dnl
 ])dnl

-};
+[};

 
 /* The size of the maximum gap between one aligned stack and the next.  */
 
 /* The size of the maximum gap between one aligned stack and the next.  */

-# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */

-b4_location_if(
+]b4_location_if(

 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \

-      + 2 * YYSTACK_GAP_MAX)],
+      + 2 * YYSTACK_GAP_MAXIMUM)],

 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \

-      + YYSTACK_GAP_MAX)])
+      + YYSTACK_GAP_MAXIMUM)])[

 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */


@@ -283,7 +285,7 @@ b4_location_if(
        {                                       \
          register YYSIZE_T yyi;                \
          for (yyi = 0; yyi < (Count); yyi++)   \
        {                                       \
          register YYSIZE_T yyi;                \
          for (yyi = 0; yyi < (Count); yyi++)   \

-           (To)[[yyi]] = (From)[[yyi]];        \
+           (To)[yyi] = (From)[yyi];            \

        }                                       \
       while (0)
 #  endif
        }                                       \
       while (0)
 #  endif


@@ -300,137 +302,146 @@ b4_location_if(
        YYSIZE_T yynewbytes;                                            \
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
        Stack = &yyptr->Stack;                                          \
        YYSIZE_T yynewbytes;                                            \
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
        Stack = &yyptr->Stack;                                          \

-       yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
+       yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
     while (0)
 
 #endif
 
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
     while (0)
 
 #endif
 

+#if defined (__STDC__) || defined (__cplusplus)
+   typedef signed char yysigned_char;
+#else
+   typedef short yysigned_char;
+#endif
+

 /* YYFINAL -- State number of the termination state. */
 /* YYFINAL -- State number of the termination state. */

-#define YYFINAL  b4_final_state_number
-#define YYLAST   b4_last
+#define YYFINAL  ]b4_final_state_number[
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   ]b4_last[

 
 /* YYNTOKENS -- Number of terminals. */
 
 /* YYNTOKENS -- Number of terminals. */

-#define YYNTOKENS  b4_tokens_number
+#define YYNTOKENS  ]b4_tokens_number[

 /* YYNNTS -- Number of nonterminals. */
 /* YYNNTS -- Number of nonterminals. */

-#define YYNNTS  b4_nterms_number
+#define YYNNTS  ]b4_nterms_number[

 /* YYNRULES -- Number of rules. */
 /* YYNRULES -- Number of rules. */

-#define YYNRULES  b4_rules_number
+#define YYNRULES  ]b4_rules_number[

 /* YYNRULES -- Number of states. */
 /* YYNRULES -- Number of states. */

-#define YYNSTATES  b4_states_number
+#define YYNSTATES  ]b4_states_number[

 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */

-#define YYUNDEFTOK  b4_undef_token_number
-#define YYMAXUTOK   b4_user_token_number_max
+#define YYUNDEFTOK  ]b4_undef_token_number[
+#define YYMAXUTOK   ]b4_user_token_number_max[

 
 

-#define YYTRANSLATE(X) \
-  ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
+#define YYTRANSLATE(YYX)                                               \
+  ((YYX <= 0) ? YYEOF :                                                        \
+   (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

 
 

-/* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
-static const b4_int_type_for([b4_translate]) yytranslate[[]] =
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const ]b4_int_type_for([b4_translate])[ yytranslate[] =

 {
 {

-  b4_translate
+  ]b4_translate[

 };
 
 #if YYDEBUG
 };
 
 #if YYDEBUG

-/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in

    YYRHS.  */
    YYRHS.  */

-static const b4_int_type_for([b4_prhs]) yyprhs[[]] =
+static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =

 {
 {

-  b4_prhs
+  ]b4_prhs[

 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */

-static const b4_int_type_for([b4_rhs]) yyrhs[[]] =
+static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =

 {
 {

-  b4_rhs
+  ]b4_rhs[

 };
 
 };
 

-/* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
-static const b4_int_type_for([b4_rline]) yyrline[[]] =
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const ]b4_int_type_for([b4_rline])[ yyrline[] =

 {
 {

-  b4_rline
+  ]b4_rline[

 };
 #endif
 
 #if YYDEBUG || YYERROR_VERBOSE
 };
 #endif
 
 #if YYDEBUG || YYERROR_VERBOSE

-/* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
+/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.

    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */

-static const char *const yytname[[]] =
+static const char *const yytname[] =

 {
 {

-  b4_tname
+  ]b4_tname[

 };
 #endif
 
 # ifdef YYPRINT
 };
 #endif
 
 # ifdef YYPRINT

-/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to

    token YYLEX-NUM.  */
    token YYLEX-NUM.  */

-static const b4_int_type_for([b4_toknum]) yytoknum[[]] =
+static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =

 {
 {

-  b4_toknum
+  ]b4_toknum[

 };
 # endif
 
 };
 # endif
 

-/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
-static const b4_int_type_for([b4_r1]) yyr1[[]] =
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const ]b4_int_type_for([b4_r1])[ yyr1[] =

 {
 {

-  b4_r1
+  ]b4_r1[

 };
 
 };
 

-/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
-static const b4_int_type_for([b4_r2]) yyr2[[]] =
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const ]b4_int_type_for([b4_r2])[ yyr2[] =

 {
 {

-  b4_r2
+  ]b4_r2[

 };
 
 };
 

-/* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state

    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */

-static const b4_int_type_for([b4_defact]) yydefact[[]] =
+static const ]b4_int_type_for([b4_defact])[ yydefact[] =

 {
 {

-  b4_defact
+  ]b4_defact[

 };
 
 };
 

-/* YYDEFGOTO[[NTERM-NUM]]. */
-static const b4_int_type_for([b4_defgoto]) yydefgoto[[]] =
+/* YYDEFGOTO[NTERM-NUM]. */
+static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =

 {
 {

-  b4_defgoto
+  ]b4_defgoto[

 };
 
 };
 

-/* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing

    STATE-NUM.  */
    STATE-NUM.  */

-#define YYPACT_NINF b4_pact_ninf
-static const b4_int_type_for([b4_pact]) yypact[[]] =
+#define YYPACT_NINF ]b4_pact_ninf[
+static const ]b4_int_type_for([b4_pact])[ yypact[] =

 {
 {

-  b4_pact
+  ]b4_pact[

 };
 
 };
 

-/* YYPGOTO[[NTERM-NUM]].  */
-static const b4_int_type_for([b4_pgoto]) yypgoto[[]] =
+/* YYPGOTO[NTERM-NUM].  */
+static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =

 {
 {

-  b4_pgoto
+  ]b4_pgoto[

 };
 
 };
 

-/* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If

    positive, shift that token.  If negative, reduce the rule which
    positive, shift that token.  If negative, reduce the rule which

-   number is the opposite.  If zero, do what YYDEFACT says.  */
-#define YYTABLE_NINF b4_table_ninf
-static const b4_int_type_for([b4_table]) yytable[[]] =
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF ]b4_table_ninf[
+static const ]b4_int_type_for([b4_table])[ yytable[] =

 {
 {

-  b4_table
+  ]b4_table[

 };
 
 };
 

-static const b4_int_type_for([b4_check]) yycheck[[]] =
+static const ]b4_int_type_for([b4_check])[ yycheck[] =

 {
 {

-  b4_check
+  ]b4_check[

 };
 
 };
 

-/* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing

    symbol of state STATE-NUM.  */
    symbol of state STATE-NUM.  */

-static const b4_int_type_for([b4_stos]) yystos[[]] =
+static const ]b4_int_type_for([b4_stos])[ yystos[] =

 {
 {

-  b4_stos
+  ]b4_stos[

 };
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 };
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)


@@ -450,7 +461,7 @@ static const b4_int_type_for([b4_stos]) yystos[[]] =
 #endif
 
 #define yyerrok                (yyerrstatus = 0)
 #endif
 
 #define yyerrok                (yyerrstatus = 0)

-#define yyclearin      (yychar = YYEMPTY)
+#define yyclearin      (yytoken = YYEMPTY)

 #define YYEMPTY                -2
 #define YYEOF          0
 
 #define YYEMPTY                -2
 #define YYEOF          0
 


@@ -468,17 +479,17 @@ static const b4_int_type_for([b4_stos]) yystos[[]] =
 
 #define YYBACKUP(Token, Value)                                 \
 do                                                             \
 
 #define YYBACKUP(Token, Value)                                 \
 do                                                             \

-  if (yychar == YYEMPTY && yylen == 1)                         \
+  if (yytoken == YYEMPTY && yylen == 1)                                \

     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \
     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \

-      yychar1 = YYTRANSLATE (yychar);                          \
+      yytoken = YYTRANSLATE (yychar);                          \

       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
     {                                                          \
       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
     {                                                          \

-      yyerror ("syntax error: cannot back up");                        \
+      yyerror (]b4_yyerror_args["syntax error: cannot back up");\

       YYERROR;                                                 \
     }                                                          \
 while (0)
       YYERROR;                                                 \
     }                                                          \
 while (0)


@@ -490,22 +501,20 @@ while (0)
    are run).  */
 
 #ifndef YYLLOC_DEFAULT
    are run).  */
 
 #ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(Current, Rhs, N)           \
-  Current.first_line   = Rhs[[1]].first_line;      \
-  Current.first_column = Rhs[[1]].first_column;    \
-  Current.last_line    = Rhs[[N]].last_line;       \
-  Current.last_column  = Rhs[[N]].last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N)         \
+  Current.first_line   = Rhs[1].first_line;      \
+  Current.first_column = Rhs[1].first_column;    \
+  Current.last_line    = Rhs[N].last_line;       \
+  Current.last_column  = Rhs[N].last_column;

 #endif
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #endif
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 

-b4_pure_if(
-[#ifdef YYLEX_PARAM
-# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]), YYLEX_PARAM)
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)

 #else
 #else

-# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]))
-#endif],
-[#define YYLEX yylex ()])
+# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
+#endif

 
 /* Enable debugging if requested.  */
 #if YYDEBUG
 
 /* Enable debugging if requested.  */
 #if YYDEBUG


@@ -520,22 +529,84 @@ do {                                              \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)

+

 # define YYDSYMPRINT(Args)                     \
 do {                                           \
   if (yydebug)                                 \
     yysymprint Args;                           \
 } while (0)
 # define YYDSYMPRINT(Args)                     \
 do {                                           \
   if (yydebug)                                 \
     yysymprint Args;                           \
 } while (0)

+
+# define YYDSYMPRINTF(Title, Token, Value, Location)           \
+do {                                                           \
+  if (yydebug)                                                 \
+    {                                                          \
+      YYFPRINTF (stderr, "%s ", Title);                                \
+      yysymprint (stderr,                                      \
+                  Token, Value]b4_location_if([, Location])[); \
+      YYFPRINTF (stderr, "\n");                                        \
+    }                                                          \
+} while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (cinluded).                                                   |
+`------------------------------------------------------------------*/
+
+]b4_c_function_def([yy_stack_print], [static void],
+                   [[short *bottom], [bottom]],
+                   [[short *top],    [top]])[
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (/* Nothing. */; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                           \
+do {                                                           \
+  if (yydebug)                                                 \
+    yy_stack_print ((Bottom), (Top));                          \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+]b4_c_function_def([yy_reduce_print], [static void],
+                   [[int yyrule], [yyrule]])[
+{
+  int yyi;
+  unsigned int yylineno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
+             yyrule - 1, yylineno);
+  /* Print the symbols being reduced, and their result.  */
+  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
+  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+}
+
+# define YY_REDUCE_PRINT(Rule)         \
+do {                                   \
+  if (yydebug)                         \
+    yy_reduce_print (Rule);            \
+} while (0)
+

 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 # define YYDSYMPRINT(Args)
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 # define YYDSYMPRINT(Args)

+# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)

 #endif /* !YYDEBUG */
 
 #endif /* !YYDEBUG */
 

+

 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH

-# define YYINITDEPTH b4_initdepth
+# define YYINITDEPTH ]b4_stack_depth_init[

 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only


@@ -550,7 +621,7 @@ int yydebug;
 #endif
 
 #ifndef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH

-# define YYMAXDEPTH b4_maxdepth
+# define YYMAXDEPTH ]b4_stack_depth_max[

 #endif
 
 \f
 #endif
 
 \f


@@ -611,101 +682,29 @@ yystpcpy (yydest, yysrc)
 \f
 
 #if YYDEBUG
 \f
 
 #if YYDEBUG

-/*-----------------------------.
-| Print this symbol on YYOUT.  |
-`-----------------------------*/
-
-b4_c_function([yysymprint],
-             [static void],
-             [[FILE*],   [yyout]],
-             [[int],     [yytype]],
-             [[YYSTYPE], [yyvalue]]b4_location_if([,
-             [[YYLTYPE], [yylocation]]]))
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
-
-  if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyout, "token %s (", yytname[[yytype]]);
-# ifdef YYPRINT
-      YYPRINT (yyout, yytoknum[[yytype]], yyvalue);
-# endif
-    }
-  else
-    YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]);
-
-  switch (yytype)
-    {
-m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
-      default:
-        break;
-    }
-  YYFPRINTF (yyout, ")");
-}
-#endif /* YYDEBUG. */
-
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-b4_c_function([yydestruct],
-             [static void],
-             [[int],     [yytype]],
-             [[YYSTYPE], [yyvalue]]b4_location_if([,
-             [[YYLTYPE], [yylocation]]]))
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
-
-  switch (yytype)
-    {
-m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
-      default:
-        break;
-    }
-}
-
+]b4_yysymprint_generate([b4_c_function_def])[
+#endif /* ! YYDEBUG */
+]b4_yydestruct_generate([b4_c_function_def])

 \f
 
 \f
 

-/* The user can define YYPARSE_PARAM as the name of an argument to be passed
-   into yyparse.  The argument should have type void *.
-   It should actually point to an object.
-   Grammar actions can access the variable by casting it
-   to the proper pointer type.  */
+/* Prevent warnings from -Wmissing-prototypes.  */

 
 #ifdef YYPARSE_PARAM
 # if defined (__STDC__) || defined (__cplusplus)
 
 #ifdef YYPARSE_PARAM
 # if defined (__STDC__) || defined (__cplusplus)

-#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL
-# else
-#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-# endif
-#else /* !YYPARSE_PARAM */
-# define YYPARSE_PARAM_ARG
-# define YYPARSE_PARAM_DECL
-#endif /* !YYPARSE_PARAM */
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
-# ifdef YYPARSE_PARAM
-int yyparse (void *);
+int yyparse (void *YYPARSE_PARAM);

 # else
 # else

-int yyparse (void);
+int yyparse ();

 # endif
 # endif

-#endif
+#else /* ! YYPARSE_PARAM */
+b4_c_function_decl([yyparse], [int], b4_parse_param)
+#endif /* ! YYPARSE_PARAM */
+

 
 m4_divert_push([KILL])# ======================== M4 code.
 # b4_declare_parser_variables
 # ---------------------------
 # Declare the variables that are global, or local to YYPARSE if
 
 m4_divert_push([KILL])# ======================== M4 code.
 # b4_declare_parser_variables
 # ---------------------------
 # Declare the variables that are global, or local to YYPARSE if

-#  pure-parser
+# pure-parser.

 m4_define([b4_declare_parser_variables],
 [/* The lookahead symbol.  */
 int yychar;
 m4_define([b4_declare_parser_variables],
 [/* The lookahead symbol.  */
 int yychar;


@@ -713,7 +712,7 @@ int yychar;
 /* The semantic value of the lookahead symbol.  */
 YYSTYPE yylval;
 
 /* The semantic value of the lookahead symbol.  */
 YYSTYPE yylval;
 

-/* Number of parse errors so far.  */
+/* Number of syntax errors so far.  */

 int yynerrs;b4_location_if([
 /* Location data for the lookahead symbol.  */
 YYLTYPE yylloc;])
 int yynerrs;b4_location_if([
 /* Location data for the lookahead symbol.  */
 YYLTYPE yylloc;])


@@ -723,9 +722,21 @@ m4_divert_pop([KILL])dnl# ====================== End of M4 code.
 b4_pure_if([],
            [b4_declare_parser_variables])
 
 b4_pure_if([],
            [b4_declare_parser_variables])
 

-int
-yyparse (YYPARSE_PARAM_ARG)
-     YYPARSE_PARAM_DECL
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+# if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void *YYPARSE_PARAM)
+# else
+int yyparse (YYPARSE_PARAM)
+  void *YYPARSE_PARAM;
+# endif
+#else /* ! YYPARSE_PARAM */
+b4_c_function_def([yyparse], [int], b4_parse_param)
+#endif

 {[
   ]b4_pure_if([b4_declare_parser_variables])[
   register int yystate;
 {[
   ]b4_pure_if([b4_declare_parser_variables])[
   register int yystate;


@@ -734,7 +745,7 @@ yyparse (YYPARSE_PARAM_ARG)
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   /* Lookahead token as an internal (translated) token number.  */
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   /* Lookahead token as an internal (translated) token number.  */

-  int yychar1 = 0;
+  int yytoken = 0;

 
   /* Three stacks and their tools:
      `yyss': related to states,
 
   /* Three stacks and their tools:
      `yyss': related to states,


@@ -778,7 +789,7 @@ yyparse (YYPARSE_PARAM_ARG)
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;

-  yychar = YYEMPTY;            /* Cause a token to be read.  */
+  yychar = yytoken = YYEMPTY;          /* Cause a token to be read.  */

 
   /* Initialize stack pointers.
      Waste one element of value and location stack
 
   /* Initialize stack pointers.
      Waste one element of value and location stack


@@ -802,7 +813,7 @@ yyparse (YYPARSE_PARAM_ARG)
  yysetstate:
   *yyssp = yystate;
 
  yysetstate:
   *yyssp = yystate;
 

-  if (yyssp >= yyss + yystacksize - 1)
+  if (yyss + yystacksize - 1 <= yyssp)

     {
       /* Get the current used size of the three stacks, in elements.  */
       YYSIZE_T yysize = yyssp - yyss + 1;
     {
       /* Get the current used size of the three stacks, in elements.  */
       YYSIZE_T yysize = yyssp - yyss + 1;


@@ -834,10 +845,10 @@ yyparse (YYPARSE_PARAM_ARG)
       goto yyoverflowlab;
 # else
       /* Extend the stack our own way.  */
       goto yyoverflowlab;
 # else
       /* Extend the stack our own way.  */

-      if (yystacksize >= YYMAXDEPTH)
+      if (YYMAXDEPTH <= yystacksize)

        goto yyoverflowlab;
       yystacksize *= 2;
        goto yyoverflowlab;
       yystacksize *= 2;

-      if (yystacksize > YYMAXDEPTH)
+      if (YYMAXDEPTH < yystacksize)

        yystacksize = YYMAXDEPTH;
 
       {
        yystacksize = YYMAXDEPTH;
 
       {


@@ -863,7 +874,7 @@ yyparse (YYPARSE_PARAM_ARG)
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
                  (unsigned long int) yystacksize));
 
       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
                  (unsigned long int) yystacksize));
 

-      if (yyssp >= yyss + yystacksize - 1)
+      if (yyss + yystacksize - 1 <= yyssp)

        YYABORT;
     }
 
        YYABORT;
     }
 


@@ -888,68 +899,46 @@ yybackup:
 
   /* Not known => get a lookahead token if don't already have one.  */
 
 
   /* Not known => get a lookahead token if don't already have one.  */
 

-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
-
-  if (yychar == YYEMPTY)
+  /* YYTOKEN is either YYEMPTY or YYEOF or a valid token.  */
+  if (yytoken == YYEMPTY)

     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;

+      yytoken = YYTRANSLATE (yychar);

     }
 
     }
 

-  /* Convert token to internal form (in yychar1) for indexing tables with.  */
-
-  if (yychar <= 0)             /* This means end of input.  */
+  if (yytoken == YYEOF)

     {
     {

-      yychar1 = 0;
-      yychar = YYEOF;          /* Don't call YYLEX any more.  */
-

       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {

-      yychar1 = YYTRANSLATE (yychar);
-
-      /* We have to keep this `#if YYDEBUG', since we use variables
-        which are defined only if `YYDEBUG' is set.  */
-      YYDPRINTF ((stderr, "Next token is "));
-      YYDSYMPRINT ((stderr, yychar1, yylval]b4_location_if([, yyloc])[));
-      YYDPRINTF ((stderr, "\n"));
+      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);

     }
 
     }
 

-  yyn += yychar1;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)

     goto yydefault;
     goto yydefault;

-

   yyn = yytable[yyn];
   yyn = yytable[yyn];

-
-  /* yyn is what to do for this token type in this state.
-     Negative => reduce, -yyn is rule number.
-     Positive => shift, yyn is new state.
-       New state is final state => don't bother to shift,
-       just return success.
-     0, or most negative number => error.  */
-
-  if (yyn < 0)
+  if (yyn <= 0)

     {
     {

-      if (yyn == YYTABLE_NINF)
+      if (yyn == 0 || yyn == YYTABLE_NINF)

        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }
        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
     }

-  else if (yyn == 0)
-    goto yyerrlab;

 
   if (yyn == YYFINAL)
     YYACCEPT;
 
   /* Shift the lookahead token.  */
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
   /* Shift the lookahead token.  */

-  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
-             yychar, yytname[yychar1]));
+  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));

 
   /* Discard the token being shifted unless it is eof.  */
 
   /* Discard the token being shifted unless it is eof.  */

-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
+  if (yytoken != YYEOF)
+    yytoken = YYEMPTY;

 
   *++yyvsp = yylval;
 ]b4_location_if([  *++yylsp = yylloc;])[
 
   *++yyvsp = yylval;
 ]b4_location_if([  *++yylsp = yylloc;])[


@@ -993,45 +982,20 @@ yyreduce:
 ]b4_location_if(
 [  /* Default location. */
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
 ]b4_location_if(
 [  /* Default location. */
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[

-
-#if YYDEBUG
-  /* We have to keep this `#if YYDEBUG', since we use variables which
-     are defined only if `YYDEBUG' is set.  */
-  if (yydebug)
-    {
-      int yyi;
-
-      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
-                yyn - 1, yyrline[yyn]);
-
-      /* Print the symbols being reduced, and their result.  */
-      for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
-       YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
-      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
+  YY_REDUCE_PRINT (yyn);

   switch (yyn)
     ]{
       b4_actions
     }
 
   switch (yyn)
     ]{
       b4_actions
     }
 

-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"
+/* Line __line__ of yacc.c.  */
+b4_syncline([@oline@], [@ofile@])

 \f
 [  yyvsp -= yylen;
   yyssp -= yylen;
 ]b4_location_if([  yylsp -= yylen;])[
 
 \f
 [  yyvsp -= yylen;
   yyssp -= yylen;
 ]b4_location_if([  yylsp -= yylen;])[
 

-#if YYDEBUG
-  if (yydebug)
-    {
-      short *yyssp1 = yyss - 1;
-      YYFPRINTF (stderr, "state stack now");
-      while (yyssp1 != yyssp)
-       YYFPRINTF (stderr, " %d", *++yyssp1);
-      YYFPRINTF (stderr, "\n");
-    }
-#endif
+  YY_STACK_PRINT (yyss, yyssp);

 
   *++yyvsp = yyval;
 ]b4_location_if([  *++yylsp = yyloc;])[
 
   *++yyvsp = yyval;
 ]b4_location_if([  *++yylsp = yyloc;])[


@@ -1076,12 +1040,12 @@ yyerrlab:
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;

-         yysize += yystrlen ("parse error, unexpected ") + 1;
+         yysize += yystrlen ("syntax error, unexpected ") + 1;

          yysize += yystrlen (yytname[yytype]);
          yymsg = (char *) YYSTACK_ALLOC (yysize);
          if (yymsg != 0)
            {
          yysize += yystrlen (yytname[yytype]);
          yymsg = (char *) YYSTACK_ALLOC (yysize);
          if (yymsg != 0)
            {

-             char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+             char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");

              yyp = yystpcpy (yyp, yytname[yytype]);
 
              if (yycount < 5)
              yyp = yystpcpy (yyp, yytname[yytype]);
 
              if (yycount < 5)


@@ -1098,56 +1062,51 @@ yyerrlab:
                        yycount++;
                      }
                }
                        yycount++;
                      }
                }

-             yyerror (yymsg);
+             yyerror (]b4_yyerror_args[yymsg);

              YYSTACK_FREE (yymsg);
            }
          else
              YYSTACK_FREE (yymsg);
            }
          else

-           yyerror ("parse error; also virtual memory exhausted");
+           yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted");

        }
       else
 #endif /* YYERROR_VERBOSE */
        }
       else
 #endif /* YYERROR_VERBOSE */

-       yyerror ("parse error");
+       yyerror (]b4_yyerror_args["syntax error");

     }
     }

-  goto yyerrlab1;

 
 

-
-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
-yyerrlab1:

   if (yyerrstatus == 3)
     {
       /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */
 
       /* Return failure if at end of input.  */
   if (yyerrstatus == 3)
     {
       /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */
 
       /* Return failure if at end of input.  */

-      if (yychar == YYEOF)
+      if (yytoken == YYEOF)

         {
          /* Pop the error token.  */
           YYPOPSTACK;
          /* Pop the rest of the stack.  */
         {
          /* Pop the error token.  */
           YYPOPSTACK;
          /* Pop the rest of the stack.  */

-         while (yyssp > yyss)
+         while (yyss < yyssp)

            {
            {

-             YYDPRINTF ((stderr, "Error: popping "));
-             YYDSYMPRINT ((stderr,
-                           yystos[*yyssp],
-                           *yyvsp]b4_location_if([, *yylsp])[));
-             YYDPRINTF ((stderr, "\n"));
-             yydestruct (yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[);
+             YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+             yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);

              YYPOPSTACK;
            }
          YYABORT;
         }
 
              YYPOPSTACK;
            }
          YYABORT;
         }
 

-      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
-                 yychar, yytname[yychar1]));
-      yydestruct (yychar1, yylval]b4_location_if([, yylloc])[);
-      yychar = YYEMPTY;
+      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
+      yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
+      yytoken = YYEMPTY;

     }
 
   /* Else will try to reuse lookahead token after shifting the error
      token.  */
     }
 
   /* Else will try to reuse lookahead token after shifting the error
      token.  */

+  goto yyerrlab1;
+

 
 

+/*----------------------------------------------------.
+| yyerrlab1 -- error raised explicitly by an action.  |
+`----------------------------------------------------*/
+yyerrlab1:

   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 
   for (;;)
   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 
   for (;;)


@@ -1168,26 +1127,12 @@ yyerrlab1:
       if (yyssp == yyss)
        YYABORT;
 
       if (yyssp == yyss)
        YYABORT;
 

-      YYDPRINTF ((stderr, "Error: popping "));
-      YYDSYMPRINT ((stderr,
-                   yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[));
-      YYDPRINTF ((stderr, "\n"));
-
-      yydestruct (yystos[yystate], *yyvsp]b4_location_if([, *yylsp])[);
+      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+      yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[);

       yyvsp--;
       yystate = *--yyssp;
 ]b4_location_if([      yylsp--;])[
       yyvsp--;
       yystate = *--yyssp;
 ]b4_location_if([      yylsp--;])[

-
-#if YYDEBUG
-      if (yydebug)
-       {
-         short *yyssp1 = yyss - 1;
-         YYFPRINTF (stderr, "Error: state stack now");
-         while (yyssp1 != yyssp)
-           YYFPRINTF (stderr, " %d", *++yyssp1);
-         YYFPRINTF (stderr, "\n");
-       }
-#endif
+      YY_STACK_PRINT (yyss, yyssp);

     }
 
   if (yyn == YYFINAL)
     }
 
   if (yyn == YYFINAL)


@@ -1221,7 +1166,7 @@ yyabortlab:
 | yyoverflowlab -- parser overflow comes here.  |
 `----------------------------------------------*/
 yyoverflowlab:
 | yyoverflowlab -- parser overflow comes here.  |
 `----------------------------------------------*/
 yyoverflowlab:

-  yyerror ("parser stack overflow");
+  yyerror (]b4_yyerror_args["parser stack overflow");

   yyresult = 2;
   /* Fall through.  */
 #endif
   yyresult = 2;
   /* Fall through.  */
 #endif


@@ -1237,7 +1182,7 @@ yyreturn:
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],

-[#output "b4_output_header_name"
+[@output @output_header_name@

 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 


@@ -1246,19 +1191,17 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
    This special exception was added by the Free Software Foundation
    in version 1.24 of Bison.  */
 
    This special exception was added by the Free Software Foundation
    in version 1.24 of Bison.  */
 

-#ifndef b4_header_guard
-# define b4_header_guard
-

 b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE
 m4_ifdef([b4_stype],
 b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE
 m4_ifdef([b4_stype],

-[#line b4_stype_line "b4_filename"
+[b4_syncline([b4_stype_line], [b4_filename])

 typedef union b4_stype yystype;
 typedef union b4_stype yystype;

-/* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"],
+/* Line __line__ of yacc.c.  */
+b4_syncline([@oline@], [@ofile@])],

 [typedef int yystype;])
 # define YYSTYPE yystype
 [typedef int yystype;])
 # define YYSTYPE yystype

+# define YYSTYPE_IS_TRIVIAL 1

 #endif
 
 b4_pure_if([],
 #endif
 
 b4_pure_if([],


@@ -1279,5 +1222,4 @@ typedef struct yyltype
 m4_if(b4_pure, [0],
 [extern YYLTYPE b4_prefix[]lloc;])
 ])
 m4_if(b4_pure, [0],
 [extern YYLTYPE b4_prefix[]lloc;])
 ])

-#endif /* not b4_header_guard */

 ])
 ])