Changeset 5216

Timestamp:

Sep 30, 2005, 4:22:26 PM (21 years ago)

Author:

desonia

Message:

changed psArrayGet/psArraySet/psArrayRemove to do proper reference counting.

Location:

trunk/psLib

Files:

• pslib.kdevelop (modified) (3 diffs)
• src/Makefile.am (modified) (1 diff)
• src/db/psDB.c (modified) (6 diffs)
• src/imageops/psImageStructManip.c (modified) (3 diffs)
• src/mathtypes/psImage.c (modified) (2 diffs)
• src/sys/psMemory.c (modified) (3 diffs)
• src/sys/psMemory.h (modified) (2 diffs)
• src/types/psArray.c (modified) (7 diffs)
• src/types/psArray.h (modified) (3 diffs)
• src/types/psList.c (modified) (4 diffs)
• src/types/psMetadataConfig.c (modified) (3 diffs)
• test/FullUnitTest.in (modified) (4 diffs)
• test/astro/tst_psTime_04.c (modified) (2 diffs)
• test/db/tst_psDB.c (modified) (14 diffs)
• test/sys/verified/tst_psMemory.stderr (modified) (10 diffs)
• test/types/tst_psArray.c (modified) (4 diffs)

trunk/psLib/pslib.kdevelop

@@ -14 +14 @@
     <projectdirectory>.</projectdirectory>
     <absoluteprojectpath>false</absoluteprojectpath>
-    <description/>
+    <description></description>
     <secondaryLanguages/>
   </general>
@@ -49 +49 @@
         <envvar value="1" name="WANT_AUTOMAKE_1_6" />
       </envvars>
+      <abortonerror>false</abortonerror>
+      <numberofjobs>3</numberofjobs>
+      <dontact>false</dontact>
+      <makebin></makebin>
+      <prio>0</prio>
     </make>
   </kdevautoproject>
@@ -169 +174 @@
   <kdevdebugger>
     <general>
-      <programargs/>
-      <gdbpath/>
+      <programargs></programargs>
+      <gdbpath></gdbpath>
       <dbgshell>libtool</dbgshell>
-      <configGdbScript/>
-      <runShellScript/>
-      <runGdbScript/>
+      <configGdbScript></configGdbScript>
+      <runShellScript></runShellScript>
+      <runGdbScript></runGdbScript>
       <breakonloadinglibs>true</breakonloadinglibs>
       <separatetty>false</separatetty>

trunk/psLib/src/Makefile.am

@@ -5 +5 @@
 libpslib_la_CPPFLAGS = $(SRCINC)
 libpslib_la_LIBADD = $(SRCSUBLIBS)
+libpslib_la_DEPENDENCIES = $(SRCSUBLIBS)
 
 libpslib_la_SOURCES = psTest.c

trunk/psLib/src/db/psDB.c

@@ -12 +12 @@
  *  @author Joshua Hoblitt
  *
- *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-26 21:13:16 $
+ *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:09 $
  *
  *  Copyright 2005 Joshua Hoblitt, University of Hawaii
@@ -43 +43 @@
 }
 mysqlType;
+
+static psHash   *pTypeToSQLlookupTable = NULL;
+static psHash   *sqlToPTypeLookupTable = NULL;
+static psHash   *mysqlToSqlLookupTable = NULL;
+static psHash   *pTypeToMysqlLookupTable = NULL;
 
 // database utility functions
