ChangeLogTag:Thu Jul 8 00:23:02 1999 Douglas C. Schmidt <schmidt@tango.cs.wustl.edu>

21 files changed, 386 insertions, 172 deletions

diff --git a/ace/Based_Pointer_Repository.cpp b/ace/Based_Pointer_Repository.cpp
index cf2f54d61f4..f6fdd1b099d 100644
--- a/ace/Based_Pointer_Repository.cpp
+++ b/ace/Based_Pointer_Repository.cpp
@@ -1,14 +1,41 @@
 // $Id$
 
 #define ACE_BUILD_DLL
-#include  "ace/Based_Pointer_Repository.h"
+#include "ace/Map_Manager.h"
+#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; 
+
+class ACE_Based_Pointer_Repository_Rep
+{
+  // = TITLE
+  //   Implementation for the <ACE_Based_Pointer_Repository>.
+  // 
+  // = DESCRIPTION
+  //   Every memory pool in ACE binds it's mapping base address and
+  //   the mapped size to this repository every time it maps/remaps a
+  //   new chunk of memory successfully.
+public:
+  MAP_MANAGER addr_map_;
+  // Keeps track of the mapping between addresses and their associated
+  // values.
+
+  ACE_SYNCH_MUTEX lock_;
+  // Synchronize concurrent access to the map.
+};
 
 ACE_Based_Pointer_Repository::ACE_Based_Pointer_Repository (void)
 {
+  ACE_NEW (this->rep_,
+           ACE_Based_Pointer_Repository_Rep);
 }
 
 ACE_Based_Pointer_Repository::~ACE_Based_Pointer_Repository (void)
 {
+  delete this->rep_;
 }
 
 // Search for appropriate base address in repository
@@ -17,8 +44,8 @@ int
 ACE_Based_Pointer_Repository::find (void *addr,
                                     void *&base_addr)
 {
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->lock_, -1);
-  MAP_ITERATOR iter = addr_map_;
+  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1);
+  MAP_ITERATOR iter = this->rep_->addr_map_;
 
   for (MAP_ENTRY *ce = 0;
        iter.next (ce) != 0;
@@ -41,13 +68,14 @@ ACE_Based_Pointer_Repository::find (void *addr,
 // existing entry.
 
 int
-ACE_Based_Pointer_Repository::bind (void *addr, size_t size)
+ACE_Based_Pointer_Repository::bind (void *addr, 
+                                    size_t size)
 {
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->lock_, -1);
+  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1);
 
   size_t *sizep;
 
-  if (addr_map_.find (addr, sizep) != -1)
+  if (this->rep_->addr_map_.find (addr, sizep) != -1)
     {
       // Store new size.
       *sizep = size;
@@ -59,7 +87,7 @@ ACE_Based_Pointer_Repository::bind (void *addr, size_t size)
                       size_t,
                       -1);
       *sizep = size;
-      return addr_map_.bind (addr, sizep);
+      return this->rep_->addr_map_.bind (addr, sizep);
     }
 }
 
@@ -68,8 +96,8 @@ ACE_Based_Pointer_Repository::bind (void *addr, size_t size)
 int
 ACE_Based_Pointer_Repository::unbind (void *addr)
 {
-  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->lock_, -1);
-  MAP_ITERATOR iter = addr_map_;
+  ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1);
+  MAP_ITERATOR iter = this->rep_->addr_map_;
 
   // Search for service handlers that requested notification.
 
@@ -83,7 +111,7 @@ ACE_Based_Pointer_Repository::unbind (void *addr)
         delete ce->int_id_;
 
       // Unbind base address.
-      return addr_map_.unbind (ce->ext_id_);
+      return this->rep_->addr_map_.unbind (ce->ext_id_);
     }
 
   return 0;
diff --git a/ace/Based_Pointer_Repository.h b/ace/Based_Pointer_Repository.h
index b3180c008b9..f4f88c1f1d3 100644
--- a/ace/Based_Pointer_Repository.h
+++ b/ace/Based_Pointer_Repository.h
@@ -18,27 +18,16 @@
 #ifndef ACE_BASED_POINTER_REPOSITORY_H
 #define ACE_BASED_POINTER_REPOSITORY_H
 
-#include "ace/Singleton.h"
-#include "ace/Map_Manager.h"
+// Forward decl., using the "Cheshire Cat" technique.
+class ACE_Based_Pointer_Repository_Rep;
 
-class ACE_Export ACE_Based_Pointer_Repository 
+class ACE_Export ACE_Based_Pointer_Repository
 {
   // = TITLE
   //   Maps pointers to the base address of the region to which each
   //   pointer belongs.
-  // 
-  // = DESCRIPTION
-  //   Every memory pool in ACE binds it's mapping base address and
-  //   the mapped size to this repository every time it maps/remaps a
-  //   new chunk of memory successfully.
 public:
   // = Use <ACE_Null_Mutex> to allow locking while iterating.
-  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; 
 
   // = Initialization and termination methods.
   ACE_Based_Pointer_Repository (void);
@@ -61,14 +50,13 @@ public:
   // contained within.
 
 private:
-  MAP_MANAGER addr_map_;
-  // Keeps track of the mapping between addresses and their associated
-  // values.
-
-  ACE_SYNCH_MUTEX lock_;
-  // Synchronize concurrent access to the map.
+  ACE_Based_Pointer_Repository_Rep *rep_;
+  // Use the "Cheshire-Cat" technique to hide the implementation in
+  // order to avoid circular #include dependencies.
 };
 
+#include "ace/Singleton.h"
+
 // Provide a Singleton access point to the based pointer repository.
 typedef ACE_Singleton<ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX>
         ACE_BASED_POINTER_REPOSITORY;
diff --git a/ace/Based_Pointer_T.cpp b/ace/Based_Pointer_T.cpp
index 6a01f656f8c..5c993b8855f 100644
--- a/ace/Based_Pointer_T.cpp
+++ b/ace/Based_Pointer_T.cpp
@@ -3,8 +3,22 @@
 #ifndef ACE_BASED_POINTER_T_CPP
 #define ACE_BASED_POINTER_T_CPP
 
