* data/yacc.c (YY_LOCATION_PRINT): Use YYLTYPE_IS_TRIVIAL as a

[bison.git] / data / yacc.c

diff --git a/data/yacc.c b/data/yacc.c
index 631547d1284948ab66a10990fc5efb9c915abbe9..f1040ebd6915849fa755bbd7284baec2faa0a01a 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.


@@ -186,49 +182,59 @@ b4_location_if([#define yylloc b4_prefix[]lloc])])[
 # define YYERROR_VERBOSE ]b4_error_verbose[
 #endif
 
 # define YYERROR_VERBOSE ]b4_error_verbose[
 #endif
 

-#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
 

-#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.  */
 ]b4_post_prologue
 
 
 /* Copy the second part of user declarations.  */
 ]b4_post_prologue
 

-/* Line __line__ of __file__.  */
+/* Line __line__ of yacc.c.  */

 b4_syncline([@oline@], [@ofile@])[
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
 b4_syncline([@oline@], [@ofile@])[
 
 #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;
   ]b4_location_if([  YYLTYPE yyls;
 ])dnl
 [};
 
 /* The size of the maximum gap between one aligned stack and the next.  */
   YYSTYPE yyvs;
   ]b4_location_if([  YYLTYPE yyls;
 ])dnl
 [};
 
 /* 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.  */
 ]b4_location_if(
 [# define YYSTACK_BYTES(N) \
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 ]b4_location_if(
 [# 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


@@ -302,7 +309,7 @@ union yyalloc
        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,7 +319,7 @@ union yyalloc
 #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. */


@@ -334,8 +341,7 @@ union yyalloc
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
 #define YYTRANSLATE(YYX)                                               \
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
 #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[] =


@@ -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);                                                \


@@ -494,20 +501,38 @@ do                                                                \
     }                                                          \
 while (0)
 
     }                                                          \
 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].  */

 
 #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)               \
