Index: trunk/ippdb/src/ippdb.c
===================================================================
--- trunk/ippdb/src/ippdb.c	(revision 10748)
+++ trunk/ippdb/src/ippdb.c	(revision 10753)
@@ -66,7 +66,7 @@
 #define P4INPUTIMFILE_TABLE_NAME "p4InputImfile"
 #define P4WARPEDIMFILE_TABLE_NAME "p4WarpedImfile"
-#define P4PSTACKEDIMFILE_TABLE_NAME "p4PStackedImfile"
-#define P4PDIFFIMFILE_TABLE_NAME "p4PDiffImfile"
-#define P4PMAGICMASKIMFILE_TABLE_NAME "p4PMagicMaskImfile"
+#define P4STACKEDIMFILE_TABLE_NAME "p4StackedImfile"
+#define P4DIFFIMFILE_TABLE_NAME "p4DiffImfile"
+#define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile"
 #define MAX_STRING_LENGTH 1024
 
@@ -14861,12 +14861,12 @@
     return true;
 }
-static void p4PStackedImfileRowFree(p4PStackedImfileRow *object);
-
-p4PStackedImfileRow *p4PStackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
-{
-    p4PStackedImfileRow *_object;
-
-    _object = psAlloc(sizeof(p4PStackedImfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4PStackedImfileRowFree);
+static void p4StackedImfileRowFree(p4StackedImfileRow *object);
+
+p4StackedImfileRow *p4StackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+{
+    p4StackedImfileRow *_object;
+
+    _object = psAlloc(sizeof(p4StackedImfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4StackedImfileRowFree);
 
     _object->p4_id = p4_id;
@@ -14879,5 +14879,5 @@
 }
 
-static void p4PStackedImfileRowFree(p4PStackedImfileRow *object)
+static void p4StackedImfileRowFree(p4StackedImfileRow *object)
 {
     psFree(object->class_id);
@@ -14887,5 +14887,5 @@
 }
 
-bool p4PStackedImfileCreateTable(psDB *dbh)
+bool p4StackedImfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14916,5 +14916,5 @@
     }
 
-    bool status = psDBCreateTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md);
+    bool status = psDBCreateTable(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -14923,10 +14923,10 @@
 }
 
-bool p4PStackedImfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME);
-}
-
-bool p4PStackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+bool p4StackedImfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4STACKEDIMFILE_TABLE_NAME);
+}
+
+bool p4StackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14957,5 +14957,5 @@
     }
 
-    bool status = psDBInsertOneRow(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md);
+    bool status = psDBInsertOneRow(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -14963,11 +14963,11 @@
 }
 
-long long p4PStackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4StackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
         return count;
 
@@ -14977,13 +14977,13 @@
     return deleted;
 }
-bool p4PStackedImfileInsertObject(psDB *dbh, p4PStackedImfileRow *object)
-{
-    return p4PStackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri);
-}
-
-bool p4PStackedImfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4StackedImfileInsertObject(psDB *dbh, p4StackedImfileRow *object)
+{
+    return p4StackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri);
+}
+
+bool p4StackedImfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4PStackedImfileInsertObject(dbh, objects->data[i])) {
+        if (!p4StackedImfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -14993,11 +14993,11 @@
 }
 
-bool p4PStackedImfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4StackedImfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4PSTACKEDIMFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4PSTACKEDIMFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PSTACKEDIMFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4STACKEDIMFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4STACKEDIMFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4STACKEDIMFILE_TABLE_NAME);
         return false;
     }
@@ -15017,5 +15017,5 @@
     }
 
-    if (!psDBInsertRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4STACKEDIMFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -15028,9 +15028,9 @@
 }
 
-bool p4PStackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4StackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -15038,5 +15038,5 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4PSTACKEDIMFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4STACKEDIMFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -15049,5 +15049,5 @@
 }
 
-psMetadata *p4PStackedImfileMetadataFromObject(const p4PStackedImfileRow *object)
+psMetadata *p4StackedImfileMetadataFromObject(const p4StackedImfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15082,5 +15082,5 @@
 }
 
