* src/scan-gram.l: When it starts with `%', complain about the

[bison.git] / data / yacc.c

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

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

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


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

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

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


@@ -65,19 +128,6 @@ m4_define([b4_rhs_location],
 
 
 
 
 
 

-## -------------- ##
-## %pure-parser.  ##
-## -------------- ##
-
-# b4_pure_if(IF-TRUE, IF-FALSE)
-# -----------------------------
-# Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise.
-m4_define([b4_pure_if],
-[m4_if(b4_pure, [1],
-       [$1],
-       [$2])])
-
-

 ## ------------------- ##
 ## Output file names.  ##
 ## ------------------- ##
 ## ------------------- ##
 ## Output file names.  ##
 ## ------------------- ##


@@ -124,12 +174,18 @@ m4_popdef([b4_dollar_dollar])dnl
 ])
 
 
 ])
 
 

-
+# We do want M4 expansion after # for CPP macros.
+m4_changecom()

 m4_divert(0)dnl
 #output "b4_output_parser_name"
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 
 m4_divert(0)dnl
 #output "b4_output_parser_name"
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 

+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+

 /* Written by Richard Stallman by simplifying the original so called
    ``semantic'' parser.  */
 
 /* Written by Richard Stallman by simplifying the original so called
    ``semantic'' parser.  */
 


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

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

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


@@ -161,11 +209,11 @@ m4_if(b4_prefix[], [yy], [],
 #define yynerrs b4_prefix[]nerrs
 b4_location_if([#define yylloc b4_prefix[]lloc])])
 
 #define yynerrs b4_prefix[]nerrs
 b4_location_if([#define yylloc b4_prefix[]lloc])])
 

+b4_token_defines(b4_tokens)
+

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

-b4_token_defines(b4_tokens)
-

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


@@ -198,7 +246,7 @@ typedef struct yyltype
   int last_line;
   int last_column;
 } yyltype;
   int last_line;
   int last_column;
 } yyltype;

-# define YYLTYPE b4_ltype
+# define YYLTYPE b4_location_type

 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 


@@ -302,8 +350,15 @@ b4_location_if(
 
 #endif
 
 
 #endif
 

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

 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  b4_final_state_number
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  b4_final_state_number

+/* YYLAST -- Last index in YYTABLE.  */

 #define YYLAST   b4_last
 
 /* YYNTOKENS -- Number of terminals. */
 #define YYLAST   b4_last
 
 /* YYNTOKENS -- Number of terminals. */


@@ -409,7 +464,8 @@ static const b4_int_type_for([b4_pgoto]) yypgoto[[]] =
 
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
 
 /* 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.  */
+   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[[]] =
 {
 #define YYTABLE_NINF b4_table_ninf
 static const b4_int_type_for([b4_table]) yytable[[]] =
 {


@@ -473,7 +529,7 @@ do                                                          \
     }                                                          \
   else                                                         \
     {                                                          \
     }                                                          \
   else                                                         \
     {                                                          \

-      yyerror ("syntax error: cannot back up");                        \
+      yyerror ("syntax error: cannot back up"b4_pure_args);    \

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


@@ -494,13 +550,11 @@ while (0)
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 

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

 #else
 #else

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

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


@@ -530,7 +584,7 @@ int yydebug;
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH

-# define YYINITDEPTH b4_initdepth
+# define YYINITDEPTH b4_stack_depth_init

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


@@ -545,7 +599,7 @@ int yydebug;
 #endif
 
 #ifndef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH

-# define YYMAXDEPTH b4_maxdepth
+# define YYMAXDEPTH b4_stack_depth_max

 #endif
 
 \f
 #endif
 
 \f


@@ -610,12 +664,12 @@ yystpcpy (yydest, yysrc)
 | Print this symbol on YYOUT.  |
 `-----------------------------*/
 
 | Print this symbol on YYOUT.  |
 `-----------------------------*/
 

-b4_c_function([yysymprint],
-             [static void],
-             [[FILE*],   [yyout]],
-             [[int],     [yytype]],
-             [[YYSTYPE], [yyvalue]]b4_location_if([,
-             [[YYLTYPE], [yylocation]]]))
+b4_c_function_def([yysymprint],
+                 [static void],
+                 [[FILE *yyout],        [yyout]],
+                 [[int yytype],         [yytype]],
+                 [[YYSTYPE yyvalue],    [yyvalue]]b4_location_if([,
+                 [[YYLTYPE yylocation], [yylocation]]]))

 {
   /* Pacify ``unused variable'' warnings.  */
   (void) yyvalue;
 {
   /* Pacify ``unused variable'' warnings.  */
   (void) yyvalue;


@@ -643,83 +697,15 @@ m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 #endif /* YYDEBUG. */
 
 
 #endif /* YYDEBUG. */
 
 

-/*----------------------------------------------------------.
-| yyreport_parse_error -- report a parse error in YYSTATE.  |
-`----------------------------------------------------------*/
-
-b4_c_function([yyreport_parse_error],
-             [static void],
-             [[int],     [yystate]],
-             [[int],     [yychar]],
-             [[YYSTYPE], [yyvalue]]b4_location_if([,
-             [[YYLTYPE], [yylloc]]]))
-[{
-#if YYERROR_VERBOSE
-  int yyn = yypact[yystate];
-
-  if (YYPACT_NINF < yyn && yyn < YYLAST)
-    {
-      YYSIZE_T yysize = 0;
-      int yytype = YYTRANSLATE (yychar);
-      char *yymsg;
-      int yyx, yycount;
-
-      yycount = 0;
-      /* 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++)
-       if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-         yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-      yysize += yystrlen ("parse error, unexpected ") + 1;
-      yysize += yystrlen (yytname[yytype]);
-      yymsg = (char *) YYSTACK_ALLOC (yysize);
-      if (yymsg != 0)
-       {
-         char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
-         yyp = yystpcpy (yyp, yytname[yytype]);
-
-         if (yycount < 5)
-           {
-             yycount = 0;
-             for (yyx = yyn < 0 ? -yyn : 0;
-                  yyx < (int) (sizeof (yytname) / sizeof (char *));
-                  yyx++)
-               if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-                 {
-                   const char *yyq = ! yycount ? ", expecting " : " or ";
-                   yyp = yystpcpy (yyp, yyq);
-                   yyp = yystpcpy (yyp, yytname[yyx]);
-                   yycount++;
-                 }
-           }
-         yyerror (yymsg);
-         YYSTACK_FREE (yymsg);
-       }
-      else
-       yyerror ("parse error; also virtual memory exhausted");
-    }
-  else
-#endif /* YYERROR_VERBOSE */
-    yyerror ("parse error");
-
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yystate;
-  (void) yychar;
-  (void) yyvalue;
-  ]b4_location_if([(void) yylloc;])[
-}]
-
-

 /*-----------------------------------------------.
 | Release the memory associated to this symbol.  |
 `-----------------------------------------------*/
 
 /*-----------------------------------------------.
 | Release the memory associated to this symbol.  |
 `-----------------------------------------------*/
 

-b4_c_function([yydestruct],
-             [static void],
-             [[int],     [yytype]],
-             [[YYSTYPE], [yyvalue]]b4_location_if([,
-             [[YYLTYPE], [yylocation]]]))
+b4_c_function_def([yydestruct],
+                 [static void],
+                 [[int yytype],         [yytype]],
+                 [[YYSTYPE yyvalue],    [yyvalue]]b4_location_if([,
+                 [[YYLTYPE yylocation], [yylocation]]]))

 {
   /* Pacify ``unused variable'' warnings.  */
   (void) yyvalue;
 {
   /* Pacify ``unused variable'' warnings.  */
   (void) yyvalue;


@@ -736,39 +722,24 @@ m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
 
 \f
 
 
 \f
 

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

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

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

 # else
 # else

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

 # endif
 # endif

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

 #endif
 
 #endif
 

+

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

-#  pure-parser
+# pure-parser.

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


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

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

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


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

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

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


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

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

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

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

        yystacksize = YYMAXDEPTH;
 
       {
        yystacksize = YYMAXDEPTH;
 
       {


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

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

        YYABORT;
     }
 
        YYABORT;
     }
 


@@ -980,28 +963,19 @@ yybackup:
       YYDPRINTF ((stderr, "\n"));
     }
 
       YYDPRINTF ((stderr, "\n"));
     }
 

+  /* If the proper action on seeing token YYCHAR1 is to reduce or to
+     detect an error, take that action.  */

   yyn += yychar1;
   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
     goto yydefault;
   yyn += yychar1;
   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
     goto yydefault;

-

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

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

     {
     {

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

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

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

 
   if (yyn == YYFINAL)
     YYACCEPT;
 
   if (yyn == YYFINAL)
     YYACCEPT;


@@ -1068,7 +1042,7 @@ yyreduce:
                 yyn - 1, yyrline[yyn]);
 
       /* Print the symbols being reduced, and their result.  */
                 yyn - 1, yyrline[yyn]);
 
       /* Print the symbols being reduced, and their result.  */

-      for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
+      for (yyi = yyprhs[yyn]; 0 <= yyrhs[yyi]; yyi++)

        YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     }
        YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     }


