build: restore C90 compatibility

[bison.git] / data / c++.m4

diff --git a/data/c++.m4 b/data/c++.m4
index 4fb280517b19960660cc43267e8d27a4d53df5cc..b034a4a629e66bb33f5d980e26d982b5917544c0 100644 (file)
--- a/data/c++.m4
+++ b/data/c++.m4
@@ -2,7 +2,7 @@
 
 # C++ skeleton for Bison
 
 
 # C++ skeleton for Bison
 

-# Copyright (C) 2002-2012 Free Software Foundation, Inc.
+# Copyright (C) 2002-2013 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


@@ -117,10 +117,10 @@ m4_define([b4_token_enums],
 # Declare semantic_type.
 m4_define([b4_semantic_type_declare],
 [    /// Symbol semantic values.
 # Declare semantic_type.
 m4_define([b4_semantic_type_declare],
 [    /// Symbol semantic values.

-m4_ifdef([b4_stype],
+m4_ifdef([b4_union_members],

 [    union semantic_type
     {
 [    union semantic_type
     {

-b4_user_stype
+b4_user_union_members

     };],
 [m4_if(b4_tag_seen_flag, 0,
 [[    typedef int semantic_type;]],
     };],
 [m4_if(b4_tag_seen_flag, 0,
 [[    typedef int semantic_type;]],


@@ -154,9 +154,15 @@ m4_define([b4_public_types_declare],
       ]b4_token_enums[
     };
 
       ]b4_token_enums[
     };
 

-    /// Token type.
+    /// (External) token type, as returned by yylex.

     typedef token::yytokentype token_type;
 
     typedef token::yytokentype token_type;
 

+    /// Internal symbol number.
+    typedef int symbol_number_type;
+
+    /// Internal symbol number for tokens (subsumed by symbol_number_type).
+    typedef ]b4_int_type_for([b4_translate])[ token_number_type;
+

     /// A complete symbol.
     ///
     /// Expects its Base type to provide access to the symbol type
     /// A complete symbol.
     ///
     /// Expects its Base type to provide access to the symbol type


@@ -166,61 +172,72 @@ m4_define([b4_public_types_declare],
     template <typename Base>
     struct basic_symbol : Base
     {
     template <typename Base>
     struct basic_symbol : Base
     {

+      /// Alias to Base.
+      typedef Base super_type;
+

       /// Default constructor.
       /// Default constructor.

-      inline basic_symbol ();
-]b4_locations_if([
-      /// Constructor.
-      inline basic_symbol (const location_type& l);])[
+      basic_symbol ();

 
       /// Copy constructor.
 
       /// Copy constructor.

-      inline basic_symbol (const basic_symbol& other);
-
+      basic_symbol (const basic_symbol& other);
+]b4_variant_if([[
+      /// Constructor for valueless symbols, and symbols from each type.
+]b4_type_foreach([b4_basic_symbol_constructor_declare])], [[

       /// Constructor for valueless symbols.
       /// Constructor for valueless symbols.

-      inline basic_symbol (]b4_join(
-        [typename Base::value_type t],
-        b4_locations_if([const location_type& l]))[);
+      basic_symbol (typename Base::kind_type t]b4_locations_if([,
+                    const location_type& l])[);]])[

 
       /// Constructor for symbols with semantic value.
 
       /// Constructor for symbols with semantic value.

-      inline basic_symbol (]b4_join(
-        [typename Base::value_type t],
-        [const semantic_type& v],
-        b4_locations_if([const location_type& l]))[);
+      basic_symbol (typename Base::kind_type t,
+                    const semantic_type& v]b4_locations_if([,
+                    const location_type& l])[);

 
 

-      /// Assignment operator.
-      inline basic_symbol& operator= (const basic_symbol& other);
+      ~basic_symbol ();

 
 

-      /// Destructive move, \a s is emptied.
-      inline void move (basic_symbol& s);
+      /// Destructive move, \a s is emptied into this.
+      void move (basic_symbol& s);

 
       /// The semantic value.
       semantic_type value;]b4_locations_if([
 
       /// The location.
       location_type location;])[
 
       /// The semantic value.
       semantic_type value;]b4_locations_if([
 
       /// The location.
       location_type location;])[

+
+    private:
+      /// Assignment operator.
+      basic_symbol& operator= (const basic_symbol& other);

     };
 
     /// Type access provider for token (enum) based symbols.
     struct by_type
     {
       /// Default constructor.
     };
 
     /// Type access provider for token (enum) based symbols.
     struct by_type
     {
       /// Default constructor.

-      inline by_type ();
+      by_type ();

 
       /// Copy constructor.
 
       /// Copy constructor.

-      inline by_type (const by_type& other);
+      by_type (const by_type& other);

 
 

-      /// Constructor.
-      inline by_type (token_type t);
+      /// The symbol type as needed by the constructor.
+      typedef token_type kind_type;

 
 

-      /// The symbol type.
-      int type;
+      /// Constructor from (external) token numbers.
+      by_type (kind_type t);

 
 

-      /// The type (corresponding to \a type).
-      inline int type_get () const;
+      /// Steal the symbol type from \a that.
+      void move (by_type& that);
+
+      /// The (internal) type number (corresponding to \a type).
+      /// -1 when this symbol is empty.
+      symbol_number_type type_get () const;

 
       /// The token.
 
       /// The token.

-      inline token_type token () const;
+      token_type token () const;
+
+      enum { empty = 0 };

 
 

-      typedef token_type value_type;
+      /// The symbol type.
+      /// -1 when this symbol is empty.
+      token_number_type type;

     };
 
     /// "External" symbols: returned by the scanner.
     };
 
     /// "External" symbols: returned by the scanner.


@@ -233,7 +250,7 @@ m4_define([b4_public_types_declare],
 # ----------------------
 # Provide the implementation needed by the public types.
 m4_define([b4_public_types_define],
 # ----------------------
 # Provide the implementation needed by the public types.
 m4_define([b4_public_types_define],

-[[inline
+[[  inline

   ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
     : std::runtime_error (m)]b4_locations_if([
     , location (l)])[
   ]b4_parser_class_name[::syntax_error::syntax_error (]b4_locations_if([const location_type& l, ])[const std::string& m)
     : std::runtime_error (m)]b4_locations_if([
     , location (l)])[


@@ -245,21 +262,6 @@ m4_define([b4_public_types_define],
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
     : value ()
   {}
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
     : value ()
   {}

-]b4_locations_if([
-  template <typename Base>
-  inline
-  ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const location_type& l)
-    : value ()
-    , location (l)
-  {}])[
-
-  template <typename Base>
-  inline
-  ]b4_parser_class_name[::basic_symbol<Base>&
-  ]b4_parser_class_name[::basic_symbol<Base>::operator= (const basic_symbol& other)
-  {
-    abort ();
-  }

 
   template <typename Base>
   inline
 
   template <typename Base>
   inline


@@ -277,44 +279,63 @@ m4_define([b4_public_types_define],
   template <typename Base>
   inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
   template <typename Base>
   inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(

-          [typename Base::value_type t],
+          [typename Base::kind_type t],

           [const semantic_type& v],
           b4_locations_if([const location_type& l]))[)
     : Base (t)
           [const semantic_type& v],
           b4_locations_if([const location_type& l]))[)
     : Base (t)

-    , value ()]b4_locations_if([
+    , value (]b4_variant_if([], [v])[)]b4_locations_if([

     , location (l)])[
     , location (l)])[

-  {
-    (void) v; /* FIXME: */
-    ]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [copy],
-                                      [v])],
-                   [value = v;])[
-  }
-
+  {]b4_variant_if([[
+    (void) v;
+    ]b4_symbol_variant([this->type_get ()], [value], [copy], [v])])[}
+
+]b4_variant_if([[
+  // Implementation of basic_symbol constructor for each type.
+]b4_type_foreach([b4_basic_symbol_constructor_define])], [[
+  /// Constructor for valueless symbols.

   template <typename Base>
   inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
   template <typename Base>
   inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(

-          [typename Base::value_type t],
+          [typename Base::kind_type t],

           b4_locations_if([const location_type& l]))[)
           b4_locations_if([const location_type& l]))[)

-    : Base (t)]b4_locations_if([
+    : Base (t)
+    , value ()]b4_locations_if([

     , location (l)])[
     , location (l)])[

-  {}
+  {}]])[
+
+  template <typename Base>
+  inline
+  ]b4_parser_class_name[::basic_symbol<Base>::~basic_symbol ()
+  {]b4_variant_if([[
+    // User destructor.
+    symbol_number_type yytype = this->type_get ();
+    switch (yytype)
+    {
+]b4_symbol_foreach([b4_symbol_destructor])dnl
+[   default:
+      break;
+    }
+
+    // Type destructor.
+  ]b4_symbol_variant([[yytype]], [[value]], [[template destroy]])])[
+  }

 
   template <typename Base>
   inline
   void
   ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
   {
 
   template <typename Base>
   inline
   void
   ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
   {

-    this->type = s.type_get ();]b4_locations_if([
-    location = s.location;])[
-    ]b4_variant_if([b4_symbol_variant([s.type_get ()], [value], [build],
+    super_type::move(s);
+    ]b4_variant_if([b4_symbol_variant([this->type_get ()], [value], [move],

                                       [s.value])],
                                       [s.value])],

-                   [value = s.value;])[
+                   [value = s.value;])[]b4_locations_if([
+    location = s.location;])[

   }
 
   // by_type.
   inline
   ]b4_parser_class_name[::by_type::by_type ()
   }
 
   // by_type.
   inline
   ]b4_parser_class_name[::by_type::by_type ()

-     : type ()
+     : type (empty)

   {}
 
   inline
   {}
 
   inline


@@ -327,6 +348,14 @@ m4_define([b4_public_types_define],
     : type (yytranslate_ (t))
   {}
 
     : type (yytranslate_ (t))
   {}
 

+  inline
+  void
+  ]b4_parser_class_name[::by_type::move (by_type& that)
+  {
+    type = that.type;
+    that.type = empty;
+  }
+

   inline
   int
   ]b4_parser_class_name[::by_type::type_get () const
   inline
   int
   ]b4_parser_class_name[::by_type::type_get () const


@@ -367,6 +396,7 @@ m4_define([b4_symbol_constructor_define], [])
 # sometimes in the cc file.
 m4_define([b4_yytranslate_define],
 [[  // Symbol number corresponding to token number t.
 # sometimes in the cc file.
 m4_define([b4_yytranslate_define],
 [[  // Symbol number corresponding to token number t.

+  inline

   ]b4_parser_class_name[::token_number_type
   ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type],
                                                           [int])[ t)
   ]b4_parser_class_name[::token_number_type
   ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type],
                                                           [int])[ t)