-p4PStackedImfileRow *p4PStackedImfileObjectFromMetadata(psMetadata *md)
+p4StackedImfileRow *p4StackedImfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -15112,7 +15112,7 @@
     }
 
-    return p4PStackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri);
-}
-psArray *p4PStackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    return p4StackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri);
+}
+psArray *p4StackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -15120,5 +15120,5 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -15130,5 +15130,5 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4PStackedImfileRow *object = p4PStackedImfileObjectFromMetadata(rowSet->data[i]);
+        p4StackedImfileRow *object = p4StackedImfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -15139,11 +15139,11 @@
     return returnSet;
 }
-bool p4PStackedImfileDeleteObject(psDB *dbh, const p4PStackedImfileRow *object)
-{
-    psMetadata *where = p4PStackedImfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, 0);
+bool p4StackedImfileDeleteObject(psDB *dbh, const p4StackedImfileRow *object)
+{
+    psMetadata *where = p4StackedImfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, 0);
     psFree(where)
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
         return false;
     }
@@ -15151,21 +15151,21 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4PStackedImfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4PStackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4StackedImfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4StackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4PStackedImfileRow *object = objects->data[i];
-        psMetadata *where = p4PStackedImfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+        p4StackedImfileRow *object = objects->data[i];
+        psMetadata *where = p4StackedImfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
         psFree(where)
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
             return count;
         }
@@ -15176,5 +15176,5 @@
     return deleted;
 }
-bool p4PStackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4StackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -15182,9 +15182,9 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4PStackedImfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4StackedImfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4PSTACKEDIMFILE_TABLE_NAME,
+            P4STACKEDIMFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -15207,9 +15207,9 @@
     return true;
 }
-bool p4PStackedImfilePrintObject(FILE *stream, p4PStackedImfileRow *object, bool mdcf)
+bool p4StackedImfilePrintObject(FILE *stream, p4StackedImfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4PStackedImfileMetadataFromObject(object);
+    psMetadata *md = p4StackedImfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -15222,12 +15222,12 @@
     return true;
 }
-static void p4PDiffImfileRowFree(p4PDiffImfileRow *object);
-
-p4PDiffImfileRow *p4PDiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
-{
-    p4PDiffImfileRow *_object;
-
-    _object = psAlloc(sizeof(p4PDiffImfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4PDiffImfileRowFree);
+static void p4DiffImfileRowFree(p4DiffImfileRow *object);
+
+p4DiffImfileRow *p4DiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+{
+    p4DiffImfileRow *_object;
+
+    _object = psAlloc(sizeof(p4DiffImfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4DiffImfileRowFree);
 
     _object->p4_id = p4_id;
@@ -15242,5 +15242,5 @@
 }
 
-static void p4PDiffImfileRowFree(p4PDiffImfileRow *object)
+static void p4DiffImfileRowFree(p4DiffImfileRow *object)
 {
     psFree(object->exp_tag);
@@ -15251,5 +15251,5 @@
 }
 
-bool p4PDiffImfileCreateTable(psDB *dbh)
+bool p4DiffImfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15290,5 +15290,5 @@
     }
 
-    bool status = psDBCreateTable(dbh, P4PDIFFIMFILE_TABLE_NAME, md);
+    bool status = psDBCreateTable(dbh, P4DIFFIMFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -15297,10 +15297,10 @@
 }
 
-bool p4PDiffImfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4PDIFFIMFILE_TABLE_NAME);
-}
-
-bool p4PDiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+bool p4DiffImfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4DIFFIMFILE_TABLE_NAME);
+}
+
+bool p4DiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15341,5 +15341,5 @@
     }
 
-    bool status = psDBInsertOneRow(dbh, P4PDIFFIMFILE_TABLE_NAME, md);
+    bool status = psDBInsertOneRow(dbh, P4DIFFIMFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -15347,11 +15347,11 @@
 }
 
-long long p4PDiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4DiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
         return count;
 
@@ -15361,13 +15361,13 @@
     return deleted;
 }
