Changeset 472

Timestamp:

Apr 19, 2004, 5:08:35 PM (22 years ago)

Author:

desonia

Message:

* empty log message *

Location:

trunk/psLib/src

Files:

• sys/psMemory.c (modified) (13 diffs)
• sysUtils/psMemory.c (modified) (13 diffs)

trunk/psLib/src/sys/psMemory.c

@@ -8 +8 @@
  *  @author Robert Lupton, Princeton University
  *
- *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-04-20 03:08:16 $
+ *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-04-20 03:08:35 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -39 +39 @@
 static void *memExhaustedCallbackDefault(size_t size)
 {
-    return NULL;
+  return NULL;
 }
 
@@ -46 +46 @@
 psMemExhaustedCallback psMemExhaustedSetCallback(psMemExhaustedCallback func)
 {
-    psMemExhaustedCallback old = memExhaustedCallback;
-
-    if (func != NULL)
-    {
-        memExhaustedCallback = func;
-    }
-    else
-    {
-        memExhaustedCallback = memExhaustedCallbackDefault;
-    }
-
-    return old;
+  psMemExhaustedCallback old = memExhaustedCallback;
+
+  if (func != NULL)
+    {
+      memExhaustedCallback = func;
+    }
+  else
+    {
+      memExhaustedCallback = memExhaustedCallbackDefault;
+    }
+
+  return old;
 }
 
@@ -63 +63 @@
                                       const char *file, int lineno)
 {
-    checkMemBlock(ptr, __func__);
-
-    if (ptr->refCounter <= 0)
-    {
-        psError(__func__,
-                "Block %ld allocated at %s:%d freed more than once at %s:%d\n",
-                ptr->id, ptr->file, ptr->lineno, file, lineno);
-    }
-    else if (ptr->refCounter > 1)
-    {
-        psError(__func__,
-                "Block %ld allocated at %s:%d freed while still referenced 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);
+  checkMemBlock(ptr, __func__);
+
+  if (ptr->refCounter <= 0)
+    {
+      psError(__func__,
+              "Block %ld allocated at %s:%d freed more than once at %s:%d\n",
+              ptr->id, ptr->file, ptr->lineno, file, lineno);
+    }
+  else if (ptr->refCounter > 1)
+    {
+      psError(__func__,
+              "Block %ld allocated at %s:%d freed while still referenced 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);
     }
 }
@@ -87 +87 @@
 psMemProblemCallback psMemProblemSetCallback(psMemProblemCallback func)
 {
-    psMemProblemCallback old = memProblemCallback;
-
-    if (func != NULL)
-    {
-        memProblemCallback = func;
-    }
-    else
-    {
-        memProblemCallback = memProblemCallbackDefault;
-    }
-
-    return old;
+  psMemProblemCallback old = memProblemCallback;
+
+  if (func != NULL)
+    {
+      memProblemCallback = func;
+    }
+  else
+    {
+      memProblemCallback = memProblemCallbackDefault;
+    }
+
+  return old;
 }
 /*
@@ -110 +110 @@
 long psMemSetAllocateID(long id) // set p_psMemAllocateID to id
 {
-    long old = p_psMemAllocateID;
-    p_psMemAllocateID = id;
-
-    return old;
+  long old = p_psMemAllocateID;
+  p_psMemAllocateID = id;
+
+  return old;
 }
 
 long psMemSetFreeID(long id)  // set p_psMemFreeID to id
 {
-    long old = p_psMemFreeID;
-    p_psMemFreeID = id;
-
-    return old;
+  long old = p_psMemFreeID;
+  p_psMemFreeID = id;
+
+  return old;
 }
 
@@ -132 +132 @@
 static long memAllocateCallbackDefault(const psMemBlock *ptr)
 {
-    static int incr = 0;  // "p_psMemAllocateID += incr"
-
-    return incr;
+  static int incr = 0;  // "p_psMemAllocateID += incr"
+
+  return incr;
 }
 
 static long memFreeCallbackDefault(const psMemBlock *ptr)
 {
-    static int incr = 0;  // "p_psMemFreeID += incr"
-
-    return incr;
+  static int incr = 0;  // "p_psMemFreeID += incr"
+
+  return incr;
 }
 
@@ -152 +152 @@
 psMemAllocateCallback psMemAllocateSetCallback(psMemAllocateCallback func)
 {
-    psMemFreeCallback old = memAllocateCallback;
-
-    if (func != NULL)
-    {
-        memAllocateCallback =  func;
-    }
-    else
-    {
-        memAllocateCallback = memAllocateCallbackDefault;
-    }
-
-    return old;
+  psMemFreeCallback old = memAllocateCallback;
+
+  if (func != NULL)
+    {
+      memAllocateCallback =  func;
+    }
+  else
+    {
+      memAllocateCallback = memAllocateCallbackDefault;
+    }
+
+  return old;
 }
 
 psMemFreeCallback psMemFreeSetCallback(psMemFreeCallback func)
 {
-    psMemFreeCallback old = memFreeCallback;
-
-    if (func != NULL)
-    {
-        memFreeCallback = func;
-    }
-    else
-    {
-        memFreeCallback = memFreeCallbackDefault;
-    }
-
-    return old;
+  psMemFreeCallback old = memFreeCallback;
+
+  if (func != NULL)
+    {
+      memFreeCallback = func;
+    }
+  else
+    {
+      memFreeCallback = memFreeCallbackDefault;
+    }
+
+  return old;
 }
 
@@ -187 +187 @@
 int psMemGetId(void)
 {
-    return memid + 1;
+  return memid + 1;
 }
 
@@ -201 +201 @@
               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.");
-        return(1);
-    }
-
-    if (!ALIGNED(m))
-    {
-        psError(funcName, "psMemCheckCorruption: non-aligned memory block");
-        return(1);
-    }
-
-    if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC)
-    {
-        psError(funcName, "psMemCheckCorruption: memory block %ld is corrupted", m->id);
-        return(1);
-    }
-
-    return(0);
+  // 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.");
+      return(1);
+    }
+
+  if (!ALIGNED(m))
+    {
+      psError(funcName, "psMemCheckCorruption: non-aligned memory block");
+      return(1);
+    }
+
+  if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC)
+    {
+      psError(funcName, "psMemCheckCorruption: memory block %ld is corrupted", m->id);
+      return(1);
+    }
+
+  return(0);
 }
 
 int psMemCheckCorruption(int 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__))
-        {
-            nbad++;
-
-            memProblemCallback(iter, __func__, __LINE__);
-
-            if (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__))
+        {
+          nbad++;
+
+          memProblemCallback(iter, __func__, __LINE__);
+
+          if (abort_on_error)
             {
-                // release the lock on the memblock list
-                pthread_mutex_unlock(&memBlockListMutex);
-                psAbort(__func__, "Detected memory corruption");
-                return nbad;
-            }
-        }
-    }
-
-    // release the lock on the memblock list
-    pthread_mutex_unlock(&memBlockListMutex);
-    return nbad;
+              // release the lock on the memblock list
+              pthread_mutex_unlock(&memBlockListMutex);
+              psAbort(__func__, "Detected memory corruption");
+              return nbad;
+            }
+        }
+    }
+
+  // release the lock on the memblock list
+  pthread_mutex_unlock(&memBlockListMutex);
+  return nbad;
 }
 
 void *p_psAlloc(size_t size, const char *file, int lineno)
 {
-    psMemBlock *ptr = malloc(sizeof(psMemBlock) + size);
-
-    if (ptr == NULL)
-    {
-        ptr = memExhaustedCallback(size);
-        if (ptr == NULL)
-        {
-            psAbort(__func__, "Failed to allocate %ld bytes at %s:%d",
-                    size, file, lineno);
-        }
-    }
-
-    *(unsigned long*)&ptr->id = ++memid;
-    ptr->file = file;
-    *(unsigned int*)&ptr->lineno = lineno;
-    ptr->startblock = P_PS_MEMMAGIC;
-    ptr->endblock = P_PS_MEMMAGIC;
-    ptr->refCounter = 1;                // one user so far
-
-    // need exclusive access of the memory block list now...
-    pthread_mutex_lock(&memBlockListMutex);
-
-    // insert the new block to the front of the memBlock linked-list
-    ptr->previousBlock = NULL;
-    ptr->nextBlock = lastMemBlockAllocated;
-    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);
-    }
-
-    // And return the user the memory that they allocated
-    return ptr + 1;   // user memory
+  psMemBlock *ptr = malloc(sizeof(psMemBlock) + size);
+
+  if (ptr == NULL)
+    {
+      ptr = memExhaustedCallback(size);
+      if (ptr == NULL)
+        {
+          psAbort(__func__, "Failed to allocate %ld bytes at %s:%d",
+                  size, file, lineno);
+        }
+    }
+
+  *(unsigned long*)&ptr->id = ++memid;
+  ptr->file = file;
+  *(unsigned int*)&ptr->lineno = lineno;
+  ptr->startblock = P_PS_MEMMAGIC;
+  ptr->endblock = P_PS_MEMMAGIC;
+  ptr->refCounter = 1;                // one user so far
+
+  // need exclusive access of the memory block list now...
+  pthread_mutex_lock(&memBlockListMutex);
+
+  // insert the new block to the front of the memBlock linked-list
+  ptr->previousBlock = NULL;
+  ptr->nextBlock = lastMemBlockAllocated;
+  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);
+    }
+
+  // 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);
-    }
-    else
-    {
-        psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-        pthread_mutex_lock(&memBlockListMutex);
-
-        ptr = (psMemBlock*)realloc(ptr, sizeof(psMemBlock) + size);
-
-        // the block location may have changed, so fix the linked list addresses.
-        if (ptr->nextBlock != NULL)
-        {
-            ptr->nextBlock->previousBlock = ptr;
-        }
-        if (ptr->previousBlock != NULL)
-        {
-            ptr->previousBlock->nextBlock = ptr;
-        }
-
-        pthread_mutex_unlock(&memBlockListMutex);
-
-        return ptr + 1;   // usr memory
+  if (vptr == NULL)
+    {
+      return p_psAlloc(size, file, lineno);
+    }
+  else
+    {
+      psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+      pthread_mutex_lock(&memBlockListMutex);
+
+      ptr = (psMemBlock*)realloc(ptr, sizeof(psMemBlock) + size);
+
+      // the block location may have changed, so fix the linked list addresses.
+      if (ptr->nextBlock != NULL)
+        {
+          ptr->nextBlock->previousBlock = ptr;
+        }
+      if (ptr->previousBlock != NULL)
+        {
+          ptr->previousBlock->nextBlock = ptr;
+        }
+
+      pthread_mutex_unlock(&memBlockListMutex);
+
+      return ptr + 1;   // usr memory
     }
 }
@@ -332 +332 @@
 void p_psFree(void *vptr, const char *file, int lineno)
 {
-    if (vptr == NULL)
-    {
-        return;
-    }
-
-    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-    // Did the user ask to be informed about this deallocation?
-    if (ptr->id == p_psMemFreeID)
-    {
-        p_psMemFreeID += memFreeCallback(ptr);
-    }
-
-    if (checkMemBlock(ptr, "psFree") != 0)
-    {
-        memProblemCallback(ptr, file, lineno); // we may not own this block; don't free it
-    }
-    else
-    {
-        if (ptr->refCounter > 1)
-        {
-            psError(__func__,"The buffer being freed is referenced elsewhere. "
-                    "Buffer's reference count was decremented instead.");
-            ptr->refCounter--;
-            memProblemCallback(ptr, file, lineno);
-        }
-        else
-        {
-
-            // cut the memBlock out of the memBlock list
-            pthread_mutex_lock(&memBlockListMutex);
-            if (ptr->nextBlock != NULL)
+  if (vptr == NULL)
+    {
+      return;
+    }
+
+  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+  // Did the user ask to be informed about this deallocation?
+  if (ptr->id == p_psMemFreeID)
+    {
+      p_psMemFreeID += memFreeCallback(ptr);
+    }
+
+  if (checkMemBlock(ptr, "psFree") != 0)
+    {
+      memProblemCallback(ptr, file, lineno); // we may not own this block; don't free it
+    }
+  else
+    {
+      if (ptr->refCounter > 1)
+        {
+          psError(__func__,"The buffer being freed is referenced elsewhere. "
+                  "Buffer's reference count was decremented instead.");
+          ptr->refCounter--;
+          memProblemCallback(ptr, file, lineno);
+        }
+      else
+        {
+
+          // cut the memBlock out of the memBlock list
+          pthread_mutex_lock(&memBlockListMutex);
+          if (ptr->nextBlock != NULL)
             {
-                ptr->nextBlock->previousBlock = ptr->previousBlock;
-            }
-            if (ptr->previousBlock != NULL)
+              ptr->nextBlock->previousBlock = ptr->previousBlock;
+            }
+          if (ptr->previousBlock != NULL)
             {
-                ptr->previousBlock->nextBlock = ptr->nextBlock;
-            }
-            if (lastMemBlockAllocated == ptr)
+              ptr->previousBlock->nextBlock = ptr->nextBlock;
+            }
+          if (lastMemBlockAllocated == ptr)
             {
-                lastMemBlockAllocated = ptr->nextBlock;
-            }
-
-            pthread_mutex_unlock(&memBlockListMutex);
-
-            free(ptr);
+              lastMemBlockAllocated = ptr->nextBlock;
+            }
+
+          pthread_mutex_unlock(&memBlockListMutex);
+
+          free(ptr);
         }
     }
@@ -387 +387 @@
  */
 int psMemCheckLeaks(
-    int id0,                            // don't list blocks with id < id0
-    psMemBlock ***arr,                  // pointer to array of pointers to leaked blocks, or NULL
-    FILE *fd)                           // print list of leaks to fd (or NULL)
-{
-    int nleak = 0;
-    int j = 0;
-
-    pthread_mutex_lock(&memBlockListMutex);
-
-    for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
-    {
-        if ( (iter->refCounter > 0) && (iter->id >= id0) )
-        {
-            nleak++;
-
-            if (fd != NULL)
+  int id0,                            // don't list blocks with id < id0
+  psMemBlock ***arr,                  // pointer to array of pointers to leaked blocks, or NULL
+  FILE *fd)                           // print list of leaks to fd (or NULL)
+{
+  int nleak = 0;
+  int j = 0;
+
+  pthread_mutex_lock(&memBlockListMutex);
+
+  for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
+    {
+      if ( (iter->refCounter > 0) && (iter->id >= id0) )
+        {
+          nleak++;
+
+          if (fd != NULL)
             {
-                if (nleak == 1)
+              if (nleak == 1)
                 {
-                    fprintf(fd, "   %20s:line ID\n", "file");
+                  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)
-    {
-        return nleak;
-    }
-
-    p_psFree(*arr,__FILE__, __LINE__);  // Don't generate a memory leak!
-
-    *arr = p_psAlloc(nleak*sizeof(psMemBlock), __FILE__, __LINE__);
-
-    pthread_mutex_lock(&memBlockListMutex);
-
-    for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
-    {
-        if ( (iter->refCounter > 0) && (iter->id >= id0) )
-        {
-            (*arr)[j++] = iter;
-            if (j == nleak)
+              fprintf(fd, "   %20s:%-4d %ld\n", iter->file, iter->lineno, iter->id);
+            }
+        }
+    }
+
+  pthread_mutex_unlock(&memBlockListMutex);
+
+  if (nleak == 0 || arr == NULL)
+    {
+      return nleak;
+    }
+
+  p_psFree(*arr,__FILE__, __LINE__);  // Don't generate a memory leak!
+
+  *arr = p_psAlloc(nleak*sizeof(psMemBlock), __FILE__, __LINE__);
+
+  pthread_mutex_lock(&memBlockListMutex);
+
+  for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
+    {
+      if ( (iter->refCounter > 0) && (iter->id >= id0) )
+        {
+          (*arr)[j++] = iter;
+          if (j == nleak)
             { // found them all
-                break;
-            }
-        }
-    }
-
-    pthread_mutex_unlock(&memBlockListMutex);
-
-    return nleak;
+              break;
+            }
+        }
+    }
+
+  pthread_mutex_unlock(&memBlockListMutex);
+
+  return nleak;
 }
 
@@ -449 +449 @@
 int psMemGetRefCounter(void *vptr) // return refCounter
 {
-    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__) != 0)
-    {
-        memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-    return ptr->refCounter;
+  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+  if (checkMemBlock(ptr, __func__) != 0)
+    {
+      memProblemCallback(ptr, __func__, __LINE__);
+    }
+
+  return ptr->refCounter;
 }
 
 void *psMemIncrRefCounter(void *vptr) // increment and return refCounter
 {
-    if (vptr == NULL)
-    {
-        return vptr;
-    }
-
-    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__))
-    {
-        memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-    ptr->refCounter++;
-
-    return vptr;
+  if (vptr == NULL)
+    {
+      return vptr;
+    }
+
+  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+  if (checkMemBlock(ptr, __func__))
+    {
+      memProblemCallback(ptr, __func__, __LINE__);
+    }
+
+  ptr->refCounter++;
+
+  return vptr;
 }
 
 void *psMemDecrRefCounter(void *vptr) // decrement and return refCounter
 {
-    if (vptr == NULL)
-    {
-        return vptr;
-    }
-
-    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-    if (checkMemBlock(ptr, __func__))
-    {
-        memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-    ptr->refCounter--;
-
-    return vptr;
-}
+  if (vptr == NULL)
+    {
+      return vptr;
+    }
+
+  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+  if (checkMemBlock(ptr, __func__))
+    {
+      memProblemCallback(ptr, __func__, __LINE__);
+    }
+
+  ptr->refCounter--;
+
+  return vptr;
+}

trunk/psLib/src/sysUtils/psMemory.c

@@ -8 +8 @@
  *  @author Robert Lupton, Princeton University
  *
- *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-04-20 03:07:53 $
+ *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-04-20 03:08:16 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -39 +39 @@
 static void *memExhaustedCallbackDefault(size_t size)
 {
-  return NULL;
+    return NULL;
 }
 
@@ -46 +46 @@
 psMemExhaustedCallback psMemExhaustedSetCallback(psMemExhaustedCallback func)
 {
-  psMemExhaustedCallback old = memExhaustedCallback;
-
-  if (func != NULL)
-    {
-      memExhaustedCallback = func;
-    }
-  else
-    {
-      memExhaustedCallback = memExhaustedCallbackDefault;
-    }
-
-  return old;
+    psMemExhaustedCallback old = memExhaustedCallback;
+
+    if (func != NULL)
+    {
+        memExhaustedCallback = func;
+    }
+    else
+    {
+        memExhaustedCallback = memExhaustedCallbackDefault;
+    }
+
+    return old;
 }
 
@@ -63 +63 @@
                                       const char *file, int lineno)
 {
-  checkMemBlock(ptr, __func__);
-
-  if (ptr->refCounter <= 0)
-    {
-      psError(__func__,
-              "Block %ld allocated at %s:%d freed more than once at %s:%d\n",
-              ptr->id, ptr->file, ptr->lineno, file, lineno);
-    }
-  else if (ptr->refCounter > 1)
-    {
-      psError(__func__,
-              "Block %ld allocated at %s:%d freed while still referenced 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);
+    checkMemBlock(ptr, __func__);
+
+    if (ptr->refCounter <= 0)
+    {
+        psError(__func__,
+                "Block %ld allocated at %s:%d freed more than once at %s:%d\n",
+                ptr->id, ptr->file, ptr->lineno, file, lineno);
+    }
+    else if (ptr->refCounter > 1)
+    {
+        psError(__func__,
+                "Block %ld allocated at %s:%d freed while still referenced 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);
     }
 }
@@ -87 +87 @@
 psMemProblemCallback psMemProblemSetCallback(psMemProblemCallback func)
 {
-  psMemProblemCallback old = memProblemCallback;
-
-  if (func != NULL)
-    {
-      memProblemCallback = func;
-    }
-  else
-    {
-      memProblemCallback = memProblemCallbackDefault;
-    }
-
-  return old;
+    psMemProblemCallback old = memProblemCallback;
+
+    if (func != NULL)
+    {
+        memProblemCallback = func;
+    }
+    else
+    {
+        memProblemCallback = memProblemCallbackDefault;
+    }
+
+    return old;
 }
 /*
@@ -110 +110 @@
 long psMemSetAllocateID(long id) // set p_psMemAllocateID to id
 {
-  long old = p_psMemAllocateID;
-  p_psMemAllocateID = id;
-
-  return old;
+    long old = p_psMemAllocateID;
+    p_psMemAllocateID = id;
+
+    return old;
 }
 
 long psMemSetFreeID(long id)  // set p_psMemFreeID to id
 {
-  long old = p_psMemFreeID;
-  p_psMemFreeID = id;
-
-  return old;
+    long old = p_psMemFreeID;
+    p_psMemFreeID = id;
+
+    return old;
 }
 
@@ -132 +132 @@
 static long memAllocateCallbackDefault(const psMemBlock *ptr)
 {
-  static int incr = 0;  // "p_psMemAllocateID += incr"
-
-  return incr;
+    static int incr = 0;  // "p_psMemAllocateID += incr"
+
+    return incr;
 }
 
 static long memFreeCallbackDefault(const psMemBlock *ptr)
 {
-  static int incr = 0;  // "p_psMemFreeID += incr"
-
-  return incr;
+    static int incr = 0;  // "p_psMemFreeID += incr"
+
+    return incr;
 }
 
@@ -152 +152 @@
 psMemAllocateCallback psMemAllocateSetCallback(psMemAllocateCallback func)
 {
-  psMemFreeCallback old = memAllocateCallback;
-
-  if (func != NULL)
-    {
-      memAllocateCallback =  func;
-    }
-  else
-    {
-      memAllocateCallback = memAllocateCallbackDefault;
-    }
-
-  return old;
+    psMemFreeCallback old = memAllocateCallback;
+
+    if (func != NULL)
+    {
+        memAllocateCallback =  func;
+    }
+    else
+    {
+        memAllocateCallback = memAllocateCallbackDefault;
+    }
+
+    return old;
 }
 
 psMemFreeCallback psMemFreeSetCallback(psMemFreeCallback func)
 {
-  psMemFreeCallback old = memFreeCallback;
-
-  if (func != NULL)
-    {
-      memFreeCallback = func;
-    }
-  else
-    {
-      memFreeCallback = memFreeCallbackDefault;
-    }
-
-  return old;
+    psMemFreeCallback old = memFreeCallback;
+
+    if (func != NULL)
+    {
+        memFreeCallback = func;
+    }
+    else
+    {
+        memFreeCallback = memFreeCallbackDefault;
+    }
+
+    return old;
 }
 
@@ -187 +187 @@
 int psMemGetId(void)
 {
-  return memid + 1;
+    return memid + 1;
 }
 
@@ -201 +201 @@
               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.");
-      return(1);
-    }
-
-  if (!ALIGNED(m))
-    {
-      psError(funcName, "psMemCheckCorruption: non-aligned memory block");
-      return(1);
-    }
-
-  if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC)
-    {
-      psError(funcName, "psMemCheckCorruption: memory block %ld is corrupted", m->id);
-      return(1);
-    }
-
-  return(0);
+    // 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.");
+        return(1);
+    }
+
+    if (!ALIGNED(m))
+    {
+        psError(funcName, "psMemCheckCorruption: non-aligned memory block");
+        return(1);
+    }
+
+    if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC)
+    {
+        psError(funcName, "psMemCheckCorruption: memory block %ld is corrupted", m->id);
+        return(1);
+    }
+
+    return(0);
 }
 
 int psMemCheckCorruption(int 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__))
-        {
-          nbad++;
-
-          memProblemCallback(iter, __func__, __LINE__);
-
-          if (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__))
+        {
+            nbad++;
+
+            memProblemCallback(iter, __func__, __LINE__);
+
+            if (abort_on_error)
             {
-              // release the lock on the memblock list
-              pthread_mutex_unlock(&memBlockListMutex);
-              psAbort(__func__, "Detected memory corruption");
-              return nbad;
-            }
-        }
-    }
-
-  // release the lock on the memblock list
-  pthread_mutex_unlock(&memBlockListMutex);
-  return nbad;
+                // release the lock on the memblock list
+                pthread_mutex_unlock(&memBlockListMutex);
+                psAbort(__func__, "Detected memory corruption");
+                return nbad;
+            }
+        }
+    }
+
+    // release the lock on the memblock list
+    pthread_mutex_unlock(&memBlockListMutex);
+    return nbad;
 }
 
 void *p_psAlloc(size_t size, const char *file, int lineno)
 {
-  psMemBlock *ptr = malloc(sizeof(psMemBlock) + size);
-
-  if (ptr == NULL)
-    {
-      ptr = memExhaustedCallback(size);
-      if (ptr == NULL)
-        {
-          psAbort(__func__, "Failed to allocate %ld bytes at %s:%d",
-                  size, file, lineno);
-        }
-    }
-
-  *(unsigned long*)&ptr->id = ++memid;
-  ptr->file = file;
-  *(unsigned int*)&ptr->lineno = lineno;
-  ptr->startblock = P_PS_MEMMAGIC;
-  ptr->endblock = P_PS_MEMMAGIC;
-  ptr->refCounter = 1;                // one user so far
-
-  // need exclusive access of the memory block list now...
-  pthread_mutex_lock(&memBlockListMutex);
-
-  // insert the new block to the front of the memBlock linked-list
-  ptr->previousBlock = NULL;
-  ptr->nextBlock = lastMemBlockAllocated;
-  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);
-    }
-
-  // And return the user the memory that they allocated
-  return ptr + 1;   // user memory
+    psMemBlock *ptr = malloc(sizeof(psMemBlock) + size);
+
+    if (ptr == NULL)
+    {
+        ptr = memExhaustedCallback(size);
+        if (ptr == NULL)
+        {
+            psAbort(__func__, "Failed to allocate %ld bytes at %s:%d",
+                    size, file, lineno);
+        }
+    }
+
+    *(unsigned long*)&ptr->id = ++memid;
+    ptr->file = file;
+    *(unsigned int*)&ptr->lineno = lineno;
+    ptr->startblock = P_PS_MEMMAGIC;
+    ptr->endblock = P_PS_MEMMAGIC;
+    ptr->refCounter = 1;                // one user so far
+
+    // need exclusive access of the memory block list now...
+    pthread_mutex_lock(&memBlockListMutex);
+
+    // insert the new block to the front of the memBlock linked-list
+    ptr->previousBlock = NULL;
+    ptr->nextBlock = lastMemBlockAllocated;
+    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);
+    }
+
+    // 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);
-    }
-  else
-    {
-      psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-      pthread_mutex_lock(&memBlockListMutex);
-
-      ptr = (psMemBlock*)realloc(ptr, sizeof(psMemBlock) + size);
-
-      // the block location may have changed, so fix the linked list addresses.
-      if (ptr->nextBlock != NULL)
-        {
-          ptr->nextBlock->previousBlock = ptr;
-        }
-      if (ptr->previousBlock != NULL)
-        {
-          ptr->previousBlock->nextBlock = ptr;
-        }
-
-      pthread_mutex_unlock(&memBlockListMutex);
-
-      return ptr + 1;   // usr memory
+    if (vptr == NULL)
+    {
+        return p_psAlloc(size, file, lineno);
+    }
+    else
+    {
+        psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+        pthread_mutex_lock(&memBlockListMutex);
+
+        ptr = (psMemBlock*)realloc(ptr, sizeof(psMemBlock) + size);
+
+        // the block location may have changed, so fix the linked list addresses.
+        if (ptr->nextBlock != NULL)
+        {
+            ptr->nextBlock->previousBlock = ptr;
+        }
+        if (ptr->previousBlock != NULL)
+        {
+            ptr->previousBlock->nextBlock = ptr;
+        }
+
+        pthread_mutex_unlock(&memBlockListMutex);
+
+        return ptr + 1;   // usr memory
     }
 }
@@ -332 +332 @@
 void p_psFree(void *vptr, const char *file, int lineno)
 {
-  if (vptr == NULL)
-    {
-      return;
-    }
-
-  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-  // Did the user ask to be informed about this deallocation?
-  if (ptr->id == p_psMemFreeID)
-    {
-      p_psMemFreeID += memFreeCallback(ptr);
-    }
-
-  if (checkMemBlock(ptr, "psFree") != 0)
-    {
-      memProblemCallback(ptr, file, lineno); // we may not own this block; don't free it
-    }
-  else
-    {
-      if (ptr->refCounter > 1)
-        {
-          psError(__func__,"The buffer being freed is referenced elsewhere. "
-                  "Buffer's reference count was decremented instead.");
-          ptr->refCounter--;
-          memProblemCallback(ptr, file, lineno);
-        }
-      else
-        {
-
-          // cut the memBlock out of the memBlock list
-          pthread_mutex_lock(&memBlockListMutex);
-          if (ptr->nextBlock != NULL)
+    if (vptr == NULL)
+    {
+        return;
+    }
+
+    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+    // Did the user ask to be informed about this deallocation?
+    if (ptr->id == p_psMemFreeID)
+    {
+        p_psMemFreeID += memFreeCallback(ptr);
+    }
+
+    if (checkMemBlock(ptr, "psFree") != 0)
+    {
+        memProblemCallback(ptr, file, lineno); // we may not own this block; don't free it
+    }
+    else
+    {
+        if (ptr->refCounter > 1)
+        {
+            psError(__func__,"The buffer being freed is referenced elsewhere. "
+                    "Buffer's reference count was decremented instead.");
+            ptr->refCounter--;
+            memProblemCallback(ptr, file, lineno);
+        }
+        else
+        {
+
+            // cut the memBlock out of the memBlock list
+            pthread_mutex_lock(&memBlockListMutex);
+            if (ptr->nextBlock != NULL)
             {
-              ptr->nextBlock->previousBlock = ptr->previousBlock;
-            }
-          if (ptr->previousBlock != NULL)
+                ptr->nextBlock->previousBlock = ptr->previousBlock;
+            }
+            if (ptr->previousBlock != NULL)
             {
-              ptr->previousBlock->nextBlock = ptr->nextBlock;
-            }
-          if (lastMemBlockAllocated == ptr)
+                ptr->previousBlock->nextBlock = ptr->nextBlock;
+            }
+            if (lastMemBlockAllocated == ptr)
             {
-              lastMemBlockAllocated = ptr->nextBlock;
-            }
-
-          pthread_mutex_unlock(&memBlockListMutex);
-
-          free(ptr);
+                lastMemBlockAllocated = ptr->nextBlock;
+            }
+
+            pthread_mutex_unlock(&memBlockListMutex);
+
+            free(ptr);
         }
     }
@@ -387 +387 @@
  */
 int psMemCheckLeaks(
-  int id0,                            // don't list blocks with id < id0
-  psMemBlock ***arr,                  // pointer to array of pointers to leaked blocks, or NULL
-  FILE *fd)                           // print list of leaks to fd (or NULL)
-{
-  int nleak = 0;
-  int j = 0;
-
-  pthread_mutex_lock(&memBlockListMutex);
-
-  for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
-    {
-      if ( (iter->refCounter > 0) && (iter->id >= id0) )
-        {
-          nleak++;
-
-          if (fd != NULL)
+    int id0,                            // don't list blocks with id < id0
+    psMemBlock ***arr,                  // pointer to array of pointers to leaked blocks, or NULL
+    FILE *fd)                           // print list of leaks to fd (or NULL)
+{
+    int nleak = 0;
+    int j = 0;
+
+    pthread_mutex_lock(&memBlockListMutex);
+
+    for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
+    {
+        if ( (iter->refCounter > 0) && (iter->id >= id0) )
+        {
+            nleak++;
+
+            if (fd != NULL)
             {
-              if (nleak == 1)
+                if (nleak == 1)
                 {
-                  fprintf(fd, "   %20s:line ID\n", "file");
+                    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)
-    {
-      return nleak;
-    }
-
-  p_psFree(*arr,__FILE__, __LINE__);  // Don't generate a memory leak!
-
-  *arr = p_psAlloc(nleak*sizeof(psMemBlock), __FILE__, __LINE__);
-
-  pthread_mutex_lock(&memBlockListMutex);
-
-  for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
-    {
-      if ( (iter->refCounter > 0) && (iter->id >= id0) )
-        {
-          (*arr)[j++] = iter;
-          if (j == nleak)
+                fprintf(fd, "   %20s:%-4d %ld\n", iter->file, iter->lineno, iter->id);
+            }
+        }
+    }
+
+    pthread_mutex_unlock(&memBlockListMutex);
+
+    if (nleak == 0 || arr == NULL)
+    {
+        return nleak;
+    }
+
+    p_psFree(*arr,__FILE__, __LINE__);  // Don't generate a memory leak!
+
+    *arr = p_psAlloc(nleak*sizeof(psMemBlock), __FILE__, __LINE__);
+
+    pthread_mutex_lock(&memBlockListMutex);
+
+    for (psMemBlock* iter = lastMemBlockAllocated; iter != NULL; iter=iter->nextBlock)
+    {
+        if ( (iter->refCounter > 0) && (iter->id >= id0) )
+        {
+            (*arr)[j++] = iter;
+            if (j == nleak)
             { // found them all
-              break;
-            }
-        }
-    }
-
-  pthread_mutex_unlock(&memBlockListMutex);
-
-  return nleak;
+                break;
+            }
+        }
+    }
+
+    pthread_mutex_unlock(&memBlockListMutex);
+
+    return nleak;
 }
 
@@ -449 +449 @@
 int psMemGetRefCounter(void *vptr) // return refCounter
 {
-  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-  if (checkMemBlock(ptr, __func__) != 0)
-    {
-      memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-  return ptr->refCounter;
+    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__) != 0)
+    {
+        memProblemCallback(ptr, __func__, __LINE__);
+    }
+
+    return ptr->refCounter;
 }
 
 void *psMemIncrRefCounter(void *vptr) // increment and return refCounter
 {
-  if (vptr == NULL)
-    {
-      return vptr;
-    }
-
-  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-  if (checkMemBlock(ptr, __func__))
-    {
-      memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-  ptr->refCounter++;
-
-  return vptr;
+    if (vptr == NULL)
+    {
+        return vptr;
+    }
+
+    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__))
+    {
+        memProblemCallback(ptr, __func__, __LINE__);
+    }
+
+    ptr->refCounter++;
+
+    return vptr;
 }
 
 void *psMemDecrRefCounter(void *vptr) // decrement and return refCounter
 {
-  if (vptr == NULL)
-    {
-      return vptr;
-    }
-
-  psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
-
-  if (checkMemBlock(ptr, __func__))
-    {
-      memProblemCallback(ptr, __func__, __LINE__);
-    }
-
-  ptr->refCounter--;
-
-  return vptr;
-}
+    if (vptr == NULL)
+    {
+        return vptr;
+    }
+
+    psMemBlock *ptr = ((psMemBlock *)vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__))
+    {
+        memProblemCallback(ptr, __func__, __LINE__);
+    }
+
+    ptr->refCounter--;
+
+    return vptr;
+}