@@ -1421 +1426 @@
 static psHash *psDBGetPTypeToSQLTable(void)
 {
-    static psHash   *lookupTable = NULL;
-
-    if (!lookupTable) {
-        lookupTable = psHashAlloc(14);
+
+    if (!pTypeToSQLlookupTable) {
+        pTypeToSQLlookupTable = psHashAlloc(14);
 
         // no support for CHAR, TEXT or GLOB
-        psDBAddToLookupTable(lookupTable, PS_TYPE_S8,  "TINYINT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_S16, "SMALLINT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_S32, "INT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_S64, "BIGINT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_U8,  "UNSIGNED TINYINT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_U32, "UNSIGNED INT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_U64, "UNSIGNED BIGINT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_F32, "FLOAT");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_F64, "DOUBLE");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
-        psDBAddToLookupTable(lookupTable, PS_TYPE_BOOL,"TINYINT");
-        psDBAddToLookupTable(lookupTable, PS_DATA_STRING, "VARCHAR");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S8,  "TINYINT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S16, "SMALLINT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S32, "INT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_S64, "BIGINT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U8,  "UNSIGNED TINYINT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U16, "UNSIGNED SMALLINT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U32, "UNSIGNED INT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_U64, "UNSIGNED BIGINT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_F32, "FLOAT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_F64, "DOUBLE");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C32, "PS_TYPE_C32 is not supported");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_C64, "PS_TYPE_C64 is not supported");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_TYPE_BOOL,"TINYINT");
+        psDBAddToLookupTable(pTypeToSQLlookupTable, PS_DATA_STRING, "VARCHAR");
     }
 
     // simulate true ref counting
-    psMemIncrRefCounter(lookupTable);
-
-    return lookupTable;
+    psMemIncrRefCounter(pTypeToSQLlookupTable);
+
+    return pTypeToSQLlookupTable;
 }
 
 static void psDBPTypeToSQLTableCleanup(void)
 {
-    psHash          *lookupTable;
-
-    lookupTable = psDBGetPTypeToSQLTable();
-
-    psMemDecrRefCounter(lookupTable);
-    psFree(lookupTable);
+    psFree(pTypeToSQLlookupTable);
+    pTypeToSQLlookupTable = NULL;
 }
 
 static psHash *psDBGetSQLToPTypeTable(void)
 {
-    static psHash   *lookupTable = NULL;
     psHash          *psToSQLTable;
     psList          *list;
@@ -1468 +1467 @@
     char            *value;
 
-    if (!lookupTable) {
+    if (!sqlToPTypeLookupTable) {
         // invert the PSToSQL table
         psToSQLTable = psDBGetPTypeToSQLTable();
-        lookupTable = psHashAlloc(psToSQLTable->n);
+        sqlToPTypeLookupTable = psHashAlloc(psToSQLTable->n);
 
         list = psHashKeyList(psToSQLTable);
@@ -1479 +1478 @@
             value = psHashLookup(psToSQLTable, key);
             // switch key and value
-            psHashAdd(lookupTable, value, key);
+            psHashAdd(sqlToPTypeLookupTable, value, key);
         }
 
         // Add BLOB & TEXT reverse mappings
         value = psDBIntToString((psU64)PS_DATA_STRING);
-        psHashAdd(lookupTable, "BLOB",    value);
-        psHashAdd(lookupTable, "TEXT",    value);
+        psHashAdd(sqlToPTypeLookupTable, "BLOB",    value);
+        psHashAdd(sqlToPTypeLookupTable, "TEXT",    value);
         psFree(value);
 
         // DECIMAL does not exist in the pType to SQL table
         value = psDBIntToString(0);
-        psHashAdd(lookupTable, "DECIMAL", value);
+        psHashAdd(sqlToPTypeLookupTable, "DECIMAL", value);
         psFree(value);
 
@@ -1499 +1498 @@
 
     // simulate true ref counting
-    psMemIncrRefCounter(lookupTable);
-
-    return lookupTable;
+    psMemIncrRefCounter(sqlToPTypeLookupTable);
+
+    return sqlToPTypeLookupTable;
 }
 
 static void psDBSQLToPTypeTableCleanup(void)
 {
-    psHash          *lookupTable;
-
-    lookupTable = psDBGetSQLToPTypeTable();
-
-    psMemDecrRefCounter(lookupTable);
-    psFree(lookupTable);
+    psFree(sqlToPTypeLookupTable);
+    sqlToPTypeLookupTable = NULL;
 }
 
 static psHash *psDBGetMySQLToSQLTable(void)
 {
-    static psHash   *lookupTable = NULL;
-
-    if (!lookupTable) {
-        lookupTable = psHashAlloc(20);
-
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_TINY,      "TINYINT");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_SHORT,     "SMALLINT");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONG,      "INT");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_INT24,     "MEDIUMINT");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_LONGLONG,  "BIGINT");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DECIMAL,   "DECIMAL");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_FLOAT,     "FLOAT");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DOUBLE,    "DOUBLE");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATE,      "DATE");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_TIME,      "TIME");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_DATETIME,  "DATETIME");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_YEAR,      "YEAR");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_STRING,    "CHAR");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_BLOB,      "BLOB");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_SET,       "SET");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_ENUM,      "ENUM");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_NULL,      "NULL-type");
-        psDBAddToLookupTable(lookupTable, FIELD_TYPE_CHAR,      "TINYINT");
+    if (!mysqlToSqlLookupTable) {
+        mysqlToSqlLookupTable = psHashAlloc(20);
+
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_TINY,      "TINYINT");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_SHORT,     "SMALLINT");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_LONG,      "INT");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_INT24,     "MEDIUMINT");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_LONGLONG,  "BIGINT");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DECIMAL,   "DECIMAL");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_FLOAT,     "FLOAT");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DOUBLE,    "DOUBLE");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_TIMESTAMP, "TIMESTAMP");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DATE,      "DATE");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_TIME,      "TIME");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_DATETIME,  "DATETIME");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_YEAR,      "YEAR");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_STRING,    "CHAR");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_VAR_STRING,"VARCHAR");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_BLOB,      "BLOB");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_SET,       "SET");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_ENUM,      "ENUM");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_NULL,      "NULL-type");
+        psDBAddToLookupTable(mysqlToSqlLookupTable, FIELD_TYPE_CHAR,      "TINYINT");
     }
 
     // simulate true ref counting