-bool p4PDiffImfileInsertObject(psDB *dbh, p4PDiffImfileRow *object)
-{
-    return p4PDiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
-}
-
-bool p4PDiffImfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4DiffImfileInsertObject(psDB *dbh, p4DiffImfileRow *object)
+{
+    return p4DiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
+}
+
+bool p4DiffImfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4PDiffImfileInsertObject(dbh, objects->data[i])) {
+        if (!p4DiffImfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -15377,11 +15377,11 @@
 }
 
-bool p4PDiffImfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4DiffImfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4PDIFFIMFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4PDIFFIMFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PDIFFIMFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4DIFFIMFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4DIFFIMFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFIMFILE_TABLE_NAME);
         return false;
     }
@@ -15401,5 +15401,5 @@
     }
 
-    if (!psDBInsertRows(dbh, P4PDIFFIMFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4DIFFIMFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -15412,9 +15412,9 @@
 }
 
-bool p4PDiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4DiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -15422,5 +15422,5 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4PDIFFIMFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFIMFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -15433,5 +15433,5 @@
 }
 
-psMetadata *p4PDiffImfileMetadataFromObject(const p4PDiffImfileRow *object)
+psMetadata *p4DiffImfileMetadataFromObject(const p4DiffImfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15476,5 +15476,5 @@
 }
 
-p4PDiffImfileRow *p4PDiffImfileObjectFromMetadata(psMetadata *md)
+p4DiffImfileRow *p4DiffImfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -15516,7 +15516,7 @@
     }
 
-    return p4PDiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
-}
-psArray *p4PDiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    return p4DiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
+}
+psArray *p4DiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -15524,5 +15524,5 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -15534,5 +15534,5 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4PDiffImfileRow *object = p4PDiffImfileObjectFromMetadata(rowSet->data[i]);
+        p4DiffImfileRow *object = p4DiffImfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -15543,11 +15543,11 @@
     return returnSet;
 }
-bool p4PDiffImfileDeleteObject(psDB *dbh, const p4PDiffImfileRow *object)
-{
-    psMetadata *where = p4PDiffImfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, 0);
+bool p4DiffImfileDeleteObject(psDB *dbh, const p4DiffImfileRow *object)
+{
+    psMetadata *where = p4DiffImfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, 0);
     psFree(where)
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
         return false;
     }
@@ -15555,21 +15555,21 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4PDiffImfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4PDiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4DiffImfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4DiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4PDiffImfileRow *object = objects->data[i];
-        psMetadata *where = p4PDiffImfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+        p4DiffImfileRow *object = objects->data[i];
+        psMetadata *where = p4DiffImfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
         psFree(where)
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
             return count;
         }
@@ -15580,5 +15580,5 @@
     return deleted;
 }
-bool p4PDiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4DiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -15586,9 +15586,9 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4PDiffImfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4DiffImfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4PDIFFIMFILE_TABLE_NAME,
+            P4DIFFIMFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -15611,9 +15611,9 @@
     return true;
 }
-bool p4PDiffImfilePrintObject(FILE *stream, p4PDiffImfileRow *object, bool mdcf)
+bool p4DiffImfilePrintObject(FILE *stream, p4DiffImfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4PDiffImfileMetadataFromObject(object);
+    psMetadata *md = p4DiffImfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -15626,12 +15626,12 @@
     return true;
 }
-static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object);
-
-p4PMagicMaskImfileRow *p4PMagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
-{
-    p4PMagicMaskImfileRow *_object;
-
-    _object = psAlloc(sizeof(p4PMagicMaskImfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4PMagicMaskImfileRowFree);
+static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object);
+
+p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
+{
+    p4MagicMaskImfileRow *_object;
+
+    _object = psAlloc(sizeof(p4MagicMaskImfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4MagicMaskImfileRowFree);
 
     _object->p4_id = p4_id;
@@ -15644,5 +15644,5 @@
 }
 
-static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object)
+static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object)
 {
     psFree(object->exp_tag);
@@ -15651,5 +15651,5 @@
 }
 
-bool p4PMagicMaskImfileCreateTable(psDB *dbh)
+bool p4MagicMaskImfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15680,5 +15680,5 @@
     }
 
