Use #define to handle the %name-prefix.

[bison.git] / data / yacc.c

diff --git a/data/yacc.c b/data/yacc.c
index e562da0a8c2e771ce137630f4b62f4d84f4dfed5..7331b65c3e3296183af281715173b338cb91abb3 100644 (file)
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -1,7 +1,7 @@
 m4_divert(-1)                                                       -*- C -*-
 
 # Yacc compatible skeleton for Bison
 m4_divert(-1)                                                       -*- C -*-
 
 # Yacc compatible skeleton for Bison

-# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003
+# 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


@@ -58,8 +58,8 @@ m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 # 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)))

 
 
 
 
 
 


@@ -76,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],
 


@@ -134,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, 2003])[
+             [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.


@@ -153,8 +153,7 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
 
 ]b4_identification
 m4_if(b4_prefix[], [yy], [],
 
 ]b4_identification
 m4_if(b4_prefix[], [yy], [],

-[/* If NAME_PREFIX is specified substitute the variables and functions
-   names.  */
+[/* Substitute the variable and function names.  */

 #define yyparse b4_prefix[]parse
 #define yylex   b4_prefix[]lex
 #define yyerror b4_prefix[]error
 #define yyparse b4_prefix[]parse
 #define yylex   b4_prefix[]lex
 #define yyerror b4_prefix[]error


@@ -216,18 +215,25 @@ 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


@@ -240,20 +246,21 @@ 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) \

-        || (]b4_location_if([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
   YYSTYPE yyvs;
   ]b4_location_if([  YYLTYPE yyls;
 ])dnl


@@ -266,16 +273,16 @@ union yyalloc
    N elements.  */
 ]b4_location_if(
 [# define YYSTACK_BYTES(N) \
    N elements.  */
 ]b4_location_if(
 [# define YYSTACK_BYTES(N) \

-     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \

       + 2 * YYSTACK_GAP_MAXIMUM)],
 [# define YYSTACK_BYTES(N) \
       + 2 * YYSTACK_GAP_MAXIMUM)],
 [# define YYSTACK_BYTES(N) \

-     ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
+     ((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
       + YYSTACK_GAP_MAXIMUM)])[
 
 /* 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


@@ -311,7 +318,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. */


@@ -465,14 +472,7 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] =
 
 #define YYACCEPT       goto yyacceptlab
 #define YYABORT                goto yyabortlab
 
 #define YYACCEPT       goto yyacceptlab
 #define YYABORT                goto yyabortlab

-#define YYERROR                ]b4_location_if([do                             \
-                         {                             \
-                           yylerrsp = yylsp;           \
-                           *++yylerrsp = yyloc;        \
-                           goto yyerrlab1;             \
-                         }                             \
-                       while (0)],
-                       [goto yyerrlab1])[
+#define YYERROR                goto yyerrorlab

 
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
 
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily


@@ -500,20 +500,53 @@ 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].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])

 #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   = YYRHSLOC(Rhs, 1).first_line;         \
+         (Current).first_column = YYRHSLOC(Rhs, 1).first_column;       \
+         (Current).last_line    = YYRHSLOC(Rhs, N).last_line;          \
+         (Current).last_column  = YYRHSLOC(Rhs, N).last_column;        \
+       }                                                               \
+      else                                                             \
+       {                                                               \
+         (Current).first_line   = (Current).last_line   =              \
+           YYRHSLOC(Rhs, 0).last_line;                                 \
+         (Current).first_column = (Current).last_column =              \
+           YYRHSLOC(Rhs, 0).last_column;                               \
+       }                                                               \
+    while (0)

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

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


@@ -536,31 +569,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)


@@ -583,9 +610,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]]);


@@ -603,8 +630,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 */


@@ -622,7 +648,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
 


@@ -712,15 +738,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.


@@ -750,7 +776,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:


@@ -762,9 +788,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];


@@ -776,7 +802,8 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
   YYLTYPE yylsa[YYINITDEPTH];
   YYLTYPE *yyls = yylsa;
   YYLTYPE *yylsp;
   YYLTYPE yylsa[YYINITDEPTH];
   YYLTYPE *yyls = yylsa;
   YYLTYPE *yylsp;

-  YYLTYPE *yylerrsp;]])[
+  /* 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--])[)
 


@@ -805,8 +832,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.  |


@@ -831,7 +877,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


@@ -859,7 +905,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)


@@ -895,18 +941,18 @@ 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.  */

 
 

-  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */

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


@@ -921,7 +967,7 @@ yybackup:
   else
     {
       yytoken = YYTRANSLATE (yychar);
   else
     {
       yytoken = YYTRANSLATE (yychar);

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


@@ -941,8 +987,8 @@ 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.  */
   if (yychar != YYEOF)
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)


@@ -988,8 +1034,8 @@ 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. */
+  YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);]])[

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


@@ -1038,32 +1084,30 @@ yyerrlab:
        {
          YYSIZE_T yysize = 0;
          int yytype = YYTRANSLATE (yychar);
        {
          YYSIZE_T yysize = 0;
          int yytype = YYTRANSLATE (yychar);

+         const char* yyprefix;

          char *yymsg;
          int yyx;
 
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
          char *yymsg;
          int yyx;
 
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */

-         int yyxbase = yyn < 0 ? -yyn : 0;
+         int yyxbegin = yyn < 0 ? -yyn : 0;

 
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn;
 
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn;

-         int yynsyms = sizeof (yytname) / sizeof (yytname[0]);
-         int yyxlim = yychecklim < yynsyms ? yychecklim : yynsyms;
+         int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

          int yycount = 0;
 
          int yycount = 0;
 

-         for (yyx = yyxbase; yyx < yyxlim; yyx++)
+         yyprefix = ", expecting ";
+         for (yyx = yyxbegin; yyx < yyxend; ++yyx)

            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              {
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              {

-               yysize += (! yycount
-                          ? sizeof (", expecting ") - 1
-                          : sizeof (" or ") - 1);
-               yysize += yystrlen (yytname[yyx]);
-               yycount++;
+               yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
+               yycount += 1;

                if (yycount == 5)
                  {
                    yysize = 0;
                    break;
                if (yycount == 5)
                  {
                    yysize = 0;
                    break;

-                 }             
+                 }

              }
          yysize += (sizeof ("syntax error, unexpected ")
                     + yystrlen (yytname[yytype]));
              }
          yysize += (sizeof ("syntax error, unexpected ")
                     + yystrlen (yytname[yytype]));


@@ -1075,14 +1119,13 @@ yyerrlab:
 
              if (yycount < 5)
                {
 
              if (yycount < 5)
                {

-                 yycount = 0;
-                 for (yyx = yyxbase; yyx < yyxlim; 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);


@@ -1096,42 +1139,63 @@ yyerrlab:
        yyerror (]b4_yyerror_args["syntax error");
     }
 
        yyerror (]b4_yyerror_args["syntax error");
     }
 

-]b4_location_if([  yylerrsp = yylsp;])[
+]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 (yychar == 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])[);
-      yychar = YYEMPTY;
-]b4_location_if([      *++yylerrsp = yylloc;])[
+      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.  */
 


@@ -1153,22 +1217,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([  YYLLOC_DEFAULT (yyloc, yylsp, (yylerrsp - yylsp));
-  *++yylsp = yyloc;])[
+]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;


@@ -1185,6 +1253,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;
 


@@ -1211,7 +1282,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, 2003])
+             [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.