Regenerate.

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index d8782fae88dd458e17a9482c6920cd432dc32db0..7b8bf93329a43f8b60cb9479dbe4500958392a7a 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -29,8 +29,8 @@ m4_changecom()
 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],
-            [2002, 2003, 2004, 2005, 2006])
+b4_copyright([Skeleton interface for Bison LALR(1) parsers in C++],
+  [2002, 2003, 2004, 2005, 2006])
 dnl FIXME: This is wrong, we want computed header guards.
 [
 /* C++ LALR(1) parser skeleton written by Akim Demaille.  */
@@ -42,7 +42,7 @@ dnl FIXME: This is wrong, we want computed header guards.
 #include <iostream>
 #include "stack.hh"
 
-namespace yy
+namespace ]b4_namespace[
 {
   class position;
   class location;
@@ -94,7 +94,7 @@ do {                                                  \
 } while (false)
 #endif
 
-namespace yy
+namespace ]b4_namespace[
 {
 
   /// A Bison parser.
@@ -120,6 +120,8 @@ b4_syncline([@oline@], [@ofile@])
     {
       ]b4_token_enums(b4_tokens)[
     };
+    /// Token type.
+    typedef token::yytokentype token_type;
 
     /// Build a parser object.
     ]b4_parser_class_name[ (]b4_parse_param_decl[);
@@ -247,8 +249,8 @@ b4_error_verbose_if([, int tok])[);
     virtual void yystack_print_ ();
 #endif
 
-    /// Convert a scanner token number to a symbol number.
-    token_number_type yytranslate_ (int token);
+    /// Convert a scanner token number \a t to a symbol number.
+    token_number_type yytranslate_ (int t);
 
     /// \brief Reclaim the memory associated to a symbol.
     /// \param yymsg        Why this token is reclaimed.
@@ -289,15 +291,15 @@ b4_error_verbose_if([, int tok])[);
 
 #ifndef YYSTYPE
  /* Redirection for backward compatibility.  */
-# define YYSTYPE yy::b4_parser_class_name::semantic_type
+# define YYSTYPE b4_namespace::b4_parser_class_name::semantic_type
 #endif
 ])[
 #endif /* ! defined PARSER_HEADER_H */]
 ])dnl
 @output @output_parser_name@
-b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
-            [2002, 2003, 2004, 2005, 2006])
-m4_if(b4_prefix[], [yy], [],
+b4_copyright([Skeleton implementation for Bison LALR(1) parsers in C++],
+  [2002, 2003, 2004, 2005, 2006])
+m4_if(b4_prefix, [yy], [],
 [
 // Take the name prefix into account.
 #define yylex   b4_prefix[]lex])
@@ -368,49 +370,49 @@ do {                                      \
 #define YYABORT                goto yyabortlab
 #define YYERROR                goto yyerrorlab
 
-#if YYERROR_VERBOSE
-
-/* Return YYSTR after stripping away unnecessary quotes and
-   backslashes, so that it's suitable for yyerror.  The heuristic is
-   that double-quoting is unnecessary unless the string contains an
-   apostrophe, a comma, or backslash (other than backslash-backslash).
-   YYSTR is taken from yytname.  */
-std::string
-yy::]b4_parser_class_name[::yytnamerr_ (const char *yystr)
+namespace ]b4_namespace[
 {
-  if (*yystr == '"')
-    {
-      std::string yyr = "";
-      char const *yyp = yystr;
+#if YYERROR_VERBOSE
 
-      for (;;)
-       switch (*++yyp)
-         {
-         case '\'':
-         case ',':
-           goto do_not_strip_quotes;
-
-         case '\\':
-           if (*++yyp != '\\')
-             goto do_not_strip_quotes;
-           /* Fall through.  */
-         default:
-           yyr += *yyp;
-           break;
-
-         case '"':
-           return yyr;
-         }
-    do_not_strip_quotes: ;
-    }
+  /* Return YYSTR after stripping away unnecessary quotes and
+     backslashes, so that it's suitable for yyerror.  The heuristic is
+     that double-quoting is unnecessary unless the string contains an
+     apostrophe, a comma, or backslash (other than backslash-backslash).
+     YYSTR is taken from yytname.  */
+  std::string
+  ]b4_parser_class_name[::yytnamerr_ (const char *yystr)
+  {
+    if (*yystr == '"')
+      {
+        std::string yyr = "";
+        char const *yyp = yystr;
+
+        for (;;)
+          switch (*++yyp)
+            {
+            case '\'':
+            case ',':
+              goto do_not_strip_quotes;
+
+            case '\\':
+              if (*++yyp != '\\')
+                goto do_not_strip_quotes;
+              /* Fall through.  */
+            default:
+              yyr += *yyp;
+              break;
+
+            case '"':
+              return yyr;
+            }
+      do_not_strip_quotes: ;
+      }
 
-  return yystr;
-}
+    return yystr;
+  }
 
 #endif
 
-namespace yy
-{
   /// Build a parser object.
   ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)
     : yydebug_ (false),
@@ -1019,7 +1021,7 @@ b4_error_verbose_if([, int tok])[)
 
   /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
   ]b4_parser_class_name[::token_number_type
-  ]b4_parser_class_name[::yytranslate_ (int token)
+  ]b4_parser_class_name[::yytranslate_ (int t)
   {
     static
     const token_number_type
@@ -1027,8 +1029,8 @@ b4_error_verbose_if([, int tok])[)
     {
       ]b4_translate[
     };
-    if ((unsigned int) token <= yyuser_token_number_max_)
-      return translate_table[token];
+    if ((unsigned int) t <= yyuser_token_number_max_)
+      return translate_table[t];
     else
       return yyundef_token_;
   }
@@ -1045,12 +1047,12 @@ b4_error_verbose_if([, int tok])[)
   const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
   const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
 
-} // namespace yy
+} // namespace ]b4_namespace[
 
 ]b4_epilogue
 dnl
 @output b4_dir_prefix[]stack.hh
-b4_copyright([stack handling for Bison C++ parsers],
+b4_copyright([Stack handling for Bison parsers in C++],
   [2002, 2003, 2004, 2005, 2006])[
 
 #ifndef BISON_STACK_HH
@@ -1058,7 +1060,7 @@ b4_copyright([stack handling for Bison C++ parsers],
 
 #include <deque>
 
-namespace yy
+namespace ]b4_namespace[
 {
   template <class T, class S = std::deque<T> >
   class stack