-    bool status = psDBCreateTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md);
+    bool status = psDBCreateTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -15687,10 +15687,10 @@
 }
 
-bool p4PMagicMaskImfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME);
-}
-
-bool p4PMagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
+bool p4MagicMaskImfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME);
+}
+
+bool p4MagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15721,5 +15721,5 @@
     }
 
-    bool status = psDBInsertOneRow(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md);
+    bool status = psDBInsertOneRow(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -15727,11 +15727,11 @@
 }
 
-long long p4PMagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4MagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
         return count;
 
@@ -15741,13 +15741,13 @@
     return deleted;
 }
-bool p4PMagicMaskImfileInsertObject(psDB *dbh, p4PMagicMaskImfileRow *object)
-{
-    return p4PMagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
-}
-
-bool p4PMagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4MagicMaskImfileInsertObject(psDB *dbh, p4MagicMaskImfileRow *object)
+{
+    return p4MagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
+}
+
+bool p4MagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4PMagicMaskImfileInsertObject(dbh, objects->data[i])) {
+        if (!p4MagicMaskImfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -15757,11 +15757,11 @@
 }
 
-bool p4PMagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4MagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4PMAGICMASKIMFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4PMAGICMASKIMFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PMAGICMASKIMFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4MAGICMASKIMFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4MAGICMASKIMFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4MAGICMASKIMFILE_TABLE_NAME);
         return false;
     }
@@ -15781,5 +15781,5 @@
     }
 
-    if (!psDBInsertRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -15792,9 +15792,9 @@
 }
 
-bool p4PMagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4MagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -15802,5 +15802,5 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4PMAGICMASKIMFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4MAGICMASKIMFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -15813,5 +15813,5 @@
 }
 
-psMetadata *p4PMagicMaskImfileMetadataFromObject(const p4PMagicMaskImfileRow *object)
+psMetadata *p4MagicMaskImfileMetadataFromObject(const p4MagicMaskImfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15846,5 +15846,5 @@
 }
 
-p4PMagicMaskImfileRow *p4PMagicMaskImfileObjectFromMetadata(psMetadata *md)
+p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -15876,7 +15876,7 @@
     }
 
-    return p4PMagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri);
-}
-psArray *p4PMagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    return p4MagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri);
+}
+psArray *p4MagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -15884,5 +15884,5 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -15894,5 +15894,5 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4PMagicMaskImfileRow *object = p4PMagicMaskImfileObjectFromMetadata(rowSet->data[i]);
+        p4MagicMaskImfileRow *object = p4MagicMaskImfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -15903,11 +15903,11 @@
     return returnSet;
 }
-bool p4PMagicMaskImfileDeleteObject(psDB *dbh, const p4PMagicMaskImfileRow *object)
-{
-    psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, 0);
+bool p4MagicMaskImfileDeleteObject(psDB *dbh, const p4MagicMaskImfileRow *object)
+{
+    psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, 0);
     psFree(where)
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
         return false;
     }
@@ -15915,21 +15915,21 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4PMagicMaskImfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4PMagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4MagicMaskImfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4MagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4PMagicMaskImfileRow *object = objects->data[i];
-        psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+        p4MagicMaskImfileRow *object = objects->data[i];
+        psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
         psFree(where)
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
             return count;
         }
@@ -15940,5 +15940,5 @@
     return deleted;
 }
-bool p4PMagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4MagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -15946,9 +15946,9 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4PMagicMaskImfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4MagicMaskImfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4PMAGICMASKIMFILE_TABLE_NAME,
+            P4MAGICMASKIMFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -15971,9 +15971,9 @@
     return true;
 }
-bool p4PMagicMaskImfilePrintObject(FILE *stream, p4PMagicMaskImfileRow *object, bool mdcf)
+bool p4MagicMaskImfilePrintObject(FILE *stream, p4MagicMaskImfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4PMagicMaskImfileMetadataFromObject(object);
+    psMetadata *md = p4MagicMaskImfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {