* data/lalr1.cc: Move the body of the ctor and dtor into the

parser file (instead of the header).
Wrap the implementations in a "namespace yy".

ChangeLog

@@ -1,3 +1,16 @@
+2005-11-12  Akim  <akim@epita.fr>
+
+	* data/lalr1.cc: Move the body of the ctor and dtor into the
+	parser file (instead of the header).
+	Wrap the implementations in a "namespace yy".
+
+2005-11-12  Akim Demaille  <akim@epita.fr>
+
+	Have glr.c include its header file when created.
+	* data/glr.c (b4_shared_declarations): New.
+	Output them verbatim in the parser if !%defines, otherwise
+	output then in the header file, and include it instead.
+
 2005-11-11  Akim Demaille  <akim@epita.fr>
 
 	* data/glr.c: Comment changes.

data/lalr1.cc

@@ -117,15 +117,8 @@ b4_syncline([@oline@], [@ofile@])],
     };
 
     /// Build a parser object.
-    ]b4_parser_class_name[ (]b4_parse_param_decl[) :
-      yydebug_ (false),
-      yycdebug_ (&std::cerr)]b4_parse_param_cons[
-    {
-    }
-
-    virtual ~]b4_parser_class_name[ ()
-    {
-    }
+    ]b4_parser_class_name[ (]b4_parse_param_decl[);
+    virtual ~]b4_parser_class_name[ ();
 
     /// Parse.
     /// \returns  0 iff parsing succeeded.
@@ -404,15 +397,28 @@ yy::]b4_parser_class_name[::yytnamerr_ (const char *yystr)
 
 #endif
 
-#if YYDEBUG
-/*--------------------------------.
-| Print this symbol on YYOUTPUT.  |
-`--------------------------------*/
-
-void
-yy::]b4_parser_class_name[::yysymprint_ (int yytype,
-                         const semantic_type* yyvaluep, const location_type* yylocationp)
+namespace yy
 {
+  /// Build a parser object.
+  ]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)
+    : yydebug_ (false),
+      yycdebug_ (&std::cerr)]b4_parse_param_cons[
+  {
+  }
+
+  ]b4_parser_class_name::~b4_parser_class_name[ ()
+  {
+  }
+
+#if YYDEBUG
+  /*--------------------------------.
+  | Print this symbol on YYOUTPUT.  |
+  `--------------------------------*/
+
+  void
+  ]b4_parser_class_name[::yysymprint_ (int yytype,
+                           const semantic_type* yyvaluep, const location_type* yylocationp)
+  {
     /* Backward compatibility, but should be removed eventually. */
     std::ostream& cdebug_ = *yycdebug_;
 
@@ -425,18 +431,18 @@ yy::]b4_parser_class_name[::yysymprint_ (int yytype,
                << *yylocationp << ": ";
     switch (yytype)
       {
-]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
+  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
 [       default:
           break;
       }
     *yycdebug_ << ')';
-}
+  }
 #endif /* ! YYDEBUG */
 
-void
-yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
+  void
+  ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
                            int yytype, semantic_type* yyvaluep, location_type* yylocationp)
-{
+  {
     YYUSE (yylocationp);
     YYUSE (yymsg);
     YYUSE (yyvaluep);
@@ -445,49 +451,49 @@ yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
 
     switch (yytype)
       {
-]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
+  ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
         default:
           break;
       }
-}
+  }
 
