* TODO: Remove dead items.

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index d9d9af9defa7282a0ee80004c016538a1cf8d779..8f0ebe8f52de10e5df0f68b15a2a742ccd6df79c 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -2,7 +2,7 @@ m4_divert(-1)
 
 # C++ skeleton for Bison
 
 
 # C++ skeleton for Bison
 

-# Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by


@@ -30,14 +30,9 @@ m4_divert(0)dnl
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],

-             [2002, 2003, 2004, 2005])
+            [2002, 2003, 2004, 2005, 2006])

 dnl FIXME: This is wrong, we want computed header guards.
 dnl FIXME: This is wrong, we want computed header guards.

-[/* As a special exception, when this parser skeleton 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 for C++ LALR(1) parsers in version 2.2 of
-   Bison.  */
-
+[

 /* C++ LALR(1) parser skeleton written by Akim Demaille.  */
 
 #ifndef PARSER_HEADER_H
 /* C++ LALR(1) parser skeleton written by Akim Demaille.  */
 
 #ifndef PARSER_HEADER_H


@@ -107,12 +102,13 @@ namespace yy
   {
   public:
     /// Symbol semantic values.
   {
   public:
     /// Symbol semantic values.

-#if ! defined (YYSTYPE)
+#ifndef YYSTYPE

 ]m4_ifdef([b4_stype],
 ]m4_ifdef([b4_stype],

-[b4_syncline([b4_stype_line], [b4_file_name])
-    union semantic_type b4_stype;
+[    union semantic_type
+b4_stype

 /* Line __line__ of lalr1.cc.  */
 /* Line __line__ of lalr1.cc.  */

-b4_syncline([@oline@], [@ofile@])],
+b4_syncline([@oline@], [@ofile@])
+       ;],

 [    typedef int semantic_type;])[
 #else
     typedef YYSTYPE semantic_type;
 [    typedef int semantic_type;])[
 #else
     typedef YYSTYPE semantic_type;


@@ -124,6 +120,8 @@ b4_syncline([@oline@], [@ofile@])],
     {
       ]b4_token_enums(b4_tokens)[
     };
     {
       ]b4_token_enums(b4_tokens)[
     };

+    /// Token type.
+    typedef token::yytokentype token_type;

 
     /// Build a parser object.
     ]b4_parser_class_name[ (]b4_parse_param_decl[);
 
     /// Build a parser object.
     ]b4_parser_class_name[ (]b4_parse_param_decl[);


@@ -158,13 +156,20 @@ b4_syncline([@oline@], [@ofile@])],
 b4_error_verbose_if([, int tok])[);
 
 #if YYDEBUG
 b4_error_verbose_if([, int tok])[);
 
 #if YYDEBUG

+    /// \brief Report a symbol value on the debug stream.
+    /// \param yytype       The token type.
+    /// \param yyvaluep     Its semantic value.
+    /// \param yylocationp  Its location.
+    virtual void yy_symbol_value_print_ (int yytype,
+                                        const semantic_type* yyvaluep,
+                                        const location_type* yylocationp);

     /// \brief Report a symbol on the debug stream.
     /// \param yytype       The token type.
     /// \param yyvaluep     Its semantic value.
     /// \param yylocationp  Its location.
     /// \brief Report a symbol on the debug stream.
     /// \param yytype       The token type.
     /// \param yyvaluep     Its semantic value.
     /// \param yylocationp  Its location.

-    virtual void yysymprint_ (int yytype,
-                             const semantic_type* yyvaluep,
-                             const location_type* yylocationp);
+    virtual void yy_symbol_print_ (int yytype,
+                                  const semantic_type* yyvaluep,
+                                  const location_type* yylocationp);

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


@@ -245,7 +250,7 @@ b4_error_verbose_if([, int tok])[);
 #endif
 
     /// Convert a scanner token number to a symbol number.
 #endif
 
     /// Convert a scanner token number to a symbol number.

-    inline token_number_type yytranslate_ (int token);
+    token_number_type yytranslate_ (int token);

 
     /// \brief Reclaim the memory associated to a symbol.
     /// \param yymsg        Why this token is reclaimed.
 
     /// \brief Reclaim the memory associated to a symbol.
     /// \param yymsg        Why this token is reclaimed.


@@ -253,9 +258,9 @@ b4_error_verbose_if([, int tok])[);
     /// \param yyvaluep     Its semantic value.
     /// \param yylocationp  Its location.
     inline void yydestruct_ (const char* yymsg,
     /// \param yyvaluep     Its semantic value.
     /// \param yylocationp  Its location.
     inline void yydestruct_ (const char* yymsg,

-                             int yytype,
-                             semantic_type* yyvaluep,
-                             location_type* yylocationp);
+                            int yytype,
+                            semantic_type* yyvaluep,
+                            location_type* yylocationp);

 
     /// Pop \a n symbols the three stacks.
     inline void yypop_ (unsigned int n = 1);
 
     /// Pop \a n symbols the three stacks.
     inline void yypop_ (unsigned int n = 1);


@@ -285,7 +290,7 @@ b4_error_verbose_if([, int tok])[);
 [b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE
 [b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE

- /* Redirection for backward compatibility. */
+ /* Redirection for backward compatibility.  */

 # define YYSTYPE yy::b4_parser_class_name::semantic_type
 #endif
 ])[
 # define YYSTYPE yy::b4_parser_class_name::semantic_type
 #endif
 ])[


@@ -293,7 +298,7 @@ b4_error_verbose_if([, int tok])[);
 ])dnl
 @output @output_parser_name@
 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
 ])dnl
 @output @output_parser_name@
 b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],