-#include "ace/Based_Pointer_Repository.h"
+#define ACE_BUILD_DLL
 #include "ace/Based_Pointer_T.h"
+#include "ace/Based_Pointer_Repository.h"
+
+#if !defined (__ACE_INLINE__)
+#include "ace/Based_Pointer_T.i"
+#endif /* __ACE_INLINE__ */
+
+template <class CONCRETE> ACE_Based_Pointer<CONCRETE> 
+operator+ (const ACE_Based_Pointer<CONCRETE> &lhs, long increment)
+{
+  // Perform pointer arithmetic.
+  CONCRETE *ptr = ((CONCRETE *) ACE_COMPUTE_BASED_POINTER (&lhs)) + increment;
+  ACE_Based_Pointer<CONCRETE> tmp (ptr);
+  return tmp;
+}
 
 template <class CONCRETE>
 ACE_Based_Pointer<CONCRETE>::ACE_Based_Pointer (void)
@@ -21,34 +35,19 @@ ACE_Based_Pointer<CONCRETE>::ACE_Based_Pointer (void)
   this->base_offset_ = (char *) this - (char *) base_addr;
 }
 
-template <class CONCRETE> CONCRETE * 
-ACE_Based_Pointer<CONCRETE>::operator->(void)
-{
-  char *base_addr = (char *) this - this->base_offset_;
-
-  return (CONCRETE *)(base_addr + (long) this->target_);
-}
-
-template <class CONCRETE> CONCRETE *
-ACE_Based_Pointer<CONCRETE>::operator =(CONCRETE *from)
-{
-  char *base_addr = (char *) this - this->base_offset_;
-  this->target_ = (CONCRETE *)((char *) from - (char *) base_addr);
-  return from;
-}
-
-template <class CONCRETE> CONCRETE 
-ACE_Based_Pointer<CONCRETE>::operator *(void)
+template <class CONCRETE>
+ACE_Based_Pointer<CONCRETE>::ACE_Based_Pointer (CONCRETE *addr)
+  : target_ (0),
+    base_offset_ (0)
 {
-  char *base_addr = (char *) this - this->base_offset_;
-  return *(CONCRETE *)(base_addr + (long) this->target_);
-}
+  void *base_addr = 0;
 
-template <class CONCRETE> CONCRETE 
-ACE_Based_Pointer<CONCRETE>::operator [] (int index)
-{
-  char *base_addr = (char *) this - this->base_offset_;
-  return *((CONCRETE *)(base_addr + (long) this->target_) + index);
+  // 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 (addr,
+                                                   base_addr);
+  this->base_offset_ = (char *) addr - (char *) base_addr;
 }
 
 #endif/* ACE_BASED_POINTER_T_CPP */
diff --git a/ace/Based_Pointer_T.h b/ace/Based_Pointer_T.h
index 31f4547776b..0003bce08e8 100644
--- a/ace/Based_Pointer_T.h
+++ b/ace/Based_Pointer_T.h
@@ -58,25 +58,67 @@ public:
   //    based-pointer uses its address as an offset to it's base
   //    address 0.
 
+  ACE_Based_Pointer (CONCRETE *initial);
+  // Initialize this object with the <initial> pointer.
+
+  ACE_Based_Pointer (const ACE_Based_Pointer<CONCRETE> &rhs);
+  // Copy constructor.
+
   CONCRETE *operator->(void);
   // The C++ "delegation operator".
 
   CONCRETE *operator =(CONCRETE *from);
   // Pseudo-assignment operator.
 
-  CONCRETE operator *(void);
+  CONCRETE operator *(void) const;
   // Dereference operator.
 
-  CONCRETE operator [](int index);
+  int operator < (const ACE_Based_Pointer<CONCRETE> &) const;
+  // Less than operator.
+
+  int operator <= (const ACE_Based_Pointer<CONCRETE> &) const;
+  // Less than or equal operator.
+
+  int operator > (const ACE_Based_Pointer<CONCRETE> &) const;
+  // Greater than operator.
+
+  int operator >= (const ACE_Based_Pointer<CONCRETE> &) const;
+  // Greater than or equal operator.
+
+  int operator == (const ACE_Based_Pointer<CONCRETE> &) const;
+  // Equality operator.
+
+  int operator != (const ACE_Based_Pointer<CONCRETE> &) const;
+  // Inequality operator.
+
+  CONCRETE operator [](long index) const;
   // Subscript operator.
 
-private:
+  void operator+= (long index);
+  // Increment operator.
+
+  operator void *() const;
+  // Returns the underlying memory address of the smart pointer.
+
+  // The following should be private, but that causes problems due to
+  // broken C++ compilers that don't like friends for methods
+  // in templates.
+// private:
   CONCRETE *target_;
 
   long base_offset_;
   // Keep track of our offset from the base pointer.
 };
 
+ACE_Export template <class CONCRETE> 
+ACE_Based_Pointer<CONCRETE> operator+ (const ACE_Based_Pointer<CONCRETE> &lhs,
+                                       long increment);
+// Emulate "pointer arithmetic" by adding <increment> to <lhs>.
+
+#if defined (__ACE_INLINE__)
+#include "ace/Based_Pointer_T.i"
+#endif /* __ACE_INLINE__ */
+
 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
 #include "ace/Based_Pointer_T.cpp"
 #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
