Fixed some warnings

TAO/TAO_IDL/be/be_interface.cpp

@@ -2234,7 +2234,7 @@ be_interface::copy_ctor_helper (be_interface *derived,
 {
   // We can't call ourselves in a copy constructor, and
   // abstract interfaces don't exist on the skeleton side.
-  if (derived == base || base->is_abstract ())
+  if (derived == base || base->is_abstract () || derived->nmembers () > 0)
     {
       return 0;
     }

TAO/TAO_IDL/be/be_visitor_interface/amh_ss.cpp

@@ -200,7 +200,7 @@ TAO_IDL_Copy_Ctor_Worker::emit (be_interface *derived,
       TAO_OutStream *os,
       be_interface *base)
 {
-  if (derived == base)
+  if (derived == base || derived->nmembers () > 0)
     {
       return 0;
     }

TAO/TAO_IDL/be/be_visitor_interface/interface_ss.cpp

@@ -107,25 +107,37 @@ be_visitor_interface_ss::visit_interface (be_interface *node)
 
   *os << full_skel_name << "::"
       << local_name_prefix << node_local_name
-      << " ()" << be_idt_nl;
+      << " ()";
 
-  *os << ": TAO_ServantBase ()" << be_uidt_nl;
+  bool const init_bases = node->nmembers () == 0;
+  if (init_bases)
+    {
+      *os << be_idt_nl << ": TAO_ServantBase ()" << be_uidt_nl;
+    }
+  else
+    {
+      *os << be_nl;
+    }
 
   // Default constructor body.
   *os << "{" << be_idt_nl
-      << "this->optable_ = std::addressof(tao_" << flat_name
+      << "this->optable_ = std::addressof (tao_" << flat_name
       << "_optable);" << be_uidt_nl
       << "}" << be_nl_2;
 
   // find if we are at the top scope or inside some module
   *os << full_skel_name << "::"
       << local_name_prefix << node_local_name << " ("
       << "const " << local_name_prefix
-      << node_local_name << "& rhs)";
+      << node_local_name << " &"
+      << (init_bases ? "rhs" : "") << ")";
 
-  *os << be_idt_nl
-      << ": TAO_Abstract_ServantBase (rhs)," << be_nl
-      << "  TAO_ServantBase (rhs)";
+  if (init_bases)
+    {
+      *os << be_idt_nl
+          << ": TAO_Abstract_ServantBase (rhs)," << be_nl
+          << "  TAO_ServantBase (rhs)";
+    }
 
   if (this->generate_copy_ctor (node, os) == -1)
     {

TAO/tao/Bounded_Array_Sequence_T.h

@@ -93,33 +93,38 @@ class bounded_array_sequence
 namespace TAO
 {
   template <typename stream, typename T_array, typename T_slice, typename T_tag, CORBA::ULong MAX>
-  bool demarshal_sequence(stream & strm, TAO::bounded_array_sequence<T_array, T_slice, T_tag, MAX> & target) {
+  bool demarshal_sequence (stream &strm, TAO::bounded_array_sequence<T_array, T_slice, T_tag, MAX> &target) {
     typedef typename TAO::bounded_array_sequence<T_array, T_slice, T_tag, MAX> sequence;
     typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
     typedef TAO::Array_Traits<forany> array_traits;
 
     ::CORBA::ULong new_length = 0;
-    if (!(strm >> new_length)) {
-      return false;
-    }
-    if ((new_length > strm.length()) || (new_length > target.maximum ())) {
-      return false;
-    }
-    sequence tmp;
-    tmp.length(new_length);
-    typename sequence::value_type * buffer = tmp.get_buffer();
-    for(CORBA::ULong i = 0; i < new_length; ++i) {
-      forany tmp (array_traits::alloc ());
-      bool const _tao_marshal_flag = (strm >> tmp);
-      if (_tao_marshal_flag) {
-        array_traits::copy (buffer[i], tmp.in ());
+    if (!(strm >> new_length))
+      {
+        return false;
       }
-      array_traits::free (tmp.inout ());
-      if (!_tao_marshal_flag) {
+    if ((new_length > strm.length ()) || (new_length > target.maximum ()))
+      {
         return false;
       }
-    }
-    tmp.swap(target);
+    sequence tmp;
+    tmp.length (new_length);
+    typename sequence::value_type *const buffer = tmp.get_buffer ();
+    for (CORBA::ULong i = 0; i < new_length; ++i)
+      {
+        forany wrapper (array_traits::alloc ());
+        bool const _tao_marshal_flag = strm >> wrapper;
+        if (_tao_marshal_flag)
+          {
+            array_traits::copy (buffer[i], wrapper.in ());
+          }
+        array_traits::free (wrapper.inout ());
+        if (!_tao_marshal_flag)
+          {
+            return false;
+          }
+      }
+    tmp.swap (target);
     return true;
   }
 

TAO/tao/Unbounded_Array_Sequence_T.h

@@ -95,33 +95,38 @@ class unbounded_array_sequence
 namespace TAO
 {
   template <typename stream, typename T_array, typename T_slice, typename T_tag>
-  bool demarshal_sequence(stream & strm, TAO::unbounded_array_sequence<T_array, T_slice, T_tag> & target) {
+  bool demarshal_sequence (stream &strm, TAO::unbounded_array_sequence<T_array, T_slice, T_tag> &target) {
     typedef TAO::unbounded_array_sequence<T_array, T_slice, T_tag> sequence;
     typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
     typedef TAO::Array_Traits<forany> array_traits;
 
     ::CORBA::ULong new_length = 0;
-    if (!(strm >> new_length)) {
-      return false;
-    }
-    if (new_length > strm.length()) {
-      return false;
-    }
-    sequence tmp(new_length);
-    tmp.length(new_length);
-    typename sequence::value_type * buffer = tmp.get_buffer();
-    for(CORBA::ULong i = 0; i < new_length; ++i) {
-      forany tmp (array_traits::alloc ());
-      bool const _tao_marshal_flag = (strm >> tmp);
-      if (_tao_marshal_flag) {
-        array_traits::copy (buffer[i], tmp.in ());
+    if (!(strm >> new_length))
+      {
+        return false;
       }
-      array_traits::free (tmp.inout ());
-      if (!_tao_marshal_flag) {
+    if (new_length > strm.length ())
+      {
         return false;
       }
-    }
-    tmp.swap(target);
+    sequence tmp (new_length);
+    tmp.length (new_length);
+    typename sequence::value_type *const buffer = tmp.get_buffer ();
+    for (CORBA::ULong i = 0; i < new_length; ++i)
+      {
+        forany wrapper (array_traits::alloc ());
+        bool const _tao_marshal_flag = strm >> wrapper;
+        if (_tao_marshal_flag)
+          {
+            array_traits::copy (buffer[i], wrapper.in ());
+          }
+        array_traits::free (wrapper.inout ());
+        if (!_tao_marshal_flag)
+          {
+            return false;
+          }
+      }
+    tmp.swap (target);
     return true;
   }