-             [2002, 2003, 2004, 2005])
+            [2002, 2003, 2004, 2005, 2006])

 m4_if(b4_prefix[], [yy], [],
 [
 // Take the name prefix into account.
 m4_if(b4_prefix[], [yy], [],
 [
 // Take the name prefix into account.


@@ -323,7 +328,7 @@ b4_syncline([@oline@], [@ofile@])[
 /* Suppress unused-variable warnings by "using" E.  */
 #define YYUSE(e) ((void) (e))
 
 /* Suppress unused-variable warnings by "using" E.  */
 #define YYUSE(e) ((void) (e))
 

-/* A pseudo ostream that takes yydebug_ into account. */
+/* A pseudo ostream that takes yydebug_ into account.  */

 # define YYCDEBUG                                                      \
   for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false)       \
     (*yycdebug_)
 # define YYCDEBUG                                                      \
   for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false)       \
     (*yycdebug_)


@@ -336,7 +341,7 @@ do {                                                        \
   if (yydebug_)                                                \
     {                                                  \
       *yycdebug_ << Title << ' ';                      \
   if (yydebug_)                                                \
     {                                                  \
       *yycdebug_ << Title << ' ';                      \

-      yysymprint_ ((Type), (Value), (Location));       \
+      yy_symbol_print_ ((Type), (Value), (Location));  \

       *yycdebug_ << std::endl;                         \
     }                                                  \
 } while (false)
       *yycdebug_ << std::endl;                         \
     }                                                  \
 } while (false)


@@ -424,33 +429,36 @@ namespace yy
   | Print this symbol on YYOUTPUT.  |
   `--------------------------------*/
 
   | Print this symbol on YYOUTPUT.  |
   `--------------------------------*/
 

-  void
-  ]b4_parser_class_name[::yysymprint_ (int yytype,
-                           const semantic_type* yyvaluep, const location_type* yylocationp)
+  inline void
+  ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype,
+                          const semantic_type* yyvaluep, const location_type* yylocationp)

   {
   {

-    /* Backward compatibility, but should be removed eventually. */
-    std::ostream& cdebug_ = *yycdebug_;
-
-    YYUSE (!&cdebug_);

     YYUSE (yylocationp);
     YYUSE (yyvaluep);
     YYUSE (yylocationp);
     YYUSE (yyvaluep);

-
-    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
-            << ' ' << yytname_[yytype] << " ("
-               << *yylocationp << ": ";

     switch (yytype)
       {
   ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 [       default:
     switch (yytype)
       {
   ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 [       default:

-          break;
+         break;

       }
       }

+  }
+
+
+  void
+  ]b4_parser_class_name[::yy_symbol_print_ (int yytype,
+                          const semantic_type* yyvaluep, const location_type* yylocationp)
+  {
+    *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
+              << ' ' << yytname_[yytype] << " ("
+              << *yylocationp << ": ";
+    yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);

     *yycdebug_ << ')';
   }
 #endif /* ! YYDEBUG */
 
   void
   ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
     *yycdebug_ << ')';
   }
 #endif /* ! YYDEBUG */
 
   void
   ]b4_parser_class_name[::yydestruct_ (const char* yymsg,

-                           int yytype, semantic_type* yyvaluep, location_type* yylocationp)
+                          int yytype, semantic_type* yyvaluep, location_type* yylocationp)

   {
     YYUSE (yylocationp);
     YYUSE (yymsg);
   {
     YYUSE (yylocationp);
     YYUSE (yymsg);


@@ -461,8 +469,8 @@ namespace yy
     switch (yytype)
       {
   ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
     switch (yytype)
       {
   ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[

-        default:
-          break;
+       default:
+         break;

       }
   }
 
       }
   }
 


@@ -512,7 +520,7 @@ namespace yy
     int yylen = 0;
     int yystate = 0;
 
     int yylen = 0;
     int yystate = 0;
 

-    /* Error handling. */
+    /* Error handling.  */

     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 


@@ -535,7 +543,7 @@ namespace yy
 ]m4_ifdef([b4_initial_action], [
 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 m4_pushdef([b4_dollar_dollar], [yylval])dnl
 ]m4_ifdef([b4_initial_action], [
 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 m4_pushdef([b4_dollar_dollar], [yylval])dnl

-    /* User initialization code. */
+    /* User initialization code.  */

     b4_initial_action
 m4_popdef([b4_dollar_dollar])dnl
 m4_popdef([b4_at_dollar])dnl
     b4_initial_action
 m4_popdef([b4_dollar_dollar])dnl
 m4_popdef([b4_at_dollar])dnl


@@ -569,9 +577,9 @@ b4_syncline([@oline@], [@ofile@])])dnl
     /* Read a look-ahead token.  */
     if (yychar == yyempty_)
       {
     /* Read a look-ahead token.  */
     if (yychar == yyempty_)
       {

-        YYCDEBUG << "Reading a token: ";
-        yychar = ]b4_c_function_call([yylex], [int],
-                                     [[YYSTYPE*], [&yylval]][]dnl
+       YYCDEBUG << "Reading a token: ";
+       yychar = ]b4_c_function_call([yylex], [int],
+                                    [[YYSTYPE*], [&yylval]][]dnl

 b4_location_if([, [[location*], [&yylloc]]])dnl
 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       }
 b4_location_if([, [[location*], [&yylloc]]])dnl
 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       }


@@ -580,13 +588,13 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     /* Convert token to internal form.  */
     if (yychar <= yyeof_)
       {
     /* Convert token to internal form.  */
     if (yychar <= yyeof_)
       {

-        yychar = yytoken = yyeof_;
-        YYCDEBUG << "Now at end of input." << std::endl;
+       yychar = yytoken = yyeof_;
+       YYCDEBUG << "Now at end of input." << std::endl;

       }
     else
       {
       }
     else
       {

-        yytoken = yytranslate_ (yychar);
-        YY_SYMBOL_PRINT ("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


@@ -599,10 +607,10 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     yyn = yytable_[yyn];
     if (yyn <= 0)
       {
     yyn = yytable_[yyn];
     if (yyn <= 0)
       {

-        if (yyn == 0 || yyn == yytable_ninf_)
-       goto yyerrlab;
-        yyn = -yyn;
-        goto yyreduce;
+       if (yyn == 0 || yyn == yytable_ninf_)
+       goto yyerrlab;
+       yyn = -yyn;
+       goto yyreduce;

       }
 
     /* Accept?  */
       }
 
     /* Accept?  */


@@ -659,10 +667,10 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     YY_REDUCE_PRINT (yyn);
     switch (yyn)
       {
     YY_REDUCE_PRINT (yyn);
     switch (yyn)
       {

-        ]b4_actions
+       ]b4_actions

     /* Line __line__ of lalr1.cc.  */
 b4_syncline([@oline@], [@ofile@])[
     /* Line __line__ of lalr1.cc.  */
 b4_syncline([@oline@], [@ofile@])[

-        default: break;
+       default: break;

       }
     YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
 
       }
     YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
 


@@ -677,7 +685,7 @@ b4_syncline([@oline@], [@ofile@])[
     yyn = yyr1_[yyn];
     yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
     if (0 <= yystate && yystate <= yylast_
     yyn = yyr1_[yyn];
     yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
     if (0 <= yystate && yystate <= yylast_

-        && yycheck_[yystate] == yystate_stack_[0])
+       && yycheck_[yystate] == yystate_stack_[0])

       yystate = yytable_[yystate];
     else
       yystate = yydefgoto_[yyn - yyntokens_];
       yystate = yytable_[yystate];
     else
       yystate = yydefgoto_[yyn - yyntokens_];


@@ -690,28 +698,28 @@ b4_syncline([@oline@], [@ofile@])[
     /* If not already recovering from an error, report this error.  */
     if (!yyerrstatus_)
       {
     /* If not already recovering from an error, report this error.  */
     if (!yyerrstatus_)
       {

-        ++yynerrs_;
-        error (yylloc, yysyntax_error_ (yystate]dnl
+       ++yynerrs_;
+       error (yylloc, yysyntax_error_ (yystate]dnl

 b4_error_verbose_if([, yytoken])[));
       }
 
     yyerror_range[0] = yylloc;
     if (yyerrstatus_ == 3)
       {
 b4_error_verbose_if([, yytoken])[));
       }
 
     yyerror_range[0] = yylloc;
     if (yyerrstatus_ == 3)
       {

-        /* If just tried and failed to reuse look-ahead token after an
-        error, discard it.  */
-
-        if (yychar <= yyeof_)
-          {
-         /* Return failure if at end of input.  */
-         if (yychar == yyeof_)
-           YYABORT;
-          }
-        else
-          {
-            yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
-            yychar = yyempty_;
-          }
+       /* If just tried and failed to reuse look-ahead token after an
+        error, discard it.  */
+
+       if (yychar <= yyeof_)
+         {
+         /* Return failure if at end of input.  */
+         if (yychar == yyeof_)
+           YYABORT;
+         }
+       else
+         {
+           yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
+           yychar = yyempty_;
+         }

       }
 
     /* Else will try to reuse look-ahead token after shifting the error
       }
 
     /* Else will try to reuse look-ahead token after shifting the error


@@ -732,7 +740,7 @@ b4_error_verbose_if([, yytoken])[));
 
     yyerror_range[0] = yylocation_stack_[yylen - 1];
     /* Do not reclaim the symbols of the rule which action triggered
 
     yyerror_range[0] = yylocation_stack_[yylen - 1];
     /* Do not reclaim the symbols of the rule which action triggered

-       this YYERROR. */
+       this YYERROR.  */

     yypop_ (yylen);
     yylen = 0;
     yystate = yystate_stack_[0];
     yypop_ (yylen);
     yylen = 0;
     yystate = yystate_stack_[0];


@@ -746,29 +754,29 @@ b4_error_verbose_if([, yytoken])[));
 
     for (;;)
       {
 
     for (;;)
       {

-        yyn = yypact_[yystate];
-        if (yyn != yypact_ninf_)
-       {
-         yyn += yyterror_;
-         if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
-           {
-             yyn = yytable_[yyn];
-             if (0 < yyn)
-               break;
-           }
-       }
-
-        /* Pop the current state because it cannot handle the error token.  */
-        if (yystate_stack_.height () == 1)
-       YYABORT;
-
-        yyerror_range[0] = yylocation_stack_[0];
-        yydestruct_ ("Error: popping",
-                     yystos_[yystate],
-                     &yysemantic_stack_[0], &yylocation_stack_[0]);
-        yypop_ ();
-        yystate = yystate_stack_[0];
-        YY_STACK_PRINT ();
+       yyn = yypact_[yystate];
+       if (yyn != yypact_ninf_)
+       {
+         yyn += yyterror_;
+         if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
+           {
+             yyn = yytable_[yyn];
+             if (0 < yyn)
+               break;
+           }
+       }
+
+       /* Pop the current state because it cannot handle the error token.  */
+       if (yystate_stack_.height () == 1)
+       YYABORT;
+
+       yyerror_range[0] = yylocation_stack_[0];
+       yydestruct_ ("Error: popping",
+                    yystos_[yystate],
+                    &yysemantic_stack_[0], &yylocation_stack_[0]);
+       yypop_ ();
+       yystate = yystate_stack_[0];
+       YY_STACK_PRINT ();

       }
 
     if (yyn == yyfinal_)
       }
 
     if (yyn == yyfinal_)


@@ -777,13 +785,13 @@ b4_error_verbose_if([, yytoken])[));
     yyerror_range[1] = yylloc;
     // Using YYLLOC is tempting, but would change the location of
     // the look-ahead.  YYLOC is available though.
     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);
+    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);

     yysemantic_stack_.push (yylval);
     yylocation_stack_.push (yyloc);
 
     yysemantic_stack_.push (yylval);
     yylocation_stack_.push (yyloc);
 

-    /* Shift the error token. */
+    /* Shift the error token.  */

     YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
     YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],

-                  &yysemantic_stack_[0], &yylocation_stack_[0]);
+                  &yysemantic_stack_[0], &yylocation_stack_[0]);

 
     yystate = yyn;
     goto yynewstate;
 
     yystate = yyn;
     goto yynewstate;


@@ -803,15 +811,15 @@ b4_error_verbose_if([, yytoken])[));
       yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
 
     /* Do not reclaim the symbols of the rule which action triggered
       yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
 
     /* Do not reclaim the symbols of the rule which action triggered

-       this YYABORT or YYACCEPT. */
+       this YYABORT or YYACCEPT.  */

     yypop_ (yylen);
     while (yystate_stack_.height () != 1)
       {
     yypop_ (yylen);
     while (yystate_stack_.height () != 1)
       {

-        yydestruct_ ("Cleanup: popping",
-                  yystos_[yystate_stack_[0]],
-                  &yysemantic_stack_[0],
-                  &yylocation_stack_[0]);
-        yypop_ ();
+       yydestruct_ ("Cleanup: popping",
+                  yystos_[yystate_stack_[0]],
+                  &yysemantic_stack_[0],
+                  &yylocation_stack_[0]);
+       yypop_ ();

       }
 
     return yyresult;
       }
 
     return yyresult;


@@ -823,42 +831,43 @@ b4_error_verbose_if([, yytoken])[));
 b4_error_verbose_if([, int tok])[)
   {
     std::string res;
 b4_error_verbose_if([, int tok])[)
   {
     std::string res;

+    YYUSE (yystate);

 #if YYERROR_VERBOSE
     int yyn = yypact_[yystate];
     if (yypact_ninf_ < yyn && yyn < yylast_)
       {
 #if YYERROR_VERBOSE
     int yyn = yypact_[yystate];
     if (yypact_ninf_ < yyn && yyn < yylast_)
       {

-        /* Start YYX at -YYN if negative to avoid negative indexes in
-           YYCHECK.  */
-        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 count = 0;
-        for (int x = yyxbegin; x < yyxend; ++x)
-          if (yycheck_[x + yyn] == x && x != yyterror_)
-            ++count;
-
-        // FIXME: This method of building the message is not compatible
-        // with internationalization.  It should work like yacc.c does it.
-        // That is, first build a string that looks like this:
-        // "syntax error, unexpected %s or %s or %s"
-        // Then, invoke YY_ on this string.
-        // Finally, use the string as a format to output
-        // yytname_[tok], etc.
-        // Until this gets fixed, this message appears in English only.
-        res = "syntax error, unexpected ";
-        res += yytnamerr_ (yytname_[tok]);
-        if (count < 5)
-          {
-            count = 0;
-            for (int x = yyxbegin; x < yyxend; ++x)
-              if (yycheck_[x + yyn] == x && x != yyterror_)
-                {
-                  res += (!count++) ? ", expecting " : " or ";
-                  res += yytnamerr_ (yytname_[x]);
-                }
-          }
+       /* Start YYX at -YYN if negative to avoid negative indexes in
+          YYCHECK.  */
+       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 count = 0;
+       for (int x = yyxbegin; x < yyxend; ++x)
+         if (yycheck_[x + yyn] == x && x != yyterror_)
+           ++count;
+
+       // FIXME: This method of building the message is not compatible
+       // with internationalization.  It should work like yacc.c does it.
+       // That is, first build a string that looks like this:
+       // "syntax error, unexpected %s or %s or %s"
+       // Then, invoke YY_ on this string.
+       // Finally, use the string as a format to output
+       // yytname_[tok], etc.
+       // Until this gets fixed, this message appears in English only.
+       res = "syntax error, unexpected ";
+       res += yytnamerr_ (yytname_[tok]);
+       if (count < 5)
+         {
+           count = 0;
+           for (int x = yyxbegin; x < yyxend; ++x)
+             if (yycheck_[x + yyn] == x && x != yyterror_)
+               {
+                 res += (!count++) ? ", expecting " : " or ";
+                 res += yytnamerr_ (yytname_[x]);
+               }
+         }

       }
     else
 #endif
       }
     else
 #endif


@@ -950,7 +959,7 @@ b4_error_verbose_if([, int tok])[)
 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.

-     First, the terminals, then, starting at \a yyntokens_, nonterminals. */
+     First, the terminals, then, starting at \a yyntokens_, nonterminals.  */

   const char*
   const ]b4_parser_class_name[::yytname_[] =
   {
   const char*
   const ]b4_parser_class_name[::yytname_[] =
   {


@@ -959,7 +968,7 @@ b4_error_verbose_if([, int tok])[)
 #endif
 
 #if YYDEBUG
 #endif
 
 #if YYDEBUG

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

   const ]b4_parser_class_name[::rhs_number_type
   ]b4_parser_class_name[::yyrhs_[] =
   {
   const ]b4_parser_class_name[::rhs_number_type
   ]b4_parser_class_name[::yyrhs_[] =
   {


@@ -987,7 +996,7 @@ b4_error_verbose_if([, int tok])[)
   {
     *yycdebug_ << "Stack now";
     for (state_stack_type::const_iterator i = yystate_stack_.begin ();
   {
     *yycdebug_ << "Stack now";
     for (state_stack_type::const_iterator i = yystate_stack_.begin ();

-         i != yystate_stack_.end (); ++i)
+        i != yystate_stack_.end (); ++i)

       *yycdebug_ << ' ' << *i;
     *yycdebug_ << std::endl;
   }
       *yycdebug_ << ' ' << *i;
     *yycdebug_ << std::endl;
   }


@@ -1000,13 +1009,13 @@ b4_error_verbose_if([, int tok])[)
     int yynrhs = yyr2_[yyrule];
     /* Print the symbols being reduced, and their result.  */
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
     int yynrhs = yyr2_[yyrule];
     /* Print the symbols being reduced, and their result.  */
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1

-               << " (line " << yylno << "), ";
+              << " (line " << yylno << "), ";

     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
     /* The symbols being reduced.  */
     for (int yyi = 0; yyi < yynrhs; yyi++)
       YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",

-                       yyrhs_[yyprhs_[yyrule] + yyi],
-                       &]b4_rhs_value(yynrhs, yyi + 1)[,
-                       &]b4_rhs_location(yynrhs, yyi + 1)[);
+                      yyrhs_[yyprhs_[yyrule] + yyi],
+                      &]b4_rhs_value(yynrhs, yyi + 1)[,
+                      &]b4_rhs_location(yynrhs, yyi + 1)[);

   }
 #endif // YYDEBUG
 
   }
 #endif // YYDEBUG
 


@@ -1043,7 +1052,8 @@ b4_error_verbose_if([, int tok])[)
 ]b4_epilogue
 dnl
 @output b4_dir_prefix[]stack.hh
 ]b4_epilogue
 dnl
 @output b4_dir_prefix[]stack.hh

-b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004, 2005])[
+b4_copyright([stack handling for Bison C++ parsers],
+  [2002, 2003, 2004, 2005, 2006])[

 
 #ifndef BISON_STACK_HH
 # define BISON_STACK_HH
 
 #ifndef BISON_STACK_HH
 # define BISON_STACK_HH