Replaced all 'new' with 'ACE_NEW*'.

33 files changed, 2200 insertions, 456 deletions

diff --git a/TAO/tao/BoundsC.cpp b/TAO/tao/BoundsC.cpp
index e8700b87d7c..066ea238716 100644
--- a/TAO/tao/BoundsC.cpp
+++ b/TAO/tao/BoundsC.cpp
@@ -58,14 +58,22 @@ void CORBA_Bounds::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_Bounds::_alloc (void)
 {
-  return new CORBA_Bounds;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_Bounds,
+                  0);
+
+  return retval;
 }
 
 
 
 void operator<<= (CORBA::Any &_tao_any, const CORBA::Bounds &_tao_elem) // copying
 {
-  CORBA::Bounds *_tao_any_val = new CORBA::Bounds (_tao_elem);
+  CORBA::Bounds *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           CORBA::Bounds (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
diff --git a/TAO/tao/CONV_FRAMEC.i b/TAO/tao/CONV_FRAMEC.i
index 985bcc50e7c..5d07522a858 100644
--- a/TAO/tao/CONV_FRAMEC.i
+++ b/TAO/tao/CONV_FRAMEC.i
@@ -18,7 +18,7 @@ ACE_INLINE
 CONV_FRAME::CodeSetComponent_var::CodeSetComponent_var (const CONV_FRAME::CodeSetComponent_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CONV_FRAME::CodeSetComponent(*p.ptr_);
+    ACE_NEW (this->ptr_, CONV_FRAME::CodeSetComponent(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -43,7 +43,9 @@ CONV_FRAME::CodeSetComponent_var::operator= (const CONV_FRAME::CodeSetComponent_
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CONV_FRAME::CodeSetComponent (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CONV_FRAME::CodeSetComponent (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -180,7 +182,9 @@ CONV_FRAME::CodeSetComponent_out::operator-> (void)
   CONV_FRAME::CodeSetComponent::_TAO_Unbounded_Sequence_CONV_FRAME_CodeSetComponent__tao_seq_CodeSetId::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA::ULong[size];
+    CORBA::ULong *retval = 0;
+    ACE_NEW_RETURN (retval, CORBA::ULong[size], 0);
+    return retval;
   }
 
   ACE_INLINE void CONV_FRAME::CodeSetComponent::_TAO_Unbounded_Sequence_CONV_FRAME_CodeSetComponent__tao_seq_CodeSetId::freebuf (CORBA::ULong *buffer)
@@ -357,7 +361,7 @@ ACE_INLINE
 CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId_var::_tao_seq_CodeSetId_var (const CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId(*p.ptr_);
+    ACE_NEW (this->ptr_, CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -382,7 +386,9 @@ CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId_var::operator= (const CONV_FRAM
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CONV_FRAME::CodeSetComponent::_tao_seq_CodeSetId (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -541,7 +547,7 @@ ACE_INLINE
 CONV_FRAME::CodeSetComponentInfo_var::CodeSetComponentInfo_var (const CONV_FRAME::CodeSetComponentInfo_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CONV_FRAME::CodeSetComponentInfo(*p.ptr_);
+    ACE_NEW (this->ptr_, CONV_FRAME::CodeSetComponentInfo(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -566,7 +572,9 @@ CONV_FRAME::CodeSetComponentInfo_var::operator= (const CONV_FRAME::CodeSetCompon
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CONV_FRAME::CodeSetComponentInfo (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CONV_FRAME::CodeSetComponentInfo (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -710,7 +718,7 @@ ACE_INLINE
 CONV_FRAME::CodeSetContext_var::CodeSetContext_var (const CONV_FRAME::CodeSetContext_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CONV_FRAME::CodeSetContext(*p.ptr_);
+    ACE_NEW (this->ptr_, CONV_FRAME::CodeSetContext(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -735,7 +743,9 @@ CONV_FRAME::CodeSetContext_var::operator= (const CONV_FRAME::CodeSetContext_var
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CONV_FRAME::CodeSetContext (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CONV_FRAME::CodeSetContext (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/CurrentC.cpp b/TAO/tao/CurrentC.cpp
index 689fc2a63ed..edc4f93b848 100644
--- a/TAO/tao/CurrentC.cpp
+++ b/TAO/tao/CurrentC.cpp
@@ -47,10 +47,17 @@ CORBA_Current_ptr CORBA_Current::_narrow (
          || (servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/Current:1.0")) == 0
       )
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_Current::_nil ());
-  return new POA_CORBA::_tao_collocated_Current(
-      ACE_reinterpret_cast(POA_CORBA::Current_ptr, servant),
-      0
+  CORBA_Current_ptr retval = CORBA_Current::_nil ();
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_Current (
+          ACE_reinterpret_cast (POA_CORBA::Current_ptr, 
+                                servant),
+          0
+        ),
+      CORBA_Current::_nil ()
     );
+  return retval;
 }
 
 CORBA_Current_ptr CORBA_Current::_nil (void)
diff --git a/TAO/tao/CurrentS.cpp b/TAO/tao/CurrentS.cpp
index 6b31268b162..f661cc5a03e 100644
--- a/TAO/tao/CurrentS.cpp
+++ b/TAO/tao/CurrentS.cpp
@@ -86,5 +86,9 @@ POA_CORBA::Current::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_Current (this, stub);
+  CORBA::Current *retval = CORBA_Current::_nil ();
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_Current (this, stub),
+                  CORBA_Current::_nil ());
+  return retval;
 }
diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp
index 94173c6170f..1f8fae36e32 100644
--- a/TAO/tao/DomainC.cpp
+++ b/TAO/tao/DomainC.cpp
@@ -59,12 +59,29 @@ CORBA_DomainManager_ptr CORBA_DomainManager::_unchecked_narrow (
   void* servant = 0;
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/DomainManager:1.0");
+
+  CORBA_DomainManager_ptr retval = CORBA_DomainManager::_nil ();
+
   if (servant == 0)
-    return new CORBA_DomainManager(stub);
-  return new POA_CORBA::_tao_collocated_DomainManager(
-      ACE_reinterpret_cast(POA_CORBA::DomainManager_ptr, servant),
-      stub
-    );
+    {
+      ACE_NEW_RETURN (retval,
+                      CORBA_DomainManager (stub),
+                      CORBA_DomainManager::_nil ());
+    }
+  else
+    {
+      ACE_NEW_RETURN (
+          retval,
+          POA_CORBA::_tao_collocated_DomainManager (
+              ACE_reinterpret_cast (POA_CORBA::DomainManager_ptr, 
+                                    servant),
+              stub
+            ),
+          CORBA_DomainManager::_nil ()
+        );
+    }
+
+  return retval;
 }
 
 CORBA_DomainManager_ptr
@@ -162,18 +179,35 @@ CORBA::ConstructionPolicy_ptr CORBA::ConstructionPolicy::_narrow (
   TAO_Stub* stub = obj->_stubobj ();
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/ConstructionPolicy:1.0");
+
+  CORBA::ConstructionPolicy_ptr retval = 
+    CORBA::ConstructionPolicy::_nil ();
+
 #if defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA::ConstructionPolicy::_nil ());
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new CORBA::ConstructionPolicy(stub);
+    {
+      ACE_NEW_RETURN (retval,
+                      CORBA::ConstructionPolicy (stub),
+                      CORBA::ConstructionPolicy::_nil ());
+
+      return retval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_CORBA::_tao_collocated_ConstructionPolicy(
-      ACE_reinterpret_cast(POA_CORBA::ConstructionPolicy_ptr, servant),
-      stub
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_ConstructionPolicy (
+          ACE_reinterpret_cast (POA_CORBA::ConstructionPolicy_ptr, 
+                                servant), 
+          stub
+        ),
+      CORBA::ConstructionPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::ConstructionPolicy_ptr
diff --git a/TAO/tao/DomainC.i b/TAO/tao/DomainC.i
index b8c7ae4f439..719e03e5561 100644
--- a/TAO/tao/DomainC.i
+++ b/TAO/tao/DomainC.i
@@ -386,7 +386,7 @@ ACE_INLINE
 CORBA_DomainManagerList_var::CORBA_DomainManagerList_var (const CORBA_DomainManagerList_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_DomainManagerList(*p.ptr_);
+    ACE_NEW (this->ptr_, CORBA_DomainManagerList(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -411,7 +411,9 @@ CORBA_DomainManagerList_var::operator= (const CORBA_DomainManagerList_var &p) //
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_DomainManagerList (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_DomainManagerList (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/DomainS.cpp b/TAO/tao/DomainS.cpp
index 719e16da136..c2d9fc03df2 100644
--- a/TAO/tao/DomainS.cpp
+++ b/TAO/tao/DomainS.cpp
@@ -225,7 +225,15 @@ POA_CORBA::DomainManager::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_DomainManager (this, stub);
+
+  CORBA::DomainManager *retval = CORBA_DomainManager::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DomainManager (this, 
+                                                            stub),
+                  CORBA_DomainManager::_nil ());
+
+  return retval;
 }
 
 POA_CORBA::_tao_collocated_DomainManager::_tao_collocated_DomainManager (
@@ -480,7 +488,16 @@ POA_CORBA::ConstructionPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_ConstructionPolicy (this, stub);
+
+  CORBA::ConstructionPolicy *retval = 
+    CORBA_ConstructionPolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_ConstructionPolicy (this, 
+                                                                 stub),
+                  CORBA_ConstructionPolicy::_nil ());
+
+  return retval;
 }
 
 POA_CORBA::_tao_collocated_ConstructionPolicy::_tao_collocated_ConstructionPolicy (
diff --git a/TAO/tao/DynAnyC.cpp b/TAO/tao/DynAnyC.cpp
index 507955e6ecf..2664d49b0bf 100644
--- a/TAO/tao/DynAnyC.cpp
+++ b/TAO/tao/DynAnyC.cpp
@@ -59,11 +59,20 @@ CORBA_DynAny_ptr CORBA_DynAny::_narrow (CORBA::Object_ptr obj,
       || !obj->_servant ()
       || (servant = obj->_servant ()->_downcast ("IDL:/CORBA_DynAny:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_DynAny::_nil ());
-  return new POA_CORBA::_tao_collocated_DynAny (
-    ACE_reinterpret_cast (POA_CORBA::DynAny_ptr,
-                          servant),
-    0
-  );
+
+  CORBA_DynAny_ptr retval = CORBA_DynAny::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DynAny (
+          ACE_reinterpret_cast (POA_CORBA::DynAny_ptr,
+                                servant),
+          0
+        ),
+      CORBA_DynAny::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA_DynAny_ptr CORBA_DynAny::_nil (void)
@@ -117,7 +126,13 @@ void CORBA_DynAny::Invalid::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_DynAny::Invalid::_alloc (void)
 {
-  return new CORBA_DynAny::Invalid;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_DynAny::Invalid,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_CORBA_DynAny_Invalid[] =
@@ -197,7 +212,13 @@ void CORBA_DynAny::InvalidValue::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_DynAny::InvalidValue::_alloc (void)
 {
-  return new CORBA_DynAny::InvalidValue;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_DynAny::InvalidValue,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_CORBA_DynAny_InvalidValue[] =
@@ -281,7 +302,13 @@ void CORBA_DynAny::TypeMismatch::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_DynAny::TypeMismatch::_alloc (void)
 {
-  return new CORBA_DynAny::TypeMismatch;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_DynAny::TypeMismatch,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_CORBA_DynAny_TypeMismatch[] =
@@ -364,7 +391,13 @@ void CORBA_DynAny::InvalidSeq::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_DynAny::InvalidSeq::_alloc (void)
 {
-  return new CORBA_DynAny::InvalidSeq;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_DynAny::InvalidSeq,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_CORBA_DynAny_InvalidSeq[] =
@@ -714,11 +747,20 @@ CORBA_DynEnum_ptr CORBA_DynEnum::_narrow (CORBA::Object_ptr obj,
       || !obj->_servant ()
       || (servant = obj->_servant ()->_downcast ("IDL:/CORBA_DynEnum:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_DynEnum::_nil ());
-  return new POA_CORBA::_tao_collocated_DynEnum (
-    ACE_reinterpret_cast (POA_CORBA::DynEnum_ptr,
-                          servant),
-    0
-  );
+
+  CORBA_DynEnum_ptr retval = CORBA_DynEnum::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DynEnum (
+          ACE_reinterpret_cast (POA_CORBA::DynEnum_ptr,
+                                servant),
+          0
+        ),
+      CORBA_DynEnum::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA_DynEnum_ptr CORBA_DynEnum::_nil (void)
@@ -866,11 +908,20 @@ CORBA_DynStruct_ptr CORBA_DynStruct::_narrow (CORBA::Object_ptr obj,
       || !obj->_servant ()
       || (servant = obj->_servant ()->_downcast ("IDL:/CORBA_DynStruct:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (),  CORBA_DynStruct::_nil ());
-  return new POA_CORBA::_tao_collocated_DynStruct (
-    ACE_reinterpret_cast (POA_CORBA::DynStruct_ptr,
-                          servant),
-    0
-  );
+
+  CORBA_DynStruct_ptr retval = CORBA_DynStruct::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DynStruct (
+          ACE_reinterpret_cast (POA_CORBA::DynStruct_ptr,
+                                servant),
+          0
+        ),
+      CORBA_DynStruct::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA_DynStruct_ptr CORBA_DynStruct::_nil (void)
@@ -969,11 +1020,20 @@ CORBA_DynUnion_ptr CORBA_DynUnion::_narrow (CORBA::Object_ptr obj,
       || !obj->_servant ()
       || (servant = obj->_servant ()->_downcast ("IDL:/CORBA_DynUnion:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_DynUnion::_nil ());
-  return new POA_CORBA::_tao_collocated_DynUnion (
-    ACE_reinterpret_cast (POA_CORBA::DynUnion_ptr,
-                          servant),
-    0
-  );
+
+  CORBA_DynUnion_ptr retval = CORBA_DynUnion::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DynUnion (
+          ACE_reinterpret_cast (POA_CORBA::DynUnion_ptr,
+                                servant),
+          0
+        ),
+      CORBA_DynUnion::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA_DynUnion_ptr CORBA_DynUnion::_nil (void)
@@ -1151,11 +1211,20 @@ CORBA_DynSequence_ptr CORBA_DynSequence::_narrow (CORBA::Object_ptr obj,
       || !obj->_servant ()
       || (servant = obj->_servant ()->_downcast ("IDL:/CORBA_DynSequence:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_DynSequence::_nil ());
-  return new POA_CORBA::_tao_collocated_DynSequence (
-    ACE_reinterpret_cast (POA_CORBA::DynSequence_ptr,
-                          servant),
-    0
-  );
+
+  CORBA_DynSequence_ptr retval = CORBA_DynSequence::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DynSequence (
+          ACE_reinterpret_cast (POA_CORBA::DynSequence_ptr,
+                                servant),
+          0
+        ),
+      CORBA_DynSequence::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA_DynSequence_ptr CORBA_DynSequence::_nil (void)
@@ -1256,11 +1325,20 @@ CORBA_DynArray_ptr CORBA_DynArray::_narrow (CORBA::Object_ptr obj,
       || !obj->_servant ()
       || (servant = obj->_servant ()->_downcast ("IDL:/CORBA_DynArray:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_DynArray::_nil ());
-  return new POA_CORBA::_tao_collocated_DynArray (
-    ACE_reinterpret_cast (POA_CORBA::DynArray_ptr,
-                          servant),
-    0
-  );
+
+  CORBA_DynArray_ptr retval = CORBA_DynArray::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DynArray (
+          ACE_reinterpret_cast (POA_CORBA::DynArray_ptr,
+                                servant),
+          0
+        ),
+      CORBA_DynArray::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA_DynArray_ptr CORBA_DynArray::_nil (void)
diff --git a/TAO/tao/DynAnyC.i b/TAO/tao/DynAnyC.i
index a495904948f..422c678371a 100644
--- a/TAO/tao/DynAnyC.i
+++ b/TAO/tao/DynAnyC.i
@@ -430,7 +430,7 @@ ACE_INLINE
 CORBA_NameValuePair_var::CORBA_NameValuePair_var (const CORBA_NameValuePair_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_NameValuePair(*p.ptr_);
+    ACE_NEW (this->ptr_, CORBA_NameValuePair(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -455,7 +455,9 @@ CORBA_NameValuePair_var::operator= (const CORBA_NameValuePair_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_NameValuePair (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_NameValuePair (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -599,7 +601,7 @@ ACE_INLINE
 CORBA_NameValuePairSeq_var::CORBA_NameValuePairSeq_var (const CORBA_NameValuePairSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_NameValuePairSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, CORBA_NameValuePairSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -624,7 +626,9 @@ CORBA_NameValuePairSeq_var::operator= (const CORBA_NameValuePairSeq_var &p) // d
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_NameValuePairSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_NameValuePairSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -1154,7 +1158,7 @@ ACE_INLINE
 CORBA_AnySeq_var::CORBA_AnySeq_var (const CORBA_AnySeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_AnySeq(*p.ptr_);
+    ACE_NEW (this->ptr_, CORBA_AnySeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -1179,7 +1183,9 @@ CORBA_AnySeq_var::operator= (const CORBA_AnySeq_var &p) // deep copy
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_AnySeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_AnySeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/DynAnyS.cpp b/TAO/tao/DynAnyS.cpp
index e74f8a6a3a1..d66354c957b 100644
--- a/TAO/tao/DynAnyS.cpp
+++ b/TAO/tao/DynAnyS.cpp
@@ -575,8 +575,14 @@ POA_CORBA::DynAny::_this (CORBA_Environment &ACE_TRY_ENV)
 
   ACE_CHECK_RETURN (0);
 
-  return new POA_CORBA::_tao_collocated_DynAny (this, 
-                                                stub);
+  CORBA_DynAny *retval = CORBA_DynAny::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DynAny (this, 
+                                                     stub),
+                  CORBA_DynAny::_nil ());
+
+  return retval;
 }
 
 // constructor
@@ -724,8 +730,14 @@ POA_CORBA::DynEnum::_this (CORBA_Environment &ACE_TRY_ENV)
 
   ACE_CHECK_RETURN (0);
 
-  return new POA_CORBA::_tao_collocated_DynEnum (this,
-                                                 stub);
+  CORBA_DynEnum *retval = CORBA_DynEnum::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DynEnum (this, 
+                                                      stub),
+                  CORBA_DynEnum::_nil ());
+
+  return retval;
 }
 
 // constructor
@@ -867,8 +879,14 @@ POA_CORBA::DynStruct::_this (CORBA_Environment &ACE_TRY_ENV)
 
   ACE_CHECK_RETURN (0);
 
-  return new POA_CORBA::_tao_collocated_DynStruct (this,
-                                                   stub);
+  CORBA_DynStruct *retval = CORBA_DynStruct::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DynStruct (this, 
+                                                        stub),
+                  CORBA_DynStruct::_nil ());
+
+  return retval;
 }
 
 // constructor
@@ -1049,8 +1067,14 @@ POA_CORBA::DynUnion::_this (CORBA_Environment &ACE_TRY_ENV)
 
   ACE_CHECK_RETURN (0);
 
-  return new POA_CORBA::_tao_collocated_DynUnion (this,
-                                                  stub);
+  CORBA_DynUnion *retval = CORBA_DynUnion::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DynUnion (this, 
+                                                       stub),
+                  CORBA_DynUnion::_nil ());
+
+  return retval;
 }
 
 // constructor
@@ -1192,8 +1216,14 @@ POA_CORBA::DynSequence::_this (CORBA_Environment &ACE_TRY_ENV)
 
   ACE_CHECK_RETURN (0);
 
-  return new POA_CORBA::_tao_collocated_DynSequence (this,
-                                                     stub);
+  CORBA_DynSequence *retval = CORBA_DynSequence::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DynSequence (this, 
+                                                          stub),
+                  CORBA_DynSequence::_nil ());
+
+  return retval;
 }
 
 // constructor
@@ -1312,8 +1342,14 @@ POA_CORBA::DynArray::_this (CORBA_Environment &ACE_TRY_ENV)
 
   ACE_CHECK_RETURN (0);
 
-  return new POA_CORBA::_tao_collocated_DynArray (this,
-                                                  stub);
+  CORBA_DynArray *retval = CORBA_DynArray::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DynArray (this, 
+                                                       stub),
+                  CORBA_DynArray::_nil ());
+
+  return retval;
 }
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
diff --git a/TAO/tao/IOPC.i b/TAO/tao/IOPC.i
index 2e758adc062..970fb04cb64 100644
--- a/TAO/tao/IOPC.i
+++ b/TAO/tao/IOPC.i
@@ -18,7 +18,8 @@ ACE_INLINE
 IOP::TaggedProfile_var::TaggedProfile_var (const IOP::TaggedProfile_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new IOP::TaggedProfile(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             IOP::TaggedProfile(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -43,7 +44,9 @@ IOP::TaggedProfile_var::operator= (const IOP::TaggedProfile_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new IOP::TaggedProfile (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    IOP::TaggedProfile (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -187,7 +190,8 @@ ACE_INLINE
 IOP::IOR_var::IOR_var (const IOP::IOR_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new IOP::IOR(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             IOP::IOR(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -212,7 +216,9 @@ IOP::IOR_var::operator= (const IOP::IOR_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new IOP::IOR (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    IOP::IOR (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -356,7 +362,8 @@ ACE_INLINE
 IOP::TaggedComponent_var::TaggedComponent_var (const IOP::TaggedComponent_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new IOP::TaggedComponent(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             IOP::TaggedComponent(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -381,7 +388,9 @@ IOP::TaggedComponent_var::operator= (const IOP::TaggedComponent_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new IOP::TaggedComponent (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    IOP::TaggedComponent (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -525,7 +534,8 @@ ACE_INLINE
 IOP::MultipleComponentProfile_var::MultipleComponentProfile_var (const IOP::MultipleComponentProfile_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new IOP::MultipleComponentProfile(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             IOP::MultipleComponentProfile(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -550,7 +560,9 @@ IOP::MultipleComponentProfile_var::operator= (const IOP::MultipleComponentProfil
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new IOP::MultipleComponentProfile (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    IOP::MultipleComponentProfile (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -706,7 +718,8 @@ ACE_INLINE
 IOP::ServiceContext_var::ServiceContext_var (const IOP::ServiceContext_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new IOP::ServiceContext(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             IOP::ServiceContext(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -731,7 +744,9 @@ IOP::ServiceContext_var::operator= (const IOP::ServiceContext_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new IOP::ServiceContext (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    IOP::ServiceContext (*p.ptr_),
+		    *this);
   }
   return *this;
 }
@@ -875,7 +890,8 @@ ACE_INLINE
 IOP::ServiceContextList_var::ServiceContextList_var (const IOP::ServiceContextList_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new IOP::ServiceContextList(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             IOP::ServiceContextList(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -900,7 +916,9 @@ IOP::ServiceContextList_var::operator= (const IOP::ServiceContextList_var &p) //
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new IOP::ServiceContextList (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    IOP::ServiceContextList (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/IORC.cpp b/TAO/tao/IORC.cpp
index b1ce06ee86e..27fefe3e31f 100644
--- a/TAO/tao/IORC.cpp
+++ b/TAO/tao/IORC.cpp
@@ -38,10 +38,21 @@ TAO_IOP::TAO_IOR_Manipulation_ptr TAO_IOP::TAO_IOR_Manipulation::_narrow (
       || (servant = obj->_servant ()->_downcast ("IDL:TAO_IOP/TAO_IOR_Manipulation:1.0")) == 0)
       // This can only be colocated
       ACE_THROW_RETURN (CORBA::MARSHAL (), TAO_IOP::TAO_IOR_Manipulation::_nil ());
-  return new POA_TAO_IOP::_tao_collocated_TAO_IOR_Manipulation(
-        ACE_reinterpret_cast(POA_TAO_IOP::TAO_IOR_Manipulation_ptr, servant),
-        0
-      );
+
+  TAO_IOP::TAO_IOR_Manipulation_ptr retval =
+    TAO_IOP::TAO_IOR_Manipulation::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_TAO_IOP::_tao_collocated_TAO_IOR_Manipulation (
+          ACE_reinterpret_cast (POA_TAO_IOP::TAO_IOR_Manipulation_ptr, 
+                                servant),
+          0
+        ),
+      TAO_IOP::TAO_IOR_Manipulation::_nil ()
+    );
+
+  return retval;
 }
 
 TAO_IOP::TAO_IOR_Manipulation_ptr
@@ -97,7 +108,13 @@ void TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList::_alloc (void)
 {
-  return new TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  TAO_IOP::TAO_IOR_Manipulation::EmptyProfileList,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_TAO_IOP_TAO_IOR_Manipulation_EmptyProfileList[] =
@@ -155,7 +172,13 @@ void TAO_IOP::TAO_IOR_Manipulation::NotFound::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::NotFound::_alloc (void)
 {
-  return new TAO_IOP::TAO_IOR_Manipulation::NotFound;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  TAO_IOP::TAO_IOR_Manipulation::NotFound,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_TAO_IOP_TAO_IOR_Manipulation_NotFound[] =
@@ -213,7 +236,13 @@ void TAO_IOP::TAO_IOR_Manipulation::Duplicate::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::Duplicate::_alloc (void)
 {
-  return new TAO_IOP::TAO_IOR_Manipulation::Duplicate;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  TAO_IOP::TAO_IOR_Manipulation::Duplicate,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_TAO_IOP_TAO_IOR_Manipulation_Duplicate[] =
@@ -271,7 +300,13 @@ void TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR::_alloc (void)
 {
-  return new TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  TAO_IOP::TAO_IOR_Manipulation::Invalid_IOR,
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_TAO_IOP_TAO_IOR_Manipulation_Invalid_IOR[] =
diff --git a/TAO/tao/IORC.i b/TAO/tao/IORC.i
index 74f2ebace5e..383f708619a 100644
--- a/TAO/tao/IORC.i
+++ b/TAO/tao/IORC.i
@@ -239,7 +239,8 @@ ACE_INLINE
 TAO_IOP::TAO_IOR_Manipulation::IORList_var::IORList_var (const TAO_IOP::TAO_IOR_Manipulation::IORList_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new TAO_IOP::TAO_IOR_Manipulation::IORList(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             TAO_IOP::TAO_IOR_Manipulation::IORList(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -264,7 +265,9 @@ TAO_IOP::TAO_IOR_Manipulation::IORList_var::operator= (const TAO_IOP::TAO_IOR_Ma
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new TAO_IOP::TAO_IOR_Manipulation::IORList (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    TAO_IOP::TAO_IOR_Manipulation::IORList (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/IORS.cpp b/TAO/tao/IORS.cpp
index 0e1b486e7d8..b3605f85a15 100644
--- a/TAO/tao/IORS.cpp
+++ b/TAO/tao/IORS.cpp
@@ -65,7 +65,16 @@ POA_TAO_IOP::TAO_IOR_Manipulation::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_TAO_IOP::_tao_collocated_TAO_IOR_Manipulation (this, stub);
+
+  TAO_IOP::TAO_IOR_Manipulation *retval =
+    TAO_IOP::TAO_IOR_Manipulation::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_TAO_IOP::_tao_collocated_TAO_IOR_Manipulation (this, 
+                                                                     stub),
+                  TAO_IOP::TAO_IOR_Manipulation::_nil ());
+
+  return retval;
 }
 
 void*
@@ -76,10 +85,17 @@ POA_TAO_IOP::TAO_IOR_Manipulation::_create_collocated_objref (
 {
   ACE_UNUSED_ARG (type);
   if (!strcmp ("IDL:TAO_IOP/TAO_IOR_Manipulation:1.0",repository_id))
-    return ACE_static_cast (
-        TAO_IOP::TAO_IOR_Manipulation_ptr,
-        new POA_TAO_IOP::_tao_collocated_TAO_IOR_Manipulation (this, stub)
-      );
+    {      
+      TAO_IOP::TAO_IOR_Manipulation *retval =
+        TAO_IOP::TAO_IOR_Manipulation::_nil ();
+
+      ACE_NEW_RETURN (retval,
+                      POA_TAO_IOP::_tao_collocated_TAO_IOR_Manipulation (this, 
+                                                                         stub),
+                      TAO_IOP::TAO_IOR_Manipulation::_nil ());
+
+      return retval;
+    }
   return 0;
 }
 
diff --git a/TAO/tao/InconsistentTypeCodeC.cpp b/TAO/tao/InconsistentTypeCodeC.cpp
index a876b606ba3..3480fea7a0b 100644
--- a/TAO/tao/InconsistentTypeCodeC.cpp
+++ b/TAO/tao/InconsistentTypeCodeC.cpp
@@ -80,7 +80,13 @@ void CORBA_ORB_InconsistentTypeCode::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_ORB_InconsistentTypeCode::_alloc (void)
 {
-  return new CORBA_ORB_InconsistentTypeCode;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ORB_InconsistentTypeCode,
+                  0);
+
+  return retval;
 }
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
diff --git a/TAO/tao/InterceptorC.cpp b/TAO/tao/InterceptorC.cpp
index 023f44e0632..68f32a9994a 100644
--- a/TAO/tao/InterceptorC.cpp
+++ b/TAO/tao/InterceptorC.cpp
@@ -31,10 +31,21 @@ PortableInterceptor::Cookie_ptr PortableInterceptor::Cookie::_narrow (
         || (servant = obj->_servant()->_downcast ("IDL:TAO/PortableInterceptor/Cookie:1.0")) == 0
       )
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableInterceptor::Cookie::_nil ());
-  return new POA_PortableInterceptor::_tao_direct_collocated_Cookie(
-      ACE_reinterpret_cast (POA_PortableInterceptor::Cookie_ptr, servant),
-      0
+
+  PortableInterceptor::Cookie_ptr retval = 
+    PortableInterceptor::Cookie::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableInterceptor::_tao_direct_collocated_Cookie (
+          ACE_reinterpret_cast (POA_PortableInterceptor::Cookie_ptr, 
+                                servant),
+          0
+        ),
+      PortableInterceptor::Cookie::_nil ()
     );
+
+  return retval;
 }
 
 PortableInterceptor::Cookie_ptr
@@ -235,10 +246,21 @@ PortableInterceptor::Interceptor_ptr PortableInterceptor::Interceptor::_narrow (
         || (servant = obj->_servant()->_downcast ("IDL:TAO/PortableInterceptor/Interceptor:1.0")) == 0
       )
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableInterceptor::Interceptor::_nil ());
-  return new POA_PortableInterceptor::_tao_direct_collocated_Interceptor(
-      ACE_reinterpret_cast (POA_PortableInterceptor::Interceptor_ptr, servant),
-      0
+
+  PortableInterceptor::Interceptor_ptr retval = 
+    PortableInterceptor::Interceptor::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableInterceptor::_tao_direct_collocated_Interceptor (
+          ACE_reinterpret_cast (POA_PortableInterceptor::Interceptor_ptr, 
+                                servant),
+          0
+        ),
+      PortableInterceptor::Interceptor::_nil ()
     );
+
+  return retval;
 }
 
 PortableInterceptor::Interceptor_ptr
@@ -292,10 +314,21 @@ PortableInterceptor::ServerRequestInterceptor_ptr PortableInterceptor::ServerReq
         || (servant = obj->_servant()->_downcast ("IDL:TAO/PortableInterceptor/ServerRequestInterceptor:1.0")) == 0
       )
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableInterceptor::ServerRequestInterceptor::_nil ());
-  return new POA_PortableInterceptor::_tao_direct_collocated_ServerRequestInterceptor(
-      ACE_reinterpret_cast (POA_PortableInterceptor::ServerRequestInterceptor_ptr, servant),
-      0
+
+  PortableInterceptor::ServerRequestInterceptor_ptr retval = 
+    PortableInterceptor::ServerRequestInterceptor::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableInterceptor::_tao_direct_collocated_ServerRequestInterceptor (
+          ACE_reinterpret_cast (POA_PortableInterceptor::ServerRequestInterceptor_ptr, 
+                                servant),
+          0
+        ),
+      PortableInterceptor::ServerRequestInterceptor::_nil ()
     );
+
+  return retval;
 }
 
 PortableInterceptor::ServerRequestInterceptor_ptr
@@ -350,10 +383,21 @@ PortableInterceptor::ClientRequestInterceptor_ptr PortableInterceptor::ClientReq
         || (servant = obj->_servant()->_downcast ("IDL:TAO/PortableInterceptor/ClientRequestInterceptor:1.0")) == 0
       )
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableInterceptor::ClientRequestInterceptor::_nil ());
-  return new POA_PortableInterceptor::_tao_direct_collocated_ClientRequestInterceptor(
-      ACE_reinterpret_cast (POA_PortableInterceptor::ClientRequestInterceptor_ptr, servant),
-      0
+
+  PortableInterceptor::ClientRequestInterceptor_ptr retval = 
+    PortableInterceptor::ClientRequestInterceptor::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableInterceptor::_tao_direct_collocated_ClientRequestInterceptor (
+          ACE_reinterpret_cast (POA_PortableInterceptor::ClientRequestInterceptor_ptr, 
+                                servant),
+          0
+        ),
+      PortableInterceptor::ClientRequestInterceptor::_nil ()
     );
+
+  return retval;
 }
 
 PortableInterceptor::ClientRequestInterceptor_ptr
diff --git a/TAO/tao/InterceptorC.i b/TAO/tao/InterceptorC.i
index 70c548b1ad1..4e1c7934391 100644
--- a/TAO/tao/InterceptorC.i
+++ b/TAO/tao/InterceptorC.i
@@ -366,7 +366,7 @@ ACE_INLINE
 PortableInterceptor::Cookies_var::Cookies_var (const PortableInterceptor::Cookies_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new PortableInterceptor::Cookies(*p.ptr_);
+    ACE_NEW (this->ptr_, PortableInterceptor::Cookies(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -391,7 +391,9 @@ PortableInterceptor::Cookies_var::operator= (const PortableInterceptor::Cookies_
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new PortableInterceptor::Cookies (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    PortableInterceptor::Cookies (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/InterceptorS.cpp b/TAO/tao/InterceptorS.cpp
index 8e41fec4137..2b0e143b5cf 100644
--- a/TAO/tao/InterceptorS.cpp
+++ b/TAO/tao/InterceptorS.cpp
@@ -56,7 +56,16 @@ POA_PortableInterceptor::Cookie::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableInterceptor::_tao_direct_collocated_Cookie (this, stub);
+
+  PortableInterceptor::Cookie *retval =
+    PortableInterceptor::Cookie::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableInterceptor::_tao_direct_collocated_Cookie (this, 
+                                                                          stub),
+                  PortableInterceptor::Cookie::_nil ());
+
+  return retval;
 }
 
 POA_PortableInterceptor::_tao_direct_collocated_Cookie::_tao_direct_collocated_Cookie (
@@ -150,7 +159,18 @@ POA_PortableInterceptor::Interceptor::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableInterceptor::_tao_direct_collocated_Interceptor (this, stub);
+
+  PortableInterceptor::Interceptor *retval =
+    PortableInterceptor::Interceptor::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableInterceptor::_tao_direct_collocated_Interceptor (this, 
+                                                                   stub),
+      PortableInterceptor::Interceptor::_nil ()
+    );
+
+  return retval;
 }
 
 POA_PortableInterceptor::_tao_direct_collocated_Interceptor::_tao_direct_collocated_Interceptor (
@@ -247,7 +267,18 @@ POA_PortableInterceptor::ServerRequestInterceptor::_this (CORBA_Environment &ACE
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableInterceptor::_tao_direct_collocated_ServerRequestInterceptor (this, stub);
+
+  PortableInterceptor::ServerRequestInterceptor *retval =
+    PortableInterceptor::ServerRequestInterceptor::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableInterceptor::_tao_direct_collocated_ServerRequestInterceptor (this, 
+                                                                                stub),
+      PortableInterceptor::ServerRequestInterceptor::_nil ()
+    );
+
+  return retval;
 }
 
 POA_PortableInterceptor::_tao_direct_collocated_ServerRequestInterceptor::_tao_direct_collocated_ServerRequestInterceptor (
@@ -403,7 +434,18 @@ POA_PortableInterceptor::ClientRequestInterceptor::_this (CORBA_Environment &ACE
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableInterceptor::_tao_direct_collocated_ClientRequestInterceptor (this, stub);
+
+  PortableInterceptor::ClientRequestInterceptor *retval =
+    PortableInterceptor::ClientRequestInterceptor::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableInterceptor::_tao_direct_collocated_ClientRequestInterceptor (this, 
+                                                                                stub),
+      PortableInterceptor::ClientRequestInterceptor::_nil ()
+    );
+
+  return retval;
 }
 
 POA_PortableInterceptor::_tao_direct_collocated_ClientRequestInterceptor::_tao_direct_collocated_ClientRequestInterceptor (
diff --git a/TAO/tao/InterfaceC.cpp b/TAO/tao/InterfaceC.cpp
index 742a6f90d0a..5117de04486 100644
--- a/TAO/tao/InterfaceC.cpp
+++ b/TAO/tao/InterfaceC.cpp
@@ -117,7 +117,14 @@ CORBA_IRObject_ptr CORBA_IRObject::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_IRObject(stub);
+
+  CORBA_IRObject_ptr retval = CORBA_IRObject::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_IRObject (stub),
+                  CORBA_IRObject::_nil ());
+
+  return retval;
 }
 
 CORBA_IRObject_ptr 
@@ -295,7 +302,14 @@ CORBA_Contained_ptr CORBA_Contained::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_Contained(stub);
+
+  CORBA_Contained_ptr retval = CORBA_Contained::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_Contained (stub),
+                  CORBA_Contained::_nil ());
+
+  return retval;
 }
 
 CORBA_Contained_ptr 
@@ -2035,7 +2049,14 @@ CORBA_Container_ptr CORBA_Container::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_Container(stub);
+
+  CORBA_Container_ptr retval = CORBA_Container::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_Container (stub),
+                  CORBA_Container::_nil ());
+
+  return retval;
 }
 
 CORBA_Container_ptr 
@@ -3223,7 +3244,14 @@ CORBA_IDLType_ptr CORBA_IDLType::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_IDLType(stub);
+
+  CORBA_IDLType_ptr retval = CORBA_IDLType::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_IDLType (stub),
+                  CORBA_IDLType::_nil ());
+
+  return retval;
 }
 
 CORBA_IDLType_ptr 
@@ -3375,7 +3403,14 @@ CORBA_Repository_ptr CORBA_Repository::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_Repository(stub);
+
+  CORBA_Repository_ptr retval = CORBA_Repository::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_Repository (stub),
+                  CORBA_Repository::_nil ());
+
+  return retval;
 }
 
 CORBA_Repository_ptr 
@@ -3862,7 +3897,14 @@ CORBA_ModuleDef_ptr CORBA_ModuleDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_ModuleDef(stub);
+
+  CORBA_ModuleDef_ptr retval = CORBA_ModuleDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ModuleDef (stub),
+                  CORBA_ModuleDef::_nil ());
+
+  return retval;
 }
 
 CORBA_ModuleDef_ptr 
@@ -3979,7 +4021,14 @@ CORBA_ConstantDef_ptr CORBA_ConstantDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_ConstantDef(stub);
+
+  CORBA_ConstantDef_ptr retval = CORBA_ConstantDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ConstantDef (stub),
+                  CORBA_ConstantDef::_nil ());
+
+  return retval;
 }
 
 CORBA_ConstantDef_ptr 
@@ -4366,7 +4415,14 @@ CORBA_TypedefDef_ptr CORBA_TypedefDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_TypedefDef(stub);
+
+  CORBA_TypedefDef_ptr retval = CORBA_TypedefDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_TypedefDef (stub),
+                  CORBA_TypedefDef::_nil ());
+
+  return retval;
 }
 
 CORBA_TypedefDef_ptr 
@@ -4486,7 +4542,14 @@ CORBA_StructDef_ptr CORBA_StructDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_StructDef(stub);
+
+  CORBA_StructDef_ptr retval = CORBA_StructDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_StructDef (stub),
+                  CORBA_StructDef::_nil ());
+
+  return retval;
 }
 
 CORBA_StructDef_ptr 
@@ -4664,7 +4727,14 @@ CORBA_UnionDef_ptr CORBA_UnionDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_UnionDef(stub);
+
+  CORBA_UnionDef_ptr retval = CORBA_UnionDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_UnionDef (stub),
+                  CORBA_UnionDef::_nil ());
+
+  return retval;
 }
 
 CORBA_UnionDef_ptr 
@@ -5000,7 +5070,14 @@ CORBA_EnumDef_ptr CORBA_EnumDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_EnumDef(stub);
+
+  CORBA_EnumDef_ptr retval = CORBA_EnumDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_EnumDef (stub),
+                  CORBA_EnumDef::_nil ());
+
+  return retval;
 }
 
 CORBA_EnumDef_ptr 
@@ -5177,7 +5254,14 @@ CORBA_AliasDef_ptr CORBA_AliasDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_AliasDef(stub);
+
+  CORBA_AliasDef_ptr retval = CORBA_AliasDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_AliasDef (stub),
+                  CORBA_AliasDef::_nil ());
+
+  return retval;
 }
 
 CORBA_AliasDef_ptr 
@@ -5353,7 +5437,14 @@ CORBA_PrimitiveDef_ptr CORBA_PrimitiveDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_PrimitiveDef(stub);
+
+  CORBA_PrimitiveDef_ptr retval = CORBA_PrimitiveDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_PrimitiveDef (stub),
+                  CORBA_PrimitiveDef::_nil ());
+
+  return retval;
 }
 
 CORBA_PrimitiveDef_ptr 
@@ -5473,7 +5564,14 @@ CORBA_StringDef_ptr CORBA_StringDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_StringDef(stub);
+
+  CORBA_StringDef_ptr retval = CORBA_StringDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_StringDef (stub),
+                  CORBA_StringDef::_nil ());
+
+  return retval;
 }
 
 CORBA_StringDef_ptr 
@@ -5647,7 +5745,14 @@ CORBA_WstringDef_ptr CORBA_WstringDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_WstringDef(stub);
+
+  CORBA_WstringDef_ptr retval = CORBA_WstringDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_WstringDef (stub),
+                  CORBA_WstringDef::_nil ());
+
+  return retval;
 }
 
 CORBA_WstringDef_ptr 
@@ -5821,7 +5926,14 @@ CORBA_FixedDef_ptr CORBA_FixedDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_FixedDef(stub);
+
+  CORBA_FixedDef_ptr retval = CORBA_FixedDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_FixedDef (stub),
+                  CORBA_FixedDef::_nil ());
+
+  return retval;
 }
 
 CORBA_FixedDef_ptr 
@@ -6101,7 +6213,14 @@ CORBA_SequenceDef_ptr CORBA_SequenceDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_SequenceDef(stub);
+
+  CORBA_SequenceDef_ptr retval = CORBA_SequenceDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_SequenceDef (stub),
+                  CORBA_SequenceDef::_nil ());
+
+  return retval;
 }
 
 CORBA_SequenceDef_ptr 
@@ -6433,7 +6552,14 @@ CORBA_ArrayDef_ptr CORBA_ArrayDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_ArrayDef(stub);
+
+  CORBA_ArrayDef_ptr retval = CORBA_ArrayDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ArrayDef (stub),
+                  CORBA_ArrayDef::_nil ());
+
+  return retval;
 }
 
 CORBA_ArrayDef_ptr 
@@ -6765,7 +6891,14 @@ CORBA_ExceptionDef_ptr CORBA_ExceptionDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_ExceptionDef(stub);
+
+  CORBA_ExceptionDef_ptr retval = CORBA_ExceptionDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ExceptionDef (stub),
+                  CORBA_ExceptionDef::_nil ());
+
+  return retval;
 }
 
 CORBA_ExceptionDef_ptr 
@@ -7058,7 +7191,14 @@ CORBA_AttributeDef_ptr CORBA_AttributeDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_AttributeDef(stub);
+
+  CORBA_AttributeDef_ptr retval = CORBA_AttributeDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_AttributeDef (stub),
+                  CORBA_AttributeDef::_nil ());
+
+  return retval;
 }
 
 CORBA_AttributeDef_ptr 
@@ -8058,7 +8198,14 @@ CORBA_OperationDef_ptr CORBA_OperationDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_OperationDef(stub);
+
+  CORBA_OperationDef_ptr retval = CORBA_OperationDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_OperationDef (stub),
+                  CORBA_OperationDef::_nil ());
+
+  return retval;
 }
 
 CORBA_OperationDef_ptr 
@@ -9431,7 +9578,14 @@ CORBA_InterfaceDef_ptr CORBA_InterfaceDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_InterfaceDef(stub);
+
+  CORBA_InterfaceDef_ptr retval = CORBA_InterfaceDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_InterfaceDef (stub),
+                  CORBA_InterfaceDef::_nil ());
+
+  return retval;
 }
 
 CORBA_InterfaceDef_ptr 
@@ -10528,7 +10682,14 @@ CORBA_ValueMemberDef_ptr CORBA_ValueMemberDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_ValueMemberDef(stub);
+
+  CORBA_ValueMemberDef_ptr retval = CORBA_ValueMemberDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ValueMemberDef (stub),
+                  CORBA_ValueMemberDef::_nil ());
+
+  return retval;
 }
 
 CORBA_ValueMemberDef_ptr 
@@ -10860,7 +11021,14 @@ CORBA_ValueDef_ptr CORBA_ValueDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_ValueDef(stub);
+
+  CORBA_ValueDef_ptr retval = CORBA_ValueDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ValueDef (stub),
+                  CORBA_ValueDef::_nil ());
+
+  return retval;
 }
 
 CORBA_ValueDef_ptr 
@@ -12594,7 +12762,14 @@ CORBA_ValueBoxDef_ptr CORBA_ValueBoxDef::_unchecked_narrow (
       if (retv != 0)
         return retv;
     }
-  return new CORBA_ValueBoxDef(stub);
+
+  CORBA_ValueBoxDef_ptr retval = CORBA_ValueBoxDef::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_ValueBoxDef (stub),
+                  CORBA_ValueBoxDef::_nil ());
+
+  return retval;
 }
 
 CORBA_ValueBoxDef_ptr 
diff --git a/TAO/tao/InterfaceC.i b/TAO/tao/InterfaceC.i
index 4d9e2969ea5..ddaa35c812f 100644
--- a/TAO/tao/InterfaceC.i
+++ b/TAO/tao/InterfaceC.i
@@ -400,7 +400,8 @@ ACE_INLINE
 CORBA_Contained::Description_var::Description_var (const CORBA_Contained::Description_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_Contained::Description(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_Contained::Description(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -425,7 +426,9 @@ CORBA_Contained::Description_var::operator= (const CORBA_Contained::Description_
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_Contained::Description (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_Contained::Description (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -562,7 +565,9 @@ CORBA_Contained::Description_out::operator-> (void)
   {
     CORBA::InterfaceDef **buf = 0;
     
-    ACE_NEW_RETURN (buf, CORBA::InterfaceDef*[nelems], 0);
+    ACE_NEW_RETURN (buf, 
+                    CORBA::InterfaceDef*[nelems], 
+		    0);
     
     for (CORBA::ULong i = 0; i < nelems; i++)
       buf[i] = CORBA::InterfaceDef::_nil ();
@@ -721,7 +726,8 @@ ACE_INLINE
 CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (const CORBA_InterfaceDefSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA::InterfaceDefSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA::InterfaceDefSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -746,7 +752,9 @@ CORBA_InterfaceDefSeq_var::operator= (const CORBA::InterfaceDefSeq_var &p) // de
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA::InterfaceDefSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA::InterfaceDefSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -898,7 +906,9 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   {
     CORBA::ValueDef **buf = 0;
     
-    ACE_NEW_RETURN (buf, CORBA::ValueDef*[nelems], 0);
+    ACE_NEW_RETURN (buf, 
+                    CORBA::ValueDef*[nelems], 
+		    0);
     
     for (CORBA::ULong i = 0; i < nelems; i++)
       buf[i] = CORBA::ValueDef::_nil ();
@@ -1057,7 +1067,8 @@ ACE_INLINE
 CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (const CORBA::ValueDefSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA::ValueDefSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA::ValueDefSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -1082,7 +1093,9 @@ CORBA_ValueDefSeq_var::operator= (const CORBA::ValueDefSeq_var &p) // deep copy
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA::ValueDefSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA::ValueDefSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -1234,7 +1247,9 @@ CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
   {
     CORBA::Contained **buf = 0;
     
-    ACE_NEW_RETURN (buf, CORBA::Contained*[nelems], 0);
+    ACE_NEW_RETURN (buf, 
+                    CORBA::Contained*[nelems], 
+		    0);
     
     for (CORBA::ULong i = 0; i < nelems; i++)
       buf[i] = CORBA::Contained::_nil ();
@@ -1393,7 +1408,8 @@ ACE_INLINE
 CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (const CORBA_ContainedSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ContainedSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ContainedSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -1418,7 +1434,9 @@ CORBA_ContainedSeq_var::operator= (const CORBA_ContainedSeq_var &p) // deep copy
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ContainedSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ContainedSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -1577,7 +1595,8 @@ ACE_INLINE
 CORBA_StructMember_var::CORBA_StructMember_var (const CORBA_StructMember_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA::StructMember(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA::StructMember(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -1602,7 +1621,9 @@ CORBA_StructMember_var::operator= (const CORBA_StructMember_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA::StructMember (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA::StructMember (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -1739,7 +1760,11 @@ CORBA_StructMember_out::operator-> (void)
   _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_StructMember[size];
+    CORBA_StructMember *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_StructMember[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (CORBA_StructMember *buffer)
@@ -1916,7 +1941,8 @@ ACE_INLINE
 CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (const CORBA_StructMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_StructMemberSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_StructMemberSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -1941,7 +1967,9 @@ CORBA_StructMemberSeq_var::operator= (const CORBA_StructMemberSeq_var &p) // dee
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_StructMemberSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_StructMemberSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -2100,7 +2128,8 @@ ACE_INLINE
 CORBA_Initializer_var::CORBA_Initializer_var (const CORBA_Initializer_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_Initializer(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_Initializer(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2125,7 +2154,9 @@ CORBA_Initializer_var::operator= (const CORBA_Initializer_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_Initializer (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_Initializer (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -2262,7 +2293,11 @@ CORBA_Initializer_out::operator-> (void)
   _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_Initializer[size];
+    CORBA_Initializer *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_Initializer[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (CORBA_Initializer *buffer)
@@ -2439,7 +2474,8 @@ ACE_INLINE
 CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (const CORBA_InitializerSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_InitializerSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_InitializerSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2464,7 +2500,9 @@ CORBA_InitializerSeq_var::operator= (const CORBA_InitializerSeq_var &p) // deep
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_InitializerSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_InitializerSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -2623,7 +2661,8 @@ ACE_INLINE
 CORBA_UnionMember_var::CORBA_UnionMember_var (const CORBA_UnionMember_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_UnionMember(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_UnionMember(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2648,7 +2687,9 @@ CORBA_UnionMember_var::operator= (const CORBA_UnionMember_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_UnionMember (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_UnionMember (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -2785,7 +2826,11 @@ CORBA_UnionMember_out::operator-> (void)
   _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_UnionMember[size];
+    CORBA_UnionMember *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_UnionMember[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (CORBA_UnionMember *buffer)
@@ -2962,7 +3007,8 @@ ACE_INLINE
 CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (const CORBA_UnionMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_UnionMemberSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_UnionMemberSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2987,7 +3033,9 @@ CORBA_UnionMemberSeq_var::operator= (const CORBA_UnionMemberSeq_var &p) // deep
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_UnionMemberSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_UnionMemberSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -3150,7 +3198,8 @@ ACE_INLINE
 CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (const CORBA_EnumMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_EnumMemberSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_EnumMemberSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -3175,7 +3224,9 @@ CORBA_EnumMemberSeq_var::operator= (const CORBA_EnumMemberSeq_var &p) // deep co
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_EnumMemberSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_EnumMemberSeq (*p.ptr_), 
+	            *this);
   }
   return *this;
 }
@@ -3521,7 +3572,8 @@ ACE_INLINE
 CORBA_Container::Description_var::Description_var (const CORBA_Container::Description_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_Container::Description(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_Container::Description(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -3546,7 +3598,9 @@ CORBA_Container::Description_var::operator= (const CORBA_Container::Description_
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_Container::Description (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_Container::Description (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -3683,7 +3737,11 @@ CORBA_Container::Description_out::operator-> (void)
   CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_Container::Description[size];
+    CORBA_Container::Description *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_Container::Description[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (CORBA_Container::Description *buffer)
@@ -3860,7 +3918,8 @@ ACE_INLINE
 CORBA_Container::DescriptionSeq_var::DescriptionSeq_var (const CORBA_Container::DescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_Container::DescriptionSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_Container::DescriptionSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -3885,7 +3944,9 @@ CORBA_Container::DescriptionSeq_var::operator= (const CORBA_Container::Descripti
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_Container::DescriptionSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_Container::DescriptionSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -4605,7 +4666,8 @@ ACE_INLINE
 CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (const CORBA_ModuleDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ModuleDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ModuleDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -4630,7 +4692,9 @@ CORBA_ModuleDescription_var::operator= (const CORBA_ModuleDescription_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ModuleDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ModuleDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -4961,7 +5025,8 @@ ACE_INLINE
 CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (const CORBA_ConstantDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ConstantDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ConstantDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -4986,7 +5051,9 @@ CORBA_ConstantDescription_var::operator= (const CORBA_ConstantDescription_var &p
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ConstantDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ConstantDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -5317,7 +5384,8 @@ ACE_INLINE
 CORBA_TypeDescription_var::CORBA_TypeDescription_var (const CORBA_TypeDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_TypeDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_TypeDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -5342,7 +5410,9 @@ CORBA_TypeDescription_var::operator= (const CORBA_TypeDescription_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_TypeDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_TypeDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -7543,7 +7613,8 @@ ACE_INLINE
 CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (const CORBA_ExceptionDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ExceptionDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ExceptionDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -7568,7 +7639,9 @@ CORBA_ExceptionDescription_var::operator= (const CORBA_ExceptionDescription_var
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ExceptionDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ExceptionDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -7899,7 +7972,8 @@ ACE_INLINE
 CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (const CORBA_AttributeDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_AttributeDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_AttributeDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -7924,7 +7998,9 @@ CORBA_AttributeDescription_var::operator= (const CORBA_AttributeDescription_var
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_AttributeDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_AttributeDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -8068,7 +8144,8 @@ ACE_INLINE
 CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (const CORBA_ParameterDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ParameterDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ParameterDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -8093,7 +8170,9 @@ CORBA_ParameterDescription_var::operator= (const CORBA_ParameterDescription_var
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ParameterDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ParameterDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -8230,7 +8309,11 @@ CORBA_ParameterDescription_out::operator-> (void)
   _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_ParameterDescription[size];
+    CORBA_ParameterDescription *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_ParameterDescription[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA_ParameterDescription *buffer)
@@ -8407,7 +8490,8 @@ ACE_INLINE
 CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (const CORBA_ParDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ParDescriptionSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ParDescriptionSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -8432,7 +8516,9 @@ CORBA_ParDescriptionSeq_var::operator= (const CORBA_ParDescriptionSeq_var &p) //
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ParDescriptionSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ParDescriptionSeq (*p.ptr_),
+	            *this);
   }
   return *this;
 }
@@ -8595,7 +8681,8 @@ ACE_INLINE
 CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (const CORBA_ContextIdSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ContextIdSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ContextIdSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -8620,7 +8707,9 @@ CORBA_ContextIdSeq_var::operator= (const CORBA_ContextIdSeq_var &p) // deep copy
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ContextIdSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ContextIdSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -8931,7 +9020,8 @@ ACE_INLINE
 CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (const CORBA_ExceptionDefSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ExceptionDefSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ExceptionDefSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -8956,7 +9046,9 @@ CORBA_ExceptionDefSeq_var::operator= (const CORBA_ExceptionDefSeq_var &p) // dee
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ExceptionDefSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ExceptionDefSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -9108,7 +9200,11 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
   _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_ExceptionDescription[size];
+    CORBA_ExceptionDescription *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_ExceptionDescription[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA_ExceptionDescription *buffer)
@@ -9285,7 +9381,8 @@ ACE_INLINE
 CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (const CORBA_ExcDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ExcDescriptionSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ExcDescriptionSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -9310,7 +9407,9 @@ CORBA_ExcDescriptionSeq_var::operator= (const CORBA_ExcDescriptionSeq_var &p) //
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ExcDescriptionSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ExcDescriptionSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -9656,7 +9755,8 @@ ACE_INLINE
 CORBA_OperationDescription_var::CORBA_OperationDescription_var (const CORBA_OperationDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_OperationDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_OperationDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -9681,7 +9781,9 @@ CORBA_OperationDescription_var::operator= (const CORBA_OperationDescription_var
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_OperationDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_OperationDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -9829,7 +9931,8 @@ ACE_INLINE
 CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (const CORBA_RepositoryIdSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_RepositoryIdSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_RepositoryIdSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -9854,7 +9957,9 @@ CORBA_RepositoryIdSeq_var::operator= (const CORBA_RepositoryIdSeq_var &p) // dee
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_RepositoryIdSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_RepositoryIdSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -10006,7 +10111,11 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
   _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_OperationDescription[size];
+    CORBA_OperationDescription *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_OperationDescription[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA_OperationDescription *buffer)
@@ -10183,7 +10292,8 @@ ACE_INLINE
 CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (const CORBA_OpDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_OpDescriptionSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_OpDescriptionSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -10208,7 +10318,9 @@ CORBA_OpDescriptionSeq_var::operator= (const CORBA_OpDescriptionSeq_var &p) // d
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_OpDescriptionSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_OpDescriptionSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -10360,7 +10472,11 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
   _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_AttributeDescription[size];
+    CORBA_AttributeDescription *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_AttributeDescription[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA_AttributeDescription *buffer)
@@ -10537,7 +10653,8 @@ ACE_INLINE
 CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (const CORBA_AttrDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_AttrDescriptionSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_AttrDescriptionSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -10562,7 +10679,9 @@ CORBA_AttrDescriptionSeq_var::operator= (const CORBA_AttrDescriptionSeq_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_AttrDescriptionSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_AttrDescriptionSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -10908,7 +11027,8 @@ ACE_INLINE
 CORBA_InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (const CORBA_InterfaceDef::FullInterfaceDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_InterfaceDef::FullInterfaceDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_InterfaceDef::FullInterfaceDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -10933,7 +11053,9 @@ CORBA_InterfaceDef::FullInterfaceDescription_var::operator= (const CORBA_Interfa
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_InterfaceDef::FullInterfaceDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_InterfaceDef::FullInterfaceDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -11077,7 +11199,8 @@ ACE_INLINE
 CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (const CORBA_InterfaceDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_InterfaceDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_InterfaceDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -11102,7 +11225,9 @@ CORBA_InterfaceDescription_var::operator= (const CORBA_InterfaceDescription_var
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_InterfaceDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_InterfaceDescription (*p.ptr_),
+		    *this);
   }
   return *this;
 }
@@ -11246,7 +11371,8 @@ ACE_INLINE
 CORBA_ValueMember_var::CORBA_ValueMember_var (const CORBA_ValueMember_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ValueMember(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ValueMember(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -11271,7 +11397,9 @@ CORBA_ValueMember_var::operator= (const CORBA_ValueMember_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ValueMember (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ValueMember (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -11408,7 +11536,11 @@ CORBA_ValueMember_out::operator-> (void)
   _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    return new CORBA_ValueMember[size];
+    CORBA_ValueMember *retval = 0;
+    ACE_NEW_RETURN (retval,
+                    CORBA_ValueMember[size],
+		    0);
+    return retval;
   }
   
   ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA_ValueMember *buffer)
@@ -11585,7 +11717,8 @@ ACE_INLINE
 CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (const CORBA_ValueMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ValueMemberSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ValueMemberSeq(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -11610,7 +11743,9 @@ CORBA_ValueMemberSeq_var::operator= (const CORBA_ValueMemberSeq_var &p) // deep
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ValueMemberSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ValueMemberSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -12143,7 +12278,8 @@ ACE_INLINE
 CORBA_ValueDef::FullValueDescription_var::FullValueDescription_var (const CORBA_ValueDef::FullValueDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ValueDef::FullValueDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ValueDef::FullValueDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -12168,7 +12304,9 @@ CORBA_ValueDef::FullValueDescription_var::operator= (const CORBA_ValueDef::FullV
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ValueDef::FullValueDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ValueDef::FullValueDescription (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -12312,7 +12450,8 @@ ACE_INLINE
 CORBA_ValueDescription_var::CORBA_ValueDescription_var (const CORBA_ValueDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_ValueDescription(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_ValueDescription(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -12337,7 +12476,9 @@ CORBA_ValueDescription_var::operator= (const CORBA_ValueDescription_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_ValueDescription (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_ValueDescription (*p.ptr_),
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/MessagingC.cpp b/TAO/tao/MessagingC.cpp
index b16e51256d4..1a6b3adbf4f 100644
--- a/TAO/tao/MessagingC.cpp
+++ b/TAO/tao/MessagingC.cpp
@@ -196,10 +196,21 @@ Messaging::RebindPolicy_ptr Messaging::RebindPolicy::_unchecked_narrow (
     servant = obj->_servant()->_downcast ("IDL:Messaging/RebindPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::RebindPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_RebindPolicy(
-      ACE_reinterpret_cast(POA_Messaging::RebindPolicy_ptr, servant),
-      stub
+
+  Messaging::RebindPolicy_ptr retval = 
+    Messaging::RebindPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RebindPolicy (
+          ACE_reinterpret_cast (POA_Messaging::RebindPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::RebindPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::RebindPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -263,10 +274,21 @@ Messaging::SyncScopePolicy_ptr Messaging::SyncScopePolicy::_unchecked_narrow (
     servant = obj->_servant()->_downcast ("IDL:Messaging/SyncScopePolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::SyncScopePolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_SyncScopePolicy(
-      ACE_reinterpret_cast(POA_Messaging::SyncScopePolicy_ptr, servant),
-      stub
+
+  Messaging::SyncScopePolicy_ptr retval = 
+    Messaging::SyncScopePolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_SyncScopePolicy (
+          ACE_reinterpret_cast (POA_Messaging::SyncScopePolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::SyncScopePolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::SyncScopePolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -358,10 +380,21 @@ Messaging::RequestPriorityPolicy_ptr Messaging::RequestPriorityPolicy::_unchecke
     servant = obj->_servant()->_downcast ("IDL:Messaging/RequestPriorityPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::RequestPriorityPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_RequestPriorityPolicy(
-      ACE_reinterpret_cast(POA_Messaging::RequestPriorityPolicy_ptr, servant),
-      stub
+
+  Messaging::RequestPriorityPolicy_ptr retval = 
+    Messaging::RequestPriorityPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RequestPriorityPolicy (
+          ACE_reinterpret_cast (POA_Messaging::RequestPriorityPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::RequestPriorityPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::RequestPriorityPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -425,10 +458,21 @@ Messaging::ReplyPriorityPolicy_ptr Messaging::ReplyPriorityPolicy::_unchecked_na
     servant = obj->_servant()->_downcast ("IDL:Messaging/ReplyPriorityPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::ReplyPriorityPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_ReplyPriorityPolicy(
-      ACE_reinterpret_cast(POA_Messaging::ReplyPriorityPolicy_ptr, servant),
-      stub
+
+  Messaging::ReplyPriorityPolicy_ptr retval = 
+    Messaging::ReplyPriorityPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_ReplyPriorityPolicy (
+          ACE_reinterpret_cast (POA_Messaging::ReplyPriorityPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::ReplyPriorityPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::ReplyPriorityPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -492,10 +536,21 @@ Messaging::RequestStartTimePolicy_ptr Messaging::RequestStartTimePolicy::_unchec
     servant = obj->_servant()->_downcast ("IDL:Messaging/RequestStartTimePolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::RequestStartTimePolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_RequestStartTimePolicy(
-      ACE_reinterpret_cast(POA_Messaging::RequestStartTimePolicy_ptr, servant),
-      stub
+
+  Messaging::RequestStartTimePolicy_ptr retval = 
+    Messaging::RequestStartTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RequestStartTimePolicy (
+          ACE_reinterpret_cast (POA_Messaging::RequestStartTimePolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::RequestStartTimePolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::RequestStartTimePolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -559,10 +614,21 @@ Messaging::RequestEndTimePolicy_ptr Messaging::RequestEndTimePolicy::_unchecked_
     servant = obj->_servant()->_downcast ("IDL:Messaging/RequestEndTimePolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::RequestEndTimePolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_RequestEndTimePolicy(
-      ACE_reinterpret_cast(POA_Messaging::RequestEndTimePolicy_ptr, servant),
-      stub
+
+  Messaging::RequestEndTimePolicy_ptr retval = 
+    Messaging::RequestEndTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RequestEndTimePolicy (
+          ACE_reinterpret_cast (POA_Messaging::RequestEndTimePolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::RequestEndTimePolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::RequestEndTimePolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -626,10 +692,21 @@ Messaging::ReplyStartTimePolicy_ptr Messaging::ReplyStartTimePolicy::_unchecked_
     servant = obj->_servant()->_downcast ("IDL:Messaging/ReplyStartTimePolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::ReplyStartTimePolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_ReplyStartTimePolicy(
-      ACE_reinterpret_cast(POA_Messaging::ReplyStartTimePolicy_ptr, servant),
-      stub
+
+  Messaging::ReplyStartTimePolicy_ptr retval = 
+    Messaging::ReplyStartTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_ReplyStartTimePolicy (
+          ACE_reinterpret_cast (POA_Messaging::ReplyStartTimePolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::ReplyStartTimePolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::ReplyStartTimePolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -693,10 +770,21 @@ Messaging::ReplyEndTimePolicy_ptr Messaging::ReplyEndTimePolicy::_unchecked_narr
     servant = obj->_servant()->_downcast ("IDL:Messaging/ReplyEndTimePolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::ReplyEndTimePolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_ReplyEndTimePolicy(
-      ACE_reinterpret_cast(POA_Messaging::ReplyEndTimePolicy_ptr, servant),
-      stub
+
+  Messaging::ReplyEndTimePolicy_ptr retval = 
+    Messaging::ReplyEndTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_ReplyEndTimePolicy (
+          ACE_reinterpret_cast (POA_Messaging::ReplyEndTimePolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::ReplyEndTimePolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::ReplyEndTimePolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -760,10 +848,21 @@ Messaging::RelativeRequestTimeoutPolicy_ptr Messaging::RelativeRequestTimeoutPol
     servant = obj->_servant()->_downcast ("IDL:Messaging/RelativeRequestTimeoutPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::RelativeRequestTimeoutPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_RelativeRequestTimeoutPolicy(
-      ACE_reinterpret_cast(POA_Messaging::RelativeRequestTimeoutPolicy_ptr, servant),
-      stub
+
+  Messaging::RelativeRequestTimeoutPolicy_ptr retval = 
+    Messaging::RelativeRequestTimeoutPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RelativeRequestTimeoutPolicy (
+          ACE_reinterpret_cast (POA_Messaging::RelativeRequestTimeoutPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::RelativeRequestTimeoutPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::RelativeRequestTimeoutPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -828,10 +927,21 @@ Messaging::RelativeRoundtripTimeoutPolicy_ptr Messaging::RelativeRoundtripTimeou
     servant = obj->_servant()->_downcast ("IDL:Messaging/RelativeRoundtripTimeoutPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::RelativeRoundtripTimeoutPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_RelativeRoundtripTimeoutPolicy(
-      ACE_reinterpret_cast(POA_Messaging::RelativeRoundtripTimeoutPolicy_ptr, servant),
-      stub
+
+  Messaging::RelativeRoundtripTimeoutPolicy_ptr retval = 
+    Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RelativeRoundtripTimeoutPolicy (
+          ACE_reinterpret_cast (POA_Messaging::RelativeRoundtripTimeoutPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::RelativeRoundtripTimeoutPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::RelativeRoundtripTimeoutPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -923,10 +1033,21 @@ Messaging::RoutingPolicy_ptr Messaging::RoutingPolicy::_unchecked_narrow (
     servant = obj->_servant()->_downcast ("IDL:Messaging/RoutingPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::RoutingPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_RoutingPolicy(
-      ACE_reinterpret_cast(POA_Messaging::RoutingPolicy_ptr, servant),
-      stub
+
+  Messaging::RoutingPolicy_ptr retval = 
+    Messaging::RoutingPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RoutingPolicy (
+          ACE_reinterpret_cast (POA_Messaging::RoutingPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::RoutingPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::RoutingPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -990,10 +1111,21 @@ Messaging::MaxHopsPolicy_ptr Messaging::MaxHopsPolicy::_unchecked_narrow (
     servant = obj->_servant()->_downcast ("IDL:Messaging/MaxHopsPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::MaxHopsPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_MaxHopsPolicy(
-      ACE_reinterpret_cast(POA_Messaging::MaxHopsPolicy_ptr, servant),
-      stub
+
+  Messaging::MaxHopsPolicy_ptr retval = 
+    Messaging::MaxHopsPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_MaxHopsPolicy (
+          ACE_reinterpret_cast (POA_Messaging::MaxHopsPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::MaxHopsPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::MaxHopsPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -1057,10 +1189,21 @@ Messaging::QueueOrderPolicy_ptr Messaging::QueueOrderPolicy::_unchecked_narrow (
     servant = obj->_servant()->_downcast ("IDL:Messaging/QueueOrderPolicy:1.0");
   if (servant == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), Messaging::QueueOrderPolicy::_nil ());
-  return new POA_Messaging::_tao_collocated_QueueOrderPolicy(
-      ACE_reinterpret_cast(POA_Messaging::QueueOrderPolicy_ptr, servant),
-      stub
+
+  Messaging::QueueOrderPolicy_ptr retval = 
+    Messaging::QueueOrderPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_QueueOrderPolicy (
+          ACE_reinterpret_cast (POA_Messaging::QueueOrderPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::QueueOrderPolicy::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::QueueOrderPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -1308,11 +1451,31 @@ Messaging::ReplyHandler_ptr Messaging::ReplyHandler::_unchecked_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:Messaging/ReplyHandler:1.0");
   if (servant == 0)
-    return new Messaging::ReplyHandler(stub);
-  return new POA_Messaging::_tao_collocated_ReplyHandler(
-      ACE_reinterpret_cast(POA_Messaging::ReplyHandler_ptr, servant),
-      stub
+    {
+      Messaging::ReplyHandler_ptr rval = 
+        Messaging::ReplyHandler::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      Messaging::ReplyHandler (stub),
+                      Messaging::ReplyHandler::_nil ());
+
+      return rval;
+    }
+
+  Messaging::ReplyHandler_ptr retval = 
+    Messaging::ReplyHandler::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_ReplyHandler (
+          ACE_reinterpret_cast (POA_Messaging::ReplyHandler_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::ReplyHandler::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean Messaging::ReplyHandler::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -1374,11 +1537,30 @@ Messaging::Poller_ptr Messaging::Poller::_unchecked_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:Messaging/Poller:1.0");
   if (servant == 0)
-    return new Messaging::Poller(stub);
-  return new POA_Messaging::_tao_collocated_Poller(
-      ACE_reinterpret_cast(POA_Messaging::Poller_ptr, servant),
-      stub
+    {
+      Messaging::Poller_ptr rval = Messaging::Poller::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      Messaging::Poller (stub),
+                      Messaging::Poller::_nil ());
+
+      return rval;
+    }
+
+  Messaging::Poller_ptr retval = 
+    Messaging::Poller::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_Poller (
+          ACE_reinterpret_cast (POA_Messaging::Poller_ptr, 
+                                servant),
+          stub
+        ),
+      Messaging::Poller::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Object_ptr Messaging::Poller::operation_target (
diff --git a/TAO/tao/MessagingC.i b/TAO/tao/MessagingC.i
index 72547031505..476cd987853 100644
--- a/TAO/tao/MessagingC.i
+++ b/TAO/tao/MessagingC.i
@@ -400,7 +400,8 @@ ACE_INLINE
 Messaging::PriorityRange_var::PriorityRange_var (const Messaging::PriorityRange_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new Messaging::PriorityRange(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             Messaging::PriorityRange(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -425,7 +426,9 @@ Messaging::PriorityRange_var::operator= (const Messaging::PriorityRange_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new Messaging::PriorityRange (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    Messaging::PriorityRange (*p.ptr_),
+		    *this);
   }
   return *this;
 }
@@ -2005,7 +2008,8 @@ ACE_INLINE
 Messaging::RoutingTypeRange_var::RoutingTypeRange_var (const Messaging::RoutingTypeRange_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new Messaging::RoutingTypeRange(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             Messaging::RoutingTypeRange(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2030,7 +2034,9 @@ Messaging::RoutingTypeRange_var::operator= (const Messaging::RoutingTypeRange_va
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new Messaging::RoutingTypeRange (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    Messaging::RoutingTypeRange (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -2675,7 +2681,8 @@ ACE_INLINE
 Messaging::PolicyValue_var::PolicyValue_var (const Messaging::PolicyValue_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new Messaging::PolicyValue(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             Messaging::PolicyValue(*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2700,7 +2707,9 @@ Messaging::PolicyValue_var::operator= (const Messaging::PolicyValue_var &p)
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new Messaging::PolicyValue (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    Messaging::PolicyValue (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -2844,7 +2853,8 @@ ACE_INLINE
 Messaging::PolicyValueSeq_var::PolicyValueSeq_var (const Messaging::PolicyValueSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new Messaging::PolicyValueSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             Messaging::PolicyValueSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -2869,7 +2879,9 @@ Messaging::PolicyValueSeq_var::operator= (const Messaging::PolicyValueSeq_var &p
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new Messaging::PolicyValueSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    Messaging::PolicyValueSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -3026,7 +3038,8 @@ ACE_INLINE
 Messaging::ExceptionHolder_var::ExceptionHolder_var (const Messaging::ExceptionHolder_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new Messaging::ExceptionHolder(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             Messaging::ExceptionHolder (*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -3051,7 +3064,9 @@ Messaging::ExceptionHolder_var::operator= (const Messaging::ExceptionHolder_var
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new Messaging::ExceptionHolder (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    Messaging::ExceptionHolder (*p.ptr_),
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/MessagingS.cpp b/TAO/tao/MessagingS.cpp
index 23248cb434a..d15edcbcd79 100644
--- a/TAO/tao/MessagingS.cpp
+++ b/TAO/tao/MessagingS.cpp
@@ -115,7 +115,16 @@ POA_Messaging::RebindPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_RebindPolicy (this, stub);
+
+  Messaging::RebindPolicy *retval = 
+    Messaging::RebindPolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_RebindPolicy (this, 
+                                                               stub),
+                  Messaging::RebindPolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -212,7 +221,16 @@ POA_Messaging::SyncScopePolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_SyncScopePolicy (this, stub);
+
+  Messaging::SyncScopePolicy *retval = 
+    Messaging::SyncScopePolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_SyncScopePolicy (this, 
+                                                                  stub),
+                  Messaging::SyncScopePolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -309,7 +327,16 @@ POA_Messaging::RequestPriorityPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_RequestPriorityPolicy (this, stub);
+
+  Messaging::RequestPriorityPolicy *retval = 
+    Messaging::RequestPriorityPolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_RequestPriorityPolicy (this, 
+                                                                        stub),
+                  Messaging::RequestPriorityPolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -406,7 +433,16 @@ POA_Messaging::ReplyPriorityPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_ReplyPriorityPolicy (this, stub);
+
+  Messaging::ReplyPriorityPolicy *retval = 
+    Messaging::ReplyPriorityPolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_ReplyPriorityPolicy (this, 
+                                                                      stub),
+                  Messaging::ReplyPriorityPolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -503,7 +539,16 @@ POA_Messaging::RequestStartTimePolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_RequestStartTimePolicy (this, stub);
+
+  Messaging::RequestStartTimePolicy *retval = 
+    Messaging::RequestStartTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_RequestStartTimePolicy (this, 
+                                                                         stub),
+                  Messaging::RequestStartTimePolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -600,7 +645,16 @@ POA_Messaging::RequestEndTimePolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_RequestEndTimePolicy (this, stub);
+
+  Messaging::RequestEndTimePolicy *retval = 
+    Messaging::RequestEndTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_RequestEndTimePolicy (this, 
+                                                                       stub),
+                  Messaging::RequestEndTimePolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -697,7 +751,16 @@ POA_Messaging::ReplyStartTimePolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_ReplyStartTimePolicy (this, stub);
+
+  Messaging::ReplyStartTimePolicy *retval = 
+    Messaging::ReplyStartTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_ReplyStartTimePolicy (this, 
+                                                                       stub),
+                  Messaging::ReplyStartTimePolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -794,7 +857,16 @@ POA_Messaging::ReplyEndTimePolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_ReplyEndTimePolicy (this, stub);
+
+  Messaging::ReplyEndTimePolicy *retval = 
+    Messaging::ReplyEndTimePolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_Messaging::_tao_collocated_ReplyEndTimePolicy (this, 
+                                                                     stub),
+                  Messaging::ReplyEndTimePolicy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -891,7 +963,18 @@ POA_Messaging::RelativeRequestTimeoutPolicy::_this (CORBA_Environment &ACE_TRY_E
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_RelativeRequestTimeoutPolicy (this, stub);
+
+  Messaging::RelativeRequestTimeoutPolicy *retval = 
+    Messaging::RelativeRequestTimeoutPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RelativeRequestTimeoutPolicy (this, 
+                                                                   stub),
+      Messaging::RelativeRequestTimeoutPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 // ****************************************************************
@@ -988,7 +1071,18 @@ POA_Messaging::RelativeRoundtripTimeoutPolicy::_this (CORBA_Environment &ACE_TRY
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_RelativeRoundtripTimeoutPolicy (this, stub);
+
+  Messaging::RelativeRoundtripTimeoutPolicy *retval = 
+    Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RelativeRoundtripTimeoutPolicy (this, 
+                                                                     stub),
+      Messaging::RelativeRoundtripTimeoutPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 // ****************************************************************
@@ -1085,7 +1179,18 @@ POA_Messaging::RoutingPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_RoutingPolicy (this, stub);
+
+  Messaging::RoutingPolicy *retval = 
+    Messaging::RoutingPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_RoutingPolicy (this, 
+                                                    stub),
+      Messaging::RoutingPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 // ****************************************************************
@@ -1182,7 +1287,18 @@ POA_Messaging::MaxHopsPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_MaxHopsPolicy (this, stub);
+
+  Messaging::MaxHopsPolicy *retval = 
+    Messaging::MaxHopsPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_MaxHopsPolicy (this, 
+                                                    stub),
+      Messaging::MaxHopsPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 // ****************************************************************
@@ -1280,6 +1396,18 @@ POA_Messaging::QueueOrderPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
   return new POA_Messaging::_tao_collocated_QueueOrderPolicy (this, stub);
+
+  Messaging::QueueOrderPolicy *retval = 
+    Messaging::QueueOrderPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_QueueOrderPolicy (this, 
+                                                       stub),
+      Messaging::QueueOrderPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 // ****************************************************************
@@ -1363,7 +1491,18 @@ POA_Messaging::ReplyHandler::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_ReplyHandler (this, stub);
+
+  Messaging::ReplyHandler *retval = 
+    Messaging::ReplyHandler::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_ReplyHandler (this, 
+                                                   stub),
+      Messaging::ReplyHandler::_nil ()
+    );
+
+  return retval;
 }
 
 #endif /* TAO_HAS_AMI_CALLBACK */
@@ -1849,7 +1988,18 @@ POA_Messaging::Poller::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_Messaging::_tao_collocated_Poller (this, stub);
+
+  Messaging::Poller *retval = 
+    Messaging::Poller::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_Messaging::_tao_collocated_Poller (this, 
+                                             stub),
+      Messaging::Poller::_nil ()
+    );
+
+  return retval;
 }
 #endif /* TAO_HAS_AMI_POLLER */
 
diff --git a/TAO/tao/Object_KeyC.i b/TAO/tao/Object_KeyC.i
index 82bfaa7cb26..54fc24425fd 100644
--- a/TAO/tao/Object_KeyC.i
+++ b/TAO/tao/Object_KeyC.i
@@ -65,9 +65,10 @@ ACE_INLINE
 TAO_ObjectKey_var::TAO_ObjectKey_var (const TAO_ObjectKey_var &p) // copy constructor
 {
   if (p.ptr_)
-  	this->ptr_ = new TAO_ObjectKey(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             TAO_ObjectKey(*p.ptr_));
   else
-  	this->ptr_ = 0;
+    this->ptr_ = 0;
 }
 
 ACE_INLINE
@@ -90,7 +91,9 @@ TAO_ObjectKey_var::operator= (const TAO_ObjectKey_var &p) // deep copy
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new TAO_ObjectKey (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    TAO_ObjectKey (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/POAC.cpp b/TAO/tao/POAC.cpp
index c10b521a5b8..9efdc84207d 100644
--- a/TAO/tao/POAC.cpp
+++ b/TAO/tao/POAC.cpp
@@ -120,12 +120,20 @@ PortableServer::ForwardRequest::_narrow (CORBA::Exception *exc)
 // = TAO extension
 CORBA::Exception *PortableServer::ForwardRequest::_alloc (void)
 {
-  return new PortableServer::ForwardRequest;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::ForwardRequest,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::ForwardRequest &_tao_elem) // copying
 {
-  PortableServer::ForwardRequest *_tao_any_val = new PortableServer::ForwardRequest (_tao_elem);
+  PortableServer::ForwardRequest *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::ForwardRequest (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -293,12 +301,32 @@ PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_narrow (
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new PortableServer::ThreadPolicy(stub);
+    {
+      PortableServer::ThreadPolicy_ptr rval =
+        PortableServer::ThreadPolicy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      PortableServer::ThreadPolicy (stub),
+                      PortableServer::ThreadPolicy::_nil ());
+
+      return rval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_PortableServer::_tao_collocated_ThreadPolicy(
-      ACE_reinterpret_cast(POA_PortableServer::ThreadPolicy_ptr, servant),
-      stub
+  
+  PortableServer::ThreadPolicy_ptr retval =
+    PortableServer::ThreadPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ThreadPolicy (
+          ACE_reinterpret_cast (POA_PortableServer::ThreadPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      PortableServer::ThreadPolicy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -430,12 +458,32 @@ PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_narrow (
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new PortableServer::LifespanPolicy(stub);
+    {
+      PortableServer::LifespanPolicy_ptr rval =
+        PortableServer::LifespanPolicy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      PortableServer::LifespanPolicy (stub),
+                      PortableServer::LifespanPolicy::_nil ());
+
+      return rval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_PortableServer::_tao_collocated_LifespanPolicy(
-      ACE_reinterpret_cast(POA_PortableServer::LifespanPolicy_ptr, servant),
-      stub
+  
+  PortableServer::LifespanPolicy_ptr retval =
+    PortableServer::LifespanPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_LifespanPolicy (
+          ACE_reinterpret_cast (POA_PortableServer::LifespanPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      PortableServer::LifespanPolicy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -567,12 +615,32 @@ PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_narr
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new PortableServer::IdUniquenessPolicy(stub);
+    {
+      PortableServer::IdUniquenessPolicy_ptr rval =
+        PortableServer::IdUniquenessPolicy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      PortableServer::IdUniquenessPolicy (stub),
+                      PortableServer::IdUniquenessPolicy::_nil ());
+
+      return rval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_PortableServer::_tao_collocated_IdUniquenessPolicy(
-      ACE_reinterpret_cast(POA_PortableServer::IdUniquenessPolicy_ptr, servant),
-      stub
+  
+  PortableServer::IdUniquenessPolicy_ptr retval =
+    PortableServer::IdUniquenessPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_IdUniquenessPolicy (
+          ACE_reinterpret_cast (POA_PortableServer::IdUniquenessPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      PortableServer::IdUniquenessPolicy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -703,12 +771,32 @@ PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_narr
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new PortableServer::IdAssignmentPolicy(stub);
+    {
+      PortableServer::IdAssignmentPolicy_ptr rval =
+        PortableServer::IdAssignmentPolicy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      PortableServer::IdAssignmentPolicy (stub),
+                      PortableServer::IdAssignmentPolicy::_nil ());
+
+      return rval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_PortableServer::_tao_collocated_IdAssignmentPolicy(
-      ACE_reinterpret_cast(POA_PortableServer::IdAssignmentPolicy_ptr, servant),
-      stub
+  
+  PortableServer::IdAssignmentPolicy_ptr retval =
+    PortableServer::IdAssignmentPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_IdAssignmentPolicy (
+          ACE_reinterpret_cast (POA_PortableServer::IdAssignmentPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      PortableServer::IdAssignmentPolicy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -842,12 +930,32 @@ PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationP
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new PortableServer::ImplicitActivationPolicy(stub);
+    {
+      PortableServer::ImplicitActivationPolicy_ptr rval =
+        PortableServer::ImplicitActivationPolicy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      PortableServer::ImplicitActivationPolicy (stub),
+                      PortableServer::ImplicitActivationPolicy::_nil ());
+
+      return rval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_PortableServer::_tao_collocated_ImplicitActivationPolicy(
-      ACE_reinterpret_cast(POA_PortableServer::ImplicitActivationPolicy_ptr, servant),
-      stub
+  
+  PortableServer::ImplicitActivationPolicy_ptr retval =
+    PortableServer::ImplicitActivationPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ImplicitActivationPolicy (
+          ACE_reinterpret_cast (POA_PortableServer::ImplicitActivationPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      PortableServer::ImplicitActivationPolicy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -979,12 +1087,32 @@ PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolic
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new PortableServer::ServantRetentionPolicy(stub);
+    {
+      PortableServer::ServantRetentionPolicy_ptr rval =
+        PortableServer::ServantRetentionPolicy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      PortableServer::ServantRetentionPolicy (stub),
+                      PortableServer::ServantRetentionPolicy::_nil ());
+
+      return rval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_PortableServer::_tao_collocated_ServantRetentionPolicy(
-      ACE_reinterpret_cast(POA_PortableServer::ServantRetentionPolicy_ptr, servant),
-      stub
+  
+  PortableServer::ServantRetentionPolicy_ptr retval =
+    PortableServer::ServantRetentionPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ServantRetentionPolicy (
+          ACE_reinterpret_cast (POA_PortableServer::ServantRetentionPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      PortableServer::ServantRetentionPolicy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -1116,12 +1244,32 @@ PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPol
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new PortableServer::RequestProcessingPolicy(stub);
+    {
+      PortableServer::RequestProcessingPolicy_ptr rval =
+        PortableServer::RequestProcessingPolicy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      PortableServer::RequestProcessingPolicy (stub),
+                      PortableServer::RequestProcessingPolicy::_nil ());
+
+      return rval;
+    }
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_PortableServer::_tao_collocated_RequestProcessingPolicy(
-      ACE_reinterpret_cast(POA_PortableServer::RequestProcessingPolicy_ptr, servant),
-      stub
+  
+  PortableServer::RequestProcessingPolicy_ptr retval =
+    PortableServer::RequestProcessingPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_RequestProcessingPolicy (
+          ACE_reinterpret_cast (POA_PortableServer::RequestProcessingPolicy_ptr, 
+                                servant),
+          stub
+        ),
+      PortableServer::RequestProcessingPolicy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -1231,10 +1379,21 @@ PortableServer::POAManager_ptr PortableServer::POAManager::_narrow (
       || (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/POAManager:1.0")) == 0)
       // This can only be colocated
       ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::POAManager::_nil ());
-  return new POA_PortableServer::_tao_collocated_POAManager(
-                                                            ACE_reinterpret_cast(POA_PortableServer::POAManager_ptr, servant),
-                                                            0
-                                                            );
+
+  PortableServer::POAManager_ptr retval = 
+    PortableServer::POAManager::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_POAManager (
+          ACE_reinterpret_cast (POA_PortableServer::POAManager_ptr, 
+                                servant),
+          0
+        ),
+      PortableServer::POAManager::_nil ()
+    );
+
+  return retval;
 }
 
 // default constructor
@@ -1280,12 +1439,20 @@ PortableServer::POAManager::AdapterInactive::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POAManager::AdapterInactive::_alloc (void)
 {
-  return new PortableServer::POAManager::AdapterInactive;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POAManager::AdapterInactive,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POAManager::AdapterInactive &_tao_elem) // copying
 {
-  PortableServer::POAManager::AdapterInactive *_tao_any_val = new PortableServer::POAManager::AdapterInactive (_tao_elem);
+  PortableServer::POAManager::AdapterInactive *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POAManager::AdapterInactive (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -1419,10 +1586,21 @@ PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_narrow (
       (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/AdapterActivator:1.0")) == 0)
       // This can only be colocated
       ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::AdapterActivator::_nil ());
-  return new POA_PortableServer::_tao_collocated_AdapterActivator(
-                                                                  ACE_reinterpret_cast(POA_PortableServer::AdapterActivator_ptr, servant),
-                                                                  0
-                                                                  );
+
+  PortableServer::AdapterActivator_ptr retval =
+    PortableServer::AdapterActivator::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_AdapterActivator (
+          ACE_reinterpret_cast (POA_PortableServer::AdapterActivator_ptr, 
+                                servant),
+          0
+        ),
+      PortableServer::AdapterActivator::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA::Boolean PortableServer::AdapterActivator::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment)
@@ -1481,10 +1659,21 @@ PortableServer::ServantManager_ptr PortableServer::ServantManager::_narrow (
       (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/ServantManager:1.0")) == 0)
     // This can only be colocated
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ServantManager::_nil ());
-  return new POA_PortableServer::_tao_collocated_ServantManager(
-                                                                ACE_reinterpret_cast(POA_PortableServer::ServantManager_ptr, servant),
-                                                                0
-                                                                );
+
+  PortableServer::ServantManager_ptr retval =
+    PortableServer::ServantManager::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ServantManager (
+          ACE_reinterpret_cast (POA_PortableServer::ServantManager_ptr, 
+                                servant),
+          0
+        ),
+      PortableServer::ServantManager::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA::Boolean PortableServer::ServantManager::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment)
@@ -1543,10 +1732,21 @@ PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_narrow (
       (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/ServantActivator:1.0")) == 0)
       // This can only be colocated
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ServantActivator::_nil ());
-  return new POA_PortableServer::_tao_collocated_ServantActivator(
-                                                                  ACE_reinterpret_cast(POA_PortableServer::ServantActivator_ptr, servant),
-                                                                  0
-                                                                  );
+
+  PortableServer::ServantActivator_ptr retval =
+    PortableServer::ServantActivator::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ServantActivator (
+          ACE_reinterpret_cast (POA_PortableServer::ServantActivator_ptr, 
+                                servant),
+          0
+        ),
+      PortableServer::ServantActivator::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA::Boolean PortableServer::ServantActivator::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment)
@@ -1606,10 +1806,21 @@ PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_narrow (
       (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/ServantLocator:1.0")) == 0)
     // This can only be colocated
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::ServantLocator::_nil ());
-  return new POA_PortableServer::_tao_collocated_ServantLocator(
-                                                                ACE_reinterpret_cast(POA_PortableServer::ServantLocator_ptr, servant),
-                                                                0
-                                                                );
+
+  PortableServer::ServantLocator_ptr retval =
+    PortableServer::ServantLocator::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ServantLocator (
+          ACE_reinterpret_cast (POA_PortableServer::ServantLocator_ptr, 
+                                servant),
+          0
+        ),
+      PortableServer::ServantLocator::_nil ()
+    );
+
+  return retval;
 }
 
 CORBA::Boolean PortableServer::ServantLocator::_is_a (const CORBA::Char *value, CORBA::Environment &_tao_environment)
@@ -1671,10 +1882,21 @@ PortableServer::POA_ptr PortableServer::POA::_narrow (
       (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/POA:1.0")) == 0)
     // This can only be colocated
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::POA::_nil ());
-  return new POA_PortableServer::_tao_collocated_POA(
-                                                     ACE_reinterpret_cast(POA_PortableServer::POA_ptr, servant),
-                                                     0
-                                                     );
+
+  PortableServer::POA_ptr retval =
+    PortableServer::POA::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_POA (
+          ACE_reinterpret_cast (POA_PortableServer::POA_ptr, 
+                                servant),
+          0
+        ),
+      PortableServer::POA::_nil ()
+    );
+
+  return retval;
 }
 
 // default constructor
@@ -1720,12 +1942,20 @@ PortableServer::POA::AdapterAlreadyExists::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::AdapterAlreadyExists::_alloc (void)
 {
-  return new PortableServer::POA::AdapterAlreadyExists;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::AdapterAlreadyExists,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterAlreadyExists &_tao_elem) // copying
 {
-  PortableServer::POA::AdapterAlreadyExists *_tao_any_val = new PortableServer::POA::AdapterAlreadyExists (_tao_elem);
+  PortableServer::POA::AdapterAlreadyExists *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::AdapterAlreadyExists (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -1846,12 +2076,20 @@ PortableServer::POA::AdapterInactive::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::AdapterInactive::_alloc (void)
 {
-  return new PortableServer::POA::AdapterInactive;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::AdapterInactive,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterInactive &_tao_elem) // copying
 {
-  PortableServer::POA::AdapterInactive *_tao_any_val = new PortableServer::POA::AdapterInactive (_tao_elem);
+  PortableServer::POA::AdapterInactive *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::AdapterInactive (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -1972,12 +2210,20 @@ PortableServer::POA::AdapterNonExistent::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::AdapterNonExistent::_alloc (void)
 {
-  return new PortableServer::POA::AdapterNonExistent;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::AdapterNonExistent,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::AdapterNonExistent &_tao_elem) // copying
 {
-  PortableServer::POA::AdapterNonExistent *_tao_any_val = new PortableServer::POA::AdapterNonExistent (_tao_elem);
+  PortableServer::POA::AdapterNonExistent *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::AdapterNonExistent (_tao_elem));;
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2105,12 +2351,20 @@ PortableServer::POA::InvalidPolicy::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::InvalidPolicy::_alloc (void)
 {
-  return new PortableServer::POA::InvalidPolicy;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::InvalidPolicy,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::InvalidPolicy &_tao_elem) // copying
 {
-  PortableServer::POA::InvalidPolicy *_tao_any_val = new PortableServer::POA::InvalidPolicy (_tao_elem);
+  PortableServer::POA::InvalidPolicy *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::InvalidPolicy (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2234,12 +2488,20 @@ PortableServer::POA::NoServant::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::NoServant::_alloc (void)
 {
-  return new PortableServer::POA::NoServant;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::NoServant,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::NoServant &_tao_elem) // copying
 {
-  PortableServer::POA::NoServant *_tao_any_val = new PortableServer::POA::NoServant (_tao_elem);
+  PortableServer::POA::NoServant *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::NoServant (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2362,12 +2624,20 @@ PortableServer::POA::ObjectAlreadyActive::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::ObjectAlreadyActive::_alloc (void)
 {
-  return new PortableServer::POA::ObjectAlreadyActive;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::ObjectAlreadyActive,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectAlreadyActive &_tao_elem) // copying
 {
-  PortableServer::POA::ObjectAlreadyActive *_tao_any_val = new PortableServer::POA::ObjectAlreadyActive (_tao_elem);
+  PortableServer::POA::ObjectAlreadyActive *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::ObjectAlreadyActive (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2486,12 +2756,20 @@ PortableServer::POA::ObjectNotActive::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::ObjectNotActive::_alloc (void)
 {
-  return new PortableServer::POA::ObjectNotActive;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::ObjectNotActive,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ObjectNotActive &_tao_elem) // copying
 {
-  PortableServer::POA::ObjectNotActive *_tao_any_val = new PortableServer::POA::ObjectNotActive (_tao_elem);
+  PortableServer::POA::ObjectNotActive *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::ObjectNotActive (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2610,12 +2888,20 @@ PortableServer::POA::ServantAlreadyActive::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::ServantAlreadyActive::_alloc (void)
 {
-  return new PortableServer::POA::ServantAlreadyActive;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::ServantAlreadyActive,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantAlreadyActive &_tao_elem) // copying
 {
-  PortableServer::POA::ServantAlreadyActive *_tao_any_val = new PortableServer::POA::ServantAlreadyActive (_tao_elem);
+  PortableServer::POA::ServantAlreadyActive *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::ServantAlreadyActive (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2734,12 +3020,20 @@ PortableServer::POA::ServantNotActive::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::ServantNotActive::_alloc (void)
 {
-  return new PortableServer::POA::ServantNotActive;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::ServantNotActive,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::ServantNotActive &_tao_elem) // copying
 {
-  PortableServer::POA::ServantNotActive *_tao_any_val = new PortableServer::POA::ServantNotActive (_tao_elem);
+  PortableServer::POA::ServantNotActive *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::ServantNotActive (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2858,12 +3152,20 @@ PortableServer::POA::WrongAdapter::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::WrongAdapter::_alloc (void)
 {
-  return new PortableServer::POA::WrongAdapter;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::WrongAdapter,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongAdapter &_tao_elem) // copying
 {
-  PortableServer::POA::WrongAdapter *_tao_any_val = new PortableServer::POA::WrongAdapter (_tao_elem);
+  PortableServer::POA::WrongAdapter *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::WrongAdapter (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -2982,12 +3284,20 @@ PortableServer::POA::WrongPolicy::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::POA::WrongPolicy::_alloc (void)
 {
-  return new PortableServer::POA::WrongPolicy;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::POA::WrongPolicy,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::POA::WrongPolicy &_tao_elem) // copying
 {
-  PortableServer::POA::WrongPolicy *_tao_any_val = new PortableServer::POA::WrongPolicy (_tao_elem);
+  PortableServer::POA::WrongPolicy *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::POA::WrongPolicy (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -3119,10 +3429,21 @@ PortableServer::Current_ptr PortableServer::Current::_narrow (
       (servant = obj->_servant ()->_downcast ("IDL:omg.org/PortableServer/Current:1.0")) == 0)
     // This can only be colocated
     ACE_THROW_RETURN (CORBA::MARSHAL (), PortableServer::Current::_nil ());
-  return new POA_PortableServer::_tao_collocated_Current(
-                                                         ACE_reinterpret_cast(POA_PortableServer::Current_ptr, servant),
-                                                         0
-                                                         );
+
+  PortableServer::Current_ptr retval =
+    PortableServer::Current::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_Current (
+          ACE_reinterpret_cast (POA_PortableServer::Current_ptr, 
+                                servant),
+          0
+        ),
+      PortableServer::Current::_nil ()
+    );
+
+  return retval;
 }
 
 // default constructor
@@ -3168,12 +3489,20 @@ PortableServer::Current::NoContext::_narrow (CORBA::Exception *exc)
 // TAO extension - the _alloc method
 CORBA::Exception *PortableServer::Current::NoContext::_alloc (void)
 {
-  return new PortableServer::Current::NoContext;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  PortableServer::Current::NoContext,
+                  0);
+
+  return retval;
 }
 
 void operator<<= (CORBA::Any &_tao_any, const PortableServer::Current::NoContext &_tao_elem) // copying
 {
-  PortableServer::Current::NoContext *_tao_any_val = new PortableServer::Current::NoContext (_tao_elem);
+  PortableServer::Current::NoContext *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           PortableServer::Current::NoContext (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
diff --git a/TAO/tao/POAC.i b/TAO/tao/POAC.i
index fc5d5f2b64b..82876a5b4cc 100644
--- a/TAO/tao/POAC.i
+++ b/TAO/tao/POAC.i
@@ -209,7 +209,8 @@ ACE_INLINE
 PortableServer::_tao_seq_Octet_var::_tao_seq_Octet_var (const PortableServer::_tao_seq_Octet_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new PortableServer::_tao_seq_Octet(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             PortableServer::_tao_seq_Octet (*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -234,7 +235,9 @@ PortableServer::_tao_seq_Octet_var::operator= (const PortableServer::_tao_seq_Oc
   if (this != &p)
     {
       delete this->ptr_;
-      this->ptr_ = new PortableServer::_tao_seq_Octet (*p.ptr_);
+      ACE_NEW_RETURN (this->ptr_, 
+                      PortableServer::_tao_seq_Octet (*p.ptr_), 
+		      *this);
     }
   return *this;
 }
diff --git a/TAO/tao/POAS.cpp b/TAO/tao/POAS.cpp
index 3bab83dcf88..ba7d210fc18 100644
--- a/TAO/tao/POAS.cpp
+++ b/TAO/tao/POAS.cpp
@@ -302,7 +302,16 @@ POA_PortableServer::ThreadPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableServer::_tao_collocated_ThreadPolicy (this, stub);
+
+  PortableServer::ThreadPolicy *retval = 
+    PortableServer::ThreadPolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_ThreadPolicy (this, 
+                                                                    stub),
+                  PortableServer::ThreadPolicy::_nil ());
+
+  return retval;
 }
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
@@ -588,7 +597,16 @@ POA_PortableServer::LifespanPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableServer::_tao_collocated_LifespanPolicy (this, stub);
+
+  PortableServer::LifespanPolicy *retval = 
+    PortableServer::LifespanPolicy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_LifespanPolicy (this, 
+                                                                      stub),
+                  PortableServer::LifespanPolicy::_nil ());
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -873,7 +891,18 @@ POA_PortableServer::IdUniquenessPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableServer::_tao_collocated_IdUniquenessPolicy (this, stub);
+
+  PortableServer::IdUniquenessPolicy *retval = 
+    PortableServer::IdUniquenessPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_IdUniquenessPolicy (this, 
+                                                              stub),
+      PortableServer::IdUniquenessPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -1157,7 +1186,18 @@ POA_PortableServer::IdAssignmentPolicy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableServer::_tao_collocated_IdAssignmentPolicy (this, stub);
+
+  PortableServer::IdAssignmentPolicy *retval = 
+    PortableServer::IdAssignmentPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_IdAssignmentPolicy (this, 
+                                                              stub),
+      PortableServer::IdAssignmentPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_MINIMUM_CORBA)
@@ -1443,7 +1483,18 @@ POA_PortableServer::ImplicitActivationPolicy::_this (CORBA_Environment &ACE_TRY_
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableServer::_tao_collocated_ImplicitActivationPolicy (this, stub);
+
+  PortableServer::ImplicitActivationPolicy *retval = 
+    PortableServer::ImplicitActivationPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ImplicitActivationPolicy (this, 
+                                                                    stub),
+      PortableServer::ImplicitActivationPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -1727,7 +1778,18 @@ POA_PortableServer::ServantRetentionPolicy::_this (CORBA_Environment &ACE_TRY_EN
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableServer::_tao_collocated_ServantRetentionPolicy (this, stub);
+
+  PortableServer::ServantRetentionPolicy *retval = 
+    PortableServer::ServantRetentionPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_ServantRetentionPolicy (this, 
+                                                                  stub),
+      PortableServer::ServantRetentionPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -2011,7 +2073,18 @@ POA_PortableServer::RequestProcessingPolicy::_this (CORBA_Environment &ACE_TRY_E
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_PortableServer::_tao_collocated_RequestProcessingPolicy (this, stub);
+
+  PortableServer::RequestProcessingPolicy *retval = 
+    PortableServer::RequestProcessingPolicy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_PortableServer::_tao_collocated_RequestProcessingPolicy (this, 
+                                                                   stub),
+      PortableServer::RequestProcessingPolicy::_nil ()
+    );
+
+  return retval;
 }
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
@@ -2133,7 +2206,16 @@ POA_PortableServer::_tao_collocated_POAManager:: get_state(CORBA::Environment &A
 PortableServer::POAManager*
 POA_PortableServer::POAManager::_this (CORBA_Environment &)
 {
-  return new POA_PortableServer::_tao_collocated_POAManager (this, 0);
+  PortableServer::POAManager *retval = 
+    PortableServer::POAManager::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_POAManager (this,
+                                                                  0),
+                  PortableServer::POAManager::_nil ());
+
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_MINIMUM_CORBA)
@@ -2215,7 +2297,16 @@ CORBA::Boolean POA_PortableServer::_tao_collocated_AdapterActivator::unknown_ada
 PortableServer::AdapterActivator*
 POA_PortableServer::AdapterActivator::_this (CORBA_Environment &)
 {
-  return new POA_PortableServer::_tao_collocated_AdapterActivator (this, 0);
+  PortableServer::AdapterActivator *retval = 
+    PortableServer::AdapterActivator::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_AdapterActivator (this,
+                                                                        0),
+                  PortableServer::AdapterActivator::_nil ());
+
+
+  return retval;
 }
 
 // skeleton constructor
@@ -2282,7 +2373,16 @@ CORBA::Boolean POA_PortableServer::_tao_collocated_ServantManager::_is_a (
 PortableServer::ServantManager*
 POA_PortableServer::ServantManager::_this (CORBA_Environment &)
 {
-  return new POA_PortableServer::_tao_collocated_ServantManager (this, 0);
+  PortableServer::ServantManager *retval = 
+    PortableServer::ServantManager::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_ServantManager (this,
+                                                                      0),
+                  PortableServer::ServantManager::_nil ());
+
+
+  return retval;
 }
 
 // skeleton constructor
@@ -2385,7 +2485,16 @@ void POA_PortableServer::_tao_collocated_ServantActivator::etherealize (
 PortableServer::ServantActivator*
 POA_PortableServer::ServantActivator::_this (CORBA_Environment &)
 {
-  return new POA_PortableServer::_tao_collocated_ServantActivator (this, 0);
+  PortableServer::ServantActivator *retval = 
+    PortableServer::ServantActivator::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_ServantActivator (this,
+                                                                        0),
+                  PortableServer::ServantActivator::_nil ());
+
+
+  return retval;
 }
 
 // skeleton constructor
@@ -2492,7 +2601,16 @@ void POA_PortableServer::_tao_collocated_ServantLocator::postinvoke (
 PortableServer::ServantLocator*
 POA_PortableServer::ServantLocator::_this (CORBA_Environment &)
 {
-  return new POA_PortableServer::_tao_collocated_ServantLocator (this, 0);
+  PortableServer::ServantLocator *retval = 
+    PortableServer::ServantLocator::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_ServantLocator (this,
+                                                                      0),
+                  PortableServer::ServantLocator::_nil ());
+
+
+  return retval;
 }
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
@@ -2897,7 +3015,16 @@ CORBA::Object_ptr POA_PortableServer::_tao_collocated_POA::id_to_reference (
 PortableServer::POA*
 POA_PortableServer::POA::_this (CORBA_Environment &)
 {
-  return new POA_PortableServer::_tao_collocated_POA (this, 0);
+  PortableServer::POA *retval = 
+    PortableServer::POA::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_POA (this,
+                                                           0),
+                  PortableServer::POA::_nil ());
+
+
+  return retval;
 }
 
 // skeleton constructor
@@ -2986,5 +3113,14 @@ PortableServer::ObjectId * POA_PortableServer::_tao_collocated_Current::get_obje
 PortableServer::Current*
 POA_PortableServer::Current::_this (CORBA_Environment &)
 {
-  return new POA_PortableServer::_tao_collocated_Current (this, 0);
+  PortableServer::Current *retval = 
+    PortableServer::Current::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_PortableServer::_tao_collocated_Current (this,
+                                                               0),
+                  PortableServer::Current::_nil ());
+
+
+  return retval;
 }
diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp
index fb4264f628f..b3e5e2a584e 100644
--- a/TAO/tao/PolicyC.cpp
+++ b/TAO/tao/PolicyC.cpp
@@ -92,7 +92,12 @@ void CORBA_PolicyError::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_PolicyError::_alloc (void)
 {
-  return new CORBA_PolicyError;
+  CORBA::Exception *retval = 0;
+   
+  ACE_NEW_RETURN (retval,
+                  CORBA_PolicyError,
+                  0);
+  return retval;
 }
 
 CORBA_PolicyError::CORBA_PolicyError(
@@ -151,7 +156,13 @@ void CORBA_InvalidPolicies::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_InvalidPolicies::_alloc (void)
 {
-  return new CORBA_InvalidPolicies;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_InvalidPolicies,
+                  0);
+
+  return retval;
 }
 
 CORBA_InvalidPolicies::CORBA_InvalidPolicies(
@@ -185,12 +196,33 @@ CORBA_Policy_ptr CORBA_Policy::_narrow (
 #else
   stub->_incr_refcnt ();
   if (servant == 0)
-    return new CORBA_Policy(stub);
+    {
+      CORBA_Policy_ptr rval = 
+        CORBA_Policy::_nil ();
+
+      ACE_NEW_RETURN (rval,
+                      CORBA_Policy (stub),
+                      CORBA_Policy::_nil ());
+
+      return rval;
+    }
+
 #endif /* TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */
-  return new POA_CORBA::_tao_collocated_Policy(
-      ACE_reinterpret_cast(POA_CORBA::Policy_ptr, servant),
-      stub
+
+  CORBA_Policy_ptr retval = 
+    CORBA_Policy::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_Policy (
+          ACE_reinterpret_cast (POA_CORBA::Policy_ptr, 
+                                servant),
+          stub
+        ),
+      CORBA_Policy::_nil ()
     );
+
+  return retval;
 }
 
 #if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES)
@@ -413,10 +445,21 @@ CORBA::PolicyManager_ptr CORBA_PolicyManager::_narrow (
   if (!obj->_is_collocated () || !obj->_servant() ||
       (servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/PolicyManager:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_PolicyManager::_nil ());
-  return new POA_CORBA::_tao_collocated_PolicyManager(
-      ACE_reinterpret_cast(POA_CORBA::PolicyManager_ptr, servant),
-      0
+
+  CORBA::PolicyManager_ptr retval = 
+    CORBA_PolicyManager::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_PolicyManager (
+          ACE_reinterpret_cast (POA_CORBA::PolicyManager_ptr, 
+                                servant),
+          0
+        ),
+      CORBA_PolicyManager::_nil ()
     );
+
+  return retval;
 }
 
 CORBA_PolicyList * CORBA_PolicyManager::get_policy_overrides (
@@ -475,10 +518,21 @@ CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_narrow (
   if (!obj->_is_collocated () || !obj->_servant() ||
       (servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/PolicyCurrent:1.0")) == 0)
     ACE_THROW_RETURN (CORBA::MARSHAL (), CORBA_PolicyCurrent::_nil ());
-  return new POA_CORBA::_tao_collocated_PolicyCurrent(
-      ACE_reinterpret_cast(POA_CORBA::PolicyCurrent_ptr, servant),
-      0
+
+  CORBA_PolicyCurrent_ptr retval = 
+    CORBA_PolicyCurrent::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_PolicyCurrent (
+          ACE_reinterpret_cast  (POA_CORBA::PolicyCurrent_ptr, 
+                                 servant),
+          0
+        ),
+      CORBA_PolicyCurrent::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean CORBA_PolicyCurrent::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -503,7 +557,9 @@ const char* CORBA_PolicyCurrent::_interface_repository_id (void) const
 
 void operator<<= (CORBA::Any &_tao_any, const CORBA_PolicyError &_tao_elem) // copying
 {
-  CORBA_PolicyError *_tao_any_val = new CORBA_PolicyError (_tao_elem);
+  CORBA_PolicyError *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           CORBA_PolicyError (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -568,7 +624,9 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao
 
 void operator<<= (CORBA::Any &_tao_any, const CORBA_InvalidPolicies &_tao_elem) // copying
 {
-  CORBA_InvalidPolicies *_tao_any_val = new CORBA_InvalidPolicies (_tao_elem);
+  CORBA_InvalidPolicies *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           CORBA_InvalidPolicies (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
diff --git a/TAO/tao/PolicyC.i b/TAO/tao/PolicyC.i
index 9a845dbec38..9a54c1273e5 100644
--- a/TAO/tao/PolicyC.i
+++ b/TAO/tao/PolicyC.i
@@ -241,7 +241,8 @@ ACE_INLINE
 CORBA_PolicyList_var::CORBA_PolicyList_var (const CORBA_PolicyList_var &p) // copy constructor
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_PolicyList(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_PolicyList (*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -266,7 +267,9 @@ CORBA_PolicyList_var::operator= (const CORBA_PolicyList_var &p) // deep copy
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_PolicyList (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_PolicyList (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
@@ -422,7 +425,8 @@ ACE_INLINE
 CORBA_PolicyTypeSeq_var::CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq_var &p)
 {
   if (p.ptr_)
-    this->ptr_ = new CORBA_PolicyTypeSeq(*p.ptr_);
+    ACE_NEW (this->ptr_, 
+             CORBA_PolicyTypeSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
@@ -447,7 +451,9 @@ CORBA_PolicyTypeSeq_var::operator= (const CORBA_PolicyTypeSeq_var &p) // deep co
   if (this != &p)
   {
     delete this->ptr_;
-    this->ptr_ = new CORBA_PolicyTypeSeq (*p.ptr_);
+    ACE_NEW_RETURN (this->ptr_, 
+                    CORBA_PolicyTypeSeq (*p.ptr_), 
+		    *this);
   }
   return *this;
 }
diff --git a/TAO/tao/PolicyS.cpp b/TAO/tao/PolicyS.cpp
index aa7c8ffe8e3..aea80aa3015 100644
--- a/TAO/tao/PolicyS.cpp
+++ b/TAO/tao/PolicyS.cpp
@@ -333,7 +333,15 @@ POA_CORBA::Policy::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_Policy (this, stub);
+
+  CORBA::Policy *retval = CORBA::Policy::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_Policy (this, 
+                                                     stub),
+                  CORBA::Policy::_nil ());
+
+  return retval;
 }
 
 // ****************************************************************
@@ -384,7 +392,15 @@ POA_CORBA::PolicyManager::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_PolicyManager (this, stub);
+
+  CORBA::PolicyManager *retval = CORBA::PolicyManager::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_PolicyManager (this, 
+                                                            stub),
+                  CORBA::PolicyManager::_nil ());
+
+  return retval;
 }
 
 POA_CORBA::_tao_collocated_PolicyManager::_tao_collocated_PolicyManager (
@@ -494,7 +510,15 @@ POA_CORBA::PolicyCurrent::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_PolicyCurrent (this, stub);
+
+  CORBA::PolicyCurrent *retval = CORBA::PolicyCurrent::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_PolicyCurrent (this, 
+                                                            stub),
+                  CORBA::PolicyCurrent::_nil ());
+
+  return retval;
 }
 
 POA_CORBA::_tao_collocated_PolicyCurrent::_tao_collocated_PolicyCurrent (
diff --git a/TAO/tao/PollableC.cpp b/TAO/tao/PollableC.cpp
index 612e8799ccb..0e2a0623d18 100644
--- a/TAO/tao/PollableC.cpp
+++ b/TAO/tao/PollableC.cpp
@@ -49,11 +49,29 @@ CORBA_Pollable_ptr CORBA_Pollable::_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/Pollable:1.0");
   if (servant == 0)
-    return new CORBA_Pollable(stub);
-  return new POA_CORBA::_tao_collocated_Pollable(
-      ACE_reinterpret_cast(POA_CORBA::Pollable_ptr, servant),
-      stub
+    {
+      CORBA_Pollable_ptr rval = CORBA_Pollable::_nil ();
+      
+      ACE_NEW_RETURN (rval,
+                      CORBA_Pollable (stub),  
+                      CORBA_Pollable::_nil ());
+                     
+      return rval; 
+    }
+
+  CORBA_Pollable_ptr retval = CORBA_Pollable::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_Pollable (
+          ACE_reinterpret_cast (POA_CORBA::Pollable_ptr, 
+                                servant),
+          stub
+        ),
+      CORBA_Pollable::_nil ()
     );
+
+  return retval;
 }
 
 CORBA_Pollable_ptr CORBA_Pollable::_unchecked_narrow (
@@ -69,11 +87,29 @@ CORBA_Pollable_ptr CORBA_Pollable::_unchecked_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/Pollable:1.0");
   if (servant == 0)
-    return new CORBA_Pollable(stub);
-  return new POA_CORBA::_tao_collocated_Pollable(
-      ACE_reinterpret_cast(POA_CORBA::Pollable_ptr, servant),
-      stub
+    {
+      CORBA_Pollable_ptr rval = CORBA_Pollable::_nil ();
+      
+      ACE_NEW_RETURN (rval,
+                      CORBA_Pollable (stub),  
+                      CORBA_Pollable::_nil ());
+                     
+      return rval; 
+    }
+
+  CORBA_Pollable_ptr retval = CORBA_Pollable::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_Pollable (
+          ACE_reinterpret_cast (POA_CORBA::Pollable_ptr, 
+                                servant),
+          stub
+        ),
+      CORBA_Pollable::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean CORBA_Pollable::is_ready (
@@ -211,11 +247,29 @@ CORBA::DIIPollable_ptr CORBA::DIIPollable::_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/DIIPollable:1.0");
   if (servant == 0)
-    return new CORBA::DIIPollable(stub);
-  return new POA_CORBA::_tao_collocated_DIIPollable(
-      ACE_reinterpret_cast(POA_CORBA::DIIPollable_ptr, servant),
-      stub
+    {
+      CORBA::DIIPollable_ptr rval = CORBA_Pollable::_nil ();
+      
+      ACE_NEW_RETURN (rval,
+                      CORBA::DIIPollable (stub),  
+                      CORBA::DIIPollable::_nil ());
+                     
+      return rval; 
+    }
+
+  CORBA::DIIPollable_ptr retval = CORBA::DIIPollable::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DIIPollable (
+          ACE_reinterpret_cast (POA_CORBA::DIIPollable_ptr, 
+                                servant),
+          stub
+        ),
+      CORBA::DIIPollable::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::DIIPollable_ptr CORBA::DIIPollable::_unchecked_narrow (
@@ -231,11 +285,29 @@ CORBA::DIIPollable_ptr CORBA::DIIPollable::_unchecked_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/DIIPollable:1.0");
   if (servant == 0)
-    return new CORBA::DIIPollable(stub);
-  return new POA_CORBA::_tao_collocated_DIIPollable(
-      ACE_reinterpret_cast(POA_CORBA::DIIPollable_ptr, servant),
-      stub
+    {
+      CORBA::DIIPollable_ptr rval = CORBA_Pollable::_nil ();
+      
+      ACE_NEW_RETURN (rval,
+                      CORBA::DIIPollable (stub),  
+                      CORBA::DIIPollable::_nil ());
+                     
+      return rval; 
+    }
+
+  CORBA::DIIPollable_ptr retval = CORBA::DIIPollable::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_DIIPollable (
+          ACE_reinterpret_cast (POA_CORBA::DIIPollable_ptr, 
+                                servant),
+          stub
+        ),
+      CORBA::DIIPollable::_nil ()
     );
+
+  return retval;
 }
 
 CORBA::Boolean CORBA::DIIPollable::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
@@ -271,11 +343,29 @@ CORBA_PollableSet_ptr CORBA_PollableSet::_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/PollableSet:1.0");
   if (servant == 0)
-    return new CORBA_PollableSet(stub);
-  return new POA_CORBA::_tao_collocated_PollableSet(
-      ACE_reinterpret_cast(POA_CORBA::PollableSet_ptr, servant),
-      stub
+    {
+      CORBA_PollableSet_ptr rval = CORBA_PollableSet::_nil ();
+      
+      ACE_NEW_RETURN (rval,
+                      CORBA_PollableSet (stub),  
+                      CORBA_PollableSet::_nil ());
+                     
+      return rval; 
+    }
+
+  CORBA_PollableSet_ptr retval = CORBA_PollableSet::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_PollableSet (
+          ACE_reinterpret_cast (POA_CORBA::PollableSet_ptr, 
+                                servant),
+          stub
+        ),
+      CORBA_PollableSet::_nil ()
     );
+
+  return retval;
 }
 
 CORBA_PollableSet_ptr CORBA_PollableSet::_unchecked_narrow (
@@ -291,11 +381,29 @@ CORBA_PollableSet_ptr CORBA_PollableSet::_unchecked_narrow (
   if (obj->_is_collocated () && obj->_servant() != 0)
     servant = obj->_servant()->_downcast ("IDL:omg.org/CORBA/PollableSet:1.0");
   if (servant == 0)
-    return new CORBA_PollableSet(stub);
-  return new POA_CORBA::_tao_collocated_PollableSet(
-      ACE_reinterpret_cast(POA_CORBA::PollableSet_ptr, servant),
-      stub
+    {
+      CORBA_PollableSet_ptr rval = CORBA_PollableSet::_nil ();
+      
+      ACE_NEW_RETURN (rval,
+                      CORBA_PollableSet (stub),  
+                      CORBA_PollableSet::_nil ());
+                     
+      return rval; 
+    }
+
+  CORBA_PollableSet_ptr retval = CORBA_PollableSet::_nil ();
+
+  ACE_NEW_RETURN (
+      retval,
+      POA_CORBA::_tao_collocated_PollableSet (
+          ACE_reinterpret_cast (POA_CORBA::PollableSet_ptr, 
+                                servant),
+          stub
+        ),
+      CORBA_PollableSet::_nil ()
     );
+
+  return retval;
 }
 
 // default constructor
@@ -343,7 +451,13 @@ void CORBA_PollableSet::NoPossiblePollable::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_PollableSet::NoPossiblePollable::_alloc (void)
 {
-  return new CORBA_PollableSet::NoPossiblePollable;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_PollableSet::NoPossiblePollable
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_CORBA_PollableSet_NoPossiblePollable[] =
@@ -401,7 +515,13 @@ void CORBA_PollableSet::UnknownPollable::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_PollableSet::UnknownPollable::_alloc (void)
 {
-  return new CORBA_PollableSet::UnknownPollable;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_PollableSet::UnknownPollable
+                  0);
+
+  return retval;
 }
 
 static const CORBA::Long _oc_CORBA_PollableSet_UnknownPollable[] =
@@ -864,7 +984,9 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet_ptr &_
 
 void operator<<= (CORBA::Any &_tao_any, const CORBA_PollableSet::NoPossiblePollable &_tao_elem) // copying
 {
-  CORBA_PollableSet::NoPossiblePollable *_tao_any_val = new CORBA_PollableSet::NoPossiblePollable (_tao_elem);
+  CORBA_PollableSet::NoPossiblePollable *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           CORBA_PollableSet::NoPossiblePollable (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
@@ -929,7 +1051,9 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PollableSet::NoPos
 
 void operator<<= (CORBA::Any &_tao_any, const CORBA_PollableSet::UnknownPollable &_tao_elem) // copying
 {
-  CORBA_PollableSet::UnknownPollable *_tao_any_val = new CORBA_PollableSet::UnknownPollable (_tao_elem);
+  CORBA_PollableSet::UnknownPollable *_tao_any_val = 0;
+  ACE_NEW (_tao_any_val,
+           CORBA_PollableSet::UnknownPollable (_tao_elem));
   if (!_tao_any_val) return;
   ACE_TRY_NEW_ENV
   {
diff --git a/TAO/tao/PollableS.cpp b/TAO/tao/PollableS.cpp
index 6d936516930..1c6bab79dc3 100644
--- a/TAO/tao/PollableS.cpp
+++ b/TAO/tao/PollableS.cpp
@@ -322,7 +322,15 @@ POA_CORBA::Pollable::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_Pollable (this, stub);
+
+  CORBA::Pollable *retval = CORBA::Pollable::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_Pollable (this, 
+                                                       stub),'
+                  CORBA::Pollable::_nil ());
+
+  return retval;
 }
 
 class TAO_CORBA_DIIPollable_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
@@ -548,7 +556,15 @@ POA_CORBA::DIIPollable::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_DIIPollable (this, stub);
+
+  CORBA::DIIPollable *retval = CORBA::DIIPollable::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_DIIPollable (this, 
+                                                          stub),'
+                  CORBA::DIIPollable::_nil ());
+
+  return retval;
 }
 
 class TAO_CORBA_PollableSet_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
@@ -945,6 +961,14 @@ POA_CORBA::PollableSet::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
-  return new POA_CORBA::_tao_collocated_PollableSet (this, stub);
+
+  CORBA::PollableSet *retval = CORBA::PollableSet::_nil ();
+
+  ACE_NEW_RETURN (retval,
+                  POA_CORBA::_tao_collocated_PollableSet (this, 
+                                                          stub),'
+                  CORBA::PollableSet::_nil ());
+
+  return retval;
 }
 #endif /* TAO_HAS_CORBA_MESSAGING && TAO_HAS_AMI_POLLER */
diff --git a/TAO/tao/WrongTransactionC.cpp b/TAO/tao/WrongTransactionC.cpp
index e85873c1b2a..2a62ed0aedc 100644
--- a/TAO/tao/WrongTransactionC.cpp
+++ b/TAO/tao/WrongTransactionC.cpp
@@ -57,7 +57,13 @@ void CORBA_WrongTransaction::_raise ()
 // TAO extension - the _alloc method
 CORBA::Exception *CORBA_WrongTransaction::_alloc (void)
 {
-  return new CORBA_WrongTransaction;
+  CORBA::Exception *retval = 0;
+
+  ACE_NEW_RETURN (retval,
+                  CORBA_WrongTransaction,
+                  0);
+
+  return retval;
 }
 
 #endif /* TAO_HAS_MINIMUM_CORBA */