Index: trunk/psLib/src/sys/psMemory.c
===================================================================
--- trunk/psLib/src/sys/psMemory.c	(revision 1406)
+++ trunk/psLib/src/sys/psMemory.c	(revision 1407)
@@ -1,2 +1,3 @@
+
 /** @file  psMemory.c
 *
@@ -8,11 +9,11 @@
 *  @author Robert Lupton, Princeton University
 *
-*  @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-06 22:34:05 $
+*  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-07 00:06:06 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
 */
 
-#define PS_ALLOW_MALLOC                 // we're allowed to call malloc()
+#define PS_ALLOW_MALLOC                    // we're allowed to call malloc()
 
 #include <stdlib.h>
@@ -26,9 +27,9 @@
 #include "psLogMsg.h"
 
-#define P_PS_MEMMAGIC (void *)0xdeadbeef // Magic number in psMemBlock header
-
-#define P_PS_LARGE_BLOCK_SIZE 65536    // size where under, we try to recycle
-
-static int checkMemBlock( const psMemBlock *m, const char* funcName );
+#define P_PS_MEMMAGIC (void *)0xdeadbeef   // Magic number in psMemBlock header
+
+#define P_PS_LARGE_BLOCK_SIZE 65536        // size where under, we try to recycle
+
+static int checkMemBlock(const psMemBlock * m, const char *funcName);
 static psMemBlock *lastMemBlockAllocated = NULL;
 static pthread_mutex_t memBlockListMutex = PTHREAD_MUTEX_INITIALIZER;
@@ -38,17 +39,17 @@
 
 static int recycleBins = 13;
-static int recycleBinSize[ 14 ] =
-    {
-        8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, P_PS_LARGE_BLOCK_SIZE
-    };
+static int recycleBinSize[14] = {
+                                    8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, P_PS_LARGE_BLOCK_SIZE
+                                };
+
 // N.B. recycleBinSize should be terminated by P_PS_LARGE_BLOCK_SIZE (simplifies search loops)
-static psMemBlock* recycleMemBlockList[ 13 ] =
-    {
-        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
-    };
+static psMemBlock *recycleMemBlockList[13] = {
+            NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
+        };
 
 #ifdef PS_MEM_DEBUG
-static psMemBlock* deadBlockList;    // a place to put dead memBlocks in debug mode.
+static psMemBlock *deadBlockList;       // a place to put dead memBlocks in debug mode.
 #endif
+
 /**
  * Unique ID for allocated blocks
@@ -59,20 +60,22 @@
  *  Default memExhausted callback.
  */