@@ -1122,7 +1096,54 @@ yyerrlab:
   if (!yyerrstatus)
     {
       ++yynerrs;
   if (!yyerrstatus)
     {
       ++yynerrs;

-      yyreport_parse_error (yystate, yychar, yylval]b4_location_if([, yylloc])[);
+#if YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (YYPACT_NINF < yyn && yyn < YYLAST)
+       {
+         YYSIZE_T yysize = 0;
+         int yytype = YYTRANSLATE (yychar);
+         char *yymsg;
+         int yyx, yycount;
+
+         yycount = 0;
+         /* 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++)
+           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+             yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+         yysize += yystrlen ("parse error, unexpected ") + 1;
+         yysize += yystrlen (yytname[yytype]);
+         yymsg = (char *) YYSTACK_ALLOC (yysize);
+         if (yymsg != 0)
+           {
+             char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+             yyp = yystpcpy (yyp, yytname[yytype]);
+
+             if (yycount < 5)
+               {
+                 yycount = 0;
+                 for (yyx = yyn < 0 ? -yyn : 0;
+                      yyx < (int) (sizeof (yytname) / sizeof (char *));
+                      yyx++)
+                   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+                     {
+                       const char *yyq = ! yycount ? ", expecting " : " or ";
+                       yyp = yystpcpy (yyp, yyq);
+                       yyp = yystpcpy (yyp, yytname[yyx]);
+                       yycount++;
+                     }
+               }
+             yyerror (yymsg]b4_pure_args[);
+             YYSTACK_FREE (yymsg);
+           }
+         else
+           yyerror ("parse error; also virtual memory exhausted"]b4_pure_args[);
+       }
+      else
+#endif /* YYERROR_VERBOSE */
+       yyerror ("parse error"]b4_pure_args[);

     }
   goto yyerrlab1;
 
     }
   goto yyerrlab1;
 


@@ -1142,7 +1163,7 @@ yyerrlab1:
          /* Pop the error token.  */
           YYPOPSTACK;
          /* Pop the rest of the stack.  */
          /* Pop the error token.  */
           YYPOPSTACK;
          /* Pop the rest of the stack.  */

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

            {
              YYDPRINTF ((stderr, "Error: popping "));
              YYDSYMPRINT ((stderr,
            {
              YYDPRINTF ((stderr, "Error: popping "));
              YYDSYMPRINT ((stderr,


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

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

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


@@ -1255,7 +1276,12 @@ b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [#output "b4_output_header_name"
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
 m4_if(b4_defines_flag, 0, [],
 [#output "b4_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])
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */

 
 #ifndef b4_header_guard
 # define b4_header_guard
 
 #ifndef b4_header_guard
 # define b4_header_guard