]> git.saurik.com Git - bison.git/blobdiff - data/yacc.c
projects / bison.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Alexandre Duret-Lutz <adl@gnu.org>
[bison.git] / data / yacc.c
diff --git a/data/yacc.c b/data/yacc.c
index 8f5979026cfd958559208a792e54551d3f4ef38c..2e9c9fd0b0d04859b5fa1f8fad95e97b3b19fb82 100644 (file)
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -1,8 +1,7 @@
 m4_divert(-1)                                                       -*- C -*-
 m4_divert(-1)                                                       -*- C -*-
-m4_include([c.m4])
 
 # Yacc compatible skeleton for Bison
 
 # Yacc compatible skeleton for Bison
-# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002
+# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004
 # Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
@@ -30,9 +29,6 @@ m4_include([c.m4])
 m4_define_default([b4_stack_depth_max], [10000])
 m4_define_default([b4_stack_depth_init],  [200])
 
 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.  ##
 
 ## ------------------------ ##
 ## Pure/impure interfaces.  ##
@@ -58,12 +54,12 @@ m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 
 # b4_lex_param
 # ------------
 
 # b4_lex_param
 # ------------
-# Accumule in b4_lex_param all the yylex arguments.
+# Accumulate 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_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)))
+b4_location_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
+m4_ifdef([b4_lex_param], b4_lex_param)))
 
 
 
 
 
 
@@ -80,8 +76,8 @@ m4_define([b4_int_type],
 [m4_if(b4_ints_in($@,      [0],   [255]), [1], [unsigned char],
        b4_ints_in($@,   [-128],   [127]), [1], [yysigned_char],
 
 [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],
+       b4_ints_in($@,      [0], [65535]), [1], [unsigned short int],
+       b4_ints_in($@, [-32768], [32767]), [1], [short int],
 
        m4_eval([0 <= $1]),                [1], [unsigned int],
 
 
        m4_eval([0 <= $1]),                [1], [unsigned int],
 
@@ -138,7 +134,7 @@ m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
 m4_divert(0)dnl
 @output @output_parser_name@
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
-             [1984, 1989, 1990, 2000, 2001, 2002])
+             [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004])[
 
 /* 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.
@@ -155,7 +151,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.  */
 
-b4_identification
+]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.  */
@@ -166,16 +162,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.  */
@@ -183,52 +179,62 @@ 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
 
 #endif
 
-#ifndef YYSTYPE
-m4_ifdef([b4_stype],
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+]m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
 [b4_syncline([b4_stype_line], [b4_filename])
-typedef union b4_stype yystype;
-/* Line __line__ of __file__.  */
+typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+/* Line __line__ of yacc.c.  */
 b4_syncline([@oline@], [@ofile@])],
 b4_syncline([@oline@], [@ofile@])],
-[typedef int yystype;])
-# define YYSTYPE yystype
+[typedef int YYSTYPE;])[
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
-#ifndef YYLTYPE
-typedef struct yyltype
+]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+typedef struct YYLTYPE
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
-} yyltype;
-# define YYLTYPE b4_location_type
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
+])[
 
 /* Copy the second part of user declarations.  */
 
 /* Copy the second part of user declarations.  */
-b4_post_prologue
+]b4_post_prologue
 
 
-/* Line __line__ of __file__.  */
-b4_syncline([@oline@], [@ofile@])
+/* Line __line__ of yacc.c.  */
+b4_syncline([@oline@], [@ofile@])[
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
+# ifndef YYFREE
+#  define YYFREE free
+# endif
+# ifndef YYMALLOC
+#  define YYMALLOC malloc
+# endif
+
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
-# if YYSTACK_USE_ALLOCA
-#  define YYSTACK_ALLOC alloca
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   define YYSTACK_ALLOC alloca
+#  endif
 # else
 # else
-#  ifndef YYSTACK_USE_ALLOCA
-#   if defined (alloca) || defined (_ALLOCA_H)
-#    define YYSTACK_ALLOC alloca
-#   else
-#    ifdef __GNUC__
-#     define YYSTACK_ALLOC __builtin_alloca
-#    endif
+#  if defined (alloca) || defined (_ALLOCA_H)
+#   define YYSTACK_ALLOC alloca
+#  else
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
 #   endif
 #  endif
 # endif
 #   endif
 #  endif
 # endif
@@ -241,42 +247,43 @@ b4_syncline([@oline@], [@ofile@])
 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 #   define YYSIZE_T size_t
 #  endif
 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 #   define YYSIZE_T size_t
 #  endif
-#  define YYSTACK_ALLOC malloc
-#  define YYSTACK_FREE free
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
 # endif
 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 
 
 #if (! defined (yyoverflow) \
      && (! defined (__cplusplus) \
 # endif
 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
 
 
 #if (! defined (yyoverflow) \
      && (! defined (__cplusplus) \
-        || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+        || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
+             && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
-  short yyss;
+  short int yyss;
   YYSTYPE yyvs;
   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) \
 [# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
-      + 2 * YYSTACK_GAP_MAX)],
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+      + 2 * YYSTACK_GAP_MAXIMUM)],
 [# define YYSTACK_BYTES(N) \
 [# define YYSTACK_BYTES(N) \
-     ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
-      + YYSTACK_GAP_MAX)])
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                    \
+      + YYSTACK_GAP_MAXIMUM)])[
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 # ifndef YYCOPY
-#  if 1 < __GNUC__
+#  if defined (__GNUC__) && 1 < __GNUC__
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
 #   define YYCOPY(To, From, Count) \
       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 #  else
@@ -285,7 +292,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
@@ -302,7 +309,7 @@ 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)
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
     while (0)
@@ -312,136 +319,135 @@ b4_location_if(
 #if defined (__STDC__) || defined (__cplusplus)
    typedef signed char yysigned_char;
 #else
 #if defined (__STDC__) || defined (__cplusplus)
    typedef signed char yysigned_char;
 #else
-   typedef short yysigned_char;
+   typedef short int yysigned_char;
 #endif
 
 /* YYFINAL -- State number of the termination state. */
 #endif
 
 /* YYFINAL -- State number of the termination state. */
-#define YYFINAL  b4_final_state_number
+#define YYFINAL  ]b4_final_state_number[
 /* YYLAST -- Last index in YYTABLE.  */
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   b4_last
+#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(YYX)                                               \
 
 #define YYTRANSLATE(YYX)                                               \
-  ((YYX <= 0) ? YYEOF :                                                        \
-   (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+  ((unsigned int) (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
    number is the opposite.  If zero, do what YYDEFACT says.
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, parse error.  */
-#define YYTABLE_NINF b4_table_ninf
-static const b4_int_type_for([b4_table]) yytable[[]] =
+   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__)
@@ -461,13 +467,14 @@ static const b4_int_type_for([b4_stos]) yystos[[]] =
 #endif
 
 #define yyerrok                (yyerrstatus = 0)
 #endif
 
 #define yyerrok                (yyerrstatus = 0)
-#define yyclearin      (yytoken = YYEMPTY)
-#define YYEMPTY                -2
+#define yyclearin      (yychar = YYEMPTY)
+#define YYEMPTY                (-2)
 #define YYEOF          0
 
 #define YYACCEPT       goto yyacceptlab
 #define YYABORT                goto yyabortlab
 #define YYEOF          0
 
 #define YYACCEPT       goto yyacceptlab
 #define YYABORT                goto yyabortlab
-#define YYERROR                goto yyerrlab1
+#define YYERROR                goto yyerrorlab
+
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
@@ -479,7 +486,7 @@ static const b4_int_type_for([b4_stos]) yystos[[]] =
 
 #define YYBACKUP(Token, Value)                                 \
 do                                                             \
 
 #define YYBACKUP(Token, Value)                                 \
 do                                                             \
-  if (yytoken == YYEMPTY && yylen == 1)                                \
+  if (yychar == YYEMPTY && yylen == 1)                         \
     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \
     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \
@@ -489,31 +496,61 @@ do                                                                \
     }                                                          \
   else                                                         \
     {                                                          \
     }                                                          \
   else                                                         \
     {                                                          \
-      yyerror (b4_yyerror_args"syntax error: cannot back up"); \
+      yyerror (]b4_yyerror_args["syntax error: cannot back up");\
       YYERROR;                                                 \
     }                                                          \
 while (0)
 
       YYERROR;                                                 \
     }                                                          \
 while (0)
 
+
 #define YYTERROR       1
 #define YYERRCODE      256
 
 #define YYTERROR       1
 #define YYERRCODE      256
 
-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
 
 #ifndef YYLLOC_DEFAULT
 
 #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)                                    \
+do {                                                                        \
+  if (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;                        \
+    }                                                                       \
+  else                                                                      \
+    {                                                                       \
+      (Current).first_line   = (Current).last_line   = (Rhs)[0].last_line;   \
+      (Current).first_column = (Current).last_column = (Rhs)[0].last_column; \
+    }                                                                       \
+} while(0)
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)                 \
+     fprintf (File, "%d.%d-%d.%d",                     \
+              (Loc).first_line, (Loc).first_column,    \
+              (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
 #endif
 
 #endif
 
+
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM
-# define YYLEX yylex (b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])YYLEX_PARAM)
+# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
 #else
 #else
-# define YYLEX b4_c_function_call([yylex], [int], b4_lex_param)
+# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
 #endif
 
 /* Enable debugging if requested.  */
 #endif
 
 /* Enable debugging if requested.  */
@@ -529,22 +566,77 @@ do {                                              \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
-# define YYDSYMPRINT(Args)                     \
-do {                                           \
-  if (yydebug)                                 \
-    yysymprint Args;                           \
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)         \
+do {                                                           \
+  if (yydebug)                                                 \
+    {                                                          \
+      YYFPRINTF (stderr, "%s ", Title);                                \
+      yysymprint (stderr,                                      \
+                  Type, Value]b4_location_if([, Location])[);  \
+      YYFPRINTF (stderr, "\n");                                        \
+    }                                                          \
+} while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+]b4_c_function_def([yy_stack_print], [static void],
+                   [[short int *bottom], [bottom]],
+                   [[short int *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)
 } 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 yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
+             yyrule - 1, yylno);
+  /* 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)
 /* 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 YY_SYMBOL_PRINT(Title, Type, 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_stack_depth_init
+# 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
@@ -554,12 +646,12 @@ int yydebug;
    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
    evaluated with infinite-precision integer arithmetic.  */
 
    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
    evaluated with infinite-precision integer arithmetic.  */
 
-#if YYMAXDEPTH == 0
+#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
 # undef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH
 # undef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH
-# define YYMAXDEPTH b4_stack_depth_max
+# define YYMAXDEPTH ]b4_stack_depth_max[
 #endif
 
 \f
 #endif
 
 \f
@@ -620,9 +712,9 @@ yystpcpy (yydest, yysrc)
 \f
 
 #if YYDEBUG
 \f
 
 #if YYDEBUG
-b4_yysymprint_generate([b4_c_function_def])
-#endif /* YYDEBUG. */
-b4_yydestruct_generate([b4_c_function_def])
+]b4_yysymprint_generate([b4_c_function_def])[
+#endif /* ! YYDEBUG */
+]b4_yydestruct_generate([b4_c_function_def])
 \f
 
 /* Prevent warnings from -Wmissing-prototypes.  */
 \f
 
 /* Prevent warnings from -Wmissing-prototypes.  */
@@ -635,7 +727,7 @@ int yyparse ();
 # endif
 #else /* ! YYPARSE_PARAM */
 b4_c_function_decl([yyparse], [int], b4_parse_param)
 # endif
 #else /* ! YYPARSE_PARAM */
 b4_c_function_decl([yyparse], [int], b4_parse_param)
-#endif
+#endif /* ! YYPARSE_PARAM */
 
 
 m4_divert_push([KILL])# ======================== M4 code.
 
 
 m4_divert_push([KILL])# ======================== M4 code.
@@ -644,15 +736,15 @@ m4_divert_push([KILL])# ======================== M4 code.
 # Declare the variables that are global, or local to YYPARSE if
 # pure-parser.
 m4_define([b4_declare_parser_variables],
 # Declare the variables that are global, or local to YYPARSE if
 # pure-parser.
 m4_define([b4_declare_parser_variables],
-[/* The lookahead symbol.  */
+[/* The look-ahead symbol.  */
 int yychar;
 
 int yychar;
 
-/* The semantic value of the lookahead symbol.  */
+/* The semantic value of the look-ahead symbol.  */
 YYSTYPE yylval;
 
 YYSTYPE yylval;
 
-/* Number of parse errors so far.  */
+/* Number of syntax errors so far.  */
 int yynerrs;b4_location_if([
 int yynerrs;b4_location_if([
-/* Location data for the lookahead symbol.  */
+/* Location data for the look-ahead symbol.  */
 YYLTYPE yylloc;])
 ])
 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
 YYLTYPE yylloc;])
 ])
 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
@@ -682,7 +774,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
   int yyresult;
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   int yyresult;
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
+  /* Look-ahead token as an internal (translated) token number.  */
   int yytoken = 0;
 
   /* Three stacks and their tools:
   int yytoken = 0;
 
   /* Three stacks and their tools:
@@ -694,9 +786,9 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
      to reallocate them elsewhere.  */
 
   /* The state stack.  */
      to reallocate them elsewhere.  */
 
   /* The state stack.  */
-  short        yyssa[YYINITDEPTH];
-  short *yyss = yyssa;
-  register short *yyssp;
+  short int yyssa[YYINITDEPTH];
+  short int *yyss = yyssa;
+  register short int *yyssp;
 
   /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];
 
   /* The semantic value stack.  */
   YYSTYPE yyvsa[YYINITDEPTH];
@@ -707,7 +799,9 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
 [[  /* The location stack.  */
   YYLTYPE yylsa[YYINITDEPTH];
   YYLTYPE *yyls = yylsa;
 [[  /* The location stack.  */
   YYLTYPE yylsa[YYINITDEPTH];
   YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;]])[
+  YYLTYPE *yylsp;
+  /* The locations where the error started and ended. */
+  YYLTYPE yyerror_range[2];]])[
 
 #define YYPOPSTACK   (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
 
 
 #define YYPOPSTACK   (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
 
@@ -727,7 +821,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
-  yychar = yytoken = YYEMPTY;          /* Cause a token to be read.  */
+  yychar = 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
@@ -736,8 +830,27 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
 
   yyssp = yyss;
   yyvsp = yyvs;
 
   yyssp = yyss;
   yyvsp = yyvs;
-]b4_location_if([  yylsp = yyls;])[
-  goto yysetstate;
+]b4_location_if([[  yylsp = yyls;
+#if YYLTYPE_IS_TRIVIAL
+  /* Initialize the default location before parsing starts.  */
+  yylloc.first_line   = yylloc.last_line   = 1;
+  yylloc.first_column = yylloc.last_column = 0;
+#endif
+]])
+m4_ifdef([b4_initial_action], [
+m4_pushdef([b4_at_dollar],     [yylloc])dnl
+m4_pushdef([b4_dollar_dollar], [yylval])dnl
+  /* User initialization code. */
+  b4_initial_action
+m4_popdef([b4_dollar_dollar])dnl
+m4_popdef([b4_at_dollar])dnl
+/* Line __line__ of yacc.c.  */
+b4_syncline([@oline@], [@ofile@])])dnl
+[
+  yyvsp[0] = yylval;
+]b4_location_if([[    yylsp[0] = yylloc;
+]])
+[  goto yysetstate;
 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
@@ -762,7 +875,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
           these so that the &'s don't force the real ones into
           memory.  */
        YYSTYPE *yyvs1 = yyvs;
           these so that the &'s don't force the real ones into
           memory.  */
        YYSTYPE *yyvs1 = yyvs;
-       short *yyss1 = yyss;
+       short int *yyss1 = yyss;
 ]b4_location_if([      YYLTYPE *yyls1 = yyls;])[
 
        /* Each stack pointer address is followed by the size of the
 ]b4_location_if([      YYLTYPE *yyls1 = yyls;])[
 
        /* Each stack pointer address is followed by the size of the
@@ -790,7 +903,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
        yystacksize = YYMAXDEPTH;
 
       {
        yystacksize = YYMAXDEPTH;
 
       {
-       short *yyss1 = yyss;
+       short int *yyss1 = yyss;
        union yyalloc *yyptr =
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
        union yyalloc *yyptr =
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
@@ -826,36 +939,33 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
 yybackup:
 
 /* Do appropriate processing given the current state.  */
 yybackup:
 
 /* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
+/* Read a look-ahead token if we need one and don't already have one.  */
 /* yyresume: */
 
 /* yyresume: */
 
-  /* First try to decide what to do without reference to lookahead token.  */
+  /* First try to decide what to do without reference to look-ahead token.  */
 
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
 
   yyn = yypact[yystate];
   if (yyn == YYPACT_NINF)
     goto yydefault;
 
-  /* Not known => get a lookahead token if don't already have one.  */
+  /* Not known => get a look-ahead token if don't already have one.  */
 
 
-  /* YYTOKEN is either YYEMPTY or YYEOF or a valid token.  */
-  if (yytoken == YYEMPTY)
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
+  if (yychar == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
-      yytoken = YYTRANSLATE (yychar);
     }
 
     }
 
-  if (yytoken == YYEOF)
+  if (yychar <= YYEOF)
     {
     {
+      yychar = yytoken = YYEOF;
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
-      /* 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, yytoken, &yylval]b4_location_if([, &yyloc])[));
-      YYDPRINTF ((stderr, "\n"));
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
     }
 
   /* If the proper action on seeing token YYTOKEN is to reduce or to
     }
 
   /* If the proper action on seeing token YYTOKEN is to reduce or to
@@ -875,13 +985,12 @@ yybackup:
   if (yyn == YYFINAL)
     YYACCEPT;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
-             yytoken, yytname[yytoken]));
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
 
   /* Discard the token being shifted unless it is eof.  */
 
   /* Discard the token being shifted unless it is eof.  */
-  if (yytoken != YYEOF)
-    yytoken = YYEMPTY;
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
 
   *++yyvsp = yylval;
 ]b4_location_if([  *++yylsp = yylloc;])[
 
   *++yyvsp = yylval;
 ]b4_location_if([  *++yylsp = yylloc;])[
@@ -923,47 +1032,22 @@ yyreduce:
   yyval = yyvsp[1-yylen];
 
 ]b4_location_if(
   yyval = yyvsp[1-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]; 0 <= yyrhs[yyi]; yyi++)
-       YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
-      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
+[[  /* Default location. */
+  YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);]])[
+  YY_REDUCE_PRINT (yyn);
   switch (yyn)
     ]{
       b4_actions
     }
 
   switch (yyn)
     ]{
       b4_actions
     }
 
-/* Line __line__ of __file__.  */
+/* Line __line__ of yacc.c.  */
 b4_syncline([@oline@], [@ofile@])
 \f
 [  yyvsp -= yylen;
   yyssp -= yylen;
 ]b4_location_if([  yylsp -= yylen;])[
 
 b4_syncline([@oline@], [@ofile@])
 \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;])[
@@ -998,88 +1082,119 @@ yyerrlab:
        {
          YYSIZE_T yysize = 0;
          int yytype = YYTRANSLATE (yychar);
        {
          YYSIZE_T yysize = 0;
          int yytype = YYTRANSLATE (yychar);
+         const char* yyprefix;
          char *yymsg;
          char *yymsg;
-         int yyx, yycount;
+         int yyx;
 
 
-         yycount = 0;
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
-         for (yyx = yyn < 0 ? -yyn : 0;
-              yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+         int yyxbegin = yyn < 0 ? -yyn : 0;
+
+         /* Stay within bounds of both yycheck and yytname.  */
+         int yychecklim = YYLAST - yyn;
+         int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+         int yycount = 0;
+
+         yyprefix = ", expecting ";
+         for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-             yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-         yysize += yystrlen ("parse error, unexpected ") + 1;
-         yysize += yystrlen (yytname[yytype]);
+             {
+               yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
+               yycount += 1;
+               if (yycount == 5)
+                 {
+                   yysize = 0;
+                   break;
+                 }
+             }
+         yysize += (sizeof ("syntax error, unexpected ")
+                    + yystrlen (yytname[yytype]));
          yymsg = (char *) YYSTACK_ALLOC (yysize);
          if (yymsg != 0)
            {
          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)
                {
-                 yycount = 0;
-                 for (yyx = yyn < 0 ? -yyn : 0;
-                      yyx < (int) (sizeof (yytname) / sizeof (char *));
-                      yyx++)
+                 yyprefix = ", expecting ";
+                 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
                      {
                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
                      {
-                       const char *yyq = ! yycount ? ", expecting " : " or ";
-                       yyp = yystpcpy (yyp, yyq);
+                       yyp = yystpcpy (yyp, yyprefix);
                        yyp = yystpcpy (yyp, yytname[yyx]);
                        yyp = yystpcpy (yyp, yytname[yyx]);
-                       yycount++;
+                       yyprefix = " or ";
                      }
                }
              yyerror (]b4_yyerror_args[yymsg);
              YYSTACK_FREE (yymsg);
            }
          else
                      }
                }
              yyerror (]b4_yyerror_args[yymsg);
              YYSTACK_FREE (yymsg);
            }
          else
-           yyerror (]b4_yyerror_args["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 (]b4_yyerror_args["parse error");
+       yyerror (]b4_yyerror_args["syntax error");
     }
     }
-  goto yyerrlab1;
 
 
+]b4_location_if([[  yyerror_range[0] = yylloc;]])[
 
 
-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
-yyerrlab1:
   if (yyerrstatus == 3)
     {
   if (yyerrstatus == 3)
     {
-      /* If just tried and failed to reuse lookahead token after an
+      /* If just tried and failed to reuse look-ahead token after an
         error, discard it.  */
 
         error, discard it.  */
 
-      /* Return failure if at end of input.  */
-      if (yytoken == YYEOF)
+      if (yychar <= YYEOF)
         {
         {
-         /* Pop the error token.  */
-          YYPOPSTACK;
-         /* Pop the rest of the stack.  */
-         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])[);
-             YYPOPSTACK;
-           }
-         YYABORT;
+          /* If at end of input, pop the error token,
+            then the rest of the stack, then return failure.  */
+         if (yychar == YYEOF)
+            for (;;)
+              {
+]b4_location_if([[                 yyerror_range[0] = *yylsp;]])[
+                YYPOPSTACK;
+                if (yyssp == yyss)
+                  YYABORT;
+                yydestruct ("Error: popping",
+                             yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
+              }
         }
         }
-
-      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
-                 yytoken, yytname[yytoken]));
-      yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
-      yytoken = YYEMPTY;
+      else
+       {
+         yydestruct ("Error: discarding", yytoken, &yylval]b4_location_if([, &yylloc])[);
+         yychar = YYEMPTY;
+       }
     }
 
     }
 