-static void *memExhaustedCallbackDefault( size_t size )
-{
-    void * ptr = NULL;
-
-    pthread_mutex_lock( &recycleMemBlockListMutex );
+static void *memExhaustedCallbackDefault(size_t size)
+{
+    void *ptr = NULL;
+
+    pthread_mutex_lock(&recycleMemBlockListMutex);
     int level = recycleBins - 1;
-    while ( level >= 0 && ptr == NULL ) {
-        while ( recycleMemBlockList[ level ] != NULL && ptr == NULL ) {
-            psMemBlock * old = recycleMemBlockList[ level ];
-            recycleMemBlockList[ level ] = recycleMemBlockList[ level ] ->nextBlock;
-            free( old );
-            ptr = malloc( size );
+
+    while (level >= 0 && ptr == NULL) {
+        while (recycleMemBlockList[level] != NULL && ptr == NULL) {
+            psMemBlock *old = recycleMemBlockList[level];
+
+            recycleMemBlockList[level] = recycleMemBlockList[level]->nextBlock;
+            free(old);
+            ptr = malloc(size);
         }
         level--;
     }
-    pthread_mutex_unlock( &recycleMemBlockListMutex );
+    pthread_mutex_unlock(&recycleMemBlockListMutex);
 
     return ptr;
@@ -81,9 +84,9 @@
 static psMemExhaustedCallback memExhaustedCallback = memExhaustedCallbackDefault;
 
-psMemExhaustedCallback psMemExhaustedCallbackSet( psMemExhaustedCallback func )
+psMemExhaustedCallback psMemExhaustedCallbackSet(psMemExhaustedCallback func)
 {
     psMemExhaustedCallback old = memExhaustedCallback;
 
-    if ( func != NULL ) {
+    if (func != NULL) {
         memExhaustedCallback = func;
     } else {
@@ -94,24 +97,23 @@
 }
 
-static void memProblemCallbackDefault( const psMemBlock *ptr,
-                                       const char *file, int lineno )
-{
-    if ( ptr->refCounter < 1 ) {
-        psError( __func__,
-                 "Block %ld allocated at %s:%d freed more than once at %s:%d\n",
-                 ptr->id, ptr->file, ptr->lineno, file, lineno );
-    }
-
-    if ( lineno > 0 ) {
-        psAbort( __func__, "Detected a problem in the memory system at %s:%d", file, lineno );
+static void memProblemCallbackDefault(const psMemBlock * ptr, const char *file, int lineno)
+{
+    if (ptr->refCounter < 1) {
+        psError(__func__,
+                "Block %ld allocated at %s:%d freed more than once at %s:%d\n",
+                ptr->id, ptr->file, ptr->lineno, file, lineno);
+    }
+
+    if (lineno > 0) {
+        psAbort(__func__, "Detected a problem in the memory system at %s:%d", file, lineno);
     }
 }
 static psMemProblemCallback memProblemCallback = memProblemCallbackDefault;
 
-psMemProblemCallback psMemProblemCallbackSet( psMemProblemCallback func )
+psMemProblemCallback psMemProblemCallbackSet(psMemProblemCallback func)
 {
     psMemProblemCallback old = memProblemCallback;
 
-    if ( func != NULL ) {
+    if (func != NULL) {
         memProblemCallback = func;
     } else {
@@ -121,4 +123,5 @@
     return old;
 }
+
 /*
  * And now the I-want-to-be-informed callbacks
@@ -126,10 +129,11 @@
  * Call the callbacks when these IDs are allocated/freed
  */
-psMemoryId p_psMemAllocateID = 0;  // notify user this block is allocated
+psMemoryId p_psMemAllocateID = 0;       // notify user this block is allocated
 psMemoryId p_psMemFreeID = 0;   // notify user this block is freed
 
-psMemoryId psMemAllocateCallbackSetID( psMemoryId id )
+psMemoryId psMemAllocateCallbackSetID(psMemoryId id)
 {
     psMemoryId old = p_psMemAllocateID;
+
     p_psMemAllocateID = id;
 
@@ -137,7 +141,8 @@
 }
 
-psMemoryId psMemFreeCallbackSetID( psMemoryId id )
+psMemoryId psMemFreeCallbackSetID(psMemoryId id)
 {
     psMemoryId old = p_psMemFreeID;
+
     p_psMemFreeID = id;
 
@@ -151,14 +156,14 @@
  * isn't resignalled)
  */
-static psMemoryId memAllocateCallbackDefault( const psMemBlock *ptr )
-{
-    static psMemoryId incr = 0;  // "p_psMemAllocateID += incr"
+static psMemoryId memAllocateCallbackDefault(const psMemBlock * ptr)
+{
+    static psMemoryId incr = 0; // "p_psMemAllocateID += incr"
 
     return incr;
 }
 
-static psMemoryId memFreeCallbackDefault( const psMemBlock *ptr )
-{
-    static psMemoryId incr = 0;  // "p_psMemFreeID += incr"
+static psMemoryId memFreeCallbackDefault(const psMemBlock * ptr)
+{
+    static psMemoryId incr = 0; // "p_psMemFreeID += incr"
 
     return incr;
@@ -171,9 +176,9 @@
 static psMemFreeCallback memFreeCallback = memFreeCallbackDefault;
 
-psMemAllocateCallback psMemAllocateCallbackSet( psMemAllocateCallback func )
+psMemAllocateCallback psMemAllocateCallbackSet(psMemAllocateCallback func)
 {
     psMemFreeCallback old = memAllocateCallback;
 
-    if ( func != NULL ) {
+    if (func != NULL) {
         memAllocateCallback = func;
     } else {
@@ -184,9 +189,9 @@
 }
 
-psMemFreeCallback psMemFreeCallbackSet( psMemFreeCallback func )
+psMemFreeCallback psMemFreeCallbackSet(psMemFreeCallback func)
 {
     psMemFreeCallback old = memFreeCallback;
 
-    if ( func != NULL ) {
+    if (func != NULL) {
         memFreeCallback = func;
     } else {
@@ -200,10 +205,11 @@
  * Return memory ID counter for next block to be allocated
  */
-psMemoryId psMemGetId( void )
+psMemoryId psMemGetId(void)
 {
     psMemoryId id;
-    pthread_mutex_lock( &memIdMutex );
+
+    pthread_mutex_lock(&memIdMutex);
     id = memid + 1;
-    pthread_mutex_unlock( &memIdMutex );
+    pthread_mutex_unlock(&memIdMutex);
 
     return id;
@@ -216,29 +222,26 @@
  */
 
-static int checkMemBlock( const psMemBlock *m, const char* funcName )
+static int checkMemBlock(const psMemBlock * m, const char *funcName)
 {
     // n.b. since this is called by psMemCheckCorruption while the memblock list is mutex locked,
     // we shouldn't call such things as p_psAlloc/p_psFree here.
 
-    if ( m == NULL ) {
-        psError( funcName, "Memory Corruption: NULL memory block found." );
+    if (m == NULL) {
+        psError(funcName, "Memory Corruption: NULL memory block found.");
         return 1;
     }
 
-    if ( m->refCounter == 0 ) {
+    if (m->refCounter == 0) {
         // using an unreferenced block of memory, are you?
-        psError( __func__, "Memory Corruption: memory block %ld was freed but still used.",
-                 m->id );
+        psError(__func__, "Memory Corruption: memory block %ld was freed but still used.", m->id);
         return 1;
     }
 
-    if ( m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC ) {
-        psError( funcName, "Memory Corruption: memory block %ld is corrupted (buffer underflow)",
-                 m->id );
+    if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) {
+        psError(funcName, "Memory Corruption: memory block %ld is corrupted (buffer underflow)", m->id);
         return 1;
     }
-    if ( *( void** ) ( ( int8_t* ) ( m + 1 ) + m->userMemorySize ) != P_PS_MEMMAGIC ) {
-        psError( funcName, "Memory Corruption: memory block %ld is corrupted (buffer overflow)",
-                 m->id );
+    if (*(void **)((int8_t *) (m + 1) + m->userMemorySize) != P_PS_MEMMAGIC) {
+        psError(funcName, "Memory Corruption: memory block %ld is corrupted (buffer overflow)", m->id);
         return 1;
     }
@@ -247,21 +250,21 @@
 }
 
-int psMemCheckCorruption( bool abort_on_error )
-{
-    int nbad = 0;                       // number of bad blocks
+int psMemCheckCorruption(bool abort_on_error)
+{
+    int nbad = 0;               // number of bad blocks
 
     // get exclusive access to the memBlock list to avoid it changing on us while we use it.
-    pthread_mutex_lock( &memBlockListMutex );
-
-    for ( psMemBlock * iter = lastMemBlockAllocated; iter != NULL; iter = iter->nextBlock ) {
-        if ( checkMemBlock( iter, __func__ ) ) {
+    pthread_mutex_lock(&memBlockListMutex);
+
+    for (psMemBlock * iter = lastMemBlockAllocated; iter != NULL; iter = iter->nextBlock) {
+        if (checkMemBlock(iter, __func__)) {
             nbad++;
 
-            memProblemCallback( iter, __func__, __LINE__ );
-
-            if ( abort_on_error ) {
+            memProblemCallback(iter, __func__, __LINE__);
+
+            if (abort_on_error) {
                 // release the lock on the memblock list
-                pthread_mutex_unlock( &memBlockListMutex );
-                psAbort( __func__, "Detected memory corruption" );
+                pthread_mutex_unlock(&memBlockListMutex);
+                psAbort(__func__, "Detected memory corruption");
                 return nbad;
             }
@@ -270,48 +273,48 @@
 
     // release the lock on the memblock list
-    pthread_mutex_unlock( &memBlockListMutex );
+    pthread_mutex_unlock(&memBlockListMutex);
     return nbad;
 }
 
-void *p_psAlloc( size_t size, const char *file, int lineno )
-{
-
-    psMemBlock * ptr = NULL;
+void *p_psAlloc(size_t size, const char *file, int lineno)
+{
+
+    psMemBlock *ptr = NULL;
 
     // memory is of the size I want to bother recycling?
-    if ( size < P_PS_LARGE_BLOCK_SIZE ) {
+    if (size < P_PS_LARGE_BLOCK_SIZE) {
         // find the bin we need.
         int level = 0;
-        while ( size > recycleBinSize[ level ] ) {
+
+        while (size > recycleBinSize[level]) {
             level++;
         }
         // Are we in one of the bins
-        if ( level < recycleBins ) {
-
-            size = recycleBinSize[ level ];  // round-up size to next sized bin.
-
-            pthread_mutex_lock( &recycleMemBlockListMutex );
-
-            if ( recycleMemBlockList[ level ] != NULL ) {
-                ptr = recycleMemBlockList[ level ];
-                recycleMemBlockList[ level ] = ptr->nextBlock;
-                if ( recycleMemBlockList[ level ] != NULL ) {
-                    recycleMemBlockList[ level ] ->previousBlock = NULL;
+        if (level < recycleBins) {
+
+            size = recycleBinSize[level];  // round-up size to next sized bin.
+
+            pthread_mutex_lock(&recycleMemBlockListMutex);
+
+            if (recycleMemBlockList[level] != NULL) {
+                ptr = recycleMemBlockList[level];
+                recycleMemBlockList[level] = ptr->nextBlock;
+                if (recycleMemBlockList[level] != NULL) {
+                    recycleMemBlockList[level]->previousBlock = NULL;
                 }
                 size = ptr->userMemorySize;
             }
 
-            pthread_mutex_unlock( &recycleMemBlockListMutex );
-        }
-    }
-
-    if ( ptr == NULL ) {
-        ptr = malloc( sizeof( psMemBlock ) + size + sizeof( void* ) );
-
-        if ( ptr == NULL ) {
-            ptr = memExhaustedCallback( size );
-            if ( ptr == NULL ) {
-                psAbort( __func__, "Failed to allocate %u bytes at %s:%d",
-                         size, file, lineno );
+            pthread_mutex_unlock(&recycleMemBlockListMutex);
+        }
+    }
+
+    if (ptr == NULL) {
+        ptr = malloc(sizeof(psMemBlock) + size + sizeof(void *));
+
+        if (ptr == NULL) {
+            ptr = memExhaustedCallback(size);
+            if (ptr == NULL) {
+                psAbort(__func__, "Failed to allocate %u bytes at %s:%d", size, file, lineno);
             }
         }
@@ -320,95 +323,91 @@
         ptr->endblock = P_PS_MEMMAGIC;
         ptr->userMemorySize = size;
-        pthread_mutex_init( &ptr->refCounterMutex, NULL );
-    }
-
+        pthread_mutex_init(&ptr->refCounterMutex, NULL);
+    }
     // increment the memory id safely.
-    pthread_mutex_lock( &memBlockListMutex );
-    *( psMemoryId* ) & ptr->id = ++memid;
-    pthread_mutex_unlock( &memBlockListMutex );
+    pthread_mutex_lock(&memBlockListMutex);
+    *(psMemoryId *) & ptr->id = ++memid;
+    pthread_mutex_unlock(&memBlockListMutex);
 
     ptr->file = file;
     ptr->freeFcn = NULL;
-    *( unsigned int* ) & ptr->lineno = lineno;
-    *( void** ) ( ( int8_t* ) ( ptr + 1 ) + size ) = P_PS_MEMMAGIC;
+    *(unsigned int *)&ptr->lineno = lineno;
+    *(void **)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC;
     ptr->previousBlock = NULL;
 
-    ptr->refCounter = 1;                // one user so far
+    ptr->refCounter = 1;                   // one user so far
 
     // need exclusive access of the memory block list now...
-    pthread_mutex_lock( &memBlockListMutex );
+    pthread_mutex_lock(&memBlockListMutex);
 
     // insert the new block to the front of the memBlock linked-list
     ptr->nextBlock = lastMemBlockAllocated;
-    if ( ptr->nextBlock != NULL ) {
+    if (ptr->nextBlock != NULL) {
         ptr->nextBlock->previousBlock = ptr;
     }
     lastMemBlockAllocated = ptr;
 
-    pthread_mutex_unlock( &memBlockListMutex );
-
-    //  Did the user ask to be informed about this allocation?
-    if ( ptr->id == p_psMemAllocateID ) {
-        p_psMemAllocateID += memAllocateCallback( ptr );
-    }
-
+    pthread_mutex_unlock(&memBlockListMutex);
+
+    // Did the user ask to be informed about this allocation?
+    if (ptr->id == p_psMemAllocateID) {
+        p_psMemAllocateID += memAllocateCallback(ptr);
+    }
     // And return the user the memory that they allocated
-    return ptr + 1;   // user memory
-}
-
-void *p_psRealloc( void *vptr, size_t size, const char *file, int lineno )
-{
-    if ( vptr == NULL ) {
-        return p_psAlloc( size, file, lineno );
+    return ptr + 1;                        // user memory
+}
+
+void *p_psRealloc(void *vptr, size_t size, const char *file, int lineno)
+{
+    if (vptr == NULL) {
+        return p_psAlloc(size, file, lineno);
     } else {
-        psMemBlock *ptr = ( ( psMemBlock * ) vptr ) - 1;
+        psMemBlock *ptr = ((psMemBlock *) vptr) - 1;
         bool isBlockLast = false;
 
-        if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-            memProblemCallback( ptr, file, lineno );
-            psAbort( file, "Realloc detected a memory corruption (id %ld @ %s:%d).",
-                     ptr->id, ptr->file, ptr->lineno );
-        }
-
-        pthread_mutex_lock( &memBlockListMutex );
-
-        isBlockLast = ( ptr == lastMemBlockAllocated );
-
-        ptr = ( psMemBlock* ) realloc( ptr, sizeof( psMemBlock ) + size + sizeof( void* ) );
-
-        if ( ptr == NULL ) {
-            psAbort( __func__, "Failed to reallocate %ld bytes at %s:%d",
-                     size, file, lineno );
+        if (checkMemBlock(ptr, __func__) != 0) {
+            memProblemCallback(ptr, file, lineno);
+            psAbort(file, "Realloc detected a memory corruption (id %ld @ %s:%d).",
+                    ptr->id, ptr->file, ptr->lineno);
+        }
+
+        pthread_mutex_lock(&memBlockListMutex);
+
+        isBlockLast = (ptr == lastMemBlockAllocated);
+
+        ptr = (psMemBlock *) realloc(ptr, sizeof(psMemBlock) + size + sizeof(void *));
+
+        if (ptr == NULL) {
+            psAbort(__func__, "Failed to reallocate %ld bytes at %s:%d", size, file, lineno);
         }
 
         ptr->userMemorySize = size;
-        *( void** ) ( ( int8_t* ) ( ptr + 1 ) + size ) = P_PS_MEMMAGIC;
-
-        if ( isBlockLast ) {
+        *(void **)((int8_t *) (ptr + 1) + size) = P_PS_MEMMAGIC;
+
+        if (isBlockLast) {
             lastMemBlockAllocated = ptr;
         }
-
         // the block location may have changed, so fix the linked list addresses.
-        if ( ptr->nextBlock != NULL ) {
+        if (ptr->nextBlock != NULL) {
             ptr->nextBlock->previousBlock = ptr;
         }
-        if ( ptr->previousBlock != NULL ) {
+        if (ptr->previousBlock != NULL) {
             ptr->previousBlock->nextBlock = ptr;
         }
 
-        pthread_mutex_unlock( &memBlockListMutex );
-
-        //  Did the user ask to be informed about this allocation?
-        if ( ptr->id == p_psMemAllocateID ) {
-            p_psMemAllocateID += memAllocateCallback( ptr );
-        }
-
-        return ptr + 1;   // usr memory
-    }
-}
-
-void p_psFree( void *vptr, const char *file, int lineno )
-{
-    ( void ) p_psMemDecrRefCounter( vptr, file, lineno );   // this handles the free, if required.
+        pthread_mutex_unlock(&memBlockListMutex);
+
+        // Did the user ask to be informed about this allocation?
+        if (ptr->id == p_psMemAllocateID) {
+            p_psMemAllocateID += memAllocateCallback(ptr);
+        }
+
+        return ptr + 1;                    // usr memory
+    }
+}
+
+void p_psFree(void *vptr, const char *file, int lineno)
+{
+    (void)p_psMemDecrRefCounter(vptr, file, lineno);    // this handles the free, if required.
 }
 
@@ -416,39 +415,39 @@
  * Check for memory leaks.
  */
-int psMemCheckLeaks( psMemoryId id0, psMemBlock ***arr, FILE *fd )
+int psMemCheckLeaks(psMemoryId id0, psMemBlock *** arr, FILE * fd)
 {
     int nleak = 0;
     int j = 0;
-    psMemBlock* topBlock = lastMemBlockAllocated;
-
-    pthread_mutex_lock( &memBlockListMutex );
-
-    for ( psMemBlock * iter = topBlock; iter != NULL; iter = iter->nextBlock ) {
-        if ( ( psMemGetRefCounter( iter + 1 ) > 0 ) && ( iter->id >= id0 ) ) {
+    psMemBlock *topBlock = lastMemBlockAllocated;
+
+    pthread_mutex_lock(&memBlockListMutex);
+
+    for (psMemBlock * iter = topBlock; iter != NULL; iter = iter->nextBlock) {
+        if ((psMemGetRefCounter(iter + 1) > 0) && (iter->id >= id0)) {
             nleak++;
 
-            if ( fd != NULL ) {
-                if ( nleak == 1 ) {
-                    fprintf( fd, "   %20s:line ID\n", "file" );
+            if (fd != NULL) {
+                if (nleak == 1) {
+                    fprintf(fd, "   %20s:line ID\n", "file");
                 }
 
-                fprintf( fd, "   %20s:%-4d %ld\n", iter->file, iter->lineno, iter->id );
-            }
-        }
-    }
-
-    pthread_mutex_unlock( &memBlockListMutex );
-
-    if ( nleak == 0 || arr == NULL ) {
+                fprintf(fd, "   %20s:%-4d %ld\n", iter->file, iter->lineno, iter->id);
+            }
+        }
+    }
+
+    pthread_mutex_unlock(&memBlockListMutex);
+
+    if (nleak == 0 || arr == NULL) {
         return nleak;
     }
 
-    *arr = p_psAlloc( nleak * sizeof( psMemBlock ), __FILE__, __LINE__ );
-    pthread_mutex_lock( &memBlockListMutex );
-
-    for ( psMemBlock * iter = topBlock; iter != NULL; iter = iter->nextBlock ) {
-        if ( ( psMemGetRefCounter( iter + 1 ) > 0 ) && ( iter->id >= id0 ) ) {
-            ( *arr ) [ j++ ] = iter;
-            if ( j == nleak ) { // found them all
+    *arr = p_psAlloc(nleak * sizeof(psMemBlock), __FILE__, __LINE__);
+    pthread_mutex_lock(&memBlockListMutex);
+
+    for (psMemBlock * iter = topBlock; iter != NULL; iter = iter->nextBlock) {
+        if ((psMemGetRefCounter(iter + 1) > 0) && (iter->id >= id0)) {
+            (*arr)[j++] = iter;
+            if (j == nleak) {              // found them all
                 break;
             }
@@ -456,5 +455,5 @@
     }
 
-    pthread_mutex_unlock( &memBlockListMutex );
+    pthread_mutex_unlock(&memBlockListMutex);
 
     return nleak;
@@ -465,43 +464,44 @@
  */
 // return refCounter
-psReferenceCount psMemGetRefCounter( void *vptr )
-{
-    psMemBlock * ptr;
+psReferenceCount psMemGetRefCounter(void *vptr)
+{
+    psMemBlock *ptr;
     unsigned int refCount;
 
-    if ( vptr == NULL ) {
+    if (vptr == NULL) {
         return 0;
     }
 
-    ptr = ( ( psMemBlock * ) vptr ) - 1;
-
-    if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-        memProblemCallback( ptr, __func__, __LINE__ );
-    }
-
-    pthread_mutex_lock( &ptr->refCounterMutex );
+    ptr = ((psMemBlock *) vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__) != 0) {
+        memProblemCallback(ptr, __func__, __LINE__);
+    }
+
+    pthread_mutex_lock(&ptr->refCounterMutex);
     refCount = ptr->refCounter;
-    pthread_mutex_unlock( &ptr->refCounterMutex );
+    pthread_mutex_unlock(&ptr->refCounterMutex);
 
     return refCount;
 }
+
 // increment and return refCounter
-void* p_psMemIncrRefCounter( void *vptr, const char *file, int lineno )
-{
-    psMemBlock * ptr;
-
-    if ( vptr == NULL ) {
+void *p_psMemIncrRefCounter(void *vptr, const char *file, int lineno)
+{
+    psMemBlock *ptr;
+
+    if (vptr == NULL) {
         return vptr;
     }
 
-    ptr = ( ( psMemBlock * ) vptr ) - 1;
-
-    if ( checkMemBlock( ptr, __func__ ) ) {
-        memProblemCallback( ptr, file, lineno );
-    }
-
-    pthread_mutex_lock( &ptr->refCounterMutex );
+    ptr = ((psMemBlock *) vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__)) {
+        memProblemCallback(ptr, file, lineno);
+    }
+
+    pthread_mutex_lock(&ptr->refCounterMutex);
     ptr->refCounter++;
-    pthread_mutex_unlock( &ptr->refCounterMutex );
+    pthread_mutex_unlock(&ptr->refCounterMutex);
 
     return vptr;
@@ -509,57 +509,57 @@
 
 // decrement and return refCounter
-void* p_psMemDecrRefCounter( void *vptr, const char *file, int lineno )
-{
-    if ( vptr == NULL ) {
+void *p_psMemDecrRefCounter(void *vptr, const char *file, int lineno)
+{
+    if (vptr == NULL) {
         return NULL;
     }
 
-    psMemBlock *ptr = ( ( psMemBlock * ) vptr ) - 1;
-
-    if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-        memProblemCallback( ptr, file, lineno );
+    psMemBlock *ptr = ((psMemBlock *) vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__) != 0) {
+        memProblemCallback(ptr, file, lineno);
         return NULL;
     }
 
-    pthread_mutex_lock( &ptr->refCounterMutex );
-
-    if ( ptr->refCounter > 1 ) {
-        /// XXX - Probably should have another mutex here.
-        ptr->refCounter--;          // multiple references, just decrement the count.
-        pthread_mutex_unlock( &ptr->refCounterMutex );
+    pthread_mutex_lock(&ptr->refCounterMutex);
+
+    if (ptr->refCounter > 1) {
+        // / XXX - Probably should have another mutex here.
+        ptr->refCounter--;                 // multiple references, just decrement the count.
+        pthread_mutex_unlock(&ptr->refCounterMutex);
 
     } else {
-        pthread_mutex_unlock( &ptr->refCounterMutex );
+        pthread_mutex_unlock(&ptr->refCounterMutex);
 
         // Did the user ask to be informed about this deallocation?
-        if ( ptr->id == p_psMemFreeID ) {
-            p_psMemFreeID += memFreeCallback( ptr );
-        }
-
-        if ( ptr->freeFcn != NULL ) {
-            ptr->freeFcn( vptr );
-        }
-
-        pthread_mutex_lock( &memBlockListMutex );
+        if (ptr->id == p_psMemFreeID) {
+            p_psMemFreeID += memFreeCallback(ptr);
+        }
+
+        if (ptr->freeFcn != NULL) {
+            ptr->freeFcn(vptr);
+        }
+
+        pthread_mutex_lock(&memBlockListMutex);
 
         // cut the memBlock out of the memBlock list
-        if ( ptr->nextBlock != NULL ) {
+        if (ptr->nextBlock != NULL) {
             ptr->nextBlock->previousBlock = ptr->previousBlock;
         }
-        if ( ptr->previousBlock != NULL ) {
+        if (ptr->previousBlock != NULL) {
             ptr->previousBlock->nextBlock = ptr->nextBlock;
         }
-        if ( lastMemBlockAllocated == ptr ) {
+        if (lastMemBlockAllocated == ptr) {
             lastMemBlockAllocated = ptr->nextBlock;
         }
 
-        pthread_mutex_unlock( &memBlockListMutex );
-
+        pthread_mutex_unlock(&memBlockListMutex);
 
         // do we need to recycle?
-        if ( ptr->userMemorySize < P_PS_LARGE_BLOCK_SIZE ) {
+        if (ptr->userMemorySize < P_PS_LARGE_BLOCK_SIZE) {
 
             int level = 1;
-            while ( ptr->userMemorySize >= recycleBinSize[ level ] ) {
+
+            while (ptr->userMemorySize >= recycleBinSize[level]) {
                 level++;
             }
@@ -569,19 +569,19 @@
             ptr->previousBlock = NULL;
 
-            pthread_mutex_lock( &recycleMemBlockListMutex );
-            ptr->nextBlock = recycleMemBlockList[ level ];
-            if ( recycleMemBlockList[ level ] != NULL ) {
-                recycleMemBlockList[ level ] ->previousBlock = ptr;
-            }
-            recycleMemBlockList[ level ] = ptr;
-            pthread_mutex_unlock( &recycleMemBlockListMutex );
+            pthread_mutex_lock(&recycleMemBlockListMutex);
+            ptr->nextBlock = recycleMemBlockList[level];
+            if (recycleMemBlockList[level] != NULL) {
+                recycleMemBlockList[level]->previousBlock = ptr;
+            }
+            recycleMemBlockList[level] = ptr;
+            pthread_mutex_unlock(&recycleMemBlockListMutex);
 
         } else {
             // memory is larger than I want to recycle.
             #ifdef PS_MEM_DEBUG
-            ( void ) p_psRealloc( vptr, 0, file, lineno );
+            (void)p_psRealloc(vptr, 0, file, lineno);
             ptr->previousBlock = NULL;
             ptr->nextBlock = deadBlockList;
-            if ( deadBlockList != NULL ) {
+            if (deadBlockList != NULL) {
                 deadBlockList->previous = ptr;
             }
@@ -589,11 +589,11 @@
             #else
 
-            pthread_mutex_destroy( &ptr->refCounterMutex );
-            free( ptr );
+            pthread_mutex_destroy(&ptr->refCounterMutex);
+            free(ptr);
             #endif
 
         }
 
-        vptr = NULL;    // since we freed it, make sure we return NULL.
+        vptr = NULL;                       // since we freed it, make sure we return NULL.
     }
 
@@ -601,14 +601,14 @@
 }
 
-void p_psMemSetDeallocator( void* vptr, psFreeFcn freeFcn )
-{
-    if ( vptr == NULL ) {
-        return ;
-    }
-
-    psMemBlock *ptr = ( ( psMemBlock * ) vptr ) - 1;
-
-    if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-        memProblemCallback( ptr, __func__, __LINE__ );
+void p_psMemSetDeallocator(void *vptr, psFreeFcn freeFcn)
+{
+    if (vptr == NULL) {
+        return;
+    }
+
+    psMemBlock *ptr = ((psMemBlock *) vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__) != 0) {
+        memProblemCallback(ptr, __func__, __LINE__);
     }
 
@@ -616,14 +616,14 @@
 
 }
-psFreeFcn p_psMemGetDeallocator( void* vptr )
-{
-    if ( vptr == NULL ) {
+psFreeFcn p_psMemGetDeallocator(void *vptr)
+{
+    if (vptr == NULL) {
         return NULL;
     }
 
-    psMemBlock *ptr = ( ( psMemBlock * ) vptr ) - 1;
-
-    if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-        memProblemCallback( ptr, __func__, __LINE__ );
+    psMemBlock *ptr = ((psMemBlock *) vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__) != 0) {
+        memProblemCallback(ptr, __func__, __LINE__);
     }