build: restore C90 compatibility

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

diff --git a/data/c++.m4 b/data/c++.m4
index 6950360ea1af5adb660c55370ea80c03129d8541..b034a4a629e66bb33f5d980e26d982b5917544c0 100644 (file)
--- a/data/c++.m4
+++ b/data/c++.m4
@@ -117,10 +117,10 @@ m4_define([b4_token_enums],
 # Declare semantic_type.
 m4_define([b4_semantic_type_declare],
 [    /// Symbol semantic values.
-m4_ifdef([b4_stype],
+m4_ifdef([b4_union_members],
 [    union semantic_type
     {
-b4_user_stype
+b4_user_union_members
     };],
 [m4_if(b4_tag_seen_flag, 0,
 [[    typedef int semantic_type;]],
@@ -154,9 +154,15 @@ m4_define([b4_public_types_declare],
       ]b4_token_enums[
     };
 
-    /// Token type.
+    /// (External) token type, as returned by yylex.
     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
@@ -170,24 +176,26 @@ m4_define([b4_public_types_declare],
       typedef Base super_type;
 
       /// Default constructor.
-      inline basic_symbol ();
+      basic_symbol ();
 
       /// 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.
-      inline basic_symbol (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.
-      inline basic_symbol (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])[);
 
       ~basic_symbol ();
 
       /// Destructive move, \a s is emptied into this.
-      inline void move (basic_symbol& s);
+      void move (basic_symbol& s);
 
       /// The semantic value.
       semantic_type value;]b4_locations_if([
@@ -204,32 +212,32 @@ m4_define([b4_public_types_declare],
     struct by_type
     {
       /// Default constructor.
-      inline by_type ();
+      by_type ();
 
       /// 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;
 
-      /// Steal the type of \a that.
-      void move (by_type& that);
+      /// Constructor from (external) token numbers.
+      by_type (kind_type t);
 
-      /// The symbol type.
-      ///
-      /// -1 when this symbol is empty.
-      int type;
+      /// Steal the symbol type from \a that.
+      void move (by_type& that);
 
-      /// The type (corresponding to \a type).
-      ///
+      /// The (internal) type number (corresponding to \a type).
       /// -1 when this symbol is empty.
-      inline int type_get () const;
+      symbol_number_type type_get () const;
 
       /// The token.
-      inline token_type token () const;
+      token_type token () const;
+
+      enum { empty = 0 };
 
-      /// The type used to store the symbol type.
-      typedef token_type value_type;
+      /// The symbol type.
+      /// -1 when this symbol is empty.
+      token_number_type type;
     };
 
     /// "External" symbols: returned by the scanner.
@@ -250,11 +258,13 @@ m4_define([b4_public_types_define],
 
   // basic_symbol.
   template <typename Base>
+  inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
     : value ()
   {}
 
   template <typename Base>
+  inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const basic_symbol& other)
     : Base (other)
     , value ()]b4_locations_if([
@@ -267,8 +277,9 @@ m4_define([b4_public_types_define],
 
 
   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)
@@ -278,21 +289,26 @@ m4_define([b4_public_types_define],
     (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(
-          [typename Base::value_type t],
+          [typename Base::kind_type t],
           b4_locations_if([const location_type& l]))[)
     : Base (t)
     , value ()]b4_locations_if([
     , location (l)])[
-  {}
+  {}]])[
 
   template <typename Base>
   inline
   ]b4_parser_class_name[::basic_symbol<Base>::~basic_symbol ()
   {]b4_variant_if([[
     // User destructor.
-    int yytype = this->type_get ();
+    symbol_number_type yytype = this->type_get ();
     switch (yytype)
     {
 ]b4_symbol_foreach([b4_symbol_destructor])dnl
@@ -305,6 +321,7 @@ m4_define([b4_public_types_define],
   }
 
   template <typename Base>
+  inline
   void
   ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
   {
@@ -316,14 +333,17 @@ m4_define([b4_public_types_define],
   }
 
   // by_type.
+  inline
   ]b4_parser_class_name[::by_type::by_type ()
-     : type (-1)
+     : type (empty)
   {}
 
+  inline
   ]b4_parser_class_name[::by_type::by_type (const by_type& other)
     : type (other.type)
   {}
 
+  inline
   ]b4_parser_class_name[::by_type::by_type (token_type t)
     : type (yytranslate_ (t))
   {}
@@ -333,15 +353,17 @@ m4_define([b4_public_types_define],
   ]b4_parser_class_name[::by_type::move (by_type& that)
   {
     type = that.type;
-    that.type = -1;
+    that.type = empty;
   }
 
+  inline
   int
   ]b4_parser_class_name[::by_type::type_get () const
   {
     return type;
   }
 ]b4_token_ctor_if([[
+  inline
   ]b4_parser_class_name[::token_type
   ]b4_parser_class_name[::by_type::token () const
   {
@@ -374,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.
+  inline
   ]b4_parser_class_name[::token_number_type
   ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type],
                                                           [int])[ t)