diff --git a/ace/Based_Pointer_T.i b/ace/Based_Pointer_T.i
new file mode 100644
index 00000000000..cb0a3ae5fea
--- /dev/null
+++ b/ace/Based_Pointer_T.i
@@ -0,0 +1,86 @@
+/* -*- C++ -*- */
+// $Id$
+
+#define ACE_COMPUTE_BASED_POINTER(P) (((char *) (P) - (P)->base_offset_) + (long) (P)->target_)
+
+template <class CONCRETE> ACE_INLINE
+ACE_Based_Pointer<CONCRETE>::ACE_Based_Pointer (const ACE_Based_Pointer<CONCRETE> &lhs)
+  : target_ (lhs.target_),
+    base_offset_ (lhs.base_offset_)
+{
+}
+
+template <class CONCRETE> ACE_INLINE CONCRETE *
+ACE_Based_Pointer<CONCRETE>::operator->(void)
+{
+  return (CONCRETE *)(ACE_COMPUTE_BASED_POINTER (this));
+}
+
+template <class CONCRETE> ACE_INLINE CONCRETE *
+ACE_Based_Pointer<CONCRETE>::operator =(CONCRETE *from)
+{
+  this->target_ = (CONCRETE *)((char *) from 
+                               - ((char *) this - this->base_offset_));
+  return from;
+}
+
+template <class CONCRETE> ACE_INLINE CONCRETE 
+ACE_Based_Pointer<CONCRETE>::operator *(void) const
+{
+  return *(CONCRETE *)(ACE_COMPUTE_BASED_POINTER (this));
+}
+
+template <class CONCRETE> ACE_INLINE 
+ACE_Based_Pointer<CONCRETE>::operator void *() const
+{
+  return ACE_reinterpret_cast (void *,
+                               ACE_COMPUTE_BASED_POINTER (this));
+}
+
+template <class CONCRETE> ACE_INLINE CONCRETE
+ACE_Based_Pointer<CONCRETE>::operator [] (long index) const
+{
+  return *((CONCRETE *)(ACE_COMPUTE_BASED_POINTER (this)) + index);
+}
+
+template <class CONCRETE> ACE_INLINE void
+ACE_Based_Pointer<CONCRETE>::operator += (long index)
+{
+  this->base_offset_ += (index * sizeof (CONCRETE));
+}
+
+template <class CONCRETE> ACE_INLINE int 
+ACE_Based_Pointer<CONCRETE>::operator == (const ACE_Based_Pointer<CONCRETE> &rhs) const
+{
+  return ACE_COMPUTE_BASED_POINTER (this) == ACE_COMPUTE_BASED_POINTER (&rhs);
+}
+
+template <class CONCRETE> ACE_INLINE int 
+ACE_Based_Pointer<CONCRETE>::operator != (const ACE_Based_Pointer<CONCRETE> &rhs) const
+{
+  return !(*this == rhs);
+}
+
+template <class CONCRETE> ACE_INLINE int 
+ACE_Based_Pointer<CONCRETE>::operator < (const ACE_Based_Pointer<CONCRETE> &rhs) const
+{
+  return ACE_COMPUTE_BASED_POINTER (this) < ACE_COMPUTE_BASED_POINTER (&rhs);
+}
+
+template <class CONCRETE> ACE_INLINE int 
+ACE_Based_Pointer<CONCRETE>::operator <= (const ACE_Based_Pointer<CONCRETE> &rhs) const
+{
+  return ACE_COMPUTE_BASED_POINTER (this) <= ACE_COMPUTE_BASED_POINTER (&rhs);
+}
+
+template <class CONCRETE> ACE_INLINE int 
+ACE_Based_Pointer<CONCRETE>::operator > (const ACE_Based_Pointer<CONCRETE> &rhs) const
+{
+  return ACE_COMPUTE_BASED_POINTER (this) > ACE_COMPUTE_BASED_POINTER (&rhs);
+}
+
+template <class CONCRETE> ACE_INLINE int 
+ACE_Based_Pointer<CONCRETE>::operator >= (const ACE_Based_Pointer<CONCRETE> &rhs) const
+{
+  return ACE_COMPUTE_BASED_POINTER (this) >= ACE_COMPUTE_BASED_POINTER (&rhs);
+}
diff --git a/ace/Malloc.cpp b/ace/Malloc.cpp
index 21111301edc..beab22c6844 100644
--- a/ace/Malloc.cpp
+++ b/ace/Malloc.cpp
@@ -1,7 +1,7 @@
 // $Id$
 
-#if !defined (ACE_MALLOC_C)
-#define ACE_MALLOC_C
+#if !defined (ACE_MALLOC_CPP)
+#define ACE_MALLOC_CPP
 
 #define ACE_BUILD_DLL
 #include "ace/Malloc.h"
@@ -30,7 +30,7 @@ ACE_Control_Block::dump (void) const
 
   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
   this->name_head_->dump ();
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("freep_ = %x"), this->freep_));
+  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT("freep_ = %x"), (void *) this->freep_));
 
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -208,6 +208,16 @@ template class ACE_Atomic_Op<ACE_PROCESS_MUTEX, int>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 #pragma instantiate ACE_Atomic_Op<ACE_PROCESS_MUTEX, int>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
 #endif /* ACE_HAS_MALLOC_STATS */
-#endif /* ACE_MALLOC_C */
+
+#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+template class ACE_Based_Pointer<ACE_Malloc_Header>;
+template ACE_Based_Pointer<ACE_Malloc_Header> operator+ (const ACE_Based_Pointer<ACE_Malloc_Header> &lhs, long increment);
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Based_Pointer<ACE_Malloc_Header>
+#pragma ACE_Based_Pointer<ACE_Malloc_Header> operator+ (const ACE_Based_Pointer<ACE_Malloc_Header> &lhs, long increment);
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
+
+#endif /* ACE_MALLOC_CPP */
diff --git a/ace/Malloc.h b/ace/Malloc.h
index bcbc452aecf..d7d6d135ce0 100644
--- a/ace/Malloc.h
+++ b/ace/Malloc.h
@@ -25,6 +25,10 @@
 
 #include "ace/Malloc_Base.h"
 
+#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
+#include "ace/Based_Pointer_T.h"
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
+
 #if defined (ACE_HAS_MALLOC_STATS)
 #include "ace/Synch_T.h"
 #if defined (ACE_HAS_THREADS)