-void
-yy::]b4_parser_class_name[::yypop_ (unsigned int n)
-{
+  void
+  ]b4_parser_class_name[::yypop_ (unsigned int n)
+  {
     yystate_stack_.pop (n);
     yysemantic_stack_.pop (n);
     yylocation_stack_.pop (n);
-}
+  }
 
-std::ostream&
-yy::]b4_parser_class_name[::debug_stream () const
-{
+  std::ostream&
+  ]b4_parser_class_name[::debug_stream () const
+  {
     return *yycdebug_;
-}
+  }
 
-void
-yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o)
-{
+  void
+  ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
+  {
     yycdebug_ = &o;
-}
+  }
 
 
-yy::]b4_parser_class_name[::debug_level_type
-yy::]b4_parser_class_name[::debug_level () const
-{
+  ]b4_parser_class_name[::debug_level_type
+  ]b4_parser_class_name[::debug_level () const
+  {
     return yydebug_;
-}
+  }
 
-void
-yy::]b4_parser_class_name[::set_debug_level (debug_level_type l)
-{
+  void
+  ]b4_parser_class_name[::set_debug_level (debug_level_type l)
+  {
     yydebug_ = l;
-}
+  }
 
 
-int
-yy::]b4_parser_class_name[::parse ()
-{
+  int
+  ]b4_parser_class_name[::parse ()
+  {
     /// Look-ahead and look-ahead in internal form.
     int yychar = yyempty_;
     int yytoken = 0;
@@ -524,10 +530,10 @@ m4_pushdef([b4_dollar_dollar], [yylval])dnl
     b4_initial_action
 m4_popdef([b4_dollar_dollar])dnl
 m4_popdef([b4_at_dollar])dnl
-/* Line __line__ of yacc.c.  */
+  /* Line __line__ of yacc.c.  */
 b4_syncline([@oline@], [@ofile@])])dnl
 
-[  /* Initialize the stacks.  The initial state will be pushed in
+  [  /* Initialize the stacks.  The initial state will be pushed in
        yynewstate, since the latter expects the semantical and the
        location values to have been already stored, initialize these
        stacks with a primary value.  */
@@ -538,13 +544,13 @@ b4_syncline([@oline@], [@ofile@])])dnl
     yylocation_stack_.push (yylloc);
 
     /* New state.  */
-yynewstate:
+  yynewstate:
     yystate_stack_.push (yystate);
     YYCDEBUG << "Entering state " << yystate << std::endl;
     goto yybackup;
 
     /* Backup.  */
-yybackup:
+  yybackup:
 
     /* Try to take a decision without look-ahead.  */
     yyn = yypact_[yystate];
@@ -556,7 +562,7 @@ yybackup:
       {
         YYCDEBUG << "Reading a token: ";
         yychar = ]b4_c_function_call([yylex], [int],
-[[YYSTYPE*], [&yylval]][]dnl
+                                     [[YYSTYPE*], [&yylval]][]dnl
 b4_location_if([, [[location*], [&yylloc]]])dnl
 m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
       }
@@ -612,19 +618,19 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
     yystate = yyn;
     goto yynewstate;
 
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
-yydefault:
+  /*-----------------------------------------------------------.
+  | yydefault -- do the default action for the current state.  |
+  `-----------------------------------------------------------*/
+  yydefault:
     yyn = yydefact_[yystate];
     if (yyn == 0)
       goto yyerrlab;
     goto yyreduce;
 
-/*-----------------------------.
-| yyreduce -- Do a reduction.  |
-`-----------------------------*/
-yyreduce:
+  /*-----------------------------.
+  | yyreduce -- Do a reduction.  |
+  `-----------------------------*/
+  yyreduce:
     yylen = yyr2_[yyn];
     /* If LEN_ is nonzero, implement the default value of the action:
        `$$ = $1'.  Otherwise, use the top of the stack.
@@ -648,8 +654,8 @@ yyreduce:
         default: break;
       }
 
-]/* Line __line__ of lalr1.cc.  */
-b4_syncline([@oline@], [@ofile@])[
+  ]/* Line __line__ of lalr1.cc.  */
+  b4_syncline([@oline@], [@ofile@])[
 
     yypop_ (yylen);
 
@@ -668,10 +674,10 @@ b4_syncline([@oline@], [@ofile@])[
       yystate = yydefgoto_[yyn - yyntokens_];
     goto yynewstate;
 
-/*------------------------------------.
-| yyerrlab -- here on detecting error |
-`------------------------------------*/
-yyerrlab:
+  /*------------------------------------.
+  | yyerrlab -- here on detecting error |
+  `------------------------------------*/
+  yyerrlab:
     /* If not already recovering from an error, report this error.  */
     if (!yyerrstatus_)
       {
@@ -704,10 +710,10 @@ b4_error_verbose_if([, yytoken])[));
     goto yyerrlab1;
 
 
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
+  /*---------------------------------------------------.
+  | yyerrorlab -- error raised explicitly by YYERROR.  |
+  `---------------------------------------------------*/
+  yyerrorlab:
 
     /* Pacify compilers like GCC when the user code never invokes
        YYERROR and the label yyerrorlab therefore never appears in user
@@ -720,10 +726,10 @@ yyerrorlab:
     yystate = yystate_stack_[0];
     goto yyerrlab1;
 
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
+  /*-------------------------------------------------------------.
+  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
+  `-------------------------------------------------------------*/
+  yyerrlab1:
     yyerrstatus_ = 3;	/* Each real token shifted decrements this.  */
 
     for (;;)
@@ -771,16 +777,16 @@ yyerrlab1:
     goto yynewstate;
 
     /* Accept.  */
-yyacceptlab:
+  yyacceptlab:
     yyresult = 0;
     goto yyreturn;
 
     /* Abort.  */
-yyabortlab:
+  yyabortlab:
     yyresult = 1;
     goto yyreturn;
 
-yyreturn:
+  yyreturn:
     if (yychar != yyeof_ && yychar != yyempty_)
       yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
 
@@ -794,13 +800,13 @@ yyreturn:
       }
 
     return yyresult;
-}
+  }
 