-    psMemIncrRefCounter(lookupTable);
-
-    return lookupTable;
+    psMemIncrRefCounter(mysqlToSqlLookupTable);
+
+    return mysqlToSqlLookupTable;
 }
 
 static void psDBMySQLToSQLTableCleanup(void)
 {
-    psHash          *lookupTable;
-
-    lookupTable = psDBGetMySQLToSQLTable();
-
-    psMemDecrRefCounter(lookupTable);
-    psFree(lookupTable);
+    psFree(mysqlToSqlLookupTable);
+    mysqlToSqlLookupTable = NULL;
 }
 
 static psHash *psDBGetPTypeToMySQLTable(void)
 {
-    static psHash   *lookupTable = NULL;
-
-    if (!lookupTable) {
-        lookupTable = psHashAlloc(14);
-
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       false));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      false));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       false));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_S64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   false));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      true));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       true));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_U64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   true));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_F32,    psDBMySQLTypeAlloc(MYSQL_TYPE_FLOAT,      false));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_F64,    psDBMySQLTypeAlloc(MYSQL_TYPE_DOUBLE,     false));
+    if (!pTypeToMysqlLookupTable) {
+        pTypeToMysqlLookupTable = psHashAlloc(14);
+
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_S64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U8,     psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U16,    psDBMySQLTypeAlloc(MYSQL_TYPE_SHORT,      true));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U32,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONG,       true));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_U64,    psDBMySQLTypeAlloc(MYSQL_TYPE_LONGLONG,   true));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_F32,    psDBMySQLTypeAlloc(MYSQL_TYPE_FLOAT,      false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_F64,    psDBMySQLTypeAlloc(MYSQL_TYPE_DOUBLE,     false));
         // bogus type
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_C32,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C32,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
         // bogus type
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_C64,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_TYPE_BOOL,   psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_C64,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_BOOL,   psDBMySQLTypeAlloc(MYSQL_TYPE_TINY,       true));
         // XXX: removed PS_TYPE_PTR, can this be removed too?
-        // psDBAddVoidToLookupTable(lookupTable, PS_TYPE_PTR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-
-        psDBAddVoidToLookupTable(lookupTable, PS_DATA_STRING,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_DATA_VECTOR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_DATA_IMAGE,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_DATA_HASH,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_DATA_LOOKUPTABLE,
+        // psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_TYPE_PTR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_STRING,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_VECTOR,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_IMAGE,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_HASH,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_LOOKUPTABLE,
                                  psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_JPEG,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_PNG,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        //        psDBAddVoidToLookupTable(lookupTable, PS_DATA_ASTROM, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
-        psDBAddVoidToLookupTable(lookupTable, PS_DATA_UNKNOWN,psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        //        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_JPEG,   psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        //        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_PNG,    psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        //        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_ASTROM, psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
+        psDBAddVoidToLookupTable(pTypeToMysqlLookupTable, PS_DATA_UNKNOWN,psDBMySQLTypeAlloc(MYSQL_TYPE_VAR_STRING, false));
     }
 
     // simulate true ref counting
-    psMemIncrRefCounter(lookupTable);
-
-    return lookupTable;
+    psMemIncrRefCounter(pTypeToMysqlLookupTable);
+
+    return pTypeToMysqlLookupTable;
 }
 
 static void psDBPTypeToMySQLTableCleanup(void)
 {
-    psHash          *lookupTable;
-
-    lookupTable = psDBGetPTypeToMySQLTable();
-
-    psMemDecrRefCounter(lookupTable);
-    psFree(lookupTable);
+    psFree(pTypeToMysqlLookupTable);
+    pTypeToMysqlLookupTable = NULL;
 }
 

trunk/psLib/src/imageops/psImageStructManip.c

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-15 21:22:22 $
+ *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:11 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -96 +96 @@
         // if a child, need to orphan (disassociate from parent) first
         if (out->parent != NULL) {
-            psArrayRemove(out->parent->children,out); // remove from parent's knowledge
+            psArrayRemove(out->parent->children,psMemIncrRefCounter(out));
+            // remove from parent's knowledge without triggering a free
             out->parent = NULL; // break link to parent
         }
@@ -127 +128 @@
 
     // add output image as a child of the input image.
-    psS32 n = 0;
-    psArray* children = image->children;
-    if (children == NULL) {
-        children = psArrayAlloc(16); // start with a reasonable size for growth
-    } else if (children->nalloc == children->n) { // full?
-        n = children->n;
-        children = psArrayRealloc(children,n*2); // double the array size
-    } else {
-        n = children->n;
-    }
-    children->data[n] = out;
-    children->n = n+1;
-    image->children = children; // push back any change (esp. if children==NULL before)
+    image->children = psArrayAdd(image->children,16,out);
+    psMemDecrRefCounter(out); // don't count the reference held by parent as a true reference
 
     return (out);

trunk/psLib/src/mathtypes/psImage.c

@@ -9 +9 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.88 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-29 19:05:02 $
+ *  @version $Revision: 1.89 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:12 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -39 +39 @@
 
     if (image->parent != NULL) {
+        psMemBlock* ptr = ((psMemBlock*)image)-1;
+        int ref = ptr->refCounter;
+        ptr->refCounter = 2;  // make sure psFree is not retriggered
         psArrayRemove(image->parent->children,image);
+        ptr->refCounter = ref; // restore previous count (not assuming zero, but should be)
+
         image->parent = NULL;
     }

trunk/psLib/src/sys/psMemory.c

@@ -8 +8 @@
 *  @author Robert Lupton, Princeton University
 *
-*  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-08 00:17:26 $
+*  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-10-01 02:22:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -583 +583 @@
 }
 
+psPtr p_psMemSetRefCounter(
+    psPtr vptr,
+    psReferenceCount count,
+    const char *file,
+    psS32 lineno)
+{
+    psMemBlock* ptr;
+
+    if (vptr == NULL) {
+        return vptr;
+    }
+
+    if (count < 0) {
+        count = 0;
+    }
+
+    ptr = ((psMemBlock* ) vptr) - 1;
+
+    if (checkMemBlock(ptr, __func__)) {
+        memProblemCallback(ptr, file, lineno);
+    }
+
+    pthread_mutex_lock(&ptr->refCounterMutex);
+    ptr->refCounter = count;
+    pthread_mutex_unlock(&ptr->refCounterMutex);
+
+    if (count < 1) {
+        vptr = p_psMemDecrRefCounter(vptr,file,lineno);
+    }
+
+    return vptr;
+}
+
 // decrement and return refCounter
 psPtr p_psMemDecrRefCounter(psPtr vptr,
@@ -707 +740 @@
     return PTR->freeFunc;
 }
