Changeset 1385 for trunk/psLib/src/sysUtils

Timestamp:

Aug 4, 2004, 1:37:39 PM (22 years ago)

Author:

desonia

Message:

found the server astyle upgrade was faulty, so the format was reset.

Location:

trunk/psLib/src/sysUtils

Files:

• psAbort.c (modified) (1 diff)
• psError.c (modified) (1 diff)
• psHash.c (modified) (13 diffs)
• psHash.h (modified) (1 diff)
• psLogMsg.c (modified) (3 diffs)
• psLogMsg.h (modified) (1 diff)
• psMemory.c (modified) (24 diffs)
• psMemory.h (modified) (1 diff)
• psString.c (modified) (1 diff)
• psTrace.c (modified) (1 diff)
• psType.h (modified) (2 diffs)

trunk/psLib/src/sysUtils/psAbort.c

@@ -9 +9 @@
  *  @author Eric Van Alst, MHPCC
  *   
- *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-30 01:17:20 $
+ *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/sysUtils/psError.c

@@ -10 +10 @@
  *  @author Eric Van Alst, MHPCC
  *   
- *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-30 01:17:20 $
+ *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/sysUtils/psHash.c

@@ -10 +10 @@
 *  @author George Gusciora, MHPCC
 *
-*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-04 01:21:33 $
+*  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-04 23:37:39 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 static void hashBucketFree( psHashBucket *bucket );
 static void *doHashWork( psHash* table, const char* key, void* data, bool remove
-                       )
-;
+                           )
+    ;
 static void hashFree( psHash *table );
 
@@ -45 +45 @@
     psList *myLinkList = NULL;  // The output data structure
     psHashBucket *ptr = NULL;           // Used to step thru linked list.
-    
+
     if ( table == NULL ) {
-            return NULL;
-        }
-        
+        return NULL;
+    }
+
     // Create the linked list
     myLinkList = psListAlloc( NULL );
-    
+
     // Loop through every bucket in the hash table.  If that bucket is not
     // NULL, then add the bucket's key to the linked list.
     for ( i = 0;i < table->nbucket;i++ ) {
-            if ( table->buckets[ i ] != NULL ) {
-                    // Since a bucket contains a linked list of keys/data, we must
-                    // step trough each key in that linked list:
-                    
-                    ptr = table->buckets[ i ];
-                    while ( ptr != NULL ) {
-                            psListAdd( myLinkList, ptr->key, PS_LIST_HEAD );
-                            ptr = ptr->next;
-                        }
-                }
+        if ( table->buckets[ i ] != NULL ) {
+            // Since a bucket contains a linked list of keys/data, we must
+            // step trough each key in that linked list:
+
+            ptr = table->buckets[ i ];
+            while ( ptr != NULL ) {
+                psListAdd( myLinkList, ptr->key, PS_LIST_HEAD );
+                ptr = ptr->next;
+            }
         }
-        
+    }
+
     // Return the linked list
     return ( myLinkList );
@@ -89 +89 @@
 {
     if ( key == NULL ) {
-            psAbort( __func__, "psHashBucket() called with NULL key." );
-        }
-        
+        psAbort( __func__, "psHashBucket() called with NULL key." );
+    }
+
     // Allocate memory for the new hash bucket.
     psHashBucket *bucket = psAlloc( sizeof( psHashBucket ) );
     p_psMemSetDeallocator( bucket, ( psFreeFcn ) hashBucketFree );
-    
+
     // Initialize the bucket.
     bucket->key = psStringCopy( key );
-    
+
     if ( data == NULL ) {
-            // NOTE: Should we flag a warning message?
-            bucket->data = NULL;
-        } else {
-            bucket->data = psMemIncrRefCounter( data );
-        }
-        
+        // NOTE: Should we flag a warning message?
+        bucket->data = NULL;
+    } else {
+        bucket->data = psMemIncrRefCounter( data );
+    }
+
     bucket->next = next;
-    
+
     return bucket;
 }