-// Generate an error message.
-std::string
-yy::]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl
+  // Generate an error message.
+  std::string
+  ]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl
 b4_error_verbose_if([, int tok])[)
-{
+  {
     std::string res;
 #if YYERROR_VERBOSE
     int yyn = yypact_[yystate];
@@ -843,138 +849,138 @@ b4_error_verbose_if([, int tok])[)
 #endif
       res = YY_("syntax error");
     return res;
-}
+  }
 
 
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
      STATE-NUM.  */
-const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
-const ]b4_int_type_for([b4_pact])[
-yy::]b4_parser_class_name[::yypact_[] =
-{
+  const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
+  const ]b4_int_type_for([b4_pact])[
+  ]b4_parser_class_name[::yypact_[] =
+  {
     ]b4_pact[
-};
+  };
 
-/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
+  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
      doesn't specify something else to do.  Zero means the default is an
      error.  */
-const ]b4_int_type_for([b4_defact])[
-yy::]b4_parser_class_name[::yydefact_[] =
-{
+  const ]b4_int_type_for([b4_defact])[
+  ]b4_parser_class_name[::yydefact_[] =
+  {
     ]b4_defact[
-};
+  };
 
-/* YYPGOTO[NTERM-NUM].  */
-const ]b4_int_type_for([b4_pgoto])[
-yy::]b4_parser_class_name[::yypgoto_[] =
-{
+  /* YYPGOTO[NTERM-NUM].  */
+  const ]b4_int_type_for([b4_pgoto])[
+  ]b4_parser_class_name[::yypgoto_[] =
+  {
     ]b4_pgoto[
-};
+  };
 
-/* YYDEFGOTO[NTERM-NUM].  */
-const ]b4_int_type_for([b4_defgoto])[
-yy::]b4_parser_class_name[::yydefgoto_[] =
-{
+  /* YYDEFGOTO[NTERM-NUM].  */
+  const ]b4_int_type_for([b4_defgoto])[
+  ]b4_parser_class_name[::yydefgoto_[] =
+  {
     ]b4_defgoto[
-};
+  };
 
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+  /* 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.  */
-const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
-const ]b4_int_type_for([b4_table])[
-yy::]b4_parser_class_name[::yytable_[] =
-{
+  const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
+  const ]b4_int_type_for([b4_table])[
+  ]b4_parser_class_name[::yytable_[] =
+  {
     ]b4_table[
-};
+  };
 
-/* YYCHECK.  */
-const ]b4_int_type_for([b4_check])[
-yy::]b4_parser_class_name[::yycheck_[] =
-{
+  /* YYCHECK.  */
+  const ]b4_int_type_for([b4_check])[
+  ]b4_parser_class_name[::yycheck_[] =
+  {
     ]b4_check[
-};
+  };
 
-/* STOS_[STATE-NUM] -- The (internal number of the) accessing
+  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
      symbol of state STATE-NUM.  */
-const ]b4_int_type_for([b4_stos])[
-yy::]b4_parser_class_name[::yystos_[] =
-{
+  const ]b4_int_type_for([b4_stos])[
+  ]b4_parser_class_name[::yystos_[] =
+  {
     ]b4_stos[
-};
+  };
 
 #if YYDEBUG
-/* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
+  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
      to YYLEX-NUM.  */
-const ]b4_int_type_for([b4_toknum])[
-yy::]b4_parser_class_name[::yytoken_number_[] =
-{
+  const ]b4_int_type_for([b4_toknum])[
+  ]b4_parser_class_name[::yytoken_number_[] =
+  {
     ]b4_toknum[
-};
+  };
 #endif
 
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-const ]b4_int_type_for([b4_r1])[
-yy::]b4_parser_class_name[::yyr1_[] =
-{
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+  const ]b4_int_type_for([b4_r1])[
+  ]b4_parser_class_name[::yyr1_[] =
+  {
     ]b4_r1[
-};
+  };
 
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-const ]b4_int_type_for([b4_r2])[
-yy::]b4_parser_class_name[::yyr2_[] =
-{
+  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+  const ]b4_int_type_for([b4_r2])[
+  ]b4_parser_class_name[::yyr2_[] =
+  {
     ]b4_r2[
-};
+  };
 
 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
      First, the terminals, then, starting at \a yyntokens_, nonterminals. */
-const char*
-const yy::]b4_parser_class_name[::yytname_[] =
-{
+  const char*
+  const ]b4_parser_class_name[::yytname_[] =
+  {
     ]b4_tname[
-};
+  };
 #endif
 
 #if YYDEBUG
-/* YYRHS -- A `-1'-separated list of the rules' RHS. */
-const yy::]b4_parser_class_name[::rhs_number_type
-yy::]b4_parser_class_name[::yyrhs_[] =
-{
+  /* YYRHS -- A `-1'-separated list of the rules' RHS. */
+  const ]b4_parser_class_name[::rhs_number_type
+  ]b4_parser_class_name[::yyrhs_[] =
+  {
     ]b4_rhs[
-};
+  };
 
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
      YYRHS.  */
-const ]b4_int_type_for([b4_prhs])[
-yy::]b4_parser_class_name[::yyprhs_[] =
-{
+  const ]b4_int_type_for([b4_prhs])[
+  ]b4_parser_class_name[::yyprhs_[] =
+  {
     ]b4_prhs[
-};
+  };
 
-/* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
-const ]b4_int_type_for([b4_rline])[
-yy::]b4_parser_class_name[::yyrline_[] =
-{
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+  const ]b4_int_type_for([b4_rline])[
+  ]b4_parser_class_name[::yyrline_[] =
+  {
     ]b4_rline[
-};
+  };
 
-// Print the state stack on the debug stream.
-void
-yy::]b4_parser_class_name[::yystack_print_ ()
-{
+  // Print the state stack on the debug stream.
+  void
+  ]b4_parser_class_name[::yystack_print_ ()
+  {
     *yycdebug_ << "Stack now";
     for (state_stack_type::const_iterator i = yystate_stack_.begin ();
          i != yystate_stack_.end (); ++i)
       *yycdebug_ << ' ' << *i;
     *yycdebug_ << std::endl;
-}
+  }
 
-// Report on the debug stream that the rule \a yyrule is going to be reduced.
-void
-yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
-{
+  // Report on the debug stream that the rule \a yyrule is going to be reduced.
+  void
+  ]b4_parser_class_name[::yyreduce_print_ (int yyrule)
+  {
     unsigned int yylno = yyrline_[yyrule];
     /* Print the symbols being reduced, and their result.  */
     *yycdebug_ << "Reducing stack by rule " << yyrule - 1
@@ -983,13 +989,13 @@ yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
          0 <= yyrhs_[i]; ++i)
       *yycdebug_ << yytname_[yyrhs_[i]] << ' ';
     *yycdebug_ << "-> " << yytname_[yyr1_[yyrule]] << std::endl;