@@ -34,10 +38,6 @@
 #define ACE_PROCESS_MUTEX ACE_SV_Semaphore_Simple
 #endif /* ACE_HAS_THREADS */
 
-#if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-#include "ace/Based_Pointer_T.h"
-#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
-
 typedef ACE_Atomic_Op<ACE_PROCESS_MUTEX, int> ACE_INT;
 
 struct ACE_Export ACE_Malloc_Stats
@@ -61,50 +61,58 @@ struct ACE_Export ACE_Malloc_Stats
 #define AMS(X)
 #endif /* ACE_HAS_MALLOC_STATS */
 
-#if !defined (ACE_MALLOC_ALIGN)
-// ACE_MALLOC_ALIGN allows you to insure that allocated regions are at
-// least <ACE_MALLOC_ALIGN> bytes long.  It is especially useful when
-// you want areas to be at least a page long, or 32K long, or
+#if !defined (ACE_MALLOC_PADDING)
+// ACE_MALLOC_PADDING allows you to insure that allocated regions are
+// at least <ACE_MALLOC_PADDING> bytes long.  It is especially useful
+// when you want areas to be at least a page long, or 32K long, or
 // something like that.  It doesn't guarantee alignment to an address
 // multiple, like 8-byte data alignment, etc.  The allocated area's
 // padding to your selected size is done with an added array of long[]
 // and your compiler will decide how to align things in memory.
 //
-// The default ACE_MALLOC_ALIGN is 'long', which will probably add a
-// long of padding - it doesn't have any real affect.  If you want to
-// use this feature, define ACE_MALLOC_ALIGN in your config.h file and
-// use a signed integer number of bytes you want.  For example:
-// #define ACE_MALLOC_ALIGN ((int)4096)
+// If you want to use this feature, define ACE_MALLOC_PADDING in your
+// config.h file and use a signed integer number of bytes you want, e.g.:
+//
+// #define ACE_MALLOC_PADDING ((int) 4096)
 
-#define ACE_MALLOC_ALIGN ((int)(sizeof (long)))
+#define ACE_MALLOC_PADDING 1
+#endif /* ACE_MALLOC_PADDING */
+
+// The following is only for backwards compatibility.
+#if defined (ACE_MALLOC_ALIGN)
+#undef ACE_MALLOC_PADDING
+#define ACE_MALLOC_PADDING ACE_MALLOC_ALIGN
 #endif /* ACE_MALLOC_ALIGN */
 
-union ACE_Export ACE_Malloc_Header
+class ACE_Export ACE_Malloc_Header
 {
   // = TITLE
-  //   We use a union to force alignment to the most restrictive type.
+  //    This is the control block header.  It's used by <ACE_Malloc>
+  //    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)
+  typedef ACE_Based_Pointer<ACE_Malloc_Header> HEADER_PTR;
+#else 
+  typedef ACE_Malloc_Header *HEADER_PTR;
+#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
 
   class ACE_Malloc_Control_Block
   {
-    // = TITLE
-    //    This is the control block header.  It's used by <ACE_Malloc>
-    //    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)
-    ACE_Based_Pointer<ACE_Malloc_Header> next_block_;
+    HEADER_PTR next_block_;
     // Points to next block if on free list.
-#else 
-    ACE_Malloc_Header *next_block_;
-    // Points to next block if on free list.
-#endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
 
     size_t size_;
     // Size of this block.
   } s_;
 
-  long align_[ACE_MALLOC_ALIGN/sizeof (long)];
-  // Force alignment.
+#if (ACE_MALLOC_PADDING > 1)
+#define ACE_MALLOC_PADDING_SIZE ((ACE_MALLOC_PADDING - \
+                                  (sizeof (ACE_Malloc_Control_Block)) / sizeof (long)))
+  long padding_[ACE_MALLOC_PADDING_SIZE < 1 : ACE_MALLOC_PADDING_SIZE];
+#endif /* ACE_MALLOC_PADDING > 0 */
 };
 
 class ACE_Export ACE_Name_Node
@@ -137,13 +145,13 @@ class ACE_Export ACE_Control_Block
   //    This information is stored in memory allocated by the MEMORY_POOL.
   //
   // = DESCRIPTION
-  //    This class should be local to class ACE_Malloc, but cfront and
-  //    G++ don't like nested classes in templates...
+  //    This class should be local to class ACE_Malloc, but some older
+  //    C++ compilers don't like nested classes in templates...
 public:
   ACE_Name_Node *name_head_;
   // Head of the linked list of Name Nodes.
 
-  ACE_Malloc_Header *freep_;
+  ACE_Malloc_Header::HEADER_PTR freep_;
   // Current head of the freelist.
 
   char lock_name_[MAXNAMELEN];
@@ -157,18 +165,19 @@ public:
                                       + MAXNAMELEN  \
                                       + sizeof (ACE_Malloc_Stats)))
 #else
-#define ACE_CONTROL_BLOCK_SIZE ((int)(sizeof(ACE_Name_Node *) \
+#define ACE_CONTROL_BLOCK_SIZE ((int)(sizeof (ACE_Name_Node *) \
                                       + sizeof (ACE_Malloc_Header *) \
                                       + MAXNAMELEN))
 #endif /* ACE_HAS_MALLOC_STATS */
 
 // Notice the casting to int for sizeof() otherwise unsigned int
 // arithmetic is used and some awful things may happen.
-#define ACE_CONTROL_BLOCK_ALIGN_LONGS ((ACE_CONTROL_BLOCK_SIZE % ACE_MALLOC_ALIGN != 0 \
-                                        ? ACE_MALLOC_ALIGN - (ACE_CONTROL_BLOCK_SIZE) \
-                                        : ACE_MALLOC_ALIGN) / int(sizeof(long)))
+#define ACE_CONTROL_BLOCK_ALIGN_LONGS ((ACE_CONTROL_BLOCK_SIZE % ACE_MALLOC_PADDING != 0 \
+                                        ? ACE_MALLOC_PADDING - (ACE_CONTROL_BLOCK_SIZE) \
+                                        : ACE_MALLOC_PADDING) / int (sizeof (long)))
 
   long align_[ACE_CONTROL_BLOCK_ALIGN_LONGS < 1 ? 1 : ACE_CONTROL_BLOCK_ALIGN_LONGS];
+  // Force alignment.
 
   ACE_Malloc_Header base_;
   // Dummy node used to anchor the freelist.
@@ -188,9 +197,9 @@ class ACE_Export ACE_New_Allocator : public ACE_Allocator
   //     up memory.  Please note that the only methods that are
   //     supported are malloc and free. All other methods are no-ops.
   //     If you require this functionality, please use:
-  //     ACE_Allocator_Adapter <ACE_Malloc <ACE_LOCAL_MEMORY_POOL, MUTEX>>
-  //     This will allow you to use the added functionality of
-  //     bind/find/etc. while using the new/delete operators.
+  //     ACE_Allocator_Adapter <ACE_Malloc <ACE_LOCAL_MEMORY_POOL,
+  //     MUTEX> > This will allow you to use the added functionality
+  //     of bind/find/etc. while using the new/delete operators.
 public:
   virtual void *malloc (size_t nbytes);
   virtual void *calloc (size_t nbytes, char initial_value = '\0');
diff --git a/ace/Malloc_T.cpp b/ace/Malloc_T.cpp
index 50818cf70a9..2d2fcc17ad8 100644
--- a/ace/Malloc_T.cpp
+++ b/ace/Malloc_T.cpp
@@ -22,19 +22,26 @@ ACE_Cached_Allocator<T, ACE_LOCK>::ACE_Cached_Allocator (size_t n_chunks)
   : pool_ (0),
     free_list_ (ACE_PURE_FREE_LIST)
 {
-  this->pool_ = (T*) new char[n_chunks * sizeof (T)];
-  // ERRNO could be lost because this is within ctor
-
-  for (size_t c = 0 ; c < n_chunks ; c++)
+  char *tmp = 0;
+  
+  ACE_NEW (tmp,
+           char[n_chunks * sizeof (T)]);
+  this->pool_ = ACE_reinterpret_cast (T *,
+                                      tmp);
+
+  for (size_t c = 0;
+       c < n_chunks;
+       c++)
     this->free_list_.add (new (&this->pool_ [c]) ACE_Cached_Mem_Pool_Node<T>);
   // Put into free list using placement contructor, no real memory
-  // allocation in the above new.
+  // allocation in the above <new>.
 }
 
 template <class T, class ACE_LOCK>
 ACE_Cached_Allocator<T, ACE_LOCK>::~ACE_Cached_Allocator (void)
 {
-  char* tmp = (char *) this->pool_;
+  char *tmp = ACE_reinterpret_cast (char *,
+                                    this->pool_);
   delete [] tmp;
 }
 
@@ -79,7 +86,8 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::dump (void) const
   ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("cb_ptr_ = %x"), this->cb_ptr_));
   ACE_DEBUG ((LM_DEBUG, ASYS_TEXT ("\n")));
 #if defined (ACE_HAS_MALLOC_STATS)
-  this->cb_ptr_->malloc_stats_.dump ();
+  if (this->cb_ptr_ != 0)
+    this->cb_ptr_->malloc_stats_.dump ();
 #endif /* ACE_HAS_MALLOC_STATS */
   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
 }
@@ -92,10 +100,13 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::print_stats (void) const
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::print_stats");
   ACE_GUARD (ACE_LOCK, ace_mon, this->lock_);
 
+  if (this->cb_ptr_ == 0)
+    return;
   this->cb_ptr_->malloc_stats_.dump ();
-  ACE_DEBUG ((LM_DEBUG, ASYS_TEXT (" (%P|%t) contents of freelist:\n")));
+  ACE_DEBUG ((LM_DEBUG,
+              ASYS_TEXT (" (%P|%t) contents of freelist:\n")));
 
-  for (ACE_Malloc_Header *currp = this->cb_ptr_->freep_->s_.next_block_;
+  for (ACE_Malloc_Header::HEADER_PTR currp = this->cb_ptr_->freep_->s_.next_block_;
        ;
        currp = currp->s_.next_block_)
     {
@@ -109,15 +120,15 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::print_stats (void) const
 }
 #endif /* ACE_HAS_MALLOC_STATS */
 
-// Put block AP in the free list (locked version).
+// Put <ptr> in the free list (locked version).
 
 template<ACE_MEM_POOL_1, class ACE_LOCK> void
-ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::free (void *ap)
+ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::free (void *ptr)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::free");
   ACE_GUARD (ACE_LOCK, ace_mon, this->lock_);
 
-  this->shared_free (ap);
+  this->shared_free (ptr);
 }
 
 // This function is called by the ACE_Malloc constructor to initialize
@@ -171,14 +182,14 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
           // 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 = this->cb_ptr_->freep_ + 1;
+          ACE_Malloc_Header::HEADER_PTR p (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 size_ really big
-          // without this hack.
+          // 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
+          // size_ really big without this hack.
 #if defined (__hpux) && defined (__LP64__)
           size_t hpux11_hack = (rounded_bytes - sizeof *this->cb_ptr_)
-                               / sizeof(ACE_Malloc_Header);
+                               / sizeof (ACE_Malloc_Header);
           p->s_.size_ = hpux11_hack;
 #else
           p->s_.size_ = (rounded_bytes - sizeof *this->cb_ptr_)
@@ -189,9 +200,12 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::open (void)
           AMS (++this->cb_ptr_->malloc_stats_.nblocks_);
           AMS (++this->cb_ptr_->malloc_stats_.ninuse_);
 
+          // Skip over the ACE_Malloc_Header when returning pointer.
+          ACE_Malloc_Header::HEADER_PTR tmp (p + 1);
           // Insert the newly allocated chunk of memory into the free
-          // list.
-          this->shared_free ((void *) (p + 1));
+          // list.  Note that this triggers operator void *() if we're
+          // using the ACE_POSITION_INDEPENDENT_MALLOC configuration.
+          this->shared_free ((void *) tmp);
         }
     }
   return 0;