@@ -123 +123 @@
 {
     if ( bucket == NULL ) {
-            return ;
-        }
-        
+        return ;
+    }
+
     // A bucket is actually a linked list of buckets.  We recursively step
     // through that linked list, free each bucket.
     psFree( bucket->next );
-    
+
     psFree( bucket->key );
-    
+
     psFree( bucket->data );
 }
@@ -150 +150 @@
     psHash *table = psAlloc( sizeof( psHash ) );
     p_psMemSetDeallocator( table, ( psFreeFcn ) hashFree );
-    
+
     // Allocate memory for the buckets.
     table->buckets = psAlloc( nbucket * sizeof( psHashBucket * ) );
     table->nbucket = nbucket;
-    
+
     psTrace( "utils.hash", 1, "Creating %d-element hash table\n", nbucket );
-    
+
     // Initialize all buckets to NULL.
     for ( i = 0; i < nbucket; i++ )
-        {
-            table->buckets[ i ] = NULL;
-        }
-        
+    {
+        table->buckets[ i ] = NULL;
+    }
+
     // Return the new hash table.
     return table;
@@ -182 +182 @@
 {
     int i = 0;                          // Loop index variable.
-    
+
     if ( table == NULL ) {
-            return ;
-        }
-        
+        return ;
+    }
+
     // Loop through each bucket in the hash table.  If that bucket is not
     // NULL, then free the bucket via a function call to hashBucketFree();
     for ( i = 0; i < table->nbucket; i++ ) {
-    
-            // A bucket is composed of a linked list of buckets.
-            if ( table->buckets[ i ] != NULL ) {
-                    psFree( table->buckets[ i ] );
-                }
+
+        // A bucket is composed of a linked list of buckets.
+        if ( table->buckets[ i ] != NULL ) {
+            psFree( table->buckets[ i ] );
         }
-        
+    }
+
     // Free the bucket structure, then the hash table.
     psFree( table->buckets );
@@ -221 +221 @@
   *****************************************************************************/
 static void *doHashWork( psHash *table, const char *key, void *data, bool remove
-                       )
+                           )
 {
     long int hash = 1;                  // This will contain an integer value
@@ -229 +229 @@
     psHashBucket *optr = NULL;          // "original pointer": used to step
     // thru the linked list for a bucket.
-    
+
     // The following condition should never be true, since this is a private
     // function, but I'm checking it anyway since future coders might change
     // the way this procedure is called.
     if ( ( table == NULL ) || ( key == NULL ) ) {
-    
-            psAbort( __func__, "psHashRemove() called with NULL key or table." );
-        }
-        
+
+        psAbort( __func__, "psHashRemove() called with NULL key or table." );
+    }
+
     // NOTE: This is the originally supplied hash function.
     //    for (int i = 0, len = strlen(key); i < len; i++) {
@@ -243 +243 @@
     //    }
     //    hash &= (table->nbucket - 1);
-    
+
     // This hash algorithm is from Sedgewick.  NOTE: must reread to ensure that
     // the size of the hash table is not required to be a prime number.
     tmpchar = ( char * ) key;
     for ( hash = 0; *tmpchar != '\0'; tmpchar++ ) {
-            hash = ( 64 * hash + *tmpchar ) % ( table->nbucket );
-        }
-        
+        hash = ( 64 * hash + *tmpchar ) % ( table->nbucket );
+    }
+
     // NOTE: This should not be necessary, but for now, I'm checking bounds
     // anyway.
     if ( ( hash < 0 ) || ( hash >= table->nbucket ) ) {
-            psAbort( __func__, "Internal hash function out of range (%d)", hash );
-        }
-        
+        psAbort( __func__, "Internal hash function out of range (%d)", hash );
+    }
+
     // ptr will have the correct hash bucket.
     ptr = table->buckets[ hash ];
-    
+
     // We know the correct hash bucket, now we need to know what to do.
     // If the data parameter is NULL, then, by definition, this is a retrieve
     // or a remove operation on the hash table.
