ChangeLogTag:Tue Aug 3 18:50:02 1999 Douglas C. Schmidt <schmidt@tango.cs.wustl.edu>

14 files changed, 606 insertions, 227 deletions

diff --git a/ChangeLog-99b b/ChangeLog-99b
index eee7c2b0d65..48f45e696b7 100644
--- a/ChangeLog-99b
+++ b/ChangeLog-99b
@@ -1,3 +1,37 @@
+Tue Aug  3 18:50:02 1999  Douglas C. Schmidt  <schmidt@tango.cs.wustl.edu>
+
+	* examples/Shared_Malloc/test_position_independent_malloc.cpp: 
+	  Finished integrating all the features of this test.  It's pretty
+	  cool now!
+	
+	* examples/Shared_Malloc/Makefile: Updated the LSRC target so
+	  'make depend' works correctly...
+
+	* ace/Select_Reactor_Base.cpp (find): Don't set errno = ENOENT
+	  if we find a valid mapping of handle to Event_Handler.  Thanks
+ 	  to Hao Ruan <hruan@lucent.com> for reporting this.
+
+	* ace/Based_Pointer_T: Added support for operator= (const
+ 	  ACE_Based_Pointer_Basic<T> &).
+
+	* ace/Based_Pointer_T: Added definitions for
+	  ACE_Based_Pointer::operator= and
+ 	  ACE_Based_Pointer_Basic::operator= to make EGCS happy.
+  
+	* ace/Malloc.h: Factored out the common code for
+	  ACE_Based_Pointer<> and the underlying types, thereby reducing
+ 	  the number of #ifdef's.
+
+	* ace/Based_Pointer_T: Added an operator CONCRETE *() method
+
+	* ace/Based_Pointer_Repository.cpp: The original implementation
+	  of this classes stored a pointer to the size of each mapped
+ 	  address, rather than just the value.  This was causing problems
+ 	  when used for shared memory because the memory was allocated in
+ 	  one process and freed in another.  This is now fixed by not
+ 	  storing a pointer, but by storing the value instead.  Thanks to
+ 	  Nanbor for reporting this.
+
 Tue Aug 03 21:17:00 1999  Nanbor Wang  <nanbor@cs.wustl.edu>
 
 	* tests/SOCK_Connector_Test.cpp (host_is_up): Added a time out
@@ -7,25 +41,23 @@ Tue Aug 03 21:17:00 1999  Nanbor Wang  <nanbor@cs.wustl.edu>
 Tue Aug 03 18:30:47 1999  Kirthika Parameswaran  <kirthika@cs.wustl.edu>
 
 	* ace/Strategies.h (ACE_Connection_Recycling_Strategy):
-	  Added a new pure virtual method <marked_as_closed_i> which
-	  will provide a non-locking implementation of the
-	  <mark_as_closed> method.
+	  Added a new pure virtual method <marked_as_closed_i> which will
+ 	  provide a non-locking implementation of the <mark_as_closed>
+ 	  method.
 
 	* ace/Strategies_T.h (ACE_Cached_Connect_Strategy):
 	* ace/Cached_Connect_Strategy_T.h (ACE_Cached_Connect_Strategy_Ex):
 	  Made <mark_as_closed_i> public.
 
 	* ace/Caching_Utility_T.{h,cpp}
-	  (ACE_Refcounted_Recyclable_Caching_Utility):
-	  Added this class which caters to purging of refcounted and
-	  recyclable handlers.
+	  (ACE_Refcounted_Recyclable_Caching_Utility): Added this class
+ 	  which caters to purging of refcounted and recyclable handlers.
 
 	* ace/Cleanup_Strategy_T.{h,cpp}:
-	  (ACE_Refcounted_Recyclable_Cleanup_Strategy):
-	  Added this class which caters to the cleanup of handlers which
-	  are refcounted and recyclable. Heres where the necessity of
-	  making the non-locking version of <marked_as_closed> public
-	  arose in the first place.
+	  (ACE_Refcounted_Recyclable_Cleanup_Strategy): Added this class
+ 	  which caters to the cleanup of handlers which are refcounted and
+ 	  recyclable. Heres where the necessity of making the non-locking
+ 	  version of <marked_as_closed> public arose in the first place.
 
 	* ace/OS.h (ACE_Recyclable_State):
 	  Removed hardcoded values and left the enum values to the
diff --git a/TAO/ChangeLog-99c b/TAO/ChangeLog-99c
index 154887170a9..35ba7b957eb 100644
--- a/TAO/ChangeLog-99c
+++ b/TAO/ChangeLog-99c
@@ -14,7 +14,7 @@ Tue Aug 03 18:40:47 1999  Kirthika Parameswaran  <kirthika@cs.wustl.edu>
 
 	* tao/Acceptor_Impl.cpp (out_of_sockets_handler):
 	  Added the iteration over the different ORBs in the system for
-	  purging 'old' connections.
+ 	  purging 'old' connections.
 
 	* tests/Connection_Purging/Connection_Purging.cpp:
 	* tests/Connection_Purging/Makefile:
diff --git a/ace/Based_Pointer_Repository.cpp b/ace/Based_Pointer_Repository.cpp
index 6600fcec096..5c79f42cb2e 100644
--- a/ace/Based_Pointer_Repository.cpp
+++ b/ace/Based_Pointer_Repository.cpp
@@ -5,9 +5,9 @@
 #include "ace/Based_Pointer_Repository.h"
 
 // Useful typedefs.
-typedef ACE_Map_Manager <void *, size_t *, ACE_Null_Mutex> MAP_MANAGER;
-typedef ACE_Map_Iterator < void *, size_t *, ACE_Null_Mutex> MAP_ITERATOR;
-typedef ACE_Map_Entry <void *, size_t *> MAP_ENTRY;
+typedef ACE_Map_Manager <void *, size_t, ACE_Null_Mutex> MAP_MANAGER;
+typedef ACE_Map_Iterator < void *, size_t, ACE_Null_Mutex> MAP_ITERATOR;
+typedef ACE_Map_Entry <void *, size_t> MAP_ENTRY;
 
 class ACE_Based_Pointer_Repository_Rep
 {
@@ -55,7 +55,7 @@ ACE_Based_Pointer_Repository::find (void *addr,
        iter.advance ())
     // Check to see if <addr> is within any of the regions.
     if (addr >= ce->ext_id_
-        && addr < ((char *) ce->ext_id_ + *(ce->int_id_)))
+        && addr < ((char *) ce->ext_id_ + ce->int_id_))
       {
         // Assign the base address.
         base_addr = ce->ext_id_;
@@ -77,22 +77,7 @@ ACE_Based_Pointer_Repository::bind (void *addr,
   ACE_TRACE ("ACE_Based_Pointer_Repository::bind");
   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1);
 
-  size_t *sizep;
-
-  if (this->rep_->addr_map_.find (addr, sizep) != -1)
-    {
-      // Store new size.
-      *sizep = size;
-      return 0;
-    }
-  else
-    {
-      ACE_NEW_RETURN (sizep,
-                      size_t,
-                      -1);
-      *sizep = size;
-      return this->rep_->addr_map_.bind (addr, sizep);
-    }
+  return this->rep_->addr_map_.rebind (addr, size);
 }
 
 // Unbind a base from the repository.
@@ -111,15 +96,11 @@ ACE_Based_Pointer_Repository::unbind (void *addr)
        iter.advance ())
     {
       // Check to see if <addr> is within any of the regions and if
-      // so, delete the memory and unbind the key from the map.
+      // so, unbind the key from the map.
       if (addr >= ce->ext_id_
-          && addr < ((char *) ce->ext_id_ + * (ce->int_id_)))
-        {
-          delete ce->int_id_;
-
-          // Unbind base address.
-          return this->rep_->addr_map_.unbind (ce->ext_id_);
-        }
+          && addr < ((char *) ce->ext_id_ + ce->int_id_))
+        // Unbind base address.
+        return this->rep_->addr_map_.unbind (ce->ext_id_);
     }
 
   return 0;
@@ -127,16 +108,16 @@ ACE_Based_Pointer_Repository::unbind (void *addr)
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 template class ACE_Singleton <ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX>;
-template class ACE_Map_Entry<void *, size_t *>;
-template class ACE_Map_Manager<void *, size_t *, ACE_Null_Mutex>;
-template class ACE_Map_Iterator<void *, size_t *, ACE_Null_Mutex>;
-template class ACE_Map_Reverse_Iterator<void *, size_t *, ACE_Null_Mutex>;
-template class ACE_Map_Iterator_Base<void *, size_t *, ACE_Null_Mutex>;
+template class ACE_Map_Entry<void *, size_t>;
+template class ACE_Map_Manager<void *, size_t, ACE_Null_Mutex>;
+template class ACE_Map_Iterator<void *, size_t, ACE_Null_Mutex>;
+template class ACE_Map_Reverse_Iterator<void *, size_t, ACE_Null_Mutex>;
+template class ACE_Map_Iterator_Base<void *, size_t, ACE_Null_Mutex>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 #pragma instantiate ACE_Singleton <ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX>
-#pragma instantiate ACE_Map_Entry<void *, size_t *>
-#pragma instantiate ACE_Map_Manager<void *, size_t *, ACE_Null_Mutex>
-#pragma instantiate ACE_Map_Iterator<void *, size_t *, ACE_Null_Mutex>
-#pragma instantiate ACE_Map_Reverse_Iterator<void *, size_t *, ACE_Null_Mutex>
-#pragma instantiate ACE_Map_Iterator_Base<void *, size_t *, ACE_Null_Mutex>
+#pragma instantiate ACE_Map_Entry<void *, size_t>
+#pragma instantiate ACE_Map_Manager<void *, size_t, ACE_Null_Mutex>
+#pragma instantiate ACE_Map_Iterator<void *, size_t, ACE_Null_Mutex>
+#pragma instantiate ACE_Map_Reverse_Iterator<void *, size_t, ACE_Null_Mutex>
+#pragma instantiate ACE_Map_Iterator_Base<void *, size_t, ACE_Null_Mutex>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/ace/Based_Pointer_T.cpp b/ace/Based_Pointer_T.cpp
index ec469c31f91..06529e8f02a 100644
--- a/ace/Based_Pointer_T.cpp
+++ b/ace/Based_Pointer_T.cpp
@@ -79,24 +79,15 @@ ACE_Based_Pointer_Basic<CONCRETE>::ACE_Based_Pointer_Basic (CONCRETE *rhs)
     }
 }
 
-template <class CONCRETE> ACE_INLINE
-ACE_Based_Pointer_Basic<CONCRETE>::ACE_Based_Pointer_Basic (const ACE_Based_Pointer_Basic<CONCRETE> &rhs)
+template <class CONCRETE>
+ACE_Based_Pointer_Basic<CONCRETE>::ACE_Based_Pointer_Basic (const ACE_Based_Pointer_Basic<CONCRETE> &)
 {
   ACE_TRACE ("ACE_Based_Pointer_Basic<CONCRETE>::ACE_Based_Pointer_Basic");
 
   ACE_ASSERT (!"not implemented");
-  void *base_addr = 0;
-
-  // Find the base address associated with the <addr> pointer.  Note
-  // that it's ok for <find> to return 0, which simply indicates that
-  // the address is not in memory-mapped virtual address space.
-  ACE_BASED_POINTER_REPOSITORY::instance ()->find (this,
-                                                   base_addr);
-  this->base_offset_ = (char *) this - (char *) base_addr;
-  this->target_ = ((char *) &rhs - (char *) base_addr);
 }
 
-template <class CONCRETE> ACE_INLINE
+template <class CONCRETE>
 ACE_Based_Pointer<CONCRETE>::ACE_Based_Pointer (const ACE_Based_Pointer<CONCRETE> &rhs)
   : ACE_Based_Pointer_Basic<CONCRETE> (rhs)
 {
diff --git a/ace/Based_Pointer_T.h b/ace/Based_Pointer_T.h
index 82c40e2a87d..3306016b8c3 100644
--- a/ace/Based_Pointer_T.h
+++ b/ace/Based_Pointer_T.h
@@ -82,6 +82,9 @@ public:
   void operator = (CONCRETE *from);
   // Pseudo-assignment operator.
 
+  void operator = (const ACE_Based_Pointer_Basic<CONCRETE> &);
+  // Pseudo-assignment operator.
+
   CONCRETE operator * (void) const;
   // Dereference operator.
 
@@ -109,6 +112,9 @@ public:
   void operator+= (long index);
   // Increment operator.
 
+  operator CONCRETE *() const;
+  // Returns the underlying memory address of the smart pointer.
+
   CONCRETE *addr (void) const;
   // Returns the underlying memory address of the smart pointer.
 
@@ -118,17 +124,11 @@ public:
   void dump (void) const;
   // Dump the state of the object.
 
-  // The following should be private, but that causes problems due to
-  // broken C++ compilers that don't like friends for methods
-  // in templates.
 protected:
   long target_;
 
   long base_offset_;
   // Keep track of our offset from the base pointer.
-
-  // = Prevent assignment and initialization (for now).
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Based_Pointer_Basic<CONCRETE> &))
 };
 
 template <class CONCRETE> 
@@ -152,16 +152,16 @@ public:
   // Initialize this object using the <initial> pointer.  
 
   ACE_Based_Pointer (const ACE_Based_Pointer<CONCRETE> &);