+   ((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
 
 #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)
+# endif
+#else
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+

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


@@ -530,31 +555,25 @@ do {                                              \
     YYFPRINTF Args;                            \
 } while (0)
 
     YYFPRINTF Args;                            \
 } while (0)
 

-# define YYDSYMPRINT(Args)                     \
-do {                                           \
-  if (yydebug)                                 \
-    yysymprint Args;                           \
-} while (0)
-
-# define YYDSYMPRINTF(Title, Token, Value, Location)           \
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)         \

 do {                                                           \
   if (yydebug)                                                 \
     {                                                          \
       YYFPRINTF (stderr, "%s ", Title);                                \
       yysymprint (stderr,                                      \
 do {                                                           \
   if (yydebug)                                                 \
     {                                                          \
       YYFPRINTF (stderr, "%s ", Title);                                \
       yysymprint (stderr,                                      \

-                  Token, Value]b4_location_if([, Location])[); \
+                  Type, Value]b4_location_if([, Location])[);  \

       YYFPRINTF (stderr, "\n");                                        \
     }                                                          \
 } while (0)
 
 /*------------------------------------------------------------------.
 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
       YYFPRINTF (stderr, "\n");                                        \
     }                                                          \
 } while (0)
 
 /*------------------------------------------------------------------.
 | yy_stack_print -- Print the state stack from its BOTTOM up to its |

-| TOP (cinluded).                                                   |
+| TOP (included).                                                   |

 `------------------------------------------------------------------*/
 
 ]b4_c_function_def([yy_stack_print], [static void],
 `------------------------------------------------------------------*/
 
 ]b4_c_function_def([yy_stack_print], [static void],

-                   [[short *bottom], [bottom]],
-                   [[short *top],    [top]])[
+                   [[short int *bottom], [bottom]],
+                   [[short int *top],    [top]])[

 {
   YYFPRINTF (stderr, "Stack now");
   for (/* Nothing. */; bottom <= top; ++bottom)
 {
   YYFPRINTF (stderr, "Stack now");
   for (/* Nothing. */; bottom <= top; ++bottom)


@@ -577,9 +596,9 @@ do {                                                                \
                    [[int yyrule], [yyrule]])[
 {
   int yyi;
                    [[int yyrule], [yyrule]])[
 {
   int yyi;

-  unsigned int yylineno = yyrline[yyrule];
+  unsigned int yylno = yyrline[yyrule];

   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",

-             yyrule - 1, yylineno);
+             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]]);
   /* Print the symbols being reduced, and their result.  */
   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);


@@ -597,8 +616,7 @@ do {                                        \
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)

-# define YYDSYMPRINT(Args)
-# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)

 # define YY_STACK_PRINT(Bottom, Top)
 # define YY_REDUCE_PRINT(Rule)
 #endif /* !YYDEBUG */
 # define YY_STACK_PRINT(Bottom, Top)
 # define YY_REDUCE_PRINT(Rule)
 #endif /* !YYDEBUG */


@@ -616,7 +634,7 @@ 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
 
 # undef YYMAXDEPTH
 #endif
 


@@ -706,15 +724,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;
 
 /* Number of syntax errors so far.  */
 int yynerrs;b4_location_if([
 YYSTYPE yylval;
 
 /* Number of syntax errors so far.  */
 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.


@@ -744,7 +762,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:


@@ -756,9 +774,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];


@@ -769,7 +787,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--])[)
 


@@ -789,7 +809,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


@@ -798,8 +818,24 @@ 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.  */
+  yyls[0].first_line   = yyls[0].last_line   = 1;
+  yyls[0].first_column = yyls[0].last_column = 0;
+#endif
+]])
+m4_ifdef([b4_initial_action], [
+m4_pushdef([b4_at_dollar],     [(*yylsp)])dnl
+m4_pushdef([b4_dollar_dollar], [(*yyvsp)])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
+
+[  goto yysetstate;

 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |


@@ -824,7 +860,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


@@ -852,7 +888,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)


@@ -888,32 +924,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
     {

-      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
+      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


@@ -933,12 +970,12 @@ yybackup:
   if (yyn == YYFINAL)
     YYACCEPT;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 

-  /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %s, ", 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;])[


@@ -980,15 +1017,18 @@ yyreduce:
   yyval = yyvsp[1-yylen];
 
 ]b4_location_if(
   yyval = yyvsp[1-yylen];
 
 ]b4_location_if(

-[  /* Default location. */
-  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
+[[  /* Default location. */
+  if (yylen)
+    YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
+  else
+    yyloc = yylsp[0];]])[

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

-/* Line __line__ of __file__.  */
+/* Line __line__ of yacc.c.  */

 b4_syncline([@oline@], [@ofile@])
 \f
 [  yyvsp -= yylen;
 b4_syncline([@oline@], [@ofile@])
 \f
 [  yyvsp -= yylen;


@@ -1030,18 +1070,33 @@ 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 ("syntax 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)
            {


@@ -1050,16 +1105,13 @@ yyerrlab:
 
              if (yycount < 5)
                {
 
              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);
                      }
                }
              yyerror (]b4_yyerror_args[yymsg);


@@ -1073,39 +1125,63 @@ yyerrlab:
        yyerror (]b4_yyerror_args["syntax error");
     }
 
        yyerror (]b4_yyerror_args["syntax error");
     }
 

+]b4_location_if([[  yyerror_range[0] = yylloc;]])[
+

   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)
-           {
-             YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-             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])[);
+              }

         }
         }

-
-      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
-      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.  */
   goto yyerrlab1;
 
 
      token.  */
   goto yyerrlab1;
 
 

-/*----------------------------------------------------.
-| yyerrlab1 -- error raised explicitly by an action.  |
-`----------------------------------------------------*/
+/*---------------------------------------------------.
+| 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.  */
 
 yyerrlab1:
   yyerrstatus = 3;     /* Each real token shifted decrements this.  */
 


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

-      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
-      yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
-      yyvsp--;
-      yystate = *--yyssp;
-]b4_location_if([      yylsp--;])[
+]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;
 
       YY_STACK_PRINT (yyss, yyssp);
     }
 
   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;


@@ -1158,6 +1239,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;
 


@@ -1184,7 +1268,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.


@@ -1193,14 +1277,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
 


@@ -1208,15 +1293,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],