-    
+
     if ( data == NULL ) {
-            if ( remove
+        if ( remove
                ) {
-                    // We search through the linked list for this bucket in
-                    // the hash table and look for an entry for this key.
-                    
+                // We search through the linked list for this bucket in
+                // the hash table and look for an entry for this key.
+
+                optr = ptr;
+                while ( ptr != NULL ) {
+                    // Dtermine if this entry holds the correct key.
+                    if ( strcmp( key, ptr->key ) == 0 ) {
+                        // The following lines of code are fairly standard ways
+                        // of removing an item from a single-linked list.
+
+                        void * data = ptr->data;
+                        optr->next = ptr->next;
+                        if ( ptr == table->buckets[ hash ] ) {
+                            table->buckets[ hash ] = ptr->next;
+                        }
+
+                        psFree( ptr );
+
+                        // By definition, the data associated with that key
+                        // must be returned, not freed.
+                        return data;
+                    }
                     optr = ptr;
-                    while ( ptr != NULL ) {
-                            // Dtermine if this entry holds the correct key.
-                            if ( strcmp( key, ptr->key ) == 0 ) {
-                                    // The following lines of code are fairly standard ways
-                                    // of removing an item from a single-linked list.
-                                    
-                                    void * data = ptr->data;
-                                    optr->next = ptr->next;
-                                    if ( ptr == table->buckets[ hash ] ) {
-                                            table->buckets[ hash ] = ptr->next;
-                                        }
-                                        
-                                    psFree( ptr );
-                                    
-                                    // By definition, the data associated with that key
-                                    // must be returned, not freed.
-                                    return data;
-                                }
-                            optr = ptr;
-                            ptr = ptr->next;
-                        }
-                    return NULL;   // not in hash
-                }
-            else {
-                    // If we get here, then a retrieve operation is requested.  So,
-                    // we step trough the linked list at this bucket, and return the
-                    // data once we find it, or return NULL if we don't.
-                    while ( ptr != NULL ) {
-                            if ( strcmp( key, ptr->key ) == 0 ) {
-                                    return ptr->data;
-                                }
-                            ptr = ptr->next;
-                        }
-                    return NULL;   // not in hash
-                }
-        } else {
-            // We get here if this procedure was called with non-NULL data.
-            // Therefore, we should insert that data into the hash table.
-            // First, we search through the linked list for this bucket in
-            // the hash table and look for a duplicate entry for this key.
-            
-            while ( ptr != NULL ) {
-                    if ( strcmp( key, ptr->key ) == 0 ) {
-                            // We have found this key in the hash table.
-                            
-                            psTrace( "utils.hash.insert", 3, "Replacing data for %s\n",
-                                     key );
-                                     
-                            // NOTE: I have changed this behavior from the originally
-                            // supplied code.  Formerly, if itemFree was NULL, then
-                            // the new data was not inserted into the hash table.
-                            
-                            psFree( ptr->data );
-                            
-                            ptr->data = psMemIncrRefCounter( data );
-                            return data;
-                        }
                     ptr = ptr->next;
                 }
-            // We did not found key in the linked list for this bucket of the hash
-            // table.  So, we insert this data at the head of that linked list.
-            
-            table->buckets[ hash ] = hashBucketAlloc( key,
-                                     data,
-                                     table->buckets[ hash ] );
-            return data;
+                return NULL;   // not in hash
+            }
+        else {
+            // If we get here, then a retrieve operation is requested.  So,
+            // we step trough the linked list at this bucket, and return the
+            // data once we find it, or return NULL if we don't.
+            while ( ptr != NULL ) {
+                if ( strcmp( key, ptr->key ) == 0 ) {
+                    return ptr->data;
+                }
+                ptr = ptr->next;
+            }
+            return NULL;   // not in hash
         }
+    } else {
+        // We get here if this procedure was called with non-NULL data.
+        // Therefore, we should insert that data into the hash table.
+        // First, we search through the linked list for this bucket in
+        // the hash table and look for a duplicate entry for this key.
+
+        while ( ptr != NULL ) {
+            if ( strcmp( key, ptr->key ) == 0 ) {
+                // We have found this key in the hash table.
+
+                psTrace( "utils.hash.insert", 3, "Replacing data for %s\n",
+                         key );
+
+                // NOTE: I have changed this behavior from the originally
+                // supplied code.  Formerly, if itemFree was NULL, then
+                // the new data was not inserted into the hash table.
+
+                psFree( ptr->data );
+
+                ptr->data = psMemIncrRefCounter( data );
+                return data;
+            }
+            ptr = ptr->next;
+        }
+        // We did not found key in the linked list for this bucket of the hash
+        // table.  So, we insert this data at the head of that linked list.
+
+        table->buckets[ hash ] = hashBucketAlloc( key,
+                                 data,
+                                 table->buckets[ hash ] );
+        return data;
+    }
 }
 
@@ -354 +354 @@
 {
     if ( table == NULL ) {
-            psAbort( __func__, "psHashInsert() called with NULL hash table." );
-        }
+        psAbort( __func__, "psHashInsert() called with NULL hash table." );
+    }
     if ( key == NULL ) {
-            psAbort( __func__, "psHashInsert() called with NULL key." );
-        }
+        psAbort( __func__, "psHashInsert() called with NULL key." );
+    }
     if ( data == NULL ) {
-            psAbort( __func__, "psHashLookup() called with NULL data." );
-        }
-        
+        psAbort( __func__, "psHashLookup() called with NULL data." );
+    }
+
     return ( doHashWork( table, key, data, 0 ) != NULL );
 }
@@ -381 +381 @@
 {
     if ( table == NULL ) {
-            psAbort( __func__, "psHashLookup() called with NULL hash table." );
-        }
+        psAbort( __func__, "psHashLookup() called with NULL hash table." );
+    }
     if ( key == NULL ) {
-            psAbort( __func__, "psHashLookup() called with NULL key." );
-        }
-        
-        
+        psAbort( __func__, "psHashLookup() called with NULL key." );
+    }
+
+
     return doHashWork( table, key, NULL, 0 );
 }
@@ -405 +405 @@
     void * data = NULL;
     bool retVal = false;
-    
+
     if ( table == NULL ) {
-            psAbort( __func__, "psHashRemove() called with NULL hash table." );
-        }
+        psAbort( __func__, "psHashRemove() called with NULL hash table." );
+    }
     if ( key == NULL ) {
-            psAbort( __func__, "psHashRemove() called with NULL key." );
-        }
-        
+        psAbort( __func__, "psHashRemove() called with NULL key." );
+    }
+
     data = doHashWork( table, key, NULL, 1 );
     if ( data != NULL ) {
-            psFree( data );
-            retVal = true;
-        } else {
-            retVal = false;
-        }
+        psFree( data );
+        retVal = true;
+    } else {
+        retVal = false;
+    }
     return retVal;
 }

trunk/psLib/src/sysUtils/psHash.h

@@ -10 +10 @@
  *  @author George Gusciora, MHPCC
  *   
- *  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-27 23:09:23 $
+ *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/sysUtils/psLogMsg.c

@@ -11 +11 @@
  *  @author George Gusciora, MHPCC
  *
- *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-30 20:22:37 $
+ *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -132 +132 @@
         psError(__func__,"The location, %s, for protocol 'dest' is invalid.",location);
         return 1;
-    } else if (strcmp(protocol,"file") == 0) {
-        FILE* file = fopen(location,"w");
-        if (file == NULL) {
-            psError(__func__,"Could not open file '%s' for output.",location);
-            return 1;
-        }
-        if (logDest != NULL && logDest != stderr && logDest != stdout) {
-            fclose(logDest);
-        }
-        logDest = file;
-        return 0;
-    }
+    } else
+        if (strcmp(protocol,"file") == 0) {
+            FILE* file = fopen(location,"w");
+            if (file == NULL) {
+                psError(__func__,"Could not open file '%s' for output.",location);
+                return 1;
+            }
+            if (logDest != NULL && logDest != stderr && logDest != stdout) {
+                fclose(logDest);
+            }
+            logDest = file;
+            return 0;
+        }
 
     psError(__func__,"Do not know how to handle the protocol '%s'.",protocol);
@@ -336 +337 @@
     if (head_ptr > head) {
         *head_ptr++ = '|';
-    } else if (!logMsg) { // no output desired
-        return;
-    }
+    } else
+        if (!logMsg) { // no output desired
+            return;
+        }
     *head_ptr = '\0';
 

trunk/psLib/src/sysUtils/psLogMsg.h

@@ -11 +11 @@
  *  @author George Gusciora, MHPCC
  *
- *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-30 20:22:37 $
+ *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/sysUtils/psMemory.c

@@ -8 +8 @@
 *  @author Robert Lupton, Princeton University
 *
-*  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-07-31 02:28:10 $
+*  @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-04 23:37:39 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -47 +47 @@
         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.
@@ -62 +62 @@
 {
     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 );
-                }
-            level--;
-        }
+        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 );
-    
+
     return ptr;
 }
@@ -84 +84 @@
 {
     psMemExhaustedCallback old = memExhaustedCallback;
-    
+
     if ( func != NULL ) {
-            memExhaustedCallback = func;
-        } else {
-            memExhaustedCallback = memExhaustedCallbackDefault;
-        }
-        
+        memExhaustedCallback = func;
+    } else {
+        memExhaustedCallback = memExhaustedCallbackDefault;
+    }
+
     return old;
 }
@@ -98 +98 @@
 {
     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 );
-        }
-        
+        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 );
-        }
+        psAbort( __func__, "Detected a problem in the memory system at %s:%d", file, lineno );
+    }
 }
 static psMemProblemCallback memProblemCallback = memProblemCallbackDefault;
@@ -112 +112 @@
 {
     psMemProblemCallback old = memProblemCallback;
-    
+
     if ( func != NULL ) {
-            memProblemCallback = func;
-        } else {
-            memProblemCallback = memProblemCallbackDefault;
-        }
-        
+        memProblemCallback = func;
+    } else {
+        memProblemCallback = memProblemCallbackDefault;
+    }
+
     return old;
 }
@@ -133 +133 @@
     psMemoryId old = p_psMemAllocateID;
     p_psMemAllocateID = id;
-    
+
     return old;
 }
@@ -141 +141 @@
     psMemoryId old = p_psMemFreeID;
     p_psMemFreeID = id;
-    
+
     return old;
 }
@@ -154 +154 @@
 {
     static psMemoryId incr = 0;  // "p_psMemAllocateID += incr"
-    
+
     return incr;
 }
@@ -161 +161 @@
 {
     static psMemoryId incr = 0;  // "p_psMemFreeID += incr"
-    
+
     return incr;
 }
@@ -174 +174 @@
 {
     psMemFreeCallback old = memAllocateCallback;
-    
+
     if ( func != NULL ) {
-            memAllocateCallback = func;
-        } else {
-            memAllocateCallback = memAllocateCallbackDefault;
-        }
-        
+        memAllocateCallback = func;
+    } else {
+        memAllocateCallback = memAllocateCallbackDefault;
+    }
+
     return old;
 }
@@ -187 +187 @@
 {
     psMemFreeCallback old = memFreeCallback;
-    
+
     if ( func != NULL ) {
-            memFreeCallback = func;
-        } else {
-            memFreeCallback = memFreeCallbackDefault;
-        }
-        
+        memFreeCallback = func;
+    } else {
+        memFreeCallback = memFreeCallbackDefault;
+    }
+
     return old;
 }
@@ -206 +206 @@
     id = memid + 1;
     pthread_mutex_unlock( &memIdMutex );
-    
+
     return id;
 }
@@ -220 +220 @@
     // 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;
-        }
-        
+        psError( funcName, "Memory Corruption: NULL memory block found." );
+        return 1;
+    }
+
     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 );