-
 
 bool psMemCheckType(psDataType type,

trunk/psLib/src/sys/psMemory.h

@@ -12 +12 @@
  *  @ingroup MemoryManagement
  *
- *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-08-31 02:07:11 $
+ *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:13 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -350 +350 @@
 #endif // !DOXYGEN
 
+/** Set reference counter and return the pointer
+ *
+ *  @ingroup memRefCount
+ *
+ *  @return psPtr    the pointer with refCount set, or NULL if pointer is
+ *                   fully dereferenced.
+ */
+#ifdef DOXYGEN
+psPtr psMemSetRefCounter(
+    psPtr ptr,                        ///< Pointer to decrement refCounter, and return
+    psReferenceCount count            ///< New reference count
+);
+#else // DOXYGEN
+psPtr p_psMemSetRefCounter(
+    psPtr vptr,                        ///< Pointer to decrement refCounter, and return
+    psReferenceCount count,            ///< New reference count
+    const char *file,                  ///< File of call
+    psS32 lineno                       ///< Line number of call
+);
+
+#ifndef SWIG
+#define psMemSetRefCounter(vptr, count) p_psMemSetRefCounter(vptr, count, __FILE__, __LINE__)
+#endif // !SWIG
+
+#endif // !DOXYGEN
+
 /** Set callback for problems.
  *

trunk/psLib/src/types/psArray.c

@@ -9 +9 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-24 00:17:44 $
+ *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:15 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -41 +41 @@
     }
 
-    psArrayElementFree(psArr);
+    psArrayElementsFree(psArr);
 
     psFree(psArr->data);
@@ -98 +98 @@
 {
     if (array == NULL) {
-        return array;
+        int d = (delta > 0) ? delta : 10; // as spec'ed in SDRS.
+        array = psArrayAlloc(d);
+        array->n = 0;
     }
 
@@ -132 +134 @@
         if (psArrData[i] == data) {
             memmove(&array->data[i],&array->data[i+1],(n-i-1)*sizeof(psPtr));
+            psFree(data); // free the removed item (see Bug #449)
             n--;
             success = true;
@@ -141 +144 @@
 }
 
-void psArrayElementFree(psArray* psArr)
+void psArrayElementsFree(psArray* psArr)
 {
 
@@ -205 +208 @@
     }
     psFree(array->data[position]);
-    array->data[position] = data;
+    array->data[position] = psMemIncrRefCounter(data);
 
     return true;
@@ -232 +235 @@
         return NULL;
     }
-    return array->data[position];
-}
-
-
-
-
+    return psMemIncrRefCounter(array->data[position]);
+}

trunk/psLib/src/types/psArray.h

@@ -1 @@
-
 /** @file  psArray.h
  *
@@ -12 +11 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-24 00:17:44 $
+ *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:15 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -116 +115 @@
  *
  */
-void psArrayElementFree(
+void psArrayElementsFree(
     psArray* psArr                     ///< Void pointer array to destroy.
 );

trunk/psLib/src/types/psList.c

@@ -6 +6 @@
  *  @author Robert Daniel DeSonia, MHPCC
  *
- *  @version $Revision: 1.43 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-29 01:15:38 $
+ *  @version $Revision: 1.44 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:15 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -41 +41 @@
     pthread_mutex_lock(&list->p_lock);
 
-    // remove the free function of iterators to avoid double removal from list
+    // remove the associated iterators -- any references are invalid once psList is freed.
     psArray* iterators = list->iterators;
-    for (int i = 0; i < iterators->n; i++) {
-        psMemSetDeallocator(iterators->data[i], NULL);
-    }
-
-    psFree(list->iterators);
+    // ONLY orphan the iterators if the list iterators are about to be destroyed
+    // a case where this is not the case is in psListSort.
+    if (psMemGetRefCounter(iterators)  < 2) {
+        for (int i = 0; i < iterators->n; i++) {
+            // orphan iterators first to avoid any callbacks to dying list
+            ((psListIterator*)iterators->data[i])->list = NULL;
+            // remove all external references
+            psMemSetRefCounter(iterators->data[i], 1);
+        }
+    }
+    psFree(iterators);
 
     for (psListElem* ptr = list->head; ptr != NULL;) {
@@ -71 +77 @@
 
     // remove this iterator from the parent list
-    psArrayRemove(iter->list->iterators,iter);
-
+    if (iter->list != NULL) {
+        psArray* iters = iter->list->iterators;
+        for (int lcv = 0; lcv < iters->n; lcv++) {
+            if (iters->data[lcv] == iter) {
+                // following is done to match SDRS.
+                iters->data[lcv] = iters->data[iters->n-1];
+                iters->n--;
+                break;
+            }
+        }
+    }
 }
 
@@ -164 +179 @@
     iter->mutable = mutable;
 
-    // add to the list's array of iterators
-    psArray* listIterators = list->iterators;
-    int num = listIterators->n;
-    if ( num >= listIterators->nalloc) {
-        // need to resize the array to make more room for another iterator.
-        list->iterators = psArrayRealloc(listIterators,listIterators->nalloc*2);
-        listIterators = list->iterators;
-    }
-    listIterators->data[num] = iter;
-    listIterators->n = num+1;
+    // associate the iterator with the list
+    list->iterators = psArrayAdd(list->iterators,0,iter);
+    // don't want the list's array of iterators to hold a true reference
+    psMemDecrRefCounter(iter);
 
     if (! psListIteratorSet(iter,location)) {
         psFree(iter);
-        iter = NULL;
+        return NULL;
     }
 

trunk/psLib/src/types/psMetadataConfig.c

@@ -10 +10 @@
 *  @author Eric Van Alst, MHPCC
 *
-*  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-29 01:15:38 $
+*  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-10-01 02:22:15 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -995 +995 @@
         nextLevelInfo->name = psStringCopy(keyName);
         // Add next level to levelArray
-        levelArray = psArrayAdd(levelArray,1,nextLevelInfo);
+        levelArray = psArrayAdd(levelArray,0,nextLevelInfo);
         psFree(nextLevelInfo);
         // Increment level counter
@@ -1132 +1132 @@
                         return false;
                     }
-                    psFree(lowerLevelInfo);
                     (*level)--;
                 }

trunk/psLib/test/FullUnitTest.in

@@ -5 +5 @@
 #  the script
 #
-#  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-#  $Date: 2005-05-12 01:35:35 $
+#  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+#  $Date: 2005-10-01 02:22:19 $
 #
 #  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -23 +23 @@
 
 $recursive=1;
+$jobs=1;
 # Assign variables based on the presence of command line options to the script
 # The ! option allows for --nooption to be set to zero
 # (e.g. --noverbose --recursive causes $verbose=0 and $recursive=1)
 GetOptions(
+    "jobs!"      => \$jobs,
     "verbose!"   => \$verbose,
     "recursive!" => \$recursive,
@@ -41 +43 @@
     where:
         options =
+            --jobs        number of threads to use for make
             --help        Print this help text
             --verbose     Display extra information to user
@@ -241 +244 @@
 
         # Execute the make and save results
-        $_ = join( "\n|| ", split( "\n", "\n" . `make tests` ) );
+        $_ = join( "\n|| ", split( "\n", "\n" . `make -j $jobs tests` ) );
 
         # Check the output of make for return value != 0 or any of the

trunk/psLib/test/astro/tst_psTime_04.c

@@ -15 +15 @@
  *  @author  Eric Van Alst, MHPCC
  *
- *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2005-09-21 02:11:16 $
+ *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2005-10-01 02:22:20 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -35 +35 @@
 
 testDescription tests[] = {
-                              {testTimeInit1,000,"p_psTimeInit",0,false},
-                              {testTimeInit2,000,"p_psTimeInit",0,false},
-                              {testTimeInit3,000,"p_psTimeInit",0,false},
-                              {testTimeInit4,000,"p_psTimeInit",0,false},
-                              {testTimeInit5,000,"p_psTimeInit",0,false},
-                              {testTimeInit6,000,"p_psTimeInit",0,false},
-                              {testTimer1,000,"psTimer",0,false},
+                              {testTimeInit1,-1,"p_psTimeInit",0,false},
+                              {testTimeInit2,-2,"p_psTimeInit",0,false},
+                              {testTimeInit3,-3,"p_psTimeInit",0,false},
+                              {testTimeInit4,-4,"p_psTimeInit",0,false},
+                              {testTimeInit5,-5,"p_psTimeInit",0,false},
+                              {testTimeInit6,-6,"p_psTimeInit",0,false},
+                              {testTimer1,-7,"psTimer",0,false},
                               {NULL}
                           };

trunk/psLib/test/db/tst_psDB.c

@@ -9 +9 @@
  *  @author Aaron Culliney, MHPCC
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-26 21:13:29 $
+ *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-10-01 02:22:22 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -777 +777 @@
         return 7;
     }
+    psFree(ptr);
     ptr = psArrayGet(ary, 1);
     if (strcmp(ptr, CONST_ROW_2_STR)) {
@@ -785 +786 @@
         return 8;
     }
+    psFree(ptr);
     ptr = psArrayGet(ary, 0);
     if (strcmp(ptr, STR_1)) {
@@ -793 +795 @@
         return 9;
     }
+    psFree(ptr);
     psFree(ary);
 
@@ -820 +823 @@
         return 11;
     }
+    psFree(ptr);
     ptr = psArrayGet(ary, 1);
     if(atoi(ptr) != CONST_ROW_2_BOOL) {
@@ -828 +832 @@
         return 12;
     }
+    psFree(ptr);
     ptr = psArrayGet(ary, 0);
     if(atoi(ptr) != B_1) {
@@ -836 +841 @@
         return 13;
     }
+    psFree(ptr);
     psFree(ary);
 
@@ -1158 +1164 @@
         }
         psFree(ary);
+        psFree(row);
     }
 
@@ -1386 +1393 @@
     }
     psFree(dumpRowSet);
+    psFree(row);
 
     // Insert rows with NULL database object
