*** empty log message ***

22 files changed, 383 insertions, 278 deletions

diff --git a/TAO/tao/Any.cpp b/TAO/tao/Any.cpp
index 6e13d186bbe..37aca1ea1ce 100644
--- a/TAO/tao/Any.cpp
+++ b/TAO/tao/Any.cpp
@@ -580,12 +580,6 @@ CORBA_Any::operator>>= (CORBA::TypeCode_ptr &tc) const
                             0,
                             env)
               == CORBA::TypeCode::TRAVERSE_CONTINUE) ? 1 : 0;
-	  if (flag)
-	    {
-	      CORBA::TypeCode_ptr *tmp = new CORBA::TypeCode_ptr;
-	      *tmp = tc;
-	      ACE_const_cast(CORBA_Any*,this)->value_ = tmp;
-	    }
           return flag;
         }
       else
@@ -597,6 +591,7 @@ CORBA_Any::operator>>= (CORBA::TypeCode_ptr &tc) const
   else
     return 0;
 }
+
 // = extraction into the special types
 
 CORBA::Boolean
@@ -700,13 +695,7 @@ CORBA_Any::operator>>= (to_string s) const
           if (this->any_owns_data_)
             {
               TAO_InputCDR stream ((ACE_Message_Block *) this->cdr_);
-	      if (stream.read_string (s.val_))
-	        {
-	          char **tmp = new char*;
-	          *tmp = s.val_;
-	          ACE_const_cast(CORBA_Any*,this)->value_ = tmp;
-	          return 1;
-	        }
+              return stream.read_string (s.val_);
             }
           else
             {
diff --git a/TAO/tao/DynAnyC.h b/TAO/tao/DynAnyC.h
index dfadadddf5f..cdeb70ca512 100644
--- a/TAO/tao/DynAnyC.h
+++ b/TAO/tao/DynAnyC.h
@@ -111,7 +111,7 @@ private:
 #if !defined (_CORBA_DYNANY_CH_)
 #define _CORBA_DYNANY_CH_
 
-class  CORBA_DynAny : public virtual ACE_CORBA_1 (Object)
+class TAO_Export CORBA_DynAny : public virtual ACE_CORBA_1 (Object)
 {
 public:
   // the static operations
@@ -136,7 +136,7 @@ public:
 #if !defined (_CORBA_DYNANY_INVALID_CH_)
 #define _CORBA_DYNANY_INVALID_CH_
 
-  class  Invalid : public CORBA::UserException
+  class TAO_Export Invalid : public CORBA::UserException
   {
   public:
     Invalid (void); // default ctor
@@ -173,7 +173,7 @@ public:
 #if !defined (_CORBA_DYNANY_INVALIDVALUE_CH_)
 #define _CORBA_DYNANY_INVALIDVALUE_CH_
 
-  class  InvalidValue : public CORBA::UserException
+  class TAO_Export InvalidValue : public CORBA::UserException
   {
   public:
     InvalidValue (void); // default ctor
@@ -210,7 +210,7 @@ public:
 #if !defined (_CORBA_DYNANY_TYPEMISMATCH_CH_)
 #define _CORBA_DYNANY_TYPEMISMATCH_CH_
 
-  class  TypeMismatch : public CORBA::UserException
+  class TAO_Export TypeMismatch : public CORBA::UserException
   {
   public:
     TypeMismatch (void); // default ctor
@@ -247,7 +247,7 @@ public:
 #if !defined (_CORBA_DYNANY_INVALIDSEQ_CH_)
 #define _CORBA_DYNANY_INVALIDSEQ_CH_
 
-  class  InvalidSeq : public CORBA::UserException
+  class TAO_Export InvalidSeq : public CORBA::UserException
   {
   public:
     InvalidSeq (void); // default ctor
@@ -550,7 +550,7 @@ private:
 #if !defined (_CORBA_DYNENUM_CH_)
 #define _CORBA_DYNENUM_CH_
 
-class  CORBA_DynEnum: public virtual CORBA_DynAny
+class TAO_Export CORBA_DynEnum: public virtual CORBA_DynAny
 {
 public:
   // the static operations
@@ -1021,7 +1021,7 @@ private:
 #if !defined (_CORBA_DYNSTRUCT_CH_)
 #define _CORBA_DYNSTRUCT_CH_
 
-class  CORBA_DynStruct: public virtual CORBA_DynAny
+class TAO_Export CORBA_DynStruct: public virtual CORBA_DynAny
 {
 public:
   // the static operations
@@ -1142,7 +1142,7 @@ private:
 #if !defined (_CORBA_DYNUNION_CH_)
 #define _CORBA_DYNUNION_CH_
 
-class  CORBA_DynUnion: public virtual CORBA_DynAny
+class TAO_Export CORBA_DynUnion: public virtual CORBA_DynAny
 {
 public:
   // the static operations
@@ -1571,7 +1571,7 @@ private:
 #if !defined (_CORBA_DYNSEQUENCE_CH_)
 #define _CORBA_DYNSEQUENCE_CH_
 
-class  CORBA_DynSequence: public virtual CORBA_DynAny
+class TAO_Export CORBA_DynSequence: public virtual CORBA_DynAny
 {
 public:
   // the static operations
@@ -1693,7 +1693,7 @@ private:
 #if !defined (_CORBA_DYNARRAY_CH_)
 #define _CORBA_DYNARRAY_CH_
 
-class  CORBA_DynArray: public virtual CORBA_DynAny
+class TAO_Export CORBA_DynArray: public virtual CORBA_DynAny
 {
 public:
   // the static operations
diff --git a/TAO/tao/DynAny_i.cpp b/TAO/tao/DynAny_i.cpp
index 5f14c8b49a5..86e8f6e64fa 100644
--- a/TAO/tao/DynAny_i.cpp
+++ b/TAO/tao/DynAny_i.cpp
@@ -48,7 +48,7 @@ TAO_DynAny_i::TAO_DynAny_i (CORBA_TypeCode_ptr tc)
       case CORBA::tk_string:
         break;
       default:
-         env.exception (new CORBA_ORB_InconsistentTypeCode);
+        env.exception (new CORBA_ORB_InconsistentTypeCode);
         break;
     }
 }
@@ -121,7 +121,7 @@ TAO_DynAny_i::copy (CORBA::Environment &env)
 void
 TAO_DynAny_i::destroy (CORBA::Environment &env)
 {
-  CORBA::release (this->_this (env));
+  delete this;
 }
 
 void
@@ -277,7 +277,8 @@ TAO_DynAny_i::insert_string (const char * value,
 {
   if (this->value_.type ()->kind (env) == CORBA::tk_string)
     this->value_ <<= CORBA::Any::from_string (CORBA::string_dup (value), 
-                                              0);
+                                              0,
+                                              1);
   else
     env.exception (new CORBA_DynAny::InvalidValue);
 }
diff --git a/TAO/tao/DynArray_i.cpp b/TAO/tao/DynArray_i.cpp
index 6a5e0393d12..f6875cf2494 100644
--- a/TAO/tao/DynArray_i.cpp
+++ b/TAO/tao/DynArray_i.cpp
@@ -36,11 +36,10 @@ TAO_DynArray_i::TAO_DynArray_i (const CORBA_Any& any)
                                                      env);
 
       // Resize the array.
-      this->da_members_ = ACE_Array<CORBA_DynAny_var> (numfields);
+      this->da_members_.size (numfields);
 
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
 
       TAO_InputCDR cdr (mb);
 
@@ -82,7 +81,7 @@ TAO_DynArray_i::TAO_DynArray_i (CORBA_TypeCode_ptr tc)
                                                      env);
 
       // Resize the array.
-      this->da_members_ = ACE_Array<CORBA_DynAny_var> (numfields);
+      this->da_members_.size (numfields);
 
       for (CORBA::ULong i = 0; i < numfields; i++)
 
@@ -137,10 +136,7 @@ TAO_DynArray_i::set_elements (const AnySeq& value,
   CORBA::ULong length = value.length ();
   CORBA::ULong size = this->da_members_.size ();
 
-  if (size == 0)
-    // Resize the array, it hasn't yet been initialized.
-    this->da_members_ = ACE_Array<CORBA_DynAny_var> (length);
-  else if (size != length)
+  if (size != length)
     {
       env.exception (new CORBA_DynAny::InvalidSeq);
       return;
@@ -151,11 +147,16 @@ TAO_DynArray_i::set_elements (const AnySeq& value,
   for (CORBA::ULong i = 0; i < length; i++)
     {
       // Check each arg element for type match.
-      if (value[i].type ()->equal (element_type, env))
+      if (value[i].type ()->equal (element_type,
+                                   env))
+        {
+          if (!CORBA::is_nil (this->da_members_[i].in ()))
+            this->da_members_[i]->destroy (env);
 
-        this->da_members_[i] =
-          TAO_DynAny_i::create_dyn_any (value[i],
-                                        env);
+          this->da_members_[i] =
+            TAO_DynAny_i::create_dyn_any (value[i],
+                                          env);
+        }
       else
         {
           env.exception (new CORBA_DynAny::InvalidSeq);
@@ -193,10 +194,11 @@ TAO_DynArray_i::destroy (CORBA::Environment &env)
 {
   // Do a deep destroy
   for (CORBA::ULong i = 0; i < this->da_members_.size (); i++)
-    this->da_members_[i]->destroy (env);
+    if (!CORBA::is_nil (this->da_members_[i].in ()))
+      this->da_members_[i]->destroy (env);
 
   // Free the top level
-  CORBA::release (this->_this (env));
+  delete this;
 }
 
 void
@@ -206,18 +208,14 @@ TAO_DynArray_i::from_any (const CORBA_Any& any,
   if (this->type_.in ()->equal (any.type (), env))
     {
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
       TAO_InputCDR cdr (mb);
 
       CORBA::ULong length = this->da_members_.size ();
       CORBA::ULong arg_length = this->get_arg_length (any.type (),
                                                       env);
 
-      if (length == 0)
-        // Resize the array, it hasn't yet been initialized.
-        this->da_members_ = ACE_Array<CORBA_DynAny_var> (arg_length);
-      else if (length != arg_length)
+      if (length != arg_length)
         {
           env.exception (new CORBA_DynAny::Invalid);
           return;
@@ -231,10 +229,10 @@ TAO_DynArray_i::from_any (const CORBA_Any& any,
           CORBA_Any field_any (field_tc,
                                cdr.start ());
 
-          // Actually a recursive step. Can't call from_any()
-          // recursively because maybe only the top level is created,
-          // but create_dyn_any will do the right thing.
-          this->da_members_[i] =
+          if (!CORBA::is_nil (this->da_members_[i].in ()))
+            this->da_members_[i]->destroy (env);
+
+          this->da_members_[i] = 
             TAO_DynAny_i::create_dyn_any (field_any,
                                           env);
 
@@ -265,12 +263,13 @@ TAO_DynArray_i::to_any (CORBA::Environment& _env)
       // Recursive step
       CORBA_Any_ptr field_any = this->da_members_[i]->to_any (_env);
 
-      ACE_Message_Block* field_mb =
-        ACE_Message_Block::duplicate (field_any->_tao_get_cdr ());
+      ACE_Message_Block* field_mb = field_any->_tao_get_cdr ();
 
       TAO_InputCDR field_cdr (field_mb);
 
-      out_cdr.append (field_tc, &field_cdr, _env);
+      out_cdr.append (field_tc, 
+                      &field_cdr, 
+                      _env);
 
       delete field_any;
     }
diff --git a/TAO/tao/DynEnum_i.cpp b/TAO/tao/DynEnum_i.cpp
index 65e0c3253f0..8404745e38f 100644
--- a/TAO/tao/DynEnum_i.cpp
+++ b/TAO/tao/DynEnum_i.cpp
@@ -20,7 +20,8 @@
 // Constructors and destructor
 
 TAO_DynEnum_i::TAO_DynEnum_i (const CORBA_Any& any)
-  : type_ (any.type ())
+  : type_ (any.type ()),
+    value_ (0)
 {
   CORBA::Environment env;
 
@@ -30,8 +31,7 @@ TAO_DynEnum_i::TAO_DynEnum_i (const CORBA_Any& any)
   if (TAO_DynAny_i::unalias (this->type_.in (), env) == CORBA::tk_enum)
     {
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
 
       TAO_InputCDR cdr (mb);
 
@@ -133,7 +133,7 @@ void
 TAO_DynEnum_i::destroy (CORBA::Environment &env)
 {
   // Freeing the top level is all we have to do.
-  CORBA::release (this->_this (env));
+  delete this;
 }
 
 void
@@ -143,8 +143,7 @@ TAO_DynEnum_i::from_any (const CORBA_Any& any,
   if (TAO_DynAny_i::unalias (any.type (), env) == CORBA::tk_enum)
     {
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
 
       TAO_InputCDR cdr (mb);
 
diff --git a/TAO/tao/DynSequence_i.cpp b/TAO/tao/DynSequence_i.cpp
index f4356ef771b..4dfd7220243 100644
--- a/TAO/tao/DynSequence_i.cpp
+++ b/TAO/tao/DynSequence_i.cpp
@@ -34,8 +34,7 @@ TAO_DynSequence_i::TAO_DynSequence_i (const CORBA_Any& any)
        == CORBA::tk_sequence)
     {
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
 
       TAO_InputCDR cdr (mb);
 
@@ -45,7 +44,7 @@ TAO_DynSequence_i::TAO_DynSequence_i (const CORBA_Any& any)
       cdr.read_ulong (length);
 
       // Resize the array.
-      this->da_members_ = ACE_Array<CORBA_DynAny_var> (length);
+      this->da_members_.size (length);
 
       // Get the type of the sequence elments.
       CORBA::TypeCode_ptr field_tc = this->get_element_type (env);
@@ -106,23 +105,7 @@ void
 TAO_DynSequence_i::length (CORBA::ULong length,
                            CORBA::Environment& env)
 {
-  // We might get off easy.
-  if (length == this->da_members_.size ())
-    return;
-
-  ACE_Array<CORBA_DynAny_var> new_array (length);
-
-  // Choose the shorter one for the loop bound.
-  CORBA::ULong len =
-    length > this->da_members_.size () ? this->da_members_.size () : length;
-
-  // Copy over.
-  for (CORBA::ULong i = 0; i < len; i++)
-    new_array[i] = this->da_members_[i];
-
-  // Copy back. If length decreases, the extra original members are
-  // still there, but da_members_.size returns the new smaller value.
-  this->da_members_ = new_array;
+  this->da_members_.size (length);
 }
 
 AnySeq_ptr
@@ -150,7 +133,6 @@ TAO_DynSequence_i::get_elements (CORBA::Environment& _env)
       delete temp;
     }
 
-
   return elements;
 }
 
@@ -163,7 +145,7 @@ TAO_DynSequence_i::set_elements (const AnySeq& value,
 
   if (size == 0)
     // Resize the array, it hasn't yet been initialized.
-    this->da_members_ = ACE_Array<CORBA_DynAny_var> (length);
+    this->da_members_.size (length);
   else if (size != length)
     {
       env.exception (new CORBA_DynAny::InvalidSeq);
@@ -177,11 +159,14 @@ TAO_DynSequence_i::set_elements (const AnySeq& value,
       // Check each arg element for type match.
       if (value[i].type ()->equal (element_type,
                                    env))
+        {
+          if (!CORBA::is_nil (this->da_members_[i].in ()))
+            this->da_members_[i]->destroy (env);
 
-        this->da_members_[i] =
-          TAO_DynAny_i::create_dyn_any (value[i],
-                                        env);
-
+          this->da_members_[i] =
+            TAO_DynAny_i::create_dyn_any (value[i],
+                                          env);
+        }
       else
         {
           env.exception (new CORBA_DynAny::InvalidSeq);
@@ -219,10 +204,11 @@ TAO_DynSequence_i::destroy (CORBA::Environment &env)
 {
   // Do a deep destroy
   for (CORBA::ULong i = 0; i < this->da_members_.size (); i++)
-    this->da_members_[i]->destroy (env);
+    if (!CORBA::is_nil (this->da_members_[i].in ()))
+      this->da_members_[i]->destroy (env);
 
   // Free the top level
-  CORBA::release (this->_this (env));
+  delete this;
 }
 
 void
@@ -233,8 +219,7 @@ TAO_DynSequence_i::from_any (const CORBA_Any& any,
                                 env))
     {
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
       TAO_InputCDR cdr (mb);
 
       CORBA::ULong arg_length;
@@ -246,7 +231,7 @@ TAO_DynSequence_i::from_any (const CORBA_Any& any,
 
       if (length == 0)
         // Resize the array, it hasn't yet been initialized.
-        this->da_members_ = ACE_Array<CORBA_DynAny_var> (arg_length);
+        this->da_members_.size (arg_length);
       else if (length != arg_length)
         {
           env.exception (new CORBA_DynAny::Invalid);
@@ -261,9 +246,9 @@ TAO_DynSequence_i::from_any (const CORBA_Any& any,
           CORBA_Any field_any (field_tc,
                                cdr.start ());
 
-          // Actually a recursive step. Can't call from_any()
-          // recursively because maybe only the top level is created,
-          // but create_dyn_any will do the right thing.
+          if (!CORBA::is_nil (this->da_members_[i].in ()))
+            this->da_members_[i]->destroy (env);
+
           this->da_members_[i] =
             TAO_DynAny_i::create_dyn_any (field_any,
                                           env);
@@ -297,8 +282,7 @@ TAO_DynSequence_i::to_any (CORBA::Environment& _env)
       // Recursive step
       CORBA_Any_ptr field_any = this->da_members_[i]->to_any (_env);
 
-      ACE_Message_Block* field_mb =
-        ACE_Message_Block::duplicate (field_any->_tao_get_cdr ());
+      ACE_Message_Block* field_mb = field_any->_tao_get_cdr ();
 
       TAO_InputCDR field_cdr (field_mb);
 
diff --git a/TAO/tao/DynStruct_i.cpp b/TAO/tao/DynStruct_i.cpp
index e5be473a943..6662d145841 100644
--- a/TAO/tao/DynStruct_i.cpp
+++ b/TAO/tao/DynStruct_i.cpp
@@ -37,8 +37,7 @@ TAO_DynStruct_i::TAO_DynStruct_i (const CORBA_Any& any)
       this->da_members_ = ACE_Array<CORBA_DynAny_var> (numfields);
 
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
 
       TAO_InputCDR cdr (mb);
 
@@ -79,7 +78,7 @@ TAO_DynStruct_i::TAO_DynStruct_i (CORBA_TypeCode_ptr tc)
       CORBA::ULong numfields = tc->member_count (env);
 
       // Resize the array.
-      this->da_members_ = ACE_Array<CORBA_DynAny_var> (numfields);
+      this->da_members_.size (numfields);
 
       for (CORBA::ULong i = 0; i < numfields; i++)
 
@@ -156,11 +155,14 @@ TAO_DynStruct_i::set_members (const NameValuePairSeq& value,
                                                                              env))
               && !ACE_OS::strcmp (value[i].id,
                                   this->type_.in ()->member_name (i)))
+            {
+              if (!CORBA::is_nil (this->da_members_[i].in ()))
+                this->da_members_[i]->destroy (env);
 
-            this->da_members_[i] =
-              TAO_DynAny_i::create_dyn_any (value[i].value,
-                                            env);
-
+              this->da_members_[i] =
+                TAO_DynAny_i::create_dyn_any (value[i].value,
+                                              env);
+            }
           else
             {
               env.exception (new CORBA_DynAny::InvalidSeq);
@@ -201,10 +203,11 @@ TAO_DynStruct_i::destroy (CORBA::Environment &env)
 {
   // Do a deep destroy
   for (CORBA::ULong i = 0; i < this->da_members_.size (); i++)
-    this->da_members_[i]->destroy (env);
+    if (!CORBA::is_nil (this->da_members_[i].in ()))
+      this->da_members_[i]->destroy (env);
 
   // Free the top level
-  CORBA::release (this->_this (env));
+  delete this;
 }
 
 void
@@ -215,8 +218,7 @@ TAO_DynStruct_i::from_any (const CORBA_Any& any,
                                 env))
     {
       // Get the CDR stream of the argument.
-      ACE_Message_Block* mb =
-        ACE_Message_Block::duplicate (any._tao_get_cdr ());
+      ACE_Message_Block* mb = any._tao_get_cdr ();
       TAO_InputCDR cdr (mb);
 
       for (CORBA::ULong i = 0; i < this->da_members_.size (); i++)
@@ -229,9 +231,9 @@ TAO_DynStruct_i::from_any (const CORBA_Any& any,
           CORBA_Any field_any (field_tc,
                                cdr.start ());
 
-          // Actually a recursive step. Can't call from_any()
-          // recursively because maybe only the top level is created,
-          // but create_dyn_any will do the right thing.
+          if (!CORBA::is_nil (this->da_members_[i].in ()))
+            this->da_members_[i]->destroy (env);
+
           this->da_members_[i] =
             TAO_DynAny_i::create_dyn_any (field_any,
                                           env);
@@ -245,7 +247,7 @@ TAO_DynStruct_i::from_any (const CORBA_Any& any,
 }
 
 CORBA::Any_ptr
-TAO_DynStruct_i::to_any (CORBA::Environment& env)
+TAO_DynStruct_i::to_any (CORBA::Environment& _env)
 {
   TAO_OutputCDR out_cdr;
 
@@ -254,31 +256,35 @@ TAO_DynStruct_i::to_any (CORBA::Environment& env)
       // Each component must have been initialied.
       if (!this->da_members_[i].in ())
         {
-          env.exception (new CORBA_DynAny::Invalid);
+          _env.exception (new CORBA_DynAny::Invalid);
           return 0;
         }
 
-      CORBA_TypeCode_ptr field_tc = this->da_members_[i]->type (env);
+      CORBA_TypeCode_ptr field_tc = this->da_members_[i]->type (_env);
 
       // Recursive step
-      CORBA_Any_ptr field_any = this->da_members_[i]->to_any (env);
+      CORBA_Any_ptr field_any = this->da_members_[i]->to_any (_env);
 
-      ACE_Message_Block* field_mb =
-        ACE_Message_Block::duplicate (field_any->_tao_get_cdr ());
+      ACE_Message_Block* field_mb = field_any->_tao_get_cdr ();
 
       TAO_InputCDR field_cdr (field_mb);
 
       out_cdr.append (field_tc,
                       &field_cdr,
-                      env);
+                      _env);
 
       delete field_any;
     }
 
   TAO_InputCDR in_cdr (out_cdr);
 
-  return new CORBA_Any (this->type (env),
-                        in_cdr.start ());
+  CORBA_Any* retval;
+  ACE_NEW_THROW_RETURN (retval,
+                        CORBA_Any (this->type (_env),
+                                   in_cdr.start ()),
+                        CORBA::NO_MEMORY (),
+                        0);
+  return retval;
 }
 
 CORBA::TypeCode_ptr
diff --git a/TAO/tao/DynUnion_i.cpp b/TAO/tao/DynUnion_i.cpp
index 0c60f124531..892ff62eeb7 100644
--- a/TAO/tao/DynUnion_i.cpp
+++ b/TAO/tao/DynUnion_i.cpp
@@ -191,7 +191,7 @@ TAO_DynUnion_i::destroy (CORBA::Environment &env)
   this->discriminator_->destroy (env);
 
   // Free the top level
-  CORBA::release (this->_this (env));
+  delete this;
 }
 
 void
@@ -224,8 +224,7 @@ TAO_DynUnion_i::to_any (CORBA::Environment& _env)
 
   CORBA_Any_ptr disc_any = this->discriminator_->to_any (_env);
 
-  ACE_Message_Block* disc_mb =
-    ACE_Message_Block::duplicate (disc_any->_tao_get_cdr ());
+  ACE_Message_Block* disc_mb = disc_any->_tao_get_cdr ();
 
   TAO_InputCDR disc_cdr (disc_mb);
 
@@ -241,8 +240,7 @@ TAO_DynUnion_i::to_any (CORBA::Environment& _env)
 
   CORBA_Any_ptr member_any = this->member_->to_any (_env);
 
-  ACE_Message_Block* member_mb =
-    ACE_Message_Block::duplicate (member_any->_tao_get_cdr ());
+  ACE_Message_Block* member_mb = member_any->_tao_get_cdr ();
 
   TAO_InputCDR member_cdr (member_mb);
 
@@ -284,6 +282,9 @@ TAO_DynUnion_i::next (CORBA::Environment &env)
 
   ++this->index_;
 
+  if (!CORBA::is_nil (this->member_))
+    this->member_->destroy (env);
+
   this->member_ =
     TAO_DynAny_i::create_dyn_any (this->type_->member_type (this->index_,
                                                             env),
@@ -300,6 +301,9 @@ TAO_DynUnion_i::seek (CORBA::Long index,
 
   this->index_ = index;
 
+  if (!CORBA::is_nil (this->member_))
+    this->member_->destroy (env);
+
   this->member_ =
     TAO_DynAny_i::create_dyn_any (this->type_->member_type (this->index_,
                                                             env),
@@ -315,6 +319,9 @@ TAO_DynUnion_i::rewind (CORBA::Environment &env)
 
   this->index_ = 0;
 
+  if (!CORBA::is_nil (this->member_))
+    this->member_->destroy (env);
+
   this->member_ =
     TAO_DynAny_i::create_dyn_any (this->type_->member_type (this->index_,
                                                             env),
@@ -1234,15 +1241,14 @@ TAO_DynUnion_i::Enum_extractor::check_match (const CORBA_Any& inside_any,
                                              const CORBA_Any& outside_any)
 {
   // Get the CDR stream of one argument...
-  ACE_Message_Block* mb =
-    ACE_Message_Block::duplicate (inside_any._tao_get_cdr ());
+  ACE_Message_Block* mb = inside_any._tao_get_cdr ();
 
   TAO_InputCDR inside_cdr (mb);
 
   inside_cdr.read_ulong (this->member_index_);
 
   // And of the other...
-  mb = ACE_Message_Block::duplicate (outside_any._tao_get_cdr ());
+  mb = outside_any._tao_get_cdr ();
 
   TAO_InputCDR outside_cdr (mb);
 
@@ -1338,8 +1344,7 @@ TAO_DynUnion_i::set_from_any (const CORBA_Any& any,
                               CORBA::Environment &env)
 {
   // Get the CDR stream of the argument.
-  ACE_Message_Block* mb =
-    ACE_Message_Block::duplicate (any._tao_get_cdr ());
+  ACE_Message_Block* mb = any._tao_get_cdr ();
 
   TAO_InputCDR cdr (mb);
 
@@ -1348,6 +1353,9 @@ TAO_DynUnion_i::set_from_any (const CORBA_Any& any,
   CORBA_Any disc_any (disc_tc,
                       cdr.start ());
 
+  if (!CORBA::is_nil (this->discriminator_))
+    this->discriminator_->destroy (env);
+
   // Set the discriminator holder.
   this->discriminator_ = TAO_DynAny_i::create_dyn_any (disc_any,
                                                        env);
@@ -1401,6 +1409,9 @@ TAO_DynUnion_i::set_from_any (const CORBA_Any& any,
                                                       env),
                             cdr.start ());
 
+      if (!CORBA::is_nil (this->member_))
+        this->member_->destroy (env);
+
       this->member_ = TAO_DynAny_i::create_dyn_any (member_any,
                                                     env);
     }
diff --git a/TAO/tao/POA_CORBA.h b/TAO/tao/POA_CORBA.h
index 394b4fb600d..c7e3272972b 100644
--- a/TAO/tao/POA_CORBA.h
+++ b/TAO/tao/POA_CORBA.h
@@ -176,7 +176,7 @@ public:
 
 class DynAny;
 typedef DynAny *DynAny_ptr;
-class  DynAny : public virtual TAO_Local_ServantBase
+class TAO_Export DynAny : public virtual TAO_Local_ServantBase
 {
 protected:
   DynAny (void);
@@ -650,7 +650,7 @@ private:
 
 class DynEnum;
 typedef DynEnum *DynEnum_ptr;
-class  DynEnum : public virtual DynAny
+class TAO_Export DynEnum : public virtual DynAny
 {
 protected:
   DynEnum (void);
@@ -748,7 +748,7 @@ private:
 
 class DynStruct;
 typedef DynStruct *DynStruct_ptr;
-class  DynStruct : public virtual DynAny
+class TAO_Export DynStruct : public virtual DynAny
 {
 protected:
   DynStruct (void);
@@ -844,7 +844,7 @@ private:
 
 class DynUnion;
 typedef DynUnion *DynUnion_ptr;
-class  DynUnion : public virtual DynAny
+class TAO_Export DynUnion : public virtual DynAny
 {
 protected:
   DynUnion (void);
@@ -978,7 +978,7 @@ private:
 
 class DynSequence;
 typedef DynSequence *DynSequence_ptr;
-class  DynSequence : public virtual DynAny
+class TAO_Export DynSequence : public virtual DynAny
 {
 protected:
   DynSequence (void);
@@ -1084,7 +1084,7 @@ private:
 
 class DynArray;
 typedef DynArray *DynArray_ptr;
-class  DynArray : public virtual DynAny
+class TAO_Export DynArray : public virtual DynAny
 {
 protected:
   DynArray (void);
diff --git a/TAO/tests/DynAny_Test/data.cpp b/TAO/tests/DynAny_Test/data.cpp
index fa3ee8df344..2f923cedd9b 100644
--- a/TAO/tests/DynAny_Test/data.cpp
+++ b/TAO/tests/DynAny_Test/data.cpp
@@ -59,7 +59,12 @@ Data::Data (CORBA::ORB_var orb)
   labels[15] = "type objref";
 
   // Getting the RootPOA so we can generate object references.
-  CORBA::Object_var obj = this->orb_->resolve_initial_references ("RootPOA");
+  CORBA::Object_var obj = 
+    this->orb_->resolve_initial_references ("RootPOA");
+
+  if (CORBA::is_nil (obj.in ()))
+    ACE_ERROR ((LM_ERROR,
+                "(%P|%t) Unable to get root poa reference.\n"));
 
   // Get the POA_var object from Object_var.
   PortableServer::POA_var root_poa =
@@ -82,11 +87,22 @@ Data::Data (CORBA::ORB_var orb)
                                 env);
 
   if (env.exception () != 0)
-    env.print_exception ("PortableServer::POA::create_reference_with_id"); 
+    env.print_exception ("PortableServer::POA::create_reference_with_id");
+  
+  // Clean up after the POA
+  root_poa->destroy (1,
+                     1,
+                     env);
+
+  if (env.exception () != 0)
+    env.print_exception ("PortableServer::POA::destroy");
 }
 
 Data::~Data (void)
 {
   CORBA::string_free (m_string1);
+  CORBA::string_free (m_string2);
+  CORBA::release (m_typecode1);
+  CORBA::release (m_typecode2);
 }
 
diff --git a/TAO/tests/DynAny_Test/test_dynany.cpp b/TAO/tests/DynAny_Test/test_dynany.cpp
index 11f29170abe..ae6bc6c10b3 100644
--- a/TAO/tests/DynAny_Test/test_dynany.cpp
+++ b/TAO/tests/DynAny_Test/test_dynany.cpp
@@ -16,7 +16,6 @@
 //
 // ============================================================================
 
-#include "tao/DynAny_i.h"
 #include "test_dynany.h"
 #include "data.h"
 
@@ -55,11 +54,13 @@ Test_DynAny::run_test (void)
                  "testing: constructor(Any)/insert/get\n"));
 
       CORBA_Any in1 (CORBA::_tc_double);
-      TAO_DynAny_i fa1 (in1);
-      fa1.insert_double (data.m_double1, 
-                        TAO_TRY_ENV);
+      CORBA_DynAny_ptr fa1 = this->orb_->create_dyn_any (in1,
+                                                         TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Double d_out = fa1.get_double (TAO_TRY_ENV);
+      fa1->insert_double (data.m_double1, 
+                          TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA::Double d_out = fa1->get_double (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (d_out == data.m_double1)
         ACE_DEBUG ((LM_DEBUG,
@@ -71,13 +72,16 @@ Test_DynAny::run_test (void)
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 
       d_out = data.m_double2;
-      TAO_DynAny_i ftc1 (CORBA::_tc_double);
+      CORBA_DynAny_ptr ftc1 = 
+        this->orb_->create_basic_dyn_any (CORBA::_tc_double,
+                                          TAO_TRY_ENV);
+      TAO_CHECK_ENV;
       CORBA::Any in_any1;
       in_any1 <<= data.m_double1;
-      ftc1.from_any (in_any1, 
-                    TAO_TRY_ENV);
+      ftc1->from_any (in_any1, 
+                      TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Any* out_any1 = ftc1.to_any (TAO_TRY_ENV);
+      CORBA::Any* out_any1 = ftc1->to_any (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       *out_any1 >>= d_out;
 
@@ -90,10 +94,12 @@ Test_DynAny::run_test (void)
       else 
         ++this->error_count_;
 
-      fa1.destroy (TAO_TRY_ENV);
+      fa1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      ftc1.destroy (TAO_TRY_ENV);
+      CORBA::release (fa1);
+      ftc1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
+      CORBA::release (ftc1);
 
       ACE_DEBUG ((LM_DEBUG,
                  "\t*=*=*=*= %s =*=*=*=*\n",
@@ -103,14 +109,17 @@ Test_DynAny::run_test (void)
                  "testing: constructor(Any)/insert/get\n"));
 
       CORBA_Any in (CORBA::_tc_TypeCode);
-      TAO_DynAny_i fa2 (in);
-      fa2.insert_typecode (data.m_typecode1, 
-                           TAO_TRY_ENV);
+      CORBA_DynAny_ptr fa2 = 
+        this->orb_->create_dyn_any (in,
+                                    TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::TypeCode_ptr tc_out = fa2.get_typecode (TAO_TRY_ENV);
+      fa2->insert_typecode (data.m_typecode1, 
+                            TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      if (tc_out->equal(data.m_typecode1,
-                        TAO_TRY_ENV))
+      CORBA::TypeCode_ptr tc_out = fa2->get_typecode (TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      if (tc_out->equal (data.m_typecode1,
+                         TAO_TRY_ENV))
         ACE_DEBUG ((LM_DEBUG,
                    "++ OK ++\n"));
       else 
@@ -122,13 +131,16 @@ Test_DynAny::run_test (void)
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 
       tc_out = data.m_typecode2;
-      TAO_DynAny_i ftc2 (CORBA::_tc_TypeCode);
+      CORBA_DynAny_ptr ftc2 = 
+        this->orb_->create_basic_dyn_any (CORBA::_tc_TypeCode,
+                                          TAO_TRY_ENV);
+      TAO_CHECK_ENV;
       CORBA::Any in_any2;
       in_any2 <<= data.m_typecode1;
-      ftc2.from_any (in_any2, 
-                    TAO_TRY_ENV);
+      ftc2->from_any (in_any2, 
+                      TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Any* out_any2 = ftc2.to_any (TAO_TRY_ENV);
+      CORBA::Any* out_any2 = ftc2->to_any (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       *out_any2 >>= tc_out;
 
@@ -144,10 +156,13 @@ Test_DynAny::run_test (void)
 
       TAO_CHECK_ENV;
 
-      fa2.destroy (TAO_TRY_ENV);
+      fa2->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      ftc2.destroy (TAO_TRY_ENV);
+      CORBA::release (fa2);
+      ftc2->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
+      CORBA::release (ftc2);
+      CORBA::release (tc_out);
     }
   TAO_CATCHANY
     {
diff --git a/TAO/tests/DynAny_Test/test_dynany.h b/TAO/tests/DynAny_Test/test_dynany.h
index d675c57a4bd..e282eb94f4e 100644
--- a/TAO/tests/DynAny_Test/test_dynany.h
+++ b/TAO/tests/DynAny_Test/test_dynany.h
@@ -16,11 +16,11 @@
 //
 // ============================================================================
 
-#include "tao/corba.h"
-
 #if !defined (TEST_DYNANY_H)
 #define TEST_DYNANY_H
 
+#include "tao/corba.h"
+
 class Test_DynAny
 {
 public:
diff --git a/TAO/tests/DynAny_Test/test_dynarray.cpp b/TAO/tests/DynAny_Test/test_dynarray.cpp
index d3ac479fd6a..dfde047395c 100644
--- a/TAO/tests/DynAny_Test/test_dynarray.cpp
+++ b/TAO/tests/DynAny_Test/test_dynarray.cpp
@@ -16,8 +16,6 @@
 //
 // ============================================================================
 
-#include "tao/corba.h"
-#include "tao/DynArray_i.h"
 #include "test_dynarray.h"
 #include "da_testsC.h"
 #include "data.h"
@@ -46,7 +44,7 @@ Test_DynArray::run_test (void)
 {
   Data data (this->orb_);
 
-  DynAnyTests::test_array ta;
+  DynAnyTests::test_array ta = {0};
 
   TAO_TRY
     {
@@ -59,20 +57,25 @@ Test_DynArray::run_test (void)
 
       CORBA::Any in_any1;
       in_any1 <<= ta;
-      TAO_DynArray_i fa1 (in_any1);
-      fa1.seek (1,
-                TAO_TRY_ENV);
+      CORBA_DynAny_ptr dp1 = this->orb_->create_dyn_any (in_any1,
+                                                        TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.insert_long (data.m_long1,
-                       TAO_TRY_ENV);
+      CORBA_DynArray_ptr fa1 = CORBA_DynArray::_narrow (dp1,
+                                                        TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.rewind (TAO_TRY_ENV);
+      fa1->seek (1,
+                 TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      fa1->insert_long (data.m_long1,
+                        TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      fa1->rewind (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       CORBA::Long l_out1 = data.m_long2;
-      fa1.seek (1,
-                TAO_TRY_ENV);
+      fa1->seek (1,
+                 TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      l_out1 = fa1.get_long (TAO_TRY_ENV);
+      l_out1 = fa1->get_long (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (l_out1 == data.m_long1)
         ACE_DEBUG ((LM_DEBUG,
@@ -83,14 +86,17 @@ Test_DynArray::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 
-      TAO_DynArray_i ftc1 (DynAnyTests::_tc_test_array);
+      CORBA_DynArray_ptr ftc1 = 
+        this->orb_->create_dyn_array (DynAnyTests::_tc_test_array,
+                                      TAO_TRY_ENV);
+      TAO_CHECK_ENV;
       ta[1] = data.m_long1;
       CORBA::Any in_any2;
       in_any2 <<= ta;
-      ftc1.from_any (in_any2,
-                     TAO_TRY_ENV);
+      ftc1->from_any (in_any2,
+                      TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Any* out_any1 = ftc1.to_any (TAO_TRY_ENV);
+      CORBA::Any* out_any1 = ftc1->to_any (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       DynAnyTests::test_array_forany ta_out;
       *out_any1 >>= ta_out; 
@@ -113,10 +119,10 @@ Test_DynArray::run_test (void)
       in_any3 <<= data.m_long1;
       as_in[0] = in_any3;
       as_in[1] = in_any3;
-      ftc1.set_elements (as_in,
-                         TAO_TRY_ENV);
+      ftc1->set_elements (as_in,
+                          TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      AnySeq* as_out = ftc1.get_elements (TAO_TRY_ENV);
+      AnySeq* as_out = ftc1->get_elements (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       CORBA_Any out_any2 = (*as_out)[1];
       CORBA::Long l_out2;
@@ -130,10 +136,13 @@ Test_DynArray::run_test (void)
       // Created with NEW
       delete as_out;
 
-      fa1.destroy (TAO_TRY_ENV);
+      fa1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      ftc1.destroy (TAO_TRY_ENV);
+      CORBA::release (fa1);
+      ftc1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
+      CORBA::release (ftc1);
+      CORBA::release (dp1);
     }
   TAO_CATCHANY
     {
diff --git a/TAO/tests/DynAny_Test/test_dynarray.h b/TAO/tests/DynAny_Test/test_dynarray.h
index 17e623fd704..9ac0c71658b 100644
--- a/TAO/tests/DynAny_Test/test_dynarray.h
+++ b/TAO/tests/DynAny_Test/test_dynarray.h
@@ -19,6 +19,8 @@
 #if !defined (TEST_DYNARRAY_H)
 #define TEST_DYNARRAY_H
 
+#include "tao/corba.h"
+
 class Test_DynArray
 {
 public:
diff --git a/TAO/tests/DynAny_Test/test_dynenum.cpp b/TAO/tests/DynAny_Test/test_dynenum.cpp
index 57a4ccc2de5..b34ee1770ff 100644
--- a/TAO/tests/DynAny_Test/test_dynenum.cpp
+++ b/TAO/tests/DynAny_Test/test_dynenum.cpp
@@ -16,8 +16,6 @@
 //
 // ============================================================================
 
-#include "tao/corba.h"
-#include "tao/DynEnum_i.h"
 #include "test_dynenum.h"
 #include "da_testsC.h"
 #include "data.h"
@@ -44,7 +42,7 @@ Test_DynEnum::test_name (void) const
 int
 Test_DynEnum::run_test (void)
 {
-  DynAnyTests::test_enum te;
+  DynAnyTests::test_enum te = DynAnyTests::ZEROTH;
 
   TAO_TRY
     {
@@ -52,9 +50,17 @@ Test_DynEnum::run_test (void)
                  "testing: constructor(Any)/value_as_ulong\n"));
 
       CORBA_Any in_any1;
-      in_any1 <<= DynAnyTests::SECOND;
-      TAO_DynEnum_i de1 (in_any1);
-      CORBA::ULong ul_out1 = de1.value_as_ulong (TAO_TRY_ENV);
+      in_any1 <<= te;
+      CORBA_DynAny_ptr dp1 = this->orb_->create_dyn_any (in_any1,
+                                                         TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA_DynEnum_ptr de1 = CORBA_DynEnum::_narrow (dp1,
+                                                      TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      de1->value_as_ulong (2,
+                           TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA::ULong ul_out1 = de1->value_as_ulong (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (ul_out1 == 2)
         ACE_DEBUG ((LM_DEBUG,
@@ -65,9 +71,12 @@ Test_DynEnum::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: value_as_string\n"));
 
-      CORBA::String s = de1.value_as_string (TAO_TRY_ENV);
+      de1->value_as_string ("FIRST",
+                            TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA::String_var s = de1->value_as_string (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      if (!ACE_OS::strcmp (s, "SECOND"))
+      if (!ACE_OS::strcmp (s.in (), "FIRST"))
         ACE_DEBUG ((LM_DEBUG,
                    "++ OK ++\n"));
       else 
@@ -77,15 +86,19 @@ Test_DynEnum::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 
-      TAO_DynEnum_i de2 (DynAnyTests::_tc_test_enum);
-      de2.from_any (in_any1,
+      CORBA_DynEnum_ptr de2 = 
+        this->orb_->create_dyn_enum (DynAnyTests::_tc_test_enum,
+                                     TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA_Any in_any2;
+      in_any2 <<= DynAnyTests::THIRD;
+      de2->from_any (in_any2,
                     TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA_Any* out_any1 = de2.to_any (TAO_TRY_ENV);
+      CORBA_Any* out_any1 = de2->to_any (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      ul_out1 = 0;
       *out_any1 >>= te;
-      if (te == DynAnyTests::SECOND)
+      if (te == DynAnyTests::THIRD)
         ACE_DEBUG ((LM_DEBUG,
                    "++ OK ++\n"));
       else 
@@ -94,6 +107,13 @@ Test_DynEnum::run_test (void)
       // Created with NEW
       delete out_any1;
 
+      de1->destroy (TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA::release (de1);
+      de2->destroy (TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA::release (de2);
+      CORBA::release (dp1);
     }
   TAO_CATCHANY
     {
diff --git a/TAO/tests/DynAny_Test/test_dynenum.h b/TAO/tests/DynAny_Test/test_dynenum.h
index 42b0e9f83ba..830122739a2 100644
--- a/TAO/tests/DynAny_Test/test_dynenum.h
+++ b/TAO/tests/DynAny_Test/test_dynenum.h
@@ -19,6 +19,8 @@
 #if !defined (TEST_DYNENUM_H)
 #define TEST_DYNENUM_H
 
+#include "tao/corba.h"
+
 class Test_DynEnum
 {
 public:
diff --git a/TAO/tests/DynAny_Test/test_dynsequence.cpp b/TAO/tests/DynAny_Test/test_dynsequence.cpp
index d5c911a05ce..d0591261ffc 100644
--- a/TAO/tests/DynAny_Test/test_dynsequence.cpp
+++ b/TAO/tests/DynAny_Test/test_dynsequence.cpp
@@ -16,8 +16,6 @@
 //
 // ============================================================================
 
-#include "tao/corba.h"
-#include "tao/DynSequence_i.h"
 #include "test_dynsequence.h"
 #include "da_testsC.h"
 #include "data.h"
@@ -62,37 +60,49 @@ Test_DynSequence::run_test (void)
       ts[1] = data.m_string2;
       CORBA_Any in_any1;
       in_any1 <<= ts;
-      TAO_DynSequence_i fa1 (in_any1);
-      fa1.seek (1,
-                TAO_TRY_ENV);
+      CORBA_DynAny_ptr dp1 = 
+        this->orb_->create_dyn_any (in_any1,
+                                    TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.insert_string (data.m_string1,
-                         TAO_TRY_ENV);
+      CORBA_DynSequence_ptr fa1 = CORBA_DynSequence::_narrow (dp1,
+                                                              TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.rewind (TAO_TRY_ENV);
+      fa1->seek (1,
+                 TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.seek (1,
-                TAO_TRY_ENV);
+      fa1->insert_string (data.m_string1,
+                          TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::String out_str = fa1.get_string (TAO_TRY_ENV);
+      fa1->rewind (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      if (!ACE_OS::strcmp (out_str, data.m_string1))
+      fa1->seek (1,
+                 TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA::String out_str1 = fa1->get_string (TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      if (!ACE_OS::strcmp (out_str1, data.m_string1))
         ACE_DEBUG ((LM_DEBUG,
                    "++ OK ++\n"));
       else 
         ++this->error_count_;
 
+      // Created with NEW
+      delete out_str1;
+
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 
-      TAO_DynSequence_i ftc1 (DynAnyTests::_tc_test_seq);
+      CORBA_DynSequence_ptr ftc1 =
+        this->orb_->create_dyn_sequence (DynAnyTests::_tc_test_seq,
+                                         TAO_TRY_ENV);
+      TAO_CHECK_ENV;
       ts[0] = data.m_string1;
       CORBA_Any in_any2;
       in_any2 <<= ts;
-      ftc1.from_any (in_any2,
-                     TAO_TRY_ENV);
+      ftc1->from_any (in_any2,
+                      TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Any* out_any1 = ftc1.to_any (TAO_TRY_ENV);
+      CORBA::Any* out_any1 = ftc1->to_any (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       DynAnyTests::test_seq* ts_out;
       *out_any1 >>= ts_out;
@@ -109,12 +119,12 @@ Test_DynSequence::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: length/set_elements/get_elements\n"));
 
-      if (ftc1.length (TAO_TRY_ENV) != 2)
+      if (ftc1->length (TAO_TRY_ENV) != 2)
         ++this->error_count_;
       TAO_CHECK_ENV;
 
-      ftc1.length (3,
-                   TAO_TRY_ENV);
+      ftc1->length (3,
+                    TAO_TRY_ENV);
       TAO_CHECK_ENV;
       AnySeq as_in (3);
       as_in.length (3);
@@ -124,15 +134,15 @@ Test_DynSequence::run_test (void)
       as_in[1] = in_any3;
       in_any3 <<= CORBA::Any::from_string (data.m_string1, 0);
       as_in[2] = in_any3;
-      ftc1.set_elements (as_in,
-                         TAO_TRY_ENV);
+      ftc1->set_elements (as_in,
+                          TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      AnySeq* as_out = ftc1.get_elements (TAO_TRY_ENV);
+      AnySeq* as_out = ftc1->get_elements (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       CORBA_Any out_any2 = (*as_out)[2];
-      CORBA::String str_out;
-      out_any2 >>= CORBA::Any::to_string (str_out, 0);
-      if (ACE_OS::strcmp (str_out, data.m_string1))
+      CORBA::String out_str2;
+      out_any2 >>= CORBA::Any::to_string (out_str2, 0);
+      if (ACE_OS::strcmp (out_str2, data.m_string1))
         ++this->error_count_;
       if (this->error_count_ == 0)
         ACE_DEBUG ((LM_DEBUG,
@@ -140,11 +150,15 @@ Test_DynSequence::run_test (void)
 
       // Created with NEW
       delete as_out;
+      delete out_str2;
 
-      fa1.destroy (TAO_TRY_ENV);
+      fa1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      ftc1.destroy (TAO_TRY_ENV);
+      CORBA::release (fa1);
+      CORBA::release (dp1);
+      ftc1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
+      CORBA::release (ftc1);
     }
   TAO_CATCHANY
     {
diff --git a/TAO/tests/DynAny_Test/test_dynsequence.h b/TAO/tests/DynAny_Test/test_dynsequence.h
index 58168189511..1b53a76b866 100644
--- a/TAO/tests/DynAny_Test/test_dynsequence.h
+++ b/TAO/tests/DynAny_Test/test_dynsequence.h
@@ -19,6 +19,8 @@
 #if !defined (TEST_DYNSEQUENCE_H)
 #define TEST_DYNSEQUENCE_H
 
+#include "tao/corba.h"
+
 class Test_DynSequence
 {
 public:
diff --git a/TAO/tests/DynAny_Test/test_dynstruct.cpp b/TAO/tests/DynAny_Test/test_dynstruct.cpp
index 7797cc8e7e3..2cdf9688b64 100644
--- a/TAO/tests/DynAny_Test/test_dynstruct.cpp
+++ b/TAO/tests/DynAny_Test/test_dynstruct.cpp
@@ -16,8 +16,6 @@
 //
 // ============================================================================
 
-#include "tao/corba.h"
-#include "tao/DynStruct_i.h"
 #include "test_dynstruct.h"
 #include "da_testsC.h"
 #include "data.h"
@@ -47,6 +45,10 @@ Test_DynStruct::run_test (void)
   Data data (this->orb_);
 
   DynAnyTests::test_struct ts;
+  ts.c = data.m_char2;
+  ts.ll = data.m_longlong2;
+  ts.es.f = data.m_float2;
+  ts.es.s = data.m_short2;
 
   TAO_TRY
     {
@@ -55,35 +57,41 @@ Test_DynStruct::run_test (void)
 
       CORBA_Any in_any1;
       in_any1 <<= ts;
-      TAO_DynStruct_i fa1 (in_any1);
-      fa1.insert_char (data.m_char1,
-                       TAO_TRY_ENV);
+      CORBA_DynAny_ptr dp1 = 
+        this->orb_->create_dyn_any (in_any1,
+                                    TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA_DynStruct_ptr fa1 = CORBA_DynStruct::_narrow (dp1,
+                                                          TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.insert_longlong (data.m_longlong1,
+      fa1->insert_char (data.m_char1,
+                        TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      fa1->insert_longlong (data.m_longlong1,
         TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.current_component (TAO_TRY_ENV)->insert_float (data.m_float1,
-                                                         TAO_TRY_ENV);
+      fa1->current_component (TAO_TRY_ENV)->insert_float (data.m_float1,
+                                                          TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.current_component (TAO_TRY_ENV)->insert_short (data.m_short1,
-                                                         TAO_TRY_ENV);
+      fa1->current_component (TAO_TRY_ENV)->insert_short (data.m_short1,
+                                                          TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.current_component (TAO_TRY_ENV)->rewind (TAO_TRY_ENV);
+      fa1->current_component (TAO_TRY_ENV)->rewind (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      fa1.rewind (TAO_TRY_ENV);
+      fa1->rewind (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Char c = fa1.get_char (TAO_TRY_ENV);
+      CORBA::Char c = fa1->get_char (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (c != data.m_char1)
         ++this->error_count_;
-      CORBA::LongLong ll = fa1.get_longlong (TAO_TRY_ENV);
+      CORBA::LongLong ll = fa1->get_longlong (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (ll != data.m_longlong1)
         ++this->error_count_;
-      fa1.current_component(TAO_TRY_ENV)->seek (1,
+      fa1->current_component(TAO_TRY_ENV)->seek (1,
                                                 TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Short s = fa1.current_component (TAO_TRY_ENV)->get_short (TAO_TRY_ENV);
+      CORBA::Short s = fa1->current_component (TAO_TRY_ENV)->get_short (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (s != data.m_short1)
         ++this->error_count_;
@@ -94,17 +102,20 @@ Test_DynStruct::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 
-      TAO_DynStruct_i ftc1 (DynAnyTests::_tc_test_struct);
+      CORBA_DynStruct_ptr ftc1 = 
+        this->orb_->create_dyn_struct (DynAnyTests::_tc_test_struct,
+                                       TAO_TRY_ENV);
+      TAO_CHECK_ENV;
       ts.c = data.m_char1;
       ts.ll = data.m_longlong1;
       ts.es.f = data.m_float1;
       ts.es.s = data.m_short1;
       CORBA_Any in_any2;
       in_any2 <<= ts;
-      ftc1.from_any (in_any2,
-                     TAO_TRY_ENV);
+      ftc1->from_any (in_any2,
+                      TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA_Any* out_any1 = ftc1.to_any (TAO_TRY_ENV);
+      CORBA_Any* out_any1 = ftc1->to_any (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       DynAnyTests::test_struct* ts_out;
       *out_any1 >>= ts_out;
@@ -120,14 +131,14 @@ Test_DynStruct::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: current_member_name/current_member_kind\n"));
 
-      ftc1.seek (2,
+      ftc1->seek (2,
                  TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      FieldName fn = ftc1.current_member_name (TAO_TRY_ENV);
+      FieldName fn = ftc1->current_member_name (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (ACE_OS::strcmp (fn, "es"))
         ++this->error_count_;
-      CORBA::TCKind tk = ftc1.current_member_kind (TAO_TRY_ENV);
+      CORBA::TCKind tk = ftc1->current_member_kind (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (tk != CORBA::tk_struct)
         ++this->error_count_;
@@ -138,12 +149,15 @@ Test_DynStruct::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: get_members/set_members\n"));
 
-      NameValuePairSeq* nvps = fa1.get_members (TAO_TRY_ENV);
-      TAO_DynStruct_i sm (DynAnyTests::_tc_test_struct);
-      sm.set_members (*nvps,
-                      TAO_TRY_ENV);
+      NameValuePairSeq* nvps = fa1->get_members (TAO_TRY_ENV);
+      CORBA_DynStruct_ptr sm =
+        this->orb_->create_dyn_struct (DynAnyTests::_tc_test_struct,
+                                       TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      sm->set_members (*nvps,
+                       TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      NameValuePairSeq* gm = sm.get_members (TAO_TRY_ENV);
+      NameValuePairSeq* gm = sm->get_members (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (ACE_OS::strcmp ((*gm)[2].id, "es"))
         ++this->error_count_;
@@ -152,12 +166,16 @@ Test_DynStruct::run_test (void)
       delete nvps;
       delete gm;
 
-      fa1.destroy (TAO_TRY_ENV);
+      fa1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      ftc1.destroy (TAO_TRY_ENV);
+      CORBA::release (fa1);
+      CORBA::release (dp1);
+      ftc1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      sm.destroy (TAO_TRY_ENV);
+      CORBA::release (ftc1);
+      sm->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
+      CORBA::release (sm);
     }
   TAO_CATCHANY
     {
diff --git a/TAO/tests/DynAny_Test/test_dynstruct.h b/TAO/tests/DynAny_Test/test_dynstruct.h
index b4329594411..770c496d672 100644
--- a/TAO/tests/DynAny_Test/test_dynstruct.h
+++ b/TAO/tests/DynAny_Test/test_dynstruct.h
@@ -19,6 +19,8 @@
 #if !defined (TEST_DYNSTRUCT_H)
 #define TEST_DYNSTRUCT_H
 
+#include "tao/corba.h"
+
 class Test_DynStruct
 {
 public:
diff --git a/TAO/tests/DynAny_Test/test_dynunion.cpp b/TAO/tests/DynAny_Test/test_dynunion.cpp
index 298fce3680d..33abad947ad 100644
--- a/TAO/tests/DynAny_Test/test_dynunion.cpp
+++ b/TAO/tests/DynAny_Test/test_dynunion.cpp
@@ -16,8 +16,6 @@
 //
 // ============================================================================
 
-#include "tao/corba.h"
-#include "tao/DynUnion_i.h"
 #include "test_dynunion.h"
 #include "da_testsC.h"
 #include "data.h"
@@ -58,13 +56,20 @@ Test_DynUnion::run_test (void)
                  "testing: constructor(Any)/insert/get\n"));
 
       tu._d(DynAnyTests::FIRST);
+      tu.s (data.m_short2);
       CORBA_Any in_any1;
       in_any1 <<= tu;
-      TAO_DynUnion_i fa1 (in_any1);
-      fa1.insert_short (data.m_short1,
+      CORBA_DynAny_ptr dp1 =
+        this->orb_->create_dyn_any (in_any1,
+                                    TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA_DynUnion_ptr fa1 = CORBA_DynUnion::_narrow (dp1,
+                                                        TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      fa1->insert_short (data.m_short1,
                          TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Short s_out1 = fa1.get_short (TAO_TRY_ENV);
+      CORBA::Short s_out1 = fa1->get_short (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (s_out1 == data.m_short1)
         ACE_DEBUG ((LM_DEBUG,
@@ -75,13 +80,16 @@ Test_DynUnion::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: constructor(TypeCode)/from_any/to_any\n"));
 
-      CORBA_Any* out_any1 = fa1.to_any (TAO_TRY_ENV);
+      CORBA_Any* out_any1 = fa1->to_any (TAO_TRY_ENV);
+      TAO_CHECK_ENV;
+      CORBA_DynUnion_ptr ftc1 = 
+        this->orb_->create_dyn_union (DynAnyTests::_tc_test_union,
+                                      TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      TAO_DynUnion_i ftc1 (DynAnyTests::_tc_test_union);
-      ftc1.from_any (*out_any1,
-                     TAO_TRY_ENV);
+      ftc1->from_any (*out_any1,
+                      TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::Short s_out2 = ftc1.get_short (TAO_TRY_ENV);
+      CORBA::Short s_out2 = ftc1->get_short (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (s_out2 == data.m_short1)
         ACE_DEBUG ((LM_DEBUG,
@@ -95,51 +103,57 @@ Test_DynUnion::run_test (void)
       ACE_DEBUG ((LM_DEBUG,
                  "testing: set_as_default\n"));
 
-      if (!ftc1.set_as_default (TAO_TRY_ENV))
+      if (!ftc1->set_as_default (TAO_TRY_ENV))
         ACE_DEBUG ((LM_DEBUG,
                    "++ OK ++\n"));
       else 
         ++this->error_count_;
+
       TAO_CHECK_ENV;
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing:discriminator/discriminator_kind\n"));
 
-      CORBA_DynAny_ptr dp1 = ftc1.discriminator (TAO_TRY_ENV);
+      CORBA_DynAny_ptr dp2 = ftc1->discriminator (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      if (dp1->type (TAO_TRY_ENV)->kind () 
-            == ftc1.discriminator_kind (TAO_TRY_ENV))
+      if (dp2->type (TAO_TRY_ENV)->kind () 
+            == ftc1->discriminator_kind (TAO_TRY_ENV))
         ACE_DEBUG ((LM_DEBUG,
                    "++ OK ++\n"));
       else 
-        ++this->error_count_;        
+        ++this->error_count_; 
+      
       TAO_CHECK_ENV;
 
       ACE_DEBUG ((LM_DEBUG,
                  "testing:member/member_kind/member_name\n"));
 
-      CORBA_DynAny_ptr dp2 = ftc1.member (TAO_TRY_ENV);
+      CORBA_DynAny_ptr dp3 = ftc1->member (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::String m_nm = ftc1.member_name (TAO_TRY_ENV);
+      CORBA::String m_nm = ftc1->member_name (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      CORBA::TCKind tk = ftc1.member_kind (TAO_TRY_ENV);
+      CORBA::TCKind tk = ftc1->member_kind (TAO_TRY_ENV);
       TAO_CHECK_ENV;
       if (!ACE_OS::strcmp (m_nm, "s")         && 
           tk == CORBA::tk_short               &&
-          dp2->get_short (TAO_TRY_ENV) == data.m_short1)
+          dp3->get_short (TAO_TRY_ENV) == data.m_short1)
         ACE_DEBUG ((LM_DEBUG,
                    "++ OK ++\n"));
       else 
         ++this->error_count_; 
-      
-      fa1.destroy (TAO_TRY_ENV);
-      TAO_CHECK_ENV;
-      ftc1.destroy (TAO_TRY_ENV);
+
       TAO_CHECK_ENV;
-      dp1->destroy (TAO_TRY_ENV);
+
+      // Created with string_dup
+      CORBA::string_free (m_nm);
+      
+      fa1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
-      dp2->destroy (TAO_TRY_ENV);
+      CORBA::release (fa1);
+      CORBA::release (dp1);
+      ftc1->destroy (TAO_TRY_ENV);
       TAO_CHECK_ENV;
+      CORBA::release (ftc1);
     }
   TAO_CATCHANY
     {
diff --git a/TAO/tests/DynAny_Test/test_dynunion.h b/TAO/tests/DynAny_Test/test_dynunion.h
index f9a04f1e3ab..0f5c7c51ab0 100644
--- a/TAO/tests/DynAny_Test/test_dynunion.h
+++ b/TAO/tests/DynAny_Test/test_dynunion.h
@@ -19,6 +19,8 @@
 #if !defined (TEST_DYNUNION_H)
 #define TEST_DYNUNION_H
 
+#include "tao/corba.h"
+
 class Test_DynUnion
 {
 public: