3.14

1 files changed, 291 insertions, 291 deletions

diff --git a/shared/loki/SmallObj.cpp b/shared/loki/SmallObj.cpp
index adb54c55..0d82c1bb 100644
--- a/shared/loki/SmallObj.cpp
+++ b/shared/loki/SmallObj.cpp
@@ -28,274 +28,274 @@
 //#define LOKI_CHECK_FOR_CORRUPTION
 
 #ifdef DO_EXTRA_LOKI_TESTS
-    #include <iostream>
+#include <iostream>
 #endif
 
 namespace Loki
 {
 
-    /** @struct Chunk
-        @ingroup SmallObjectGroupInternal
-     Contains info about each allocated Chunk - which is a collection of
-     contiguous blocks.  Each block is the same size, as specified by the
-     FixedAllocator.  The number of blocks in a Chunk depends upon page size.
-     This is a POD-style struct with value-semantics.  All functions and data
-     are private so that they can not be changed by anything other than the
-     FixedAllocator which owns the Chunk.
-
-     @par Minimal Interface
-     For the sake of runtime efficiency, no constructor, destructor, or
-     copy-assignment operator is defined. The inline functions made by the
-     compiler should be sufficient, and perhaps faster than hand-crafted
-     functions.  The lack of these functions allows vector to create and copy
-     Chunks as needed without overhead.  The Init and Release functions do
-     what the default constructor and destructor would do.  A Chunk is not in
-     a usable state after it is constructed and before calling Init.  Nor is
-     a Chunk usable after Release is called, but before the destructor.
-
-     @par Efficiency
-     Down near the lowest level of the allocator, runtime efficiencies trump
-     almost all other considerations.  Each function does the minimum required
-     of it.  All functions should execute in constant time to prevent higher-
-     level code from unwittingly using a version of Shlemiel the Painter's
-     Algorithm.
-
-     @par Stealth Indexes
-     The first char of each empty block contains the index of the next empty
-     block.  These stealth indexes form a singly-linked list within the blocks.
-     A Chunk is corrupt if this singly-linked list has a loop or is shorter
-     than blocksAvailable_.  Much of the allocator's time and space efficiency
-     comes from how these stealth indexes are implemented.
+/** @struct Chunk
+    @ingroup SmallObjectGroupInternal
+ Contains info about each allocated Chunk - which is a collection of
+ contiguous blocks.  Each block is the same size, as specified by the
+ FixedAllocator.  The number of blocks in a Chunk depends upon page size.
+ This is a POD-style struct with value-semantics.  All functions and data
+ are private so that they can not be changed by anything other than the
+ FixedAllocator which owns the Chunk.
+
+ @par Minimal Interface
+ For the sake of runtime efficiency, no constructor, destructor, or
+ copy-assignment operator is defined. The inline functions made by the
+ compiler should be sufficient, and perhaps faster than hand-crafted
+ functions.  The lack of these functions allows vector to create and copy
+ Chunks as needed without overhead.  The Init and Release functions do
+ what the default constructor and destructor would do.  A Chunk is not in
+ a usable state after it is constructed and before calling Init.  Nor is
+ a Chunk usable after Release is called, but before the destructor.
+
+ @par Efficiency
+ Down near the lowest level of the allocator, runtime efficiencies trump
+ almost all other considerations.  Each function does the minimum required
+ of it.  All functions should execute in constant time to prevent higher-
+ level code from unwittingly using a version of Shlemiel the Painter's
+ Algorithm.
+
+ @par Stealth Indexes
+ The first char of each empty block contains the index of the next empty
+ block.  These stealth indexes form a singly-linked list within the blocks.
+ A Chunk is corrupt if this singly-linked list has a loop or is shorter
+ than blocksAvailable_.  Much of the allocator's time and space efficiency
+ comes from how these stealth indexes are implemented.
+ */
+class Chunk
+{
+private:
+    friend class FixedAllocator;
+
+    /** Initializes a just-constructed Chunk.
+     @param blockSize Number of bytes per block.
+     @param blocks Number of blocks per Chunk.
+     @return True for success, false for failure.
      */
-    class Chunk
-    {
-    private:
-        friend class FixedAllocator;
+    bool Init( std::size_t blockSize, unsigned char blocks );
 
-        /** Initializes a just-constructed Chunk.
-         @param blockSize Number of bytes per block.
-         @param blocks Number of blocks per Chunk.
-         @return True for success, false for failure.
-         */
-        bool Init( std::size_t blockSize, unsigned char blocks );
+    /** Allocate a block within the Chunk.  Complexity is always O(1), and
+     this will never throw.  Does not actually "allocate" by calling
+     malloc, new, or any other function, but merely adjusts some internal
+     indexes to indicate an already allocated block is no longer available.
+     @return Pointer to block within Chunk.
+     */
+    void* Allocate( std::size_t blockSize );
+
+    /** Deallocate a block within the Chunk. Complexity is always O(1), and
+     this will never throw.  For efficiency, this assumes the address is
+     within the block and aligned along the correct byte boundary.  An
+     assertion checks the alignment, and a call to HasBlock is done from
+     within VicinityFind.  Does not actually "deallocate" by calling free,
+     delete, or other function, but merely adjusts some internal indexes to
+     indicate a block is now available.
+     */
+    void Deallocate( void* p, std::size_t blockSize );
 
-        /** Allocate a block within the Chunk.  Complexity is always O(1), and
-         this will never throw.  Does not actually "allocate" by calling
-         malloc, new, or any other function, but merely adjusts some internal
-         indexes to indicate an already allocated block is no longer available.
-         @return Pointer to block within Chunk.
-         */
-        void * Allocate( std::size_t blockSize );
-
-        /** Deallocate a block within the Chunk. Complexity is always O(1), and
-         this will never throw.  For efficiency, this assumes the address is
-         within the block and aligned along the correct byte boundary.  An
-         assertion checks the alignment, and a call to HasBlock is done from
-         within VicinityFind.  Does not actually "deallocate" by calling free,
-         delete, or other function, but merely adjusts some internal indexes to
-         indicate a block is now available.
-         */
-        void Deallocate( void * p, std::size_t blockSize );
+    /** Resets the Chunk back to pristine values. The available count is
+     set back to zero, and the first available index is set to the zeroth
+     block.  The stealth indexes inside each block are set to point to the
+     next block. This assumes the Chunk's data was already using Init.
+     */
+    void Reset( std::size_t blockSize, unsigned char blocks );
+
+    /// Releases the allocated block of memory.
+    void Release();
+
+    /** Determines if the Chunk has been corrupted.
+     @param numBlocks Total # of blocks in the Chunk.
+     @param blockSize # of bytes in each block.
+     @param checkIndexes True if caller wants to check indexes of available
+      blocks for corruption.  If false, then caller wants to skip some
+      tests tests just to run faster.  (Debug version does more checks, but
+      release version runs faster.)
+     @return True if Chunk is corrupt.
+     */
+    bool IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
+                    bool checkIndexes ) const;
+
+    /** Determines if block is available.
+     @param p Address of block managed by Chunk.
+     @param numBlocks Total # of blocks in the Chunk.
+     @param blockSize # of bytes in each block.
+     @return True if block is available, else false if allocated.
+     */
+    bool IsBlockAvailable( void* p, unsigned char numBlocks,
+                           std::size_t blockSize ) const;
 
-        /** Resets the Chunk back to pristine values. The available count is
-         set back to zero, and the first available index is set to the zeroth
-         block.  The stealth indexes inside each block are set to point to the
-         next block. This assumes the Chunk's data was already using Init.
-         */
-        void Reset( std::size_t blockSize, unsigned char blocks );
-
-        /// Releases the allocated block of memory.
-        void Release();
-
-        /** Determines if the Chunk has been corrupted.
-         @param numBlocks Total # of blocks in the Chunk.
-         @param blockSize # of bytes in each block.
-         @param checkIndexes True if caller wants to check indexes of available
-          blocks for corruption.  If false, then caller wants to skip some
-          tests tests just to run faster.  (Debug version does more checks, but
-          release version runs faster.)
-         @return True if Chunk is corrupt.
-         */
-        bool IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
-            bool checkIndexes ) const;
-
-        /** Determines if block is available.
-         @param p Address of block managed by Chunk.
-         @param numBlocks Total # of blocks in the Chunk.
-         @param blockSize # of bytes in each block.
-         @return True if block is available, else false if allocated.
-         */
-        bool IsBlockAvailable( void * p, unsigned char numBlocks,
-            std::size_t blockSize ) const;
+    /// Returns true if block at address P is inside this Chunk.
+    inline bool HasBlock( void* p, std::size_t chunkLength ) const
+    {
+        unsigned char* pc = static_cast< unsigned char* >( p );
+        return ( pData_ <= pc ) && ( pc < pData_ + chunkLength );
+    }
 
-        /// Returns true if block at address P is inside this Chunk.
-        inline bool HasBlock( void * p, std::size_t chunkLength ) const
-        {
-            unsigned char * pc = static_cast< unsigned char * >( p );
-            return ( pData_ <= pc ) && ( pc < pData_ + chunkLength );
-        }
+    inline bool HasAvailable( unsigned char numBlocks ) const
+    { return ( blocksAvailable_ == numBlocks ); }
+
+    inline bool IsFilled( void ) const
+    { return ( 0 == blocksAvailable_ ); }
+
+    /// Pointer to array of allocated blocks.
+    unsigned char* pData_;
+    /// Index of first empty block.
+    unsigned char firstAvailableBlock_;
+    /// Count of empty blocks.
+    unsigned char blocksAvailable_;
+};
+
+/** @class FixedAllocator
+    @ingroup SmallObjectGroupInternal
+ Offers services for allocating fixed-sized objects.  It has a container
+ of "containers" of fixed-size blocks.  The outer container has all the
+ Chunks.  The inner container is a Chunk which owns some blocks.
+
+ @par Class Level Invariants
+ - There is always either zero or one Chunk which is empty.
+ - If this has no empty Chunk, then emptyChunk_ is NULL.
+ - If this has an empty Chunk, then emptyChunk_ points to it.
+ - If the Chunk container is empty, then deallocChunk_ and allocChunk_
+   are NULL.
+ - If the Chunk container is not-empty, then deallocChunk_ and allocChunk_
+   are either NULL or point to Chunks within the container.
+ - allocChunk_ will often point to the last Chunk in the container since
+   it was likely allocated most recently, and therefore likely to have an
+   available block.
+ */
+class FixedAllocator
+{
+private:
 
-        inline bool HasAvailable( unsigned char numBlocks ) const
-        { return ( blocksAvailable_ == numBlocks ); }
-
-        inline bool IsFilled( void ) const
-        { return ( 0 == blocksAvailable_ ); }
-
-        /// Pointer to array of allocated blocks.
-        unsigned char * pData_;
-        /// Index of first empty block.
-        unsigned char firstAvailableBlock_;
-        /// Count of empty blocks.
-        unsigned char blocksAvailable_;
-    };
-
-    /** @class FixedAllocator
-        @ingroup SmallObjectGroupInternal
-     Offers services for allocating fixed-sized objects.  It has a container
-     of "containers" of fixed-size blocks.  The outer container has all the
-     Chunks.  The inner container is a Chunk which owns some blocks.
-
-     @par Class Level Invariants
-     - There is always either zero or one Chunk which is empty.
-     - If this has no empty Chunk, then emptyChunk_ is NULL.
-     - If this has an empty Chunk, then emptyChunk_ points to it.
-     - If the Chunk container is empty, then deallocChunk_ and allocChunk_
-       are NULL.
-     - If the Chunk container is not-empty, then deallocChunk_ and allocChunk_
-       are either NULL or point to Chunks within the container.
-     - allocChunk_ will often point to the last Chunk in the container since
-       it was likely allocated most recently, and therefore likely to have an
-       available block.
+    /** Deallocates the block at address p, and then handles the internal
+     bookkeeping needed to maintain class invariants.  This assumes that
+     deallocChunk_ points to the correct chunk.
      */
-    class FixedAllocator
-    {
-    private:
-
-        /** Deallocates the block at address p, and then handles the internal
-         bookkeeping needed to maintain class invariants.  This assumes that
-         deallocChunk_ points to the correct chunk.
-         */
-        void DoDeallocate( void * p );
+    void DoDeallocate( void* p );
 
-        /** Creates an empty Chunk and adds it to the end of the ChunkList.
-         All calls to the lower-level memory allocation functions occur inside
-         this function, and so the only try-catch block is inside here.
-         @return true for success, false for failure.
-         */
-        bool MakeNewChunk( void );
-
-        /** Finds the Chunk which owns the block at address p.  It starts at
-         deallocChunk_ and searches in both forwards and backwards directions
-         from there until it finds the Chunk which owns p.  This algorithm
-         should find the Chunk quickly if it is deallocChunk_ or is close to it
-         in the Chunks container.  This goes both forwards and backwards since
-         that works well for both same-order and opposite-order deallocations.
-         (Same-order = objects are deallocated in the same order in which they
-         were allocated.  Opposite order = objects are deallocated in a last to
-         first order.  Complexity is O(C) where C is count of all Chunks.  This
-         never throws.
-         @return Pointer to Chunk that owns p, or NULL if no owner found.
-         */
-        Chunk * VicinityFind( void * p ) const;
-
-        /// Not implemented.
-        FixedAllocator(const FixedAllocator&);
-        /// Not implemented.
-        FixedAllocator& operator=(const FixedAllocator&);
-
-        /// Type of container used to hold Chunks.
-        typedef std::vector< Chunk > Chunks;
-        /// Iterator through container of Chunks.
-        typedef Chunks::iterator ChunkIter;
-        /// Iterator through const container of Chunks.
-        typedef Chunks::const_iterator ChunkCIter;
-
-        /// Fewest # of objects managed by a Chunk.
-        static unsigned char MinObjectsPerChunk_;
-
-        /// Most # of objects managed by a Chunk - never exceeds UCHAR_MAX.
-        static unsigned char MaxObjectsPerChunk_;
-
-        /// Number of bytes in a single block within a Chunk.
-        std::size_t blockSize_;
-        /// Number of blocks managed by each Chunk.
-        unsigned char numBlocks_;
-
-        /// Container of Chunks.
-        Chunks chunks_;
-        /// Pointer to Chunk used for last or next allocation.
-        Chunk * allocChunk_;
-        /// Pointer to Chunk used for last or next deallocation.
-        Chunk * deallocChunk_;
-        /// Pointer to the only empty Chunk if there is one, else NULL.
-        Chunk * emptyChunk_;
-
-    public:
-        /// Create a FixedAllocator which manages blocks of 'blockSize' size.
-        FixedAllocator();
-
-        /// Destroy the FixedAllocator and release all its Chunks.
-        ~FixedAllocator();
-
-        /// Initializes a FixedAllocator by calculating # of blocks per Chunk.
-        void Initialize( std::size_t blockSize, std::size_t pageSize );
-
-        /** Returns pointer to allocated memory block of fixed size - or NULL
-         if it failed to allocate.
-         */
-        void * Allocate( void );
+    /** Creates an empty Chunk and adds it to the end of the ChunkList.
+     All calls to the lower-level memory allocation functions occur inside
+     this function, and so the only try-catch block is inside here.
+     @return true for success, false for failure.
+     */
+    bool MakeNewChunk( void );
+
+    /** Finds the Chunk which owns the block at address p.  It starts at
+     deallocChunk_ and searches in both forwards and backwards directions
+     from there until it finds the Chunk which owns p.  This algorithm
+     should find the Chunk quickly if it is deallocChunk_ or is close to it
+     in the Chunks container.  This goes both forwards and backwards since
+     that works well for both same-order and opposite-order deallocations.
+     (Same-order = objects are deallocated in the same order in which they
+     were allocated.  Opposite order = objects are deallocated in a last to
+     first order.  Complexity is O(C) where C is count of all Chunks.  This
+     never throws.
+     @return Pointer to Chunk that owns p, or NULL if no owner found.
+     */
+    Chunk* VicinityFind( void* p ) const;
+
+    /// Not implemented.
+    FixedAllocator(const FixedAllocator&);
+    /// Not implemented.
+    FixedAllocator& operator=(const FixedAllocator&);
+
+    /// Type of container used to hold Chunks.
+    typedef std::vector< Chunk > Chunks;
+    /// Iterator through container of Chunks.
+    typedef Chunks::iterator ChunkIter;
+    /// Iterator through const container of Chunks.
+    typedef Chunks::const_iterator ChunkCIter;
+
+    /// Fewest # of objects managed by a Chunk.
+    static unsigned char MinObjectsPerChunk_;
+
+    /// Most # of objects managed by a Chunk - never exceeds UCHAR_MAX.
+    static unsigned char MaxObjectsPerChunk_;
+
+    /// Number of bytes in a single block within a Chunk.
+    std::size_t blockSize_;
+    /// Number of blocks managed by each Chunk.
+    unsigned char numBlocks_;
+
+    /// Container of Chunks.
+    Chunks chunks_;
+    /// Pointer to Chunk used for last or next allocation.
+    Chunk* allocChunk_;
+    /// Pointer to Chunk used for last or next deallocation.
+    Chunk* deallocChunk_;
+    /// Pointer to the only empty Chunk if there is one, else NULL.
+    Chunk* emptyChunk_;
+
+public:
+    /// Create a FixedAllocator which manages blocks of 'blockSize' size.
+    FixedAllocator();
+
+    /// Destroy the FixedAllocator and release all its Chunks.
+    ~FixedAllocator();
+
+    /// Initializes a FixedAllocator by calculating # of blocks per Chunk.
+    void Initialize( std::size_t blockSize, std::size_t pageSize );
+
+    /** Returns pointer to allocated memory block of fixed size - or NULL
+     if it failed to allocate.
+     */
+    void* Allocate( void );
 
-        /** Deallocate a memory block previously allocated with Allocate.  If
-         the block is not owned by this FixedAllocator, it returns false so
-         that SmallObjAllocator can call the default deallocator.  If the
-         block was found, this returns true.
-         */
-        bool Deallocate( void * p, Chunk * hint );
+    /** Deallocate a memory block previously allocated with Allocate.  If
+     the block is not owned by this FixedAllocator, it returns false so
+     that SmallObjAllocator can call the default deallocator.  If the
+     block was found, this returns true.
+     */
+    bool Deallocate( void* p, Chunk* hint );
 
-        /// Returns block size with which the FixedAllocator was initialized.
-        inline std::size_t BlockSize() const { return blockSize_; }
+    /// Returns block size with which the FixedAllocator was initialized.
+    inline std::size_t BlockSize() const { return blockSize_; }
 
-        /** Releases the memory used by the empty Chunk.  This will take
-         constant time under any situation.
-         @return True if empty chunk found and released, false if none empty.
-         */
-        bool TrimEmptyChunk( void );
+    /** Releases the memory used by the empty Chunk.  This will take
+     constant time under any situation.
+     @return True if empty chunk found and released, false if none empty.
+     */
+    bool TrimEmptyChunk( void );
 
-        /** Releases unused spots from ChunkList.  This takes constant time
-         with respect to # of Chunks, but actual time depends on underlying
-         memory allocator.
-         @return False if no unused spots, true if some found and released.
-         */
-        bool TrimChunkList( void );
+    /** Releases unused spots from ChunkList.  This takes constant time
+     with respect to # of Chunks, but actual time depends on underlying
+     memory allocator.
+     @return False if no unused spots, true if some found and released.
+     */
+    bool TrimChunkList( void );
 
-        /** Returns count of empty Chunks held by this allocator.  Complexity
-         is O(C) where C is the total number of Chunks - empty or used.
-         */
-        std::size_t CountEmptyChunks( void ) const;
+    /** Returns count of empty Chunks held by this allocator.  Complexity
+     is O(C) where C is the total number of Chunks - empty or used.
+     */
+    std::size_t CountEmptyChunks( void ) const;
 
-        /** Determines if FixedAllocator is corrupt.  Checks data members to
-         see if any have erroneous values, or violate class invariants.  It
-         also checks if any Chunk is corrupt.  Complexity is O(C) where C is
-         the number of Chunks.  If any data is corrupt, this will return true
-         in release mode, or assert in debug mode.
-         */
-        bool IsCorrupt( void ) const;
+    /** Determines if FixedAllocator is corrupt.  Checks data members to
+     see if any have erroneous values, or violate class invariants.  It
+     also checks if any Chunk is corrupt.  Complexity is O(C) where C is
+     the number of Chunks.  If any data is corrupt, this will return true
+     in release mode, or assert in debug mode.
+     */
+    bool IsCorrupt( void ) const;
 
-        /** Returns true if the block at address p is within a Chunk owned by
-         this FixedAllocator.  Complexity is O(C) where C is the total number
-         of Chunks - empty or used.
-         */
-        const Chunk * HasBlock( void * p ) const;
-        inline Chunk * HasBlock( void * p )
-        {
-            return const_cast< Chunk * >(
-                const_cast< const FixedAllocator * >( this )->HasBlock( p ) );
-        }
+    /** Returns true if the block at address p is within a Chunk owned by
+     this FixedAllocator.  Complexity is O(C) where C is the total number
+     of Chunks - empty or used.
+     */
+    const Chunk* HasBlock( void* p ) const;
+    inline Chunk* HasBlock( void* p )
+    {
+        return const_cast< Chunk* >(
+                   const_cast< const FixedAllocator* >( this )->HasBlock( p ) );
+    }
 
-    };
+};
 
-    unsigned char FixedAllocator::MinObjectsPerChunk_ = 8;
-    unsigned char FixedAllocator::MaxObjectsPerChunk_ = UCHAR_MAX;
+unsigned char FixedAllocator::MinObjectsPerChunk_ = 8;
+unsigned char FixedAllocator::MaxObjectsPerChunk_ = UCHAR_MAX;
 
 // Chunk::Init ----------------------------------------------------------------
 
@@ -310,11 +310,11 @@ bool Chunk::Init( std::size_t blockSize, unsigned char blocks )
 #ifdef USE_NEW_TO_ALLOCATE
     // If this new operator fails, it will throw, and the exception will get
     // caught one layer up.
-    pData_ = static_cast< unsigned char * >( ::operator new ( allocSize ) );
+    pData_ = static_cast< unsigned char* >( ::operator new ( allocSize ) );
 #else
     // malloc can't throw, so its only way to indicate an error is to return
     // a NULL pointer, so we have to check for that.
-    pData_ = static_cast< unsigned char * >( ::std::malloc( allocSize ) );
+    pData_ = static_cast< unsigned char* >( ::std::malloc( allocSize ) );
     if ( NULL == pData_ ) return false;
 #endif
 
@@ -335,7 +335,7 @@ void Chunk::Reset(std::size_t blockSize, unsigned char blocks)
     blocksAvailable_ = blocks;
 
     unsigned char i = 0;
-    for ( unsigned char * p = pData_; i != blocks; p += blockSize )
+    for ( unsigned char* p = pData_; i != blocks; p += blockSize )
     {
         *p = ++i;
     }
@@ -349,7 +349,7 @@ void Chunk::Release()
 #ifdef USE_NEW_TO_ALLOCATE
     ::operator delete ( pData_ );
 #else
-    ::std::free( static_cast< void * >( pData_ ) );
+    ::std::free( static_cast< void* >( pData_ ) );
 #endif
 }
 
@@ -360,8 +360,8 @@ void* Chunk::Allocate(std::size_t blockSize)
     if ( IsFilled() ) return NULL;
 
     assert((firstAvailableBlock_ * blockSize) / blockSize ==
-        firstAvailableBlock_);
-    unsigned char * pResult = pData_ + (firstAvailableBlock_ * blockSize);
+           firstAvailableBlock_);
+    unsigned char* pResult = pData_ + (firstAvailableBlock_ * blockSize);
     firstAvailableBlock_ = *pResult;
     --blocksAvailable_;
 
@@ -378,7 +378,7 @@ void Chunk::Deallocate(void* p, std::size_t blockSize)
     // Alignment check
     assert((toRelease - pData_) % blockSize == 0);
     unsigned char index = static_cast< unsigned char >(
-        ( toRelease - pData_ ) / blockSize);
+                              ( toRelease - pData_ ) / blockSize);
 
 #if defined(DEBUG) || defined(_DEBUG)
     // Check if block was already deleted.  Attempting to delete the same
@@ -399,7 +399,7 @@ void Chunk::Deallocate(void* p, std::size_t blockSize)
 // Chunk::IsCorrupt -----------------------------------------------------------
 
 bool Chunk::IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
-    bool checkIndexes ) const
+                       bool checkIndexes ) const
 {
 
     if ( numBlocks < blocksAvailable_ )
@@ -428,7 +428,7 @@ bool Chunk::IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
      found on the linked-list.
      */
     std::bitset< UCHAR_MAX > foundBlocks;
-    unsigned char * nextBlock = NULL;
+    unsigned char* nextBlock = NULL;
 
     /* The loop goes along singly linked-list of stealth indexes and makes sure
      that each index is within bounds (0 <= index < numBlocks) and that the
@@ -499,19 +499,19 @@ bool Chunk::IsCorrupt( unsigned char numBlocks, std::size_t blockSize,
 
 // Chunk::IsBlockAvailable ----------------------------------------------------
 
-bool Chunk::IsBlockAvailable( void * p, unsigned char numBlocks,
-    std::size_t blockSize ) const
+bool Chunk::IsBlockAvailable( void* p, unsigned char numBlocks,
+                              std::size_t blockSize ) const
 {
     (void) numBlocks;
 
     if ( IsFilled() )
         return false;
 
-    unsigned char * place = static_cast< unsigned char * >( p );
+    unsigned char* place = static_cast< unsigned char* >( p );
     // Alignment check
     assert( ( place - pData_ ) % blockSize == 0 );
     unsigned char blockIndex = static_cast< unsigned char >(
-        ( place - pData_ ) / blockSize );
+                                   ( place - pData_ ) / blockSize );
 
     unsigned char index = firstAvailableBlock_;
     assert( numBlocks > index );
@@ -522,7 +522,7 @@ bool Chunk::IsBlockAvailable( void * p, unsigned char numBlocks,
      found on the linked-list.
      */
     std::bitset< UCHAR_MAX > foundBlocks;
-    unsigned char * nextBlock = NULL;
+    unsigned char* nextBlock = NULL;
     for ( unsigned char cc = 0; ; )
     {
         nextBlock = pData_ + ( index * blockSize );
@@ -562,7 +562,7 @@ FixedAllocator::~FixedAllocator()
     assert( chunks_.empty() && "Memory leak detected!" );
 #endif
     for ( ChunkIter i( chunks_.begin() ); i != chunks_.end(); ++i )
-       i->Release();
+        i->Release();
 }
 
 // FixedAllocator::Initialize -------------------------------------------------
@@ -592,7 +592,7 @@ std::size_t FixedAllocator::CountEmptyChunks( void ) const
     std::size_t count = 0;
     for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it )
     {
-        const Chunk & chunk = *it;
+        const Chunk& chunk = *it;
         if ( chunk.HasAvailable( numBlocks_ ) )
             ++count;
     }
@@ -642,8 +642,8 @@ bool FixedAllocator::IsCorrupt( void ) const
 
     else
     {
-        const Chunk * front = &chunks_.front();
-        const Chunk * back  = &chunks_.back();
+        const Chunk* front = &chunks_.front();
+        const Chunk* back  = &chunks_.back();
         if ( start >= last )
         {
             assert( false );
@@ -708,7 +708,7 @@ bool FixedAllocator::IsCorrupt( void ) const
         }
         for ( ChunkCIter it( start ); it != last; ++it )
         {
-            const Chunk & chunk = *it;
+            const Chunk& chunk = *it;
             if ( chunk.IsCorrupt( numBlocks_, blockSize_, true ) )
                 return true;
         }
@@ -719,12 +719,12 @@ bool FixedAllocator::IsCorrupt( void ) const
 
 // FixedAllocator::HasBlock ---------------------------------------------------
 
-const Chunk * FixedAllocator::HasBlock( void * p ) const
+const Chunk* FixedAllocator::HasBlock( void* p ) const
 {
     const std::size_t chunkLength = numBlocks_ * blockSize_;
     for ( ChunkCIter it( chunks_.begin() ); it != chunks_.end(); ++it )
     {
-        const Chunk & chunk = *it;
+        const Chunk& chunk = *it;
         if ( chunk.HasBlock( p, chunkLength ) )
             return &chunk;
     }
@@ -744,7 +744,7 @@ bool FixedAllocator::TrimEmptyChunk( void )
     // And there should be exactly 1 empty Chunk.
     assert( 1 == CountEmptyChunks() );
 
-    Chunk * lastChunk = &chunks_.back();
+    Chunk* lastChunk = &chunks_.back();
     if ( lastChunk != emptyChunk_ )
         std::swap( *emptyChunk_, *lastChunk );
     assert( lastChunk->HasAvailable( numBlocks_ ) );
@@ -828,7 +828,7 @@ bool FixedAllocator::MakeNewChunk( void )
 
 // FixedAllocator::Allocate ---------------------------------------------------
 
-void * FixedAllocator::Allocate( void )
+void* FixedAllocator::Allocate( void )
 {
     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
@@ -867,7 +867,7 @@ void * FixedAllocator::Allocate( void )
 
     assert( allocChunk_ != NULL );
     assert( !allocChunk_->IsFilled() );
-    void * place = allocChunk_->Allocate( blockSize_ );
+    void* place = allocChunk_->Allocate( blockSize_ );
 
     // prove either emptyChunk_ points nowhere, or points to a truly empty Chunk.
     assert( ( NULL == emptyChunk_ ) || ( emptyChunk_->HasAvailable( numBlocks_ ) ) );
@@ -885,7 +885,7 @@ void * FixedAllocator::Allocate( void )
 
 // FixedAllocator::Deallocate -------------------------------------------------
 
-bool FixedAllocator::Deallocate( void * p, Chunk * hint )
+bool FixedAllocator::Deallocate( void* p, Chunk* hint )
 {
     assert(!chunks_.empty());
     assert(&chunks_.front() <= deallocChunk_);
@@ -894,7 +894,7 @@ bool FixedAllocator::Deallocate( void * p, Chunk * hint )
     assert( &chunks_.back() >= allocChunk_ );
     assert( CountEmptyChunks() < 2 );
 
-    Chunk * foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint;
+    Chunk* foundChunk = ( NULL == hint ) ? VicinityFind( p ) : hint;
     if ( NULL == foundChunk )
         return false;
 
@@ -920,16 +920,16 @@ bool FixedAllocator::Deallocate( void * p, Chunk * hint )
 
 // FixedAllocator::VicinityFind -----------------------------------------------
 
-Chunk * FixedAllocator::VicinityFind( void * p ) const
+Chunk* FixedAllocator::VicinityFind( void* p ) const
 {
     if ( chunks_.empty() ) return NULL;
     assert(deallocChunk_);
 
     const std::size_t chunkLength = numBlocks_ * blockSize_;
-    Chunk * lo = deallocChunk_;
-    Chunk * hi = deallocChunk_ + 1;
-    const Chunk * loBound = &chunks_.front();
-    const Chunk * hiBound = &chunks_.back() + 1;
+    Chunk* lo = deallocChunk_;
+    Chunk* hi = deallocChunk_ + 1;
+    const Chunk* loBound = &chunks_.front();
+    const Chunk* hiBound = &chunks_.back() + 1;
 
     // Special case: deallocChunk_ is the last in the array
     if (hi == hiBound) hi = NULL;
@@ -989,7 +989,7 @@ void FixedAllocator::DoDeallocate(void* p)
             // If last Chunk is empty, just change what deallocChunk_
             // points to, and release the last.  Otherwise, swap an empty
             // Chunk with the last, and then release it.
-            Chunk * lastChunk = &chunks_.back();
+            Chunk* lastChunk = &chunks_.back();
             if ( lastChunk == deallocChunk_ )
                 deallocChunk_ = emptyChunk_;
             else if ( lastChunk != emptyChunk_ )
@@ -1025,13 +1025,13 @@ inline std::size_t GetOffset( std::size_t numBytes, std::size_t alignment )
  @param doThrow True if this function should throw an exception, or false if it
   should indicate failure by returning a NULL pointer.
 */
-void * DefaultAllocator( std::size_t numBytes, bool doThrow )
+void* DefaultAllocator( std::size_t numBytes, bool doThrow )
 {
 #ifdef USE_NEW_TO_ALLOCATE
     return doThrow ? ::operator new( numBytes ) :
-        ::operator new( numBytes, std::nothrow_t() );
+           ::operator new( numBytes, std::nothrow_t() );
 #else
-    void * p = ::std::malloc( numBytes );
+    void* p = ::std::malloc( numBytes );
     if ( doThrow && ( NULL == p ) )
         throw std::bad_alloc();
     return p;
@@ -1046,7 +1046,7 @@ void * DefaultAllocator( std::size_t numBytes, bool doThrow )
  it matches malloc which is the preferred default allocator.  SmallObjAllocator
  will call this if an address was not found among any of its own blocks.
  */
-void DefaultDeallocator( void * p )
+void DefaultDeallocator( void* p )
 {
 #ifdef USE_NEW_TO_ALLOCATE
     ::operator delete( p );
@@ -1058,7 +1058,7 @@ void DefaultDeallocator( void * p )
 // SmallObjAllocator::SmallObjAllocator ---------------------------------------
 
 SmallObjAllocator::SmallObjAllocator( std::size_t pageSize,
-    std::size_t maxObjectSize, std::size_t objectAlignSize ) :
+                                      std::size_t maxObjectSize, std::size_t objectAlignSize ) :
     pool_( NULL ),
     maxSmallObjectSize_( maxObjectSize ),
     objectAlignSize_( objectAlignSize )
@@ -1106,7 +1106,7 @@ bool SmallObjAllocator::TrimExcessMemory( void )
 
 // SmallObjAllocator::Allocate ------------------------------------------------
 
-void * SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow )
+void* SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow )
 {
     if ( numBytes > GetMaxObjectSize() )
         return DefaultAllocator( numBytes, doThrow );
@@ -1118,10 +1118,10 @@ void * SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow )
     (void) allocCount;
     assert( index < allocCount );
 
-    FixedAllocator & allocator = pool_[ index ];
+    FixedAllocator& allocator = pool_[ index ];
     assert( allocator.BlockSize() >= numBytes );
     assert( allocator.BlockSize() < numBytes + GetAlignment() );
-    void * place = allocator.Allocate();
+    void* place = allocator.Allocate();
 
     if ( ( NULL == place ) && TrimExcessMemory() )
         place = allocator.Allocate();
@@ -1141,7 +1141,7 @@ void * SmallObjAllocator::Allocate( std::size_t numBytes, bool doThrow )
 
 // SmallObjAllocator::Deallocate ----------------------------------------------
 
-void SmallObjAllocator::Deallocate( void * p, std::size_t numBytes )
+void SmallObjAllocator::Deallocate( void* p, std::size_t numBytes )
 {
     if ( NULL == p ) return;
     if ( numBytes > GetMaxObjectSize() )
@@ -1155,7 +1155,7 @@ void SmallObjAllocator::Deallocate( void * p, std::size_t numBytes )
     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
     (void) allocCount;
     assert( index < allocCount );
-    FixedAllocator & allocator = pool_[ index ];
+    FixedAllocator& allocator = pool_[ index ];
     assert( allocator.BlockSize() >= numBytes );
     assert( allocator.BlockSize() < numBytes + GetAlignment() );
     const bool found = allocator.Deallocate( p, NULL );
@@ -1165,13 +1165,13 @@ void SmallObjAllocator::Deallocate( void * p, std::size_t numBytes )
 
 // SmallObjAllocator::Deallocate ----------------------------------------------
 
-void SmallObjAllocator::Deallocate( void * p )
+void SmallObjAllocator::Deallocate( void* p )
 {
     if ( NULL == p ) return;
     assert( NULL != pool_ );
-    FixedAllocator * pAllocator = NULL;
+    FixedAllocator* pAllocator = NULL;
     const std::size_t allocCount = GetOffset( GetMaxObjectSize(), GetAlignment() );
-    Chunk * chunk = NULL;
+    Chunk* chunk = NULL;
 
     for ( std::size_t ii = 0; ii < allocCount; ++ii )
     {