-  // Copy constructor.
+  // Copy constructor (not implemented yet).
+
+  void operator = (const ACE_Based_Pointer<CONCRETE> &);
+  // Assignment operator.
 
   void operator = (CONCRETE *from);
   // Pseudo-assignment operator.
 
   CONCRETE *operator-> (void);
   // The C++ "delegation operator".
-
-  // = Prevent assignment and initialization (for now).
-  ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Based_Pointer<CONCRETE> &))
 };
 
 #if defined (__ACE_INLINE__)
diff --git a/ace/Based_Pointer_T.i b/ace/Based_Pointer_T.i
index 4409abf03b0..07ce496a908 100644
--- a/ace/Based_Pointer_T.i
+++ b/ace/Based_Pointer_T.i
@@ -45,7 +45,8 @@ ACE_Based_Pointer_Basic<CONCRETE>::operator *(void) const
 template <class CONCRETE> ACE_INLINE CONCRETE *
 ACE_Based_Pointer_Basic<CONCRETE>::addr (void) const
 {
-  ACE_TRACE ("ACE_Based_Pointer_Basic<CONCRETE>::addr");
+  ACE_TRACE ("ACE_Based_Pointer_Basic<CONCRETE>::operator CONCRETE *()");
+
   if (this->target_ == -1)
     return 0;
   else
@@ -53,6 +54,14 @@ ACE_Based_Pointer_Basic<CONCRETE>::addr (void) const
                                  ACE_COMPUTE_BASED_POINTER (this));
 }
 
+template <class CONCRETE> ACE_INLINE
+ACE_Based_Pointer_Basic<CONCRETE>::operator CONCRETE *() const
+{
+  ACE_TRACE ("ACE_Based_Pointer_Basic<CONCRETE>::operator CONCRETE *()");
+
+  return this->addr ();
+}
+
 template <class CONCRETE> ACE_INLINE CONCRETE
 ACE_Based_Pointer_Basic<CONCRETE>::operator [] (long index) const
 {
@@ -111,3 +120,17 @@ ACE_Based_Pointer_Basic<CONCRETE>::operator >= (const ACE_Based_Pointer_Basic<CO
   return ACE_COMPUTE_BASED_POINTER (this) >= ACE_COMPUTE_BASED_POINTER (&rhs);
 }
 
+template <class CONCRETE> ACE_INLINE void
+ACE_Based_Pointer_Basic<CONCRETE>::operator= (const ACE_Based_Pointer_Basic<CONCRETE> &rhs)
+{
+  ACE_TRACE ("ACE_Based_Pointer_Basic<CONCRETE>::operator=");
+  *this = rhs.addr ();
+}
+
+template <class CONCRETE> ACE_INLINE void
+ACE_Based_Pointer<CONCRETE>::operator= (const ACE_Based_Pointer<CONCRETE> &rhs)
+{
+  ACE_TRACE ("ACE_Based_Pointer<CONCRETE>::operator=");
+  *this = rhs.addr ();
+}
+
diff --git a/ace/Malloc.cpp b/ace/Malloc.cpp
index 2fa2b29cc07..f4d6d1274b7 100644
--- a/ace/Malloc.cpp
+++ b/ace/Malloc.cpp
@@ -29,8 +29,8 @@ ACE_Control_Block::dump (void) const
   ACE_TRACE ("ACE_Control_Block::dump");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_POINTER_CAST (this->name_head_)->dump ();
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("freep_ = %x"), ACE_POINTER_CAST (this->freep_)));
+  ((ACE_Name_Node *) this->name_head_)->dump ();
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("freep_ = %x"), (ACE_Malloc_Header *) this->freep_));
 
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -49,7 +49,7 @@ ACE_Name_Node::ACE_Name_Node (const char *name,
     next_ (next)
 {
   ACE_TRACE ("ACE_Name_Node::ACE_Name_Node");
-  char *n = ACE_POINTER_CAST (this->name_);
+  char *n = this->name_;
   ACE_OS::strcpy (n, name);
 }
 
@@ -62,7 +62,8 @@ ACE_Name_Node::ACE_Name_Node (const ACE_Name_Node &)
 const char *
 ACE_Name_Node::name (void) const
 {
-  return ACE_POINTER_CAST (this->name_);
+  const char *c = this->name_;
+  return c;
 }
 
 void
@@ -77,9 +78,12 @@ ACE_Name_Node::dump (void) const
   ACE_TRACE ("ACE_Name_Node");
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("pointer = %x"), ACE_POINTER_CAST (this->pointer_)));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nnext_ = %x"), ACE_POINTER_CAST (this->next_)));
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nname_ = (%x, %s)"), ACE_POINTER_CAST (this->name_), ACE_POINTER_CAST (this->name_)));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("pointer = %x"), (const char *) this->pointer_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\nnext_ = %x"), (ACE_Name_Node *) this->next_));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT("\nname_ = (%x, %s)"),
+              (const char *) this->name_,
+              (const char *) this->name_));
   ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("\n")));
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
diff --git a/ace/Malloc.h b/ace/Malloc.h
index 81eefa0ac70..3f63a3d4e02 100644
--- a/ace/Malloc.h
+++ b/ace/Malloc.h
@@ -78,6 +78,20 @@ struct ACE_Export ACE_Malloc_Stats
 #define ACE_MALLOC_PADDING 1
 #endif /* ACE_MALLOC_PADDING */
 