@@ -1507 +1515 @@
         return 5;
     }
+    psFree(row);
     row = (psMetadata*)psArrayGet(ary, 1);
     if(!_check_const_row2(row)) {
@@ -1513 +1522 @@
         return 6;
     }
+    psFree(row);
     row = (psMetadata*)psArrayGet(ary, 2);
     if(!_check_const_row1(row)) {
@@ -1519 +1529 @@
         return 7;
     }
+    psFree(row);
     psFree(ary);
 
@@ -1904 +1915 @@
         return 6;
     }
+    psFree(row);
     psFree(ary);
 
@@ -1978 +1990 @@
         return 12;
     }
+    psFree(row);
     psFree(ary);
 

trunk/psLib/test/sys/verified/tst_psMemory.stderr

@@ -5 +5 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPCheckBufferPositive
+<HOST>|I|TPCheckBufferPositive
     psAlloc shall allocate memory blocks writeable by caller.
 
@@ -16 +16 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPOutOfMemory
+<HOST>|I|TPOutOfMemory
     Upon requesting more memory than is available, psalloc shall call the psMemExhaustedCallback.
-<DATE><TIME>|<HOST>|I|TPOutOfMemoryExhaustedCallback
+<HOST>|I|TPOutOfMemoryExhaustedCallback
     Custom MemExhaustedCallback was invoked.
-<DATE><TIME>|<HOST>|A|p_psAlloc
+<HOST>|A|p_psAlloc
     Failed to allocate <N> bytes at FILE:LINENO
 
@@ -31 +31 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPReallocOutOfMemory
+<HOST>|I|TPReallocOutOfMemory
     Upon requesting more memory than is available, psRealloc shall call the psMemExhaustedCallback.
-<DATE><TIME>|<HOST>|I|TPOutOfMemoryExhaustedCallback
+<HOST>|I|TPOutOfMemoryExhaustedCallback
     Custom MemExhaustedCallback was invoked.
-<DATE><TIME>|<HOST>|A|p_psRealloc
+<HOST>|A|p_psRealloc
     Failed to reallocate <N> bytes at FILE:LINENO
 
@@ -46 +46 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPrealloc
+<HOST>|I|TPrealloc
     psRealloc shall increase/decrease memory buffer while preserving contents
-<DATE><TIME>|<HOST>|I|TPrealloc
+<HOST>|I|TPrealloc
     Expanding memory buffer.
-<DATE><TIME>|<HOST>|I|TPrealloc
+<HOST>|I|TPrealloc
     Shrinking memory buffer.
 
@@ -61 +61 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPallocCallback
+<HOST>|I|TPallocCallback
     call to psAlloc/psRealloc shall generate a callback if specified memory ID is allocated.
-<DATE><TIME>|<HOST>|I|memAllocCallback
+<HOST>|I|memAllocCallback
     block 2 was (re)allocated
-<DATE><TIME>|<HOST>|I|memAllocCallback
+<HOST>|I|memAllocCallback
     block 3 was (re)allocated
-<DATE><TIME>|<HOST>|I|memFreeCallback
+<HOST>|I|memFreeCallback
     block 2 was freed
-<DATE><TIME>|<HOST>|I|memFreeCallback
+<HOST>|I|memFreeCallback
     block 3 was freed
-<DATE><TIME>|<HOST>|I|memAllocCallback
+<HOST>|I|memAllocCallback
     block 4 was (re)allocated
-<DATE><TIME>|<HOST>|I|memAllocCallback
+<HOST>|I|memAllocCallback
     block 4 was (re)allocated
-<DATE><TIME>|<HOST>|I|memFreeCallback
+<HOST>|I|memFreeCallback
     block 4 was freed
 
@@ -86 +86 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPcheckLeaks
+<HOST>|I|TPcheckLeaks
     psMemCheckLeaks shall return the number of blocks above an ID that are still allocated
-<DATE><TIME>|<HOST>|I|TPcheckLeaks
+<HOST>|I|TPcheckLeaks
     following psMemCheckLeaks call should produce one instance.
                    file:line ID
  FILE:LINENO  1
-<DATE><TIME>|<HOST>|I|TPcheckLeaks
+<HOST>|I|TPcheckLeaks
     Testing psMemCheckLeaks again with a different leak location
-<DATE><TIME>|<HOST>|I|TPcheckLeaks
+<HOST>|I|TPcheckLeaks
     following psMemCheckLeaks call should produce one error.
                    file:line ID
  FILE:LINENO  11