-            return 1;
-        }
-        
+        // using an unreferenced block of memory, are you?
+        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 );
-            return 1;
-        }
+        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 );
-            return 1;
-        }
-        
+        psError( funcName, "Memory Corruption: memory block %ld is corrupted (buffer overflow)",
+                 m->id );
+        return 1;
+    }
+
     return 0;
 }
@@ -250 +250 @@
 {
     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;
-                        }
-                }
-        }
-        
+        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 );
@@ -278 +278 @@
 
     psMemBlock * ptr = NULL;
-    
+
     // memory is of the size I want to bother recycling?
     if ( size < P_PS_LARGE_BLOCK_SIZE ) {
-            // find the bin we need.
-            int level = 0;
-            while ( size > recycleBinSize[ level ] ) {
-                    level++;
+        // find the bin we need.
+        int level = 0;
+        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;
                 }
-            // 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;
-                                }
-                            size = ptr->userMemorySize;
-                        }
-                        
-                    pthread_mutex_unlock( &recycleMemBlockListMutex );
-                }
-        }
-        
+                size = ptr->userMemorySize;
+            }
+
+            pthread_mutex_unlock( &recycleMemBlockListMutex );
+        }
+    }
+
     if ( ptr == NULL ) {
-            ptr = malloc( sizeof( psMemBlock ) + size + sizeof( void* ) );
-            
+        ptr = malloc( sizeof( psMemBlock ) + size + sizeof( void* ) );
+
+        if ( ptr == NULL ) {
+            ptr = memExhaustedCallback( size );
             if ( ptr == NULL ) {
-                    ptr = memExhaustedCallback( size );
-                    if ( ptr == NULL ) {
-                            psAbort( __func__, "Failed to allocate %u bytes at %s:%d",
-                                     size, file, lineno );
-                        }
-                }
-                
-            ptr->startblock = P_PS_MEMMAGIC;
-            ptr->endblock = P_PS_MEMMAGIC;
-            ptr->userMemorySize = size;
-            pthread_mutex_init( &ptr->refCounterMutex, NULL );
-        }
-        
+                psAbort( __func__, "Failed to allocate %u bytes at %s:%d",
+                         size, file, lineno );
+            }
+        }
+
+        ptr->startblock = P_PS_MEMMAGIC;
+        ptr->endblock = P_PS_MEMMAGIC;
+        ptr->userMemorySize = size;
+        pthread_mutex_init( &ptr->refCounterMutex, NULL );
+    }
+
     // increment the memory id safely.
     pthread_mutex_lock( &memBlockListMutex );
     *( psMemoryId* ) & ptr->id = ++memid;
     pthread_mutex_unlock( &memBlockListMutex );
-    
+
     ptr->file = file;
     ptr->freeFcn = NULL;
@@ -333 +333 @@
     *( void** ) ( ( int8_t* ) ( ptr + 1 ) + size ) = P_PS_MEMMAGIC;
     ptr->previousBlock = NULL;
-    
+
     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->nextBlock = lastMemBlockAllocated;
     if ( ptr->nextBlock != NULL ) {
-            ptr->nextBlock->previousBlock = ptr;
-        }
+        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 );
-        }
-        
+        p_psMemAllocateID += memAllocateCallback( ptr );
+    }
+
     // And return the user the memory that they allocated
     return ptr + 1;   // user memory
@@ -360 +360 @@
 {
     if ( vptr == NULL ) {
-            return p_psAlloc( size, file, lineno );
-        } else {
-            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 );
-                }
-                
-            ptr->userMemorySize = size;
-            *( 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 ) {
-                    ptr->nextBlock->previousBlock = ptr;
-                }
-            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
-        }
+        return p_psAlloc( size, file, lineno );
+    } else {
+        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 );
+        }
+
+        ptr->userMemorySize = size;
+        *( 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 ) {
+            ptr->nextBlock->previousBlock = ptr;
+        }
+        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
+    }
 }
 