+// Forward decl.
+class ACE_Malloc_Header;
+class ACE_Name_Node;
+
+#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
+typedef ACE_Based_Pointer<ACE_Malloc_Header> ACE_MALLOC_HEADER_PTR;
+typedef ACE_Based_Pointer<ACE_Name_Node> ACE_NAME_NODE_PTR;
+typedef ACE_Based_Pointer_Basic<char> ACE_CHAR_PTR;
+#else
+typedef ACE_Malloc_Header *ACE_MALLOC_HEADER_PTR;
+typedef ACE_Name_Node *ACE_NAME_NODE_PTR;
+typedef char *ACE_CHAR_PTR;
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
+
 class ACE_Export ACE_Malloc_Header
 {
   // = TITLE
@@ -85,18 +99,10 @@ class ACE_Export ACE_Malloc_Header
   //    to keep track of each chunk of data when it's in the free
   //    list or in use.
 public:
-#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-# define ACE_POINTER_CAST(PTR) ((PTR).addr ())
-  typedef ACE_Based_Pointer<ACE_Malloc_Header> HEADER_PTR;
-#else
-# define ACE_POINTER_CAST(PTR) ((PTR))
-  typedef ACE_Malloc_Header *HEADER_PTR;
-#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
-
   class ACE_Malloc_Control_Block
   {
   public:
-    HEADER_PTR next_block_;
+    ACE_MALLOC_HEADER_PTR next_block_;
     // Points to next block if on free list.
 
     size_t size_;
@@ -150,25 +156,14 @@ public:
   void name (const char *);
   // Assign a name;
 
-#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-  ACE_Based_Pointer_Basic<char> name_;
+  ACE_CHAR_PTR name_;
   // Name of the Node.
 
-  ACE_Based_Pointer_Basic<char> pointer_;
+  ACE_CHAR_PTR pointer_;
   // Pointer to the contents.
 
-  ACE_Based_Pointer<ACE_Name_Node> next_;
+  ACE_NAME_NODE_PTR next_;
   // Pointer to the next node in the chain.
-#else
-  char *name_;
-  // Name of the Node.
-
-  char *pointer_;
-  // Pointer to the contents.
-
-  ACE_Name_Node *next_;
-  // Pointer to the next node in the chain.
-#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
 
   void dump (void) const;
   // Dump the state of the object.
@@ -188,15 +183,10 @@ class ACE_Export ACE_Control_Block
   //    This class should be local to class ACE_Malloc, but some older
   //    C++ compilers don't like nested classes in templates...
 public:
-#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-  ACE_Based_Pointer<ACE_Name_Node> name_head_;
+  ACE_NAME_NODE_PTR name_head_;
   // Head of the linked list of Name Nodes.
-#else
-  ACE_Name_Node *name_head_;
-  // Head of the linked list of Name Nodes.
-#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
 
-  ACE_Malloc_Header::HEADER_PTR freep_;
+  ACE_MALLOC_HEADER_PTR freep_;
   // Current head of the freelist.
 
   char lock_name_[MAXNAMELEN];
diff --git a/ace/Malloc_T.cpp b/ace/Malloc_T.cpp
index 3f760050910..1638c1810b4 100644
--- a/ace/Malloc_T.cpp
+++ b/ace/Malloc_T.cpp
@@ -103,16 +103,16 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::print_stats (void) const
   ACE_DEBUG ((LM_DEBUG,
               ASYS_TEXT ("(%P|%t) contents of freelist:\n")));
 
-  for (ACE_Malloc_Header *currp = ACE_POINTER_CAST (this->cb_ptr_->freep_->s_.next_block_);
+  for (ACE_Malloc_Header *currp = this->cb_ptr_->freep_->s_.next_block_;
        ;
-       currp = ACE_POINTER_CAST (currp->s_.next_block_))
+       currp = currp->s_.next_block_)
     {
       ACE_DEBUG ((LM_DEBUG,
                   ASYS_TEXT ("(%P|%t) ptr = %u, ACE_Malloc_Header units = %d, byte units = %d\n"),
                   currp,
                   currp->s_.size_,
                   currp->s_.size_ * sizeof (ACE_Malloc_Header)));
-      if (currp == ACE_POINTER_CAST (this->cb_ptr_->freep_))
+      if (currp == this->cb_ptr_->freep_)
         break;
     }
 }
@@ -167,8 +167,8 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
 #if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
       // Initialize the freelist pointer to point to the dummy
       // <ACE_Malloc_Header>.
-      new ((void *) &this->cb_ptr_->freep_) ACE_Malloc_Header::HEADER_PTR (&this->cb_ptr_->base_);
-      new ((void *) &this->cb_ptr_->name_head_) ACE_Based_Pointer<ACE_Name_Node>;
+      new ((void *) &this->cb_ptr_->freep_) ACE_MALLOC_HEADER_PTR (&this->cb_ptr_->base_);
+      new ((void *) &this->cb_ptr_->name_head_) ACE_NAME_NODE_PTR;
 #else
       // Initialize the freelist pointer to point to the dummy
       // <ACE_Malloc_Header>.
@@ -180,14 +180,14 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
 
       // Initialize the dummy <ACE_Malloc_Header> to point to itself.
       this->cb_ptr_->freep_->s_.size_ = 0;
-      this->cb_ptr_->freep_->s_.next_block_ = ACE_POINTER_CAST (this->cb_ptr_->freep_);
+      this->cb_ptr_->freep_->s_.next_block_ = this->cb_ptr_->freep_;
 
       if (rounded_bytes > (sizeof *this->cb_ptr_ + sizeof (ACE_Malloc_Header)))
         {
           // If we've got any extra space at the end of the control
           // block, then skip past the dummy ACE_Malloc_Header to
           // point at the first free block.
-          ACE_Malloc_Header *p = ACE_POINTER_CAST (this->cb_ptr_->freep_) + 1;
+          ACE_Malloc_Header *p = ((ACE_Malloc_Header *) (this->cb_ptr_->freep_)) + 1;
 
           // Why aC++ in 64-bit mode can't grok this, I have no
           // idea... but it ends up with an extra bit set which makes
@@ -247,7 +247,8 @@ template <ACE_MEM_POOL_1, class ACE_LOCK>
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Malloc (LPCTSTR pool_name,
                                                   LPCTSTR lock_name,
                                                   const void *options)
-  : memory_pool_ (pool_name, (const ACE_MEM_POOL_OPTIONS *) options),
+  : memory_pool_ (pool_name,
+                  (const ACE_MEM_POOL_OPTIONS *) options),
     lock_ (lock_name)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Malloc");
@@ -299,25 +300,25 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
 
   // Round up request to a multiple of the ACE_Malloc_Header size.
   size_t nunits =
- (nbytes + sizeof (ACE_Malloc_Header) - 1) / sizeof (ACE_Malloc_Header)
+    (nbytes + sizeof (ACE_Malloc_Header) - 1) / sizeof (ACE_Malloc_Header)
     + 1; // Add one for the <ACE_Malloc_Header> itself.
 
   // Begin the search starting at the place in the freelist where the
   // last block was found.
-  ACE_Malloc_Header *prevp = ACE_POINTER_CAST (this->cb_ptr_->freep_);
-  ACE_Malloc_Header *currp = ACE_POINTER_CAST (prevp->s_.next_block_);
+  ACE_Malloc_Header *prevp = this->cb_ptr_->freep_;
+  ACE_Malloc_Header *currp = prevp->s_.next_block_;
 
   // Search the freelist to locate a block of the appropriate size.
 
   for (int i = 0;
-       ; i++, prevp = currp, currp = ACE_POINTER_CAST (currp->s_.next_block_))
+       ; i++, prevp = currp, currp = currp->s_.next_block_)
     {
       if (currp->s_.size_ >= nunits) // Big enough
         {
           AMS (++this->cb_ptr_->malloc_stats_.ninuse_);
           if (currp->s_.size_ == nunits)
             // Exact size, just update the pointers.
-            prevp->s_.next_block_ = ACE_POINTER_CAST (currp->s_.next_block_);
+            prevp->s_.next_block_ = currp->s_.next_block_;
           else
             {
               // Remaining chunk is larger than requested block, so
@@ -332,7 +333,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
           // Skip over the ACE_Malloc_Header when returning pointer.
           return currp + 1;
         }
-      else if (currp == ACE_POINTER_CAST (this->cb_ptr_->freep_))
+      else if (currp == this->cb_ptr_->freep_)
         {
           // We've wrapped around freelist without finding a block.
           // Therefore, we need to ask the memory pool for a new chunk
@@ -357,7 +358,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
               // free list.  Skip over the ACE_Malloc_Header when
               // returning pointer.
               this->shared_free (currp + 1);
-              currp = ACE_POINTER_CAST (this->cb_ptr_->freep_);
+              currp = this->cb_ptr_->freep_;
             }
           else
             ACE_ERROR_RETURN ((LM_ERROR,
@@ -405,38 +406,38 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_free (void *ap)
     return;
 
   // Adjust AP to point to the block ACE_Malloc_Header
-  ACE_Malloc_Header *blockp = (ACE_Malloc_Header *) ap - 1;
-  ACE_Malloc_Header *currp = ACE_POINTER_CAST (this->cb_ptr_->freep_);
+  ACE_Malloc_Header *blockp = ((ACE_Malloc_Header *) ap) - 1;
+  ACE_Malloc_Header *currp = this->cb_ptr_->freep_;
 
   // Search until we find the location where the blocks belongs.  Note
   // that addresses are kept in sorted order.
 
   for (;
-       blockp <= currp || blockp >= ACE_POINTER_CAST (currp->s_.next_block_);
-       currp = ACE_POINTER_CAST (currp->s_.next_block_))
+       blockp <= currp || blockp >= currp->s_.next_block_;
+       currp = currp->s_.next_block_)
     {
-      if (currp >= ACE_POINTER_CAST (currp->s_.next_block_)
-          && (blockp > currp || blockp < ACE_POINTER_CAST (currp->s_.next_block_)))
+      if (currp >= currp->s_.next_block_
+          && (blockp > currp || blockp < currp->s_.next_block_))
         // Freed block at the start or the end of the memory pool.
         break;
     }
 
   // Join to upper neighbor.
-  if (blockp + blockp->s_.size_ == ACE_POINTER_CAST (currp->s_.next_block_))
+  if ((blockp + blockp->s_.size_) == currp->s_.next_block_)
     {
       AMS (--this->cb_ptr_->malloc_stats_.nblocks_);
       blockp->s_.size_ += currp->s_.next_block_->s_.size_;
-      blockp->s_.next_block_ = ACE_POINTER_CAST (currp->s_.next_block_->s_.next_block_);
+      blockp->s_.next_block_ = currp->s_.next_block_->s_.next_block_;
     }
   else
-    blockp->s_.next_block_ = ACE_POINTER_CAST (currp->s_.next_block_);
+    blockp->s_.next_block_ = currp->s_.next_block_;
 
   // Join to lower neighbor.
-  if (currp + currp->s_.size_ == blockp) 
+  if ((currp + currp->s_.size_) == blockp) 
     {
       AMS (--this->cb_ptr_->malloc_stats_.nblocks_);
       currp->s_.size_ += blockp->s_.size_;
-      currp->s_.next_block_ = ACE_POINTER_CAST (blockp->s_.next_block_);
+      currp->s_.next_block_ = blockp->s_.next_block_;
     }
   else
     currp->s_.next_block_ = blockp;
@@ -455,9 +456,9 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_find (const char *name)
   if (this->cb_ptr_ == 0)
     return 0;
 
-  for (ACE_Name_Node *node = ACE_POINTER_CAST (this->cb_ptr_->name_head_);
+  for (ACE_Name_Node *node = this->cb_ptr_->name_head_;
        node != 0;
-       node = ACE_POINTER_CAST (node->next_))
+       node = node->next_)
     if (ACE_OS::strcmp (node->name (),
                         name) == 0)
       return node;
@@ -488,7 +489,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind (const char *name,
                                   name_ptr,
                                   ACE_reinterpret_cast (char *,
                                                         pointer),
-                                  ACE_POINTER_CAST (this->cb_ptr_->name_head_));
+                                  this->cb_ptr_->name_head_);
   this->cb_ptr_->name_head_ = result;
   return 0;
 }
@@ -507,8 +508,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::trybind (const char *name,
   else
     {
       // Found it, so return a copy of the current entry.
-      pointer = ACE_reinterpret_cast (void *,
-                                      ACE_POINTER_CAST (node->pointer_));
+      pointer = (char *) node->pointer_;
       return 1;
     }
 }
@@ -546,8 +546,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::find (const char *name,
     return -1;
   else
     {
-      pointer = ACE_reinterpret_cast (void *,
-                                      ACE_POINTER_CAST (node->pointer_));
+      pointer = (char *) node->pointer_;
       return 0;
     }
 }
@@ -574,9 +573,9 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::avail_chunks (size_t size) const
   // Avoid dividing by 0...
   size = size == 0 ? 1 : size;
 
-  for (ACE_Malloc_Header *currp = ACE_POINTER_CAST (this->cb_ptr_->freep_->s_.next_block_);
-       currp != ACE_POINTER_CAST (this->cb_ptr_->freep_);
-       currp = ACE_POINTER_CAST (currp->s_.next_block_))
+  for (ACE_Malloc_Header *currp = this->cb_ptr_->freep_->s_.next_block_;
+       currp != this->cb_ptr_->freep_;
+       currp = currp->s_.next_block_)
     // Calculate how many will fit in this block.
     if (currp->s_.size_ * sizeof (ACE_Malloc_Header) >= size)
       count += currp->s_.size_ * sizeof (ACE_Malloc_Header) / size;
@@ -604,18 +603,18 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::unbind (const char *name, void *&pointer)
 
   ACE_Name_Node *prev = 0;
 
-  for (ACE_Name_Node *curr = ACE_POINTER_CAST (this->cb_ptr_->name_head_);
+  for (ACE_Name_Node *curr = this->cb_ptr_->name_head_;
        curr != 0;
-       curr = ACE_POINTER_CAST (curr->next_))
+       curr = curr->next_)
     {
       if (ACE_OS::strcmp (curr->name (), name) == 0)
         {
-          pointer = ACE_POINTER_CAST (curr->pointer_);
+          pointer = (char *) curr->pointer_;
 
           if (prev == 0)
-            this->cb_ptr_->name_head_ = ACE_POINTER_CAST (curr->next_);
+            this->cb_ptr_->name_head_ = curr->next_;
           else
-            prev->next_ = ACE_POINTER_CAST (curr->next_);
+            prev->next_ = curr->next_;
 
           // This will free up both the node and the name due to our
           // clever trick in <bind>!
@@ -664,7 +663,7 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Malloc_Iterator (ACE_Malloc<A
   // @@ Doug, this looks like trouble...
   ACE_Name_Node temp;
   this->curr_ = &temp;
-  this->curr_->next_ = ACE_POINTER_CAST (malloc_.cb_ptr_->name_head_);
+  this->curr_->next_ = malloc_.cb_ptr_->name_head_;
 
   this->advance ();
 }
@@ -683,7 +682,7 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::next (void *&next_entry,
 
   if (this->curr_ != 0)
     {
-      next_entry = ACE_POINTER_CAST (this->curr_->pointer_);
+      next_entry = (char *) this->curr_->pointer_;
       name = this->curr_->name ();
       return 1;
     }
@@ -698,7 +697,7 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::next (void *&next_entry)
 
   if (this->curr_ != 0)
     {
-      next_entry = ACE_POINTER_CAST (this->curr_->pointer_);
+      next_entry = this->curr_->pointer_;
       return 1;
     }
   else
@@ -718,14 +717,15 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::advance (void)
 {
   ACE_TRACE ("ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::advance");
 
-  this->curr_ = ACE_POINTER_CAST (this->curr_->next_);
+  this->curr_ = this->curr_->next_;
 
   if (this->name_ == 0)
     return this->curr_ != 0;
 
   while (this->curr_ != 0
-         && ACE_OS::strcmp (this->name_, this->curr_->name ()) != 0)
-    this->curr_ = ACE_POINTER_CAST (this->curr_->next_);
+         && ACE_OS::strcmp (this->name_,
+                            this->curr_->name ()) != 0)
+    this->curr_ = this->curr_->next_;
 
   return this->curr_ != 0;
 }
diff --git a/ace/Select_Reactor_Base.cpp b/ace/Select_Reactor_Base.cpp
index 8f8fd2c4070..72aa1cf7c81 100644
--- a/ace/Select_Reactor_Base.cpp
+++ b/ace/Select_Reactor_Base.cpp
@@ -190,12 +190,15 @@ ACE_Select_Reactor_Handler_Repository::find (ACE_HANDLE handle,
 #endif /* ACE_WIN32 */
     }
   else
-    // g++ can't figure out that i won't be used below if the handle
-    // is out of range, so keep it happy by defining i here . . .
+    // g++ can't figure out that <i> won't be used below if the handle
+    // is out of range, so keep it happy by defining <i> here . . .
     i = 0;
 
-  if (eh != 0 && index_p != 0)
-    *index_p = i;
+  if (eh != 0)
+    {
+      if (index_p != 0)
+        *index_p = i;
+    }
   else
     errno = ENOENT;
 
diff --git a/ace/config-sunos5.5.h b/ace/config-sunos5.5.h
index 07946945b44..27c6d14931d 100644
--- a/ace/config-sunos5.5.h
+++ b/ace/config-sunos5.5.h
@@ -307,7 +307,7 @@
 #define ACE_HAS_STL_QUEUE_CONFLICT
 #define ACE_HAS_IDTYPE_T
 
-#define ACE_HAS_POSITION_INDEPENDENT_MALLOC
+  // #define ACE_HAS_POSITION_INDEPENDENT_MALLOC
 
 #define ACE_HAS_GPERF
 #define ACE_HAS_DIRENT
diff --git a/examples/Shared_Malloc/Makefile b/examples/Shared_Malloc/Makefile
index 81f16f3216f..2395dc78dbf 100644
--- a/examples/Shared_Malloc/Makefile
+++ b/examples/Shared_Malloc/Makefile
@@ -18,6 +18,7 @@ FILES   = Malloc \
 
 SRC	= $(addsuffix .cpp,$(FILES))
 OBJ	= $(addsuffix .o,$(FILES))
+LSRC    = $(SRC) $(addsuffix .cpp,$(BIN))
 
 BUILD   = $(VBIN)
 
@@ -47,6 +48,8 @@ include	$(ACE_ROOT)/include/makeinclude/rules.local.GNU
 .obj/Malloc.o .obj/Malloc.so .shobj/Malloc.o .shobj/Malloc.so: Malloc.cpp Options.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -57,12 +60,222 @@ include	$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i
+.obj/Options.o .obj/Options.so .shobj/Options.o .shobj/Options.so: Options.cpp \
+ $(ACE_ROOT)/ace/Get_Opt.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
  $(ACE_ROOT)/ace/Log_Record.i \
- Malloc.h \
+ $(ACE_ROOT)/ace/Get_Opt.i Options.h
+.obj/test_malloc.o .obj/test_malloc.so .shobj/test_malloc.o .shobj/test_malloc.so: test_malloc.cpp \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Thread_Manager.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Thread_Manager.i \
+ Malloc.h Options.h
+.obj/test_persistence.o .obj/test_persistence.so .shobj/test_persistence.o .shobj/test_persistence.so: test_persistence.cpp \
  $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
  $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
  $(ACE_ROOT)/ace/Malloc.i \
  $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i
+.obj/test_position_independent_malloc.o .obj/test_position_independent_malloc.so .shobj/test_position_independent_malloc.o .shobj/test_position_independent_malloc.so: \
+ test_position_independent_malloc.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
  $(ACE_ROOT)/ace/Synch.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
  $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
@@ -77,6 +290,15 @@ include	$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Thread.i \
  $(ACE_ROOT)/ace/Atomic_Op.i \
  $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
  $(ACE_ROOT)/ace/Free_List.h \
  $(ACE_ROOT)/ace/Free_List.i \
  $(ACE_ROOT)/ace/Free_List.cpp \
@@ -90,11 +312,133 @@ include	$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/Containers_T.i \
  $(ACE_ROOT)/ace/Containers_T.cpp \
  $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i \
+ $(ACE_ROOT)/ace/Get_Opt.h \
+ $(ACE_ROOT)/ace/Get_Opt.i \
+ test_position_independent_malloc.h
+.obj/test_multiple_mallocs.o .obj/test_multiple_mallocs.so .shobj/test_multiple_mallocs.o .shobj/test_multiple_mallocs.so: test_multiple_mallocs.cpp \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
  $(ACE_ROOT)/ace/Object_Manager.h \
  $(ACE_ROOT)/ace/Object_Manager.i \
  $(ACE_ROOT)/ace/Managed_Object.h \
  $(ACE_ROOT)/ace/Managed_Object.i \
  $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
+ $(ACE_ROOT)/ace/Mem_Map.h \
+ $(ACE_ROOT)/ace/Mem_Map.i \
+ $(ACE_ROOT)/ace/Memory_Pool.i
+.obj/Malloc.o .obj/Malloc.so .shobj/Malloc.o .shobj/Malloc.so: Malloc.cpp Options.h \
+ $(ACE_ROOT)/ace/OS.h \
+ $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
+ $(ACE_ROOT)/ace/streams.h \
+ $(ACE_ROOT)/ace/Basic_Types.h \
+ $(ACE_ROOT)/ace/Basic_Types.i \
+ $(ACE_ROOT)/ace/Trace.h \
+ $(ACE_ROOT)/ace/OS.i \
+ $(ACE_ROOT)/ace/Log_Msg.h \
+ $(ACE_ROOT)/ace/Log_Record.h \
+ $(ACE_ROOT)/ace/ACE.h \
+ $(ACE_ROOT)/ace/ACE.i \
+ $(ACE_ROOT)/ace/Log_Priority.h \
+ $(ACE_ROOT)/ace/Log_Record.i Malloc.h \
+ $(ACE_ROOT)/ace/Malloc.h \
+ $(ACE_ROOT)/ace/Malloc_Base.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.h \
+ $(ACE_ROOT)/ace/Based_Pointer_T.i \
+ $(ACE_ROOT)/ace/Based_Pointer_T.cpp \
+ $(ACE_ROOT)/ace/Based_Pointer_Repository.h \
+ $(ACE_ROOT)/ace/Singleton.h \
+ $(ACE_ROOT)/ace/Synch.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \
+ $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \
+ $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \
+ $(ACE_ROOT)/ace/Synch.i \
+ $(ACE_ROOT)/ace/Synch_T.h \
+ $(ACE_ROOT)/ace/Event_Handler.h \
+ $(ACE_ROOT)/ace/Event_Handler.i \
+ $(ACE_ROOT)/ace/Synch_T.i \
+ $(ACE_ROOT)/ace/Thread.h \
+ $(ACE_ROOT)/ace/Thread.i \
+ $(ACE_ROOT)/ace/Atomic_Op.i \
+ $(ACE_ROOT)/ace/Synch_T.cpp \
+ $(ACE_ROOT)/ace/Singleton.i \
+ $(ACE_ROOT)/ace/Singleton.cpp \
+ $(ACE_ROOT)/ace/Object_Manager.h \
+ $(ACE_ROOT)/ace/Object_Manager.i \
+ $(ACE_ROOT)/ace/Managed_Object.h \
+ $(ACE_ROOT)/ace/Managed_Object.i \
+ $(ACE_ROOT)/ace/Managed_Object.cpp \
+ $(ACE_ROOT)/ace/Malloc.i \
+ $(ACE_ROOT)/ace/Malloc_T.h \
+ $(ACE_ROOT)/ace/Free_List.h \
+ $(ACE_ROOT)/ace/Free_List.i \
+ $(ACE_ROOT)/ace/Free_List.cpp \
+ $(ACE_ROOT)/ace/Malloc_T.i \
+ $(ACE_ROOT)/ace/Malloc_T.cpp \
+ $(ACE_ROOT)/ace/Memory_Pool.h \
+ $(ACE_ROOT)/ace/Signal.h \
+ $(ACE_ROOT)/ace/Containers.h \
+ $(ACE_ROOT)/ace/Containers.i \
+ $(ACE_ROOT)/ace/Containers_T.h \
+ $(ACE_ROOT)/ace/Containers_T.i \
+ $(ACE_ROOT)/ace/Containers_T.cpp \
+ $(ACE_ROOT)/ace/Signal.i \
  $(ACE_ROOT)/ace/Mem_Map.h \
  $(ACE_ROOT)/ace/Mem_Map.i \
  $(ACE_ROOT)/ace/Memory_Pool.i
@@ -103,6 +447,8 @@ include	$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/ACE.h \
  $(ACE_ROOT)/ace/OS.h \
  $(ACE_ROOT)/ace/inc_user_config.h \
+ $(ACE_ROOT)/ace/config-sunos5.6.h \
+ $(ACE_ROOT)/ace/config-sunos5.5.h \
  $(ACE_ROOT)/ace/streams.h \
  $(ACE_ROOT)/ace/Basic_Types.h \
  $(ACE_ROOT)/ace/Basic_Types.i \
@@ -113,7 +459,6 @@ include	$(ACE_ROOT)/include/makeinclude/rules.local.GNU
  $(ACE_ROOT)/ace/ACE.i \
  $(ACE_ROOT)/ace/Log_Priority.h \
  $(ACE_ROOT)/ace/Log_Record.i \
- $(ACE_ROOT)/ace/Get_Opt.i \
- Options.h
+ $(ACE_ROOT)/ace/Get_Opt.i Options.h
 
 # IF YOU PUT ANYTHING HERE IT WILL GO AWAY
diff --git a/examples/Shared_Malloc/test_position_independent_malloc.cpp b/examples/Shared_Malloc/test_position_independent_malloc.cpp
index 39ab49289a3..af420903eec 100644
--- a/examples/Shared_Malloc/test_position_independent_malloc.cpp
+++ b/examples/Shared_Malloc/test_position_independent_malloc.cpp
@@ -17,19 +17,20 @@ typedef ACE_Malloc <ACE_MMAP_MEMORY_POOL, ACE_Process_Mutex> MALLOC;
 static void *base_addr = ACE_DEFAULT_BASE_ADDR;
 
 static void
-print (Dummy_Data *data)
+print (Test_Data *data)
 {
-  ACE_DEBUG ((LM_DEBUG,
-              "<<<<\ni1_ = %d, i2_ = %d, i3_ = %d\n",
-              data->i1_,
-              data->i2_,
-              data->i3_));
-
-  ACE_DEBUG ((LM_DEBUG,
-              "i1_ = %d, i2_ = %d, i3_ = %d\n>>>>\n",
-              data->next_->i1_,
-              data->next_->i2_,
-              data->next_->i3_));
+  for (Test_Data *t = data; t != 0; t = t->next_)
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  "<<<<\ni1_ = %d, i2_ = %d, i3_ = %d\n",
+                  t->i1_,
+                  t->i2_,
+                  t->i3_));
+      ACE_DEBUG ((LM_DEBUG,
+                  "*t->bpl_ = %d, t->long_test_->array_[0] = %d\n>>>>\n",
+                  *t->long_test_->bpl_,
+                  t->long_test_->array_[0]));
+    }
 }
 
 static void *
@@ -37,9 +38,9 @@ initialize (MALLOC *allocator)
 {
   void *ptr;
   ACE_ALLOCATOR_RETURN (ptr,
-                        allocator->malloc (sizeof (Dummy_Data)),
+                        allocator->malloc (sizeof (Test_Data)),
                         0);
-  Dummy_Data *data1 = new (ptr) Dummy_Data;
+  Test_Data *data1 = new (ptr) Test_Data;
 
   data1->i1_ = 111;
   data1->i2_ = 222;
@@ -53,18 +54,18 @@ initialize (MALLOC *allocator)
   allocator->free (gap);
 
   ACE_ALLOCATOR_RETURN (ptr,
-                        allocator->malloc (sizeof (Dummy_Data)),
+                        allocator->malloc (sizeof (Test_Data)),
                         0);
-  Dummy_Data *data2 = new (ptr) Dummy_Data;
+  Test_Data *data2 = new (ptr) Test_Data;
 
-  data1->next_ = data2;
-  data1->next_->i1_ = 111;
-  data1->next_->i2_ = 222;
-  data1->next_->i3_ = 333;
+  data1->next_ = 0;
+  data1->i1_ = 111;
+  data1->i2_ = 222;
+  data1->i3_ = 333;
   data2->next_ = data1;
-  data2->next_->i1_ = -111;
-  data2->next_->i2_ = -222;
-  data2->next_->i3_ = -333;
+  data2->i1_ = -111;
+  data2->i2_ = -222;
+  data2->i3_ = -333;
 
   // Test in shared memory using long (array/pointer)
   ACE_ALLOCATOR_RETURN (ptr,
@@ -79,32 +80,36 @@ initialize (MALLOC *allocator)
   lt->array_[4] = 1004;
   lt->bpl_ = lt->array_;
 
-  long longCont1 = *lt->bpl_;
-  long longCont3 = lt->bpl_[3];
+  data1->long_test_= lt;
 
-  ACE_UNUSED_ARG (longCont1);
-  ACE_UNUSED_ARG (longCont3);
+  long long_cont_1 = *lt->bpl_;
+  long long_cont_2 = lt->bpl_[3];
 
-  // Test in local memory using long (array/pointer)
-  ACE_NEW_RETURN (ptr,
-                  long[5],
-                  0);
-  Long_Test *lt_lcl = new (ptr) Long_Test;
+  ACE_ASSERT (long_cont_1 == 1000);
+  ACE_ASSERT (long_cont_2 == 1003);
+
+  // Test in local memory using long (array/pointer).
+  ACE_ALLOCATOR_RETURN (ptr,
+                        allocator->malloc (sizeof (Long_Test)),
+                        0);
+  lt = new (ptr) Long_Test;
+
+  lt->array_[0] = 2000;
+  lt->array_[1] = 2001;
+  lt->array_[2] = 2002;
+  lt->array_[3] = 2003;
+  lt->array_[4] = 2004;
+  lt->bpl_ = lt->array_;
 
-  lt_lcl->array_[0] = 2000;
-  lt_lcl->array_[1] = 2001;
-  lt_lcl->array_[2] = 2002;
-  lt_lcl->array_[3] = 2003;
-  lt_lcl->array_[4] = 2004;
-  lt_lcl->bpl_ = lt_lcl->array_;
+  data2->long_test_= lt;
 
-  long longCont_lcl1 = *lt_lcl->bpl_;
-  long longCont_lcl4 = lt_lcl->bpl_[4];
+  long long_cont_3 = *lt->bpl_;
+  long long_cont_4 = lt->bpl_[4];
 
-  ACE_UNUSED_ARG (longCont_lcl1);
-  ACE_UNUSED_ARG (longCont_lcl4);
+  ACE_ASSERT (long_cont_3 == 2000);
+  ACE_ASSERT (long_cont_4 == 2004);
 
-  return data1;
+  return data2;
 }
 
 static void
@@ -139,8 +144,8 @@ main (int argc, char *argv[])
   // Create an allocator.
   MALLOC *allocator;
   ACE_NEW_RETURN (allocator,
-                  MALLOC ("dummy_file",
-                          "dummy_lock",
+                  MALLOC ("test_file",
+                          "test_lock",
                           &options),
                   1);
   void *data = 0;
@@ -166,7 +171,7 @@ main (int argc, char *argv[])
   // release the resources.
   else
     {
-      print ((Dummy_Data *) data);
+      print ((Test_Data *) data);
       allocator->free (data);
       allocator->remove ();
       ACE_DEBUG ((LM_DEBUG,
@@ -179,11 +184,15 @@ main (int argc, char *argv[])
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_Based_Pointer<Dummy_Data>;
-template class ACE_Based_Pointer_Basic<Dummy_Data>;
+template class ACE_Based_Pointer<Test_Data>;
+template class ACE_Based_Pointer_Basic<Test_Data>;
 template class ACE_Based_Pointer_Basic<long>;
+template class ACE_Based_Pointer_Basic<Long_Test>;
+template class ACE_Based_Pointer<Long_Test>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_Based_Pointer<Dummy_Data>
-#pragma instantiate ACE_Based_Pointer_Basic<Dummy_Data>
+#pragma instantiate ACE_Based_Pointer<Test_Data>
+#pragma instantiate ACE_Based_Pointer_Basic<Test_Data>
 #pragma instantiate ACE_Based_Pointer_Basic<long>
+#pragma instantiate ACE_Based_Pointer_Basic<Long_Test>
+#pragma instantiate ACE_Based_Pointer_Basic<Long>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
diff --git a/examples/Shared_Malloc/test_position_independent_malloc.h b/examples/Shared_Malloc/test_position_independent_malloc.h
index 54ca157bad2..243df410234 100644
--- a/examples/Shared_Malloc/test_position_independent_malloc.h
+++ b/examples/Shared_Malloc/test_position_independent_malloc.h
@@ -1,25 +1,26 @@
 // $Id$
 //
-// Define struct used in test_position_independent_malloc.cpp - needs to be in
-// a separate file for template generation on AIX IBM C++.
+// Define struct used in test_position_independent_malloc.cpp - needs
+// to be in a separate file for template generation on AIX IBM C++.
 
 #ifndef __TEST_POSITION_INDEPENDENT_MALLOC_H
 #define __TEST_POSITION_INDEPENDENT_MALLOC_H
 
-// Some dummy data 
-struct Dummy_Data
-{
-  int i1_;
-  int i2_;
-  int i3_;
-  ACE_Based_Pointer<Dummy_Data> next_;
-};
-
-// Some more dummy data.
+// Some test data.
 struct Long_Test
 {
   ACE_Based_Pointer_Basic<long> bpl_;
   long array_[10];
 };
 
+// Some more test data.
+struct Test_Data
+{
+  int i1_;
+  int i2_;
+  int i3_;
+  ACE_Based_Pointer<Test_Data> next_;
+  ACE_Based_Pointer<Long_Test> long_test_;
+};
+
 #endif /* __TEST_POSITION_INDEPENDENT_MALLOC */