@@ -285,14 +299,15 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
  (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 = this->cb_ptr_->freep_;
-  ACE_Malloc_Header *currp = prevp->s_.next_block_;
+  // Begin the search starting at the place in the freelist where the
+  // last block was found.
+  ACE_Malloc_Header::HEADER_PTR prevp = this->cb_ptr_->freep_;
+  ACE_Malloc_Header::HEADER_PTR currp = prevp->s_.next_block_;
 
   // Search the freelist to locate a block of the appropriate size.
 
-  for (int i = 0; ; i++, prevp = currp, currp = currp->s_.next_block_)
+  for (int i = 0;
+       ; i++, prevp = currp, currp = currp->s_.next_block_)
     {
       if (currp->s_.size_ >= nunits) // Big enough
         {
@@ -310,8 +325,13 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
               currp->s_.size_ = nunits;
             }
           this->cb_ptr_->freep_ = prevp;
+
           // Skip over the ACE_Malloc_Header when returning pointer.
-          return (void *) (currp + 1);
+          ACE_Malloc_Header::HEADER_PTR tmp (currp + 1);
+          // Insert the newly allocated chunk of memory into the free
+          // list.  Note that this triggers operator void *() if we're
+          // using the ACE_POSITION_INDEPENDENT_MALLOC configuration.
+          return (void *) tmp;
         }
       else if (currp == this->cb_ptr_->freep_)
         {
@@ -332,8 +352,12 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_malloc (size_t nbytes)
               // Compute the chunk size in ACE_Malloc_Header units.
               currp->s_.size_ = chunk_bytes / sizeof (ACE_Malloc_Header);
 
-              // Insert the new chunk into the freelist.
-              this->shared_free ((void *) (currp + 1));
+              // Skip over the ACE_Malloc_Header when returning pointer.
+              ACE_Malloc_Header::HEADER_PTR tmp (currp + 1);
+              // Insert the newly allocated chunk of memory into the free
+              // list.  Note that this triggers operator void *() if we're
+              // using the ACE_POSITION_INDEPENDENT_MALLOC configuration.
+              this->shared_free ((void *) tmp);
               currp = this->cb_ptr_->freep_;
             }
           else
@@ -360,7 +384,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::malloc (size_t nbytes)
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> void *
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::calloc (size_t nbytes,
-                                          char initial_value)
+                                              char initial_value)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::calloc");
   void *ptr = this->malloc (nbytes);
@@ -378,19 +402,17 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_free (void *ap)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_free");
 
-  if (ap == 0)
+  if (ap == 0 || this->cb_ptr_ == 0)
     return;
 
-  ACE_Malloc_Header *blockp; // Points to the block ACE_Malloc_Header.
-  ACE_Malloc_Header *currp;
-
   // Adjust AP to point to the block ACE_Malloc_Header
-  blockp = (ACE_Malloc_Header *) ap - 1;
+  ACE_Malloc_Header::HEADER_PTR blockp ((ACE_Malloc_Header *) ap - 1);
+  ACE_Malloc_Header::HEADER_PTR currp = this->cb_ptr_->freep_;
 
   // Search until we find the location where the blocks belongs.  Note
   // that addresses are kept in sorted order.
 