-  /* Else will try to reuse lookahead token after shifting the error
+  /* Else will try to reuse look-ahead token after shifting the error
      token.  */
      token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+#ifdef __GNUC__
+  /* Pacify GCC when the user code never invokes YYERROR and the label
+     yyerrorlab therefore never appears in user code.  */
+  if (0)
+     goto yyerrorlab;
+#endif
+
+]b4_location_if([[  yyerror_range[0] = yylsp[1-yylen];
+  yylsp -= yylen;
+  ]])[yyvsp -= yylen;
+  yyssp -= yylen;
+  yystate = *yyssp;
+  goto yyerrlab1;
+
 
 
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 
   for (;;)
   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 
   for (;;)
@@ -1100,35 +1215,26 @@ 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])[);
-      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
+]b4_location_if([[      yyerror_range[0] = *yylsp;]])[
+      yydestruct ("Error: popping", yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
+      YYPOPSTACK;
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
     }
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
     }
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  YYDPRINTF ((stderr, "Shifting error token, "));
-
   *++yyvsp = yylval;
   *++yyvsp = yylval;
-]b4_location_if([  *++yylsp = yylloc;])[
+]b4_location_if([[
+  yyerror_range[1] = yylloc;
+  /* Using YYLLOC is tempting, but would change the location of
+     the look-ahead.  YYLOC is available though. */
+  YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
+  *++yylsp = yyloc;]])[
+
+  /* Shift the error token. */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
   yystate = yyn;
   goto yynewstate;
 
   yystate = yyn;
   goto yynewstate;
@@ -1145,6 +1251,9 @@ yyacceptlab:
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
 yyabortlab:
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
 yyabortlab:
+  yydestruct ("Error: discarding lookahead",
+              yytoken, &yylval]b4_location_if([, &yylloc])[);
+  yychar = YYEMPTY;
   yyresult = 1;
   goto yyreturn;
 
   yyresult = 1;
   goto yyreturn;
 
@@ -1171,7 +1280,7 @@ b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
-             [1984, 1989, 1990, 2000, 2001, 2002])
+             [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004])
 
 /* 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.
@@ -1180,14 +1289,15 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
 
 b4_token_defines(b4_tokens)
 
 
 b4_token_defines(b4_tokens)
 
-#ifndef YYSTYPE
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
 m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
 m4_ifdef([b4_stype],
 [b4_syncline([b4_stype_line], [b4_filename])
-typedef union b4_stype yystype;
-/* Line __line__ of __file__.  */
+typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+/* Line __line__ of yacc.c.  */
 b4_syncline([@oline@], [@ofile@])],
 b4_syncline([@oline@], [@ofile@])],
-[typedef int yystype;])
-# define YYSTYPE yystype
+[typedef int YYSTYPE;])
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 
@@ -1195,15 +1305,17 @@ b4_pure_if([],
 [extern YYSTYPE b4_prefix[]lval;])
 
 b4_location_if(
 [extern YYSTYPE b4_prefix[]lval;])
 
 b4_location_if(
-[#ifndef YYLTYPE
-typedef struct yyltype
+[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+typedef struct YYLTYPE
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
 {
   int first_line;
   int first_column;
   int last_line;
   int last_column;
-} yyltype;
-# define YYLTYPE yyltype
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 m4_if(b4_pure, [0],
 #endif
 
 m4_if(b4_pure, [0],
bison