@@ -421 +421 @@
     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 ) ) {
-                    nleak++;
-                    
-                    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 );
-                        }
+        if ( ( psMemGetRefCounter( iter + 1 ) > 0 ) && ( iter->id >= id0 ) ) {
+            nleak++;
+
+            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 ) {
-            return nleak;
-        }
-        
+        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
-                            break;
-                        }
-                }
-        }
-        
+        if ( ( psMemGetRefCounter( iter + 1 ) > 0 ) && ( iter->id >= id0 ) ) {
+            ( *arr ) [ j++ ] = iter;
+            if ( j == nleak ) { // found them all
+                break;
+            }
+        }
+    }
+
     pthread_mutex_unlock( &memBlockListMutex );
-    
+
     return nleak;
 }
@@ -463 +463 @@
 /*
  * Reference counting APIs
- */ 
+ */
 // return refCounter
 psReferenceCount psMemGetRefCounter( void *vptr )
@@ -469 +469 @@
     psMemBlock * ptr;
     unsigned int refCount;
-    
+
     if ( vptr == NULL ) {
-            return 0;
-        }
-        
+        return 0;
+    }
+
     ptr = ( ( psMemBlock * ) vptr ) - 1;
-    
+
     if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-            memProblemCallback( ptr, __func__, __LINE__ );
-        }
-        
+        memProblemCallback( ptr, __func__, __LINE__ );
+    }
+
     pthread_mutex_lock( &ptr->refCounterMutex );
     refCount = ptr->refCounter;
     pthread_mutex_unlock( &ptr->refCounterMutex );
-    
+
     return refCount;
 }
@@ -490 +490 @@
 {
     psMemBlock * ptr;
-    
+
     if ( vptr == NULL ) {
-            return vptr;
-        }
-        
+        return vptr;
+    }
+
     ptr = ( ( psMemBlock * ) vptr ) - 1;
-    
+
     if ( checkMemBlock( ptr, __func__ ) ) {
-            memProblemCallback( ptr, file, lineno );
-        }
-        
+        memProblemCallback( ptr, file, lineno );
+    }
+
     pthread_mutex_lock( &ptr->refCounterMutex );
     ptr->refCounter++;
     pthread_mutex_unlock( &ptr->refCounterMutex );
-    
+
     return vptr;
 }
@@ -512 +512 @@
 {
     if ( vptr == NULL ) {
-            return NULL;
-        }
-        
+        return NULL;
+    }
+
     psMemBlock *ptr = ( ( psMemBlock * ) vptr ) - 1;
-    
+
     if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-            memProblemCallback( ptr, file, lineno );