-  for (currp = this->cb_ptr_->freep_;
+  for (;
        blockp <= currp || blockp >= currp->s_.next_block_;
        currp = currp->s_.next_block_)
     {
@@ -430,10 +452,14 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_find (const char *name)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_find");
 
+  if (this->cb_ptr_ == 0)
+    return 0;
+
   for (ACE_Name_Node *node = this->cb_ptr_->name_head_;
        node != 0;
        node = node->next_)
-    if (ACE_OS::strcmp (node->name_, name) == 0)
+    if (ACE_OS::strcmp (node->name_,
+                        name) == 0)
       return node;
 
   return 0;
@@ -441,22 +467,26 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_find (const char *name)
 
 template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::shared_bind (const char *name,
-                                               void *pointer)
+                                                   void *pointer)
 {
+  if (this->cb_ptr_ == 0)
+    return -1;
+
   // Combine the two allocations into one to avoid overhead...
-  ACE_Name_Node *new_node = (ACE_Name_Node *)
-    this->shared_malloc (sizeof (ACE_Name_Node) + ACE_OS::strlen (name) + 1);
+  ACE_Name_Node *new_node;
 
-  if (new_node == 0)
-    return -1;
+  ACE_ALLOCATOR_RETURN (new_node,
+                        (ACE_Name_Node *)
+                        this->shared_malloc (sizeof (ACE_Name_Node) + ACE_OS::strlen (name) + 1),
+                        -1);
 
-  // This is a sleezy trick ;-)
+  // This is a clever trick ;-)
   new_node->name_ = (char *) (new_node + 1);
 
   // Insert new node at the head of the list.  Note that (new_node) is
-  // *not* a cast!
+  // *not* a cast, it's operator placement new.
   ACE_NEW_RETURN (this->cb_ptr_->name_head_,
- (new_node) ACE_Name_Node (name, pointer,
+                  (new_node) ACE_Name_Node (name, pointer,
                                             this->cb_ptr_->name_head_),
                   -1);
   return 0;
@@ -531,14 +561,16 @@ template <ACE_MEM_POOL_1, class ACE_LOCK> ssize_t
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::avail_chunks (size_t size) const
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::avail_chunks");
-
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->lock_, -1);
 
+  if (this->cb_ptr_ == 0)
+    return -1;
+
   size_t count = 0;
   // Avoid dividing by 0...
   size = size == 0 ? 1 : size;
 
-  for (ACE_Malloc_Header *currp = this->cb_ptr_->freep_->s_.next_block_;
+  for (ACE_Malloc_Header::HEADER_PTR 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.
@@ -552,8 +584,8 @@ template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::find (const char *name)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::find");
-
   ACE_READ_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
+
   return this->shared_find (name) == 0 ? -1 : 0;
 }
 
@@ -561,8 +593,11 @@ template <ACE_MEM_POOL_1, class ACE_LOCK> int
 ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::unbind (const char *name, void *&pointer)
 {
   ACE_TRACE ("ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::unbind");
-
   ACE_WRITE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, -1);
+
+  if (this->cb_ptr_ == 0)
+    return -1;
+
   ACE_Name_Node *prev = 0;
 
   for (ACE_Name_Node *curr = this->cb_ptr_->name_head_;
@@ -579,7 +614,7 @@ ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK>::unbind (const char *name, void *&pointer)
             prev->next_ = curr->next_;
 
           // This will free up both the node and the name due to our
-          // sleezy trick in bind ()!
+          // clever trick in <bind>!
           this->shared_free (curr);
           return 0;
         }
@@ -614,7 +649,7 @@ ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::dump (void) const
 
 template <ACE_MEM_POOL_1, class ACE_LOCK>
 ACE_Malloc_Iterator<ACE_MEM_POOL_2, ACE_LOCK>::ACE_Malloc_Iterator (ACE_Malloc<ACE_MEM_POOL_2, ACE_LOCK> &malloc,
-                                                                const char *name)
+                                                                    const char *name)
   : malloc_ (malloc),
     curr_ (0),
     guard_ (malloc_.lock_),
diff --git a/ace/Memory_Pool.cpp b/ace/Memory_Pool.cpp
index 1d07027de11..785c52b50d8 100644
--- a/ace/Memory_Pool.cpp
+++ b/ace/Memory_Pool.cpp
@@ -80,8 +80,7 @@ ACE_MMAP_Memory_Pool::release (void)
   ACE_TRACE ("ACE_MMAP_Memory_Pool::release");
 
 #if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-  ACE_POSITION_INDEPENDENT_REPOSITORY::instance ()->unbind (this->mmap_.addr (),
-                                                     this->mmap_.size ());
+  ACE_BASED_POINTER_REPOSITORY::instance ()->unbind (this->mmap_.addr ());
 #endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
 
   this->mmap_.remove ();
@@ -265,7 +264,7 @@ ACE_MMAP_Memory_Pool::map_file (off_t map_size)
   else
     {
 #if defined (ACE_HAS_POSITION_INDEPENDENT_MALLOC)
-      ACE_POSITION_INDEPENDENT_REPOSITORY::instance ()->bind (this->base_addr_,
+      ACE_BASED_POINTER_REPOSITORY::instance ()->bind (this->base_addr_,
                                                        map_size);
 #endif /* ACE_HAS_POSITION_INDEPENDENT_MALLOC */
       return 0;
diff --git a/ace/SString.h b/ace/SString.h
index dd8e7778ebc..63f8a949d3c 100644
--- a/ace/SString.h
+++ b/ace/SString.h
@@ -348,7 +348,8 @@ private:
   // Pointer to data.
 };
 
-ACE_Export ACE_INLINE ACE_WString operator + (const ACE_WString &, const ACE_WString &);
+ACE_Export ACE_INLINE ACE_WString operator+ (const ACE_WString &,
+                                             const ACE_WString &);
 #if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
 ACE_Export ostream &operator << (ostream &, const ACE_WString &);
 #endif /* ! ACE_LACKS_IOSTREAM_TOTALLY */
diff --git a/ace/SString.i b/ace/SString.i
index 44526a9fdc8..0b886f7d8a2 100644
--- a/ace/SString.i
+++ b/ace/SString.i
@@ -313,7 +313,8 @@ ACE_CString::hash (void) const
 }
 
 ACE_INLINE ACE_WString
-operator+ (const ACE_WString &s, const ACE_WString &t)
+operator+ (const ACE_WString &s,
+           const ACE_WString &t)
 {
   ACE_WString temp (s);
   temp += t;
@@ -685,8 +686,6 @@ ACE_WString::hash (void) const
   return ACE::hash_pjw (this->rep_);
 }
 
-// ****************************************************************
-
 ACE_INLINE
 ACE_Auto_String_Free::ACE_Auto_String_Free (char* p)
   :  p_ (p)
diff --git a/ace/config-aix-4.x.h b/ace/config-aix-4.x.h
index c3b42d8a7eb..1c3bd127710 100644
--- a/ace/config-aix-4.x.h
+++ b/ace/config-aix-4.x.h
@@ -38,7 +38,6 @@
   // Denotes that GNU has cstring.h as standard, to redefine memchr().
 # define ACE_HAS_GNU_CSTRING_H
 # define ACE_HAS_SSIZE_T
-# define ACE_MALLOC_ALIGN 8
 
 # if !defined (ACE_MT_SAFE) || ACE_MT_SAFE != 0
     // ACE_MT_SAFE is #defined below, for all compilers.
diff --git a/ace/config-lynxos.h b/ace/config-lynxos.h
index 6fd9462d8a3..5665994c5d5 100644
--- a/ace/config-lynxos.h
+++ b/ace/config-lynxos.h
@@ -84,7 +84,6 @@
 #define ACE_LACKS_STRCASECMP
 #define ACE_LACKS_TIMESPEC_T
 #define ACE_LACKS_UCONTEXT_H
-#define ACE_MALLOC_ALIGN 8
 // LynxOS, through 3.0.0, does not support MAP_PRIVATE, so map it to
 // MAP_SHARED.
 #define ACE_MAP_PRIVATE ACE_MAP_SHARED
diff --git a/ace/config-psos-diab-mips.h b/ace/config-psos-diab-mips.h
index 77aa346c9b7..f73da5be558 100644
--- a/ace/config-psos-diab-mips.h
+++ b/ace/config-psos-diab-mips.h
@@ -213,7 +213,6 @@
 
 #define ACE_LACKS_UNIX_SIGNALS
 
-// #define ACE_MALLOC_ALIGN 8
 // #define ACE_LACKS_SYSTIME_H
 
 #define ACE_PAGE_SIZE 4096
diff --git a/ace/config-psos-diab-ppc.h b/ace/config-psos-diab-ppc.h
index 8bc6f9cf027..f37d033132f 100644
--- a/ace/config-psos-diab-ppc.h
+++ b/ace/config-psos-diab-ppc.h
@@ -211,7 +211,6 @@
 
 #define ACE_LACKS_UNIX_SIGNALS
 
-// #define ACE_MALLOC_ALIGN 8
 // #define ACE_LACKS_SYSTIME_H
 
 #define ACE_PAGE_SIZE 4096
diff --git a/ace/config-psos-diab.h b/ace/config-psos-diab.h
index 5e9c62c163b..792ef8ad395 100644
--- a/ace/config-psos-diab.h
+++ b/ace/config-psos-diab.h
@@ -204,7 +204,6 @@
 
 #define ACE_LACKS_UNIX_SIGNALS
 
-// #define ACE_MALLOC_ALIGN 8
 // #define ACE_LACKS_SYSTIME_H
 
 #define ACE_PAGE_SIZE 4096
diff --git a/ace/config-psos-tm.h b/ace/config-psos-tm.h
index c84025bfb64..ecf773da28f 100644
--- a/ace/config-psos-tm.h
+++ b/ace/config-psos-tm.h
@@ -174,7 +174,6 @@
 
 #define ACE_LACKS_UNIX_SIGNALS
 
-// #define ACE_MALLOC_ALIGN 8
 // #define ACE_LACKS_SYSTIME_H
 
 #define ACE_PAGE_SIZE 4096
diff --git a/ace/config-psosim-g++.h b/ace/config-psosim-g++.h
index 3b8efeb0016..02e6b975e31 100644
--- a/ace/config-psosim-g++.h
+++ b/ace/config-psosim-g++.h
@@ -214,7 +214,6 @@
 
 #define ACE_LACKS_UTSNAME_T
 
-// #define ACE_MALLOC_ALIGN 8
 // #define ACE_LACKS_SYSTIME_H
 
 #define ACE_PAGE_SIZE 4096
diff --git a/ace/config-sunos5.5.h b/ace/config-sunos5.5.h
index 1c5766e8a39..0487c26fd6c 100644
--- a/ace/config-sunos5.5.h
+++ b/ace/config-sunos5.5.h
@@ -79,7 +79,6 @@
   // Denotes that GNU has cstring.h as standard, to redefine memchr().
 # define ACE_HAS_GNU_CSTRING_H
 # define ACE_HAS_XPG4_MULTIBYTE_CHAR
-# define ACE_MALLOC_ALIGN 8
 
 # if !defined (ACE_MT_SAFE) || ACE_MT_SAFE != 0
     // ACE_MT_SAFE is #defined below, for all compilers.
@@ -308,6 +307,8 @@
 #define ACE_HAS_STL_QUEUE_CONFLICT
 #define ACE_HAS_IDTYPE_T
 
+  // #define ACE_HAS_POSITION_INDEPENDENT_MALLOC
+
 #define ACE_HAS_GPERF
 #define ACE_HAS_DIRENT
 #define ACE_HAS_MEMCHR
diff --git a/ace/config-win32-borland.h b/ace/config-win32-borland.h
index cfd8881314f..e4ab0c8daea 100644
--- a/ace/config-win32-borland.h
+++ b/ace/config-win32-borland.h
@@ -8,7 +8,12 @@
 #ifndef ACE_WIN32_BORLAND_H
 #define ACE_WIN32_BORLAND_H
 
-# if defined(__BORLANDC__)
+# if defined (__BORLANDC__)
+
+# define ACE_CC_NAME "Borland C++ Builder"
+# define ACE_CC_MAJOR_VERSION (__BORLANDC__ / 0x100)
+# define ACE_CC_MINOR_VERSION (__BORLANDC__ % 0x100)
+# define ACE_CC_BETA_VERSION  (0)
 
 #   if defined (ACE_LACKS_MODE_MASKS)
 #     undef ACE_LACKS_MODE_MASKS
@@ -20,10 +25,12 @@
 #   endif /* defined (ACE_HAS_USER_MODE_MASKS) */
 #   define ACE_HAS_USER_MODE_MASKS 1
 
-#   if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-#     undef ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION
-#   endif /* defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) */
-#   define ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION 1
+#   if (__BORLANDC__ < 0x540)
+#     if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
+#       undef ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION
+#     endif /* defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) */
+#     define ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION 1
+#   endif /* (__BORLANDC__ < 0x540) */
 
 #   if defined (ACE_EXPORT_NESTED_CLASSES)
 #     undef ACE_EXPORT_NESTED_CLASSES
diff --git a/ace/config-win32.h b/ace/config-win32.h
index 0de6d18f546..955d42a2061 100644
--- a/ace/config-win32.h
+++ b/ace/config-win32.h
@@ -50,6 +50,23 @@
 // relies on the standard c++ library.
 //  Runtime restrictions: You must be using MSVC 4.2 or above and your
 //                        application must link with the standard libraries.
+
+#if defined (_MSC_VER)
+
+# define ACE_CC_NAME "Visual C++"
+
+#if (_MSC_VER >= 1200)
+# define ACE_CC_MAJOR_VERSION 6
+#elif (_MSC_VER >= 1100)
+# define ACE_CC_MAJOR_VERSION 5
+#elif (_MSC_VER >= 1000)
+# define ACE_CC_MAJOR_VERSION 4
+#endif /* _MSC_VER  >= 1200 */
+
+# define ACE_CC_MINOR_VERSION (_MSC_VER % 100)
+# define ACE_CC_BETA_VERSION  (0)
+#endif /* _MSC_VER */
+
 #if defined (_MSC_VER) && (_MSC_VER >= 1020)
         #if !defined (ACE_HAS_STANDARD_CPP_LIBRARY)
                 #define ACE_HAS_STANDARD_CPP_LIBRARY    0