-<DATE><TIME>|<HOST>|I|TPcheckLeaks
+<HOST>|I|TPcheckLeaks
     Testing psMemCheckLeaks again with multiple leak locations.
-<DATE><TIME>|<HOST>|I|TPcheckLeaks
+<HOST>|I|TPcheckLeaks
     following psMemCheckLeaks call should produce two errors.
                    file:line ID
@@ -114 +114 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPmemCorruption
+<HOST>|I|TPmemCorruption
     psMemCheckCorruption shall detect memory corruptions
-<DATE><TIME>|<HOST>|I|TPmemCorruption
+<HOST>|I|TPmemCorruption
     psMemCheckCorruption should output an error message and memProblemCallback callback should be called.
-<DATE><TIME>|<HOST>|E|checkMemBlock (FILE:LINENO)
+<HOST>|E|checkMemBlock (FILE:LINENO)
     Memory block 1 is corrupted; buffer underflow detected.
-<DATE><TIME>|<HOST>|I|memProblemCallback
+<HOST>|I|memProblemCallback
     memory callback called for id 1 (FILE:LINENO).
 
@@ -131 +131 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPFreeReferencedMemory
+<HOST>|I|TPFreeReferencedMemory
     memory reference count shall be incrementable/decrementable
-<DATE><TIME>|<HOST>|I|TPFreeReferencedMemory
+<HOST>|I|TPFreeReferencedMemory
     psFree shall be just decrement a multiple refererenced pointer.
 
@@ -144 +144 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|TPmultipleFree
+<HOST>|I|TPmultipleFree
     Next should abort due to multiple freeing.
-<DATE><TIME>|<HOST>|A|p_psFree
+<HOST>|A|p_psFree
     Block 1, allocated at FILE:LINENO, freed multiple times at FILE:LINENO.
 
@@ -157 +157 @@
 \**********************************************************************************/
 
-<DATE><TIME>|<HOST>|I|memCheckTypes
+<HOST>|I|memCheckTypes
     Next should error from invalid datatype.
-<DATE><TIME>|<HOST>|E|psMemCheckType (FILE:LINENO)
+<HOST>|E|psMemCheckType (FILE:LINENO)
     Incorrect pointer.  Datatypes do not match.
-<DATE><TIME>|<HOST>|E|memCheckTypes (FILE:LINENO)
+<HOST>|E|memCheckTypes (FILE:LINENO)
     psMemCheckArray failed in memCheckType. 
-<DATE><TIME>|<HOST>|I|memCheckTypes
+<HOST>|I|memCheckTypes
     Next should error from invalid datatype.
-<DATE><TIME>|<HOST>|E|psMemCheckType (FILE:LINENO)
+<HOST>|E|psMemCheckType (FILE:LINENO)
     Incorrect pointer.  Datatypes do not match.
-<DATE><TIME>|<HOST>|E|memCheckTypes (FILE:LINENO)
+<HOST>|E|memCheckTypes (FILE:LINENO)
     psMemCheckBitSet failed in memCheckType. 
+<HOST>|E|psPolynomial4DAlloc (FILE:LINENO)
+    Error: nX is 0 or less.
+<HOST>|E|psPolynomial4DAlloc (FILE:LINENO)
+    Error: nX is 0 or less.
+<HOST>|E|psPolynomial2DAlloc (FILE:LINENO)
+    Error: nX is 0 or less.
+<HOST>|E|psPolynomial2DAlloc (FILE:LINENO)
+    Error: nX is 0 or less.
 
 ---> TESTPOINT PASSED (psMemory{psMemCheckType} | tst_psMemory.c)

trunk/psLib/test/types/tst_psArray.c

@@ -17 +17 @@
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2005-09-24 00:17:44 $
+ *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2005-10-01 02:22:26 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -205 +205 @@
         }
     }
-    psMemDecrRefCounter(mySt[0]);
     printFooter(stderr,"psArray","Remove valid item", true);
 
@@ -465 +464 @@
     if ( psArrayGet(test, -1) != p2)
         fprintf(stderr, "ArrayGet Failed to return the correct S32 from tail using -1\n");
+    psFree(p1); // free ref from psArrayGet
+    psFree(p2); // free ref from psArrayGet
 
     if ( psArraySet(test, -6, p3) )
@@ -470 +471 @@
 
     psFree(test);
+    psFree(p1);
+    psFree(p2);
     psFree(p3);