-}
+  }
 #endif // YYDEBUG
 
-/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-yy::]b4_parser_class_name[::token_number_type
-yy::]b4_parser_class_name[::yytranslate_ (int token)
-{
+  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+  ]b4_parser_class_name[::token_number_type
+  ]b4_parser_class_name[::yytranslate_ (int token)
+  {
     static
     const token_number_type
     translate_table[] =
@@ -1000,19 +1006,21 @@ yy::]b4_parser_class_name[::yytranslate_ (int token)
       return translate_table[token];
     else
       return yyundef_token_;
-}
+  }
 
-const int yy::]b4_parser_class_name[::yyeof_ = 0;
-const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[;
-const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
-const int yy::]b4_parser_class_name[::yyempty_ = -2;
-const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
-const int yy::]b4_parser_class_name[::yyterror_ = 1;
-const int yy::]b4_parser_class_name[::yyerrcode_ = 256;
-const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
+  const int ]b4_parser_class_name[::yyeof_ = 0;
+  const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
+  const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
+  const int ]b4_parser_class_name[::yyempty_ = -2;
+  const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
+  const int ]b4_parser_class_name[::yyterror_ = 1;
+  const int ]b4_parser_class_name[::yyerrcode_ = 256;
+  const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
 
-const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
-const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
+  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
 
 ]b4_epilogue
 dnl