-            return NULL;
-        }
-        
+        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 );
-            
+        /// 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 );
+
+        // 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 );
+
+        // cut the memBlock out of the memBlock list
+        if ( ptr->nextBlock != NULL ) {
+            ptr->nextBlock->previousBlock = ptr->previousBlock;
+        }
+        if ( ptr->previousBlock != NULL ) {
+            ptr->previousBlock->nextBlock = ptr->nextBlock;
+        }
+        if ( lastMemBlockAllocated == ptr ) {
+            lastMemBlockAllocated = ptr->nextBlock;
+        }
+
+        pthread_mutex_unlock( &memBlockListMutex );
+
+
+        // do we need to recycle?
+        if ( ptr->userMemorySize < P_PS_LARGE_BLOCK_SIZE ) {
+
+            int level = 1;
+            while ( ptr->userMemorySize >= recycleBinSize[ level ] ) {
+                level++;
+            }
+            level--;
+
+            ptr->refCounter = 0;
+            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 );
+
         } else {
-            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 );
-            
-            // cut the memBlock out of the memBlock list
-            if ( ptr->nextBlock != NULL ) {
-                    ptr->nextBlock->previousBlock = ptr->previousBlock;
-                }
-            if ( ptr->previousBlock != NULL ) {
-                    ptr->previousBlock->nextBlock = ptr->nextBlock;
-                }
-            if ( lastMemBlockAllocated == ptr ) {
-                    lastMemBlockAllocated = ptr->nextBlock;
-                }
-                
-            pthread_mutex_unlock( &memBlockListMutex );
-            
-            
-            // do we need to recycle?
-            if ( ptr->userMemorySize < P_PS_LARGE_BLOCK_SIZE ) {
-            
-                    int level = 1;
-                    while ( ptr->userMemorySize >= recycleBinSize[ level ] ) {
-                            level++;
-                        }
-                    level--;
-                    
-                    ptr->refCounter = 0;
-                    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 );
-                    
-                } else {
-                    // memory is larger than I want to recycle.
-                    #ifdef PS_MEM_DEBUG
-                    ( void ) p_psRealloc( vptr, 0, file, lineno );
-                    ptr->previousBlock = NULL;
-                    ptr->nextBlock = deadBlockList;
-                    if ( deadBlockList != NULL ) {
-                            deadBlockList->previous = ptr;
-                        }
-                    deadBlockList = ptr;
-                    #else
-                    
-                    pthread_mutex_destroy( &ptr->refCounterMutex );
-                    free( ptr );
-                    #endif
-                    
-                }
-                
-            vptr = NULL;    // since we freed it, make sure we return NULL.
-        }
-        
+            // memory is larger than I want to recycle.
+            #ifdef PS_MEM_DEBUG
+            ( void ) p_psRealloc( vptr, 0, file, lineno );
+            ptr->previousBlock = NULL;
+            ptr->nextBlock = deadBlockList;
+            if ( deadBlockList != NULL ) {
+                deadBlockList->previous = ptr;
+            }
+            deadBlockList = ptr;
+            #else
+
+            pthread_mutex_destroy( &ptr->refCounterMutex );
+            free( ptr );
+            #endif
+
+        }
+
+        vptr = NULL;    // since we freed it, make sure we return NULL.
+    }
+
     return vptr;
 }
@@ -604 +604 @@
 {
     if ( vptr == NULL ) {
-            return ;
-        }
-        
+        return ;
+    }
+
     psMemBlock *ptr = ( ( psMemBlock * ) vptr ) - 1;
-    
+
     if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-            memProblemCallback( ptr, __func__, __LINE__ );
-        }
-        
+        memProblemCallback( ptr, __func__, __LINE__ );
+    }
+
     ptr->freeFcn = freeFcn;
-    
+
 }
 psFreeFcn p_psMemGetDeallocator( void* vptr )
 {
     if ( vptr == NULL ) {
-            return NULL;
-        }
-        
+        return NULL;
+    }
+
     psMemBlock *ptr = ( ( psMemBlock * ) vptr ) - 1;
-    
+
     if ( checkMemBlock( ptr, __func__ ) != 0 ) {
-            memProblemCallback( ptr, __func__, __LINE__ );
-        }
-        
+        memProblemCallback( ptr, __func__, __LINE__ );
+    }
+
     return ptr->freeFcn;
 }

trunk/psLib/src/sysUtils/psMemory.h

@@ -14 +14 @@
  *  @ingroup MemoryManagement
  *
- *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-07-15 23:52:34 $
+ *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/sysUtils/psString.c

@@ -8 +8 @@
  *  @author Eric Van Alst, MHPCC
  *   
- *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-05-10 23:37:36 $
+ *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/sysUtils/psTrace.c

@@ -9 +9 @@
  *  @author George Gusciora, MHPCC
  *
- *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-06-30 01:09:12 $
+ *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-08-04 23:37:39 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii

trunk/psLib/src/sysUtils/psType.h

@@ -10 +10 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-07-31 02:28:10 $
+*  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-04 23:37:39 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -142 +142 @@
  */
 typedef struct
-    {
-        psElemType type;    ///< Primitive type.
-        psDimen dimen;      ///< Dimensionality.
-    }
+{
+    psElemType type;    ///< Primitive type.
+    psDimen dimen;      ///< Dimensionality.
+}
 psType;