Index: /trunk/archive/pslib/src/Metadata/metadata.c
===================================================================
--- /trunk/archive/pslib/src/Metadata/metadata.c	(revision 163)
+++ /trunk/archive/pslib/src/Metadata/metadata.c	(revision 164)
@@ -13,15 +13,15 @@
  * Handle sets of metadata
  */
-psMetaDataSet *psMetaDataSetNew(void)	// make a new set of metadata
+psMetaDataSet *psMetaDataSetAlloc(void)	// make a new set of metadata
 {
     psMetaDataSet *ms = psAlloc(sizeof(psMetaDataSet));
 
-    ms->list = psDlistNew(NULL);	// list of metadata
-    ms->table = psHashNew(128);		// hash table
+    ms->list = psDlistAlloc(NULL);	// list of metadata
+    ms->table = psHashAlloc(128);	// hash table
 
     return ms;
 }
 
-void psMetaDataSetDel(psMetaDataSet *ms) // destroy a set of metadata
+void psMetaDataSetFree(psMetaDataSet *ms) // destroy a set of metadata
 {
     if (ms == NULL) {
@@ -29,6 +29,6 @@
     }
     
-    psDlistDel(ms->list, (void (*)(void *))NULL);
-    psHashDel(ms->table, (void (*)(void *))psMetaDataItemDel);
+    psDlistFree(ms->list, (void (*)(void *))NULL);
+    psHashFree(ms->table, (void (*)(void *))psMetaDataItemFree);
 
     psFree(ms);
@@ -43,5 +43,5 @@
  * to the data will be kept.
  */
-psMetaDataItem *psMetaDataItemNew(
+psMetaDataItem *psMetaDataItemAlloc(
     int typeFlags,			// type of this piece of metadata + flags
     const void *data,			// value of new item
@@ -52,5 +52,5 @@
 {
     const psMetaDataType type = typeFlags & PS_META_TYPE_MASK; // the type part of typeFlags
-    const long flags = typeFlags & ~PS_META_TYPE_MASK;	       // the flags part of typeFlags
+    psMetaDataFlags flags = typeFlags & ~PS_META_TYPE_MASK;    // the flags part of typeFlags
     static int id = 0;			// unique ID for an item of metadata
     psMetaDataItem *ms = psAlloc(sizeof(psMetaDataItem));
@@ -94,5 +94,5 @@
       case PS_META_ITEM_SET:
 	*(void **)&ms->val.v = NULL;
-	ms->items = psDlistNew(NULL);
+	ms->items = psDlistAlloc(NULL);
 	break;
 
@@ -106,6 +106,5 @@
 	
       case PS_META_STR:
-	*(void **)&ms->val.v = psAlloc(strlen(data) + 1);
-	strcpy(ms->val.v, data);
+	*(void **)&ms->val.v = psStringCopy(data);
 	break;
 	
@@ -117,4 +116,5 @@
 	*(void **)&ms->val.v = (void *)data;
 	break;
+
       case PS_META_NTYPE:
 	psAbort(__FILE__, "You cannot get here (%d)\n", __LINE__);
@@ -125,5 +125,5 @@
 }
 
-void psMetaDataItemDel(psMetaDataItem *ms)	// piece of metadata to destroy
+void psMetaDataItemFree(psMetaDataItem *ms) // piece of metadata to destroy
 {
     if(ms == NULL) {
@@ -137,10 +137,12 @@
     switch (ms->type) {
       case PS_META_ITEM_SET:
-	psDlistDel(ms->items, (void (*)(void *))NULL); // they're still in the hash table
+	psDlistFree(ms->items, (void (*)(void *))NULL); // they're still in the hash table
 	ms->items = NULL;
 	break;
+	
       case PS_META_FLOAT:
       case PS_META_INT:
 	break;				// nothing to do
+	
       case PS_META_STR:
 	psFree(ms->val.v);
@@ -153,4 +155,5 @@
       case PS_META_UNKNOWN:
 	break;				// we don't own the memory
+	
       case PS_META_NTYPE:
 	psAbort(__FILE__, "You cannot get here (%d)\n", __LINE__);
@@ -177,5 +180,5 @@
 	psMetaDataItem *head = meta;
 	if (head == NULL) {		// this is the first item of this name
-	    head = psMetaDataAppend(ms, psMetaDataItemNew(PS_META_ITEM_SET, NULL, NULL, item->name));
+	    head = psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_ITEM_SET, NULL, NULL, item->name));
 	}	    
 
@@ -199,10 +202,10 @@
 
 	psDlistAppend(head->items, item);
-	psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemDel);
+	psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemFree);
 
 	return item;
     } else if (meta != NULL) {
 	psError(__func__, "Key \"%s\" is already present in the metaDataSet 0x%x", item->name, ms);
-	//psMetaDataItemDel(item);
+	//psMetaDataItemFree(item);
 
 	return NULL;
@@ -210,5 +213,5 @@
 
     psDlistAppend(ms->list, item);
-    psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemDel);
+    psHashInsert(ms->table, item->name, item, (void (*)(void *))psMetaDataItemFree);
 
     return item;
@@ -223,10 +226,24 @@
     assert (ms != NULL && ms->list != NULL && ms->table != NULL);
 
-    void *data = psHashRemove(ms->table, key);
-
-    if (data == NULL) {
+    psMetaDataItem *meta = psHashRemove(ms->table, key);
+
+    if (meta == NULL) {
 	return NULL;
     } else {
-	return psDlistRemove(ms->list, data, PS_DLIST_UNKNOWN);
+	if (meta->flags & PS_META_NON_UNIQUE) {	// it's on someone's ->items list; find that someone
+	    char baseKey[strlen(key) + 1];	// Name without the .nnn tacked on
+	    strcpy(baseKey, key);
+
+	    char *ptr = strrchr(baseKey, '.');
+	    assert (ptr != NULL);
+	    *ptr = '\0';
+
+	    psMetaDataItem *base = psHashLookup(ms->table, baseKey); // here's the non-qualified metadata
+	    assert (base != NULL);
+
+	    return psDlistRemove(base->items, meta, PS_DLIST_UNKNOWN);
+	} else {
+	    return psDlistRemove(ms->list, meta, PS_DLIST_UNKNOWN);
+	}
     }
 }
@@ -301,28 +318,37 @@
 	
 	break;
+	
       case PS_META_FLOAT:
 	fprintf(fd, "%g\n", ms->val.f);
 	break;
+	
       case PS_META_INT:
 	fprintf(fd, "%d\n", ms->val.i);
 	break;
+	
       case PS_META_STR:
 	fprintf(fd, "%s\n", (char *)ms->val.v);
 	break;
+	
       case PS_META_IMG:
 	fprintf(fd, "(IMG)\n");
 	break;
+	
       case PS_META_JPEG:
 	fprintf(fd, "(JPG)\n");
 	break;
+	
       case PS_META_PNG:
 	fprintf(fd, "(PNG)\n");
 	break;
+	
       case PS_META_ASTROM:
 	fprintf(fd, "(ASTROM)\n");
 	break;
+	
       case PS_META_UNKNOWN:
 	fprintf(fd, "(UNKNOWN)\n");
 	break;
+	
       case PS_META_NTYPE:
 	psAbort(__FILE__, "You cannot get here (%d)\n", __LINE__);
@@ -343,21 +369,23 @@
     psSetLogFormat("NM");		// suppress some of the psLogMsg verbosity
 
-    psMetaDataSet *ms = psMetaDataSetNew(); // set of metadata
+    psMetaDataSet *ms = psMetaDataSetAlloc(); // set of metadata
     psMetaDataItem *meta = NULL;	    // used to traverse a set of metadata
 
     for (int i = 0; i < 10; i += 5) {
 	float sqrti = sqrt(i);
-	psMetaDataAppend(ms, psMetaDataItemNew(PS_META_INT, &i, NULL, "const.%d", i));
-	psMetaDataAppend(ms, psMetaDataItemNew(PS_META_FLOAT, &sqrti, "square root", "const.sqrt%d", i));
-    }
-    psMetaDataAppend(ms, psMetaDataItemNew(PS_META_STR | PS_META_NON_UNIQUE,
+	psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_INT, &i, NULL, "const.%d", i));
+	psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_FLOAT, &sqrti, "square root", "const.sqrt%d", i));
+    }
+    psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_STR | PS_META_NON_UNIQUE,
 					   "Bonjour", "French", "lang.hello"));
-    psMetaDataAppend(ms, psMetaDataItemNew(PS_META_STR | PS_META_NON_UNIQUE,
+    psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_STR | PS_META_NON_UNIQUE,
 					   "Aloha", "Hawaiian", "lang.hello"));
-    psMetaDataAppend(ms, psMetaDataItemNew(PS_META_STR | PS_META_NON_UNIQUE,
+    psMetaDataAppend(ms, psMetaDataItemAlloc(PS_META_STR | PS_META_NON_UNIQUE,
 					   "Good Morning", "English", "lang.hello"));
     /*
      * Print all metadata starting "lang"
      */
+    psMetaDataItemFree(psMetaDataRemove(ms, "lang.hello.0"));
+
     psMetaDataSetIterator(ms);
     while ((meta = psMetaDataGetNext(ms, "lang")) != NULL) {
@@ -367,5 +395,5 @@
      * Remove a key
      */
-    psMetaDataItemDel(psMetaDataRemove(ms, "lang.hello"));
+    psMetaDataItemFree(psMetaDataRemove(ms, "lang.hello"));
     /*
      * Print all metadata
@@ -388,5 +416,5 @@
      * Clean up
      */
-    psMetaDataSetDel(ms);
+    psMetaDataSetFree(ms);
     /*
      * Check for memory leaks
Index: /trunk/archive/pslib/src/Metadata/psMetaData.h
===================================================================
--- /trunk/archive/pslib/src/Metadata/psMetaData.h	(revision 163)
+++ /trunk/archive/pslib/src/Metadata/psMetaData.h	(revision 164)
@@ -20,9 +20,9 @@
 } psMetaDataType;
 
-enum {
+typedef enum {
     PS_META_TYPE_MASK =     0xffff,	// the type enum must fit in this mask
     PS_META_UNIQUE =       0x10000,	// the name must be unique (default)
     PS_META_NON_UNIQUE =   0x20000,	// the name may be repeated, and should be disambiguated for us
-};
+} psMetaDataFlags;
 
 /*
@@ -34,5 +34,5 @@
     char *restrict name;		// Name of item
     psMetaDataType type;		// type of this item
-    int flags;				// flags associated with this item
+    psMetaDataFlags flags;		// flags associated with this item
     const union {
 	float f;			// floating value
@@ -56,5 +56,5 @@
  * Constructors and destructors
  */
-psMetaDataItem *psMetaDataItemNew(
+psMetaDataItem *psMetaDataItemAlloc(
     int typeFlags,			// type of this piece of metadata + flags
     const void *val,			// value of new item
@@ -65,8 +65,8 @@
     ...);				// possible arguments for name format
 
-void psMetaDataItemDel(psMetaDataItem *ms); // piece of metadata to destroy
+void psMetaDataItemFree(psMetaDataItem *ms); // piece of metadata to destroy
 
-psMetaDataSet *psMetaDataSetNew(void);	  // make a new set of metadata
-void psMetaDataSetDel(psMetaDataSet *ms); // destroy a set of metadata
+psMetaDataSet *psMetaDataSetAlloc(void);   // make a new set of metadata
+void psMetaDataSetFree(psMetaDataSet *ms); // destroy a set of metadata
 
 /*****************************************************************************/
Index: /trunk/archive/pslib/src/Utils/array.c
===================================================================
--- /trunk/archive/pslib/src/Utils/array.c	(revision 163)
+++ /trunk/archive/pslib/src/Utils/array.c	(revision 164)
@@ -10,7 +10,7 @@
 P_PS_CREATE_ARRAY_TYPE(static, my_, psVoidPtr);
 
-psVoidPtrArray *psVoidPtrArrayNew(int n, int s)
+psVoidPtrArray *psVoidPtrArrayAlloc(int n, int s)
 {
-    return my_psVoidPtrArrayNew(n, s);
+    return my_psVoidPtrArrayAlloc(n, s);
 }
 
@@ -20,6 +20,6 @@
 }
 
-void psVoidPtrArrayDel(psVoidPtrArray *arr,
-		       void (*elemDel)(void *)) // destructor for data on array
+void psVoidPtrArrayFree(psVoidPtrArray *arr,
+			void (*elemFree)(void *)) // destructor for data on array
 {
     if (arr == NULL) {
@@ -28,11 +28,11 @@
 	
     for (int i = 0; i < arr->n; i++) {
-	if (elemDel == NULL) {
+	if (elemFree == NULL) {
 	    psMemDecrRefCounter(arr->arr[i]);
 	} else {
-	    elemDel(psMemDecrRefCounter(arr->arr[i]));
+	    elemFree(psMemDecrRefCounter(arr->arr[i]));
 	}
     }
-    my_psVoidPtrArrayDel(arr);
+    my_psVoidPtrArrayFree(arr);
 }
 
@@ -44,10 +44,10 @@
 } psXY;
 
-psXY *psXYNew(void)
+psXY *psXYAlloc(void)
 {
     return psAlloc(sizeof(psXY));
 }
 
-void psXYDel(psXY *xy)
+void psXYFree(psXY *xy)
 {
     psFree(xy);
@@ -62,6 +62,6 @@
 int main(void)
 {
-    psXYArray *t = psXYArrayNew(10, 15);
-    psXYPtrArray *pt = psXYPtrArrayNew(10, 10);
+    psXYArray *t = psXYArrayAlloc(10, 15);
+    psXYPtrArray *pt = psXYPtrArrayAlloc(10, 10);
 
     for (int i = 0; i < t->n; i++) {
@@ -78,11 +78,11 @@
     printf("\n");
     
-    psXYArrayDel(t);
+    psXYArrayFree(t);
 
     psXY *xy = psMemDecrRefCounter(pt->arr[0]);
     pt->arr[0] = NULL;
-    psXYDel(xy);    
+    psXYFree(xy);    
     
-    psXYPtrArrayDel(pt);
+    psXYPtrArrayFree(pt);
 
     psMemCheckLeaks(0, NULL, stderr);
Index: /trunk/archive/pslib/src/Utils/psArray.h
===================================================================
--- /trunk/archive/pslib/src/Utils/psArray.h	(revision 163)
+++ /trunk/archive/pslib/src/Utils/psArray.h	(revision 164)
@@ -14,7 +14,7 @@
     } PS_CONCAT(TYPE, Array); \
     \
-PS_CONCAT(TYPE, Array) *PS_CONCAT3(TYPE,Array,New)(int n, int s); \
+PS_CONCAT(TYPE, Array) *PS_CONCAT3(TYPE,Array,Alloc)(int n, int s); \
 PS_CONCAT(TYPE, Array) *PS_CONCAT3(TYPE,Array,Realloc)(PS_CONCAT(TYPE, Array) *arr, int n); \
-void PS_CONCAT3(TYPE,Array,Del)(PS_CONCAT(TYPE, Array) *arr)
+void PS_CONCAT3(TYPE,Array,Free)(PS_CONCAT(TYPE, Array) *arr)
 
 /*****************************************************************************/
@@ -27,5 +27,5 @@
 #define P_PS_CREATE_ARRAY_TYPE(QUAL,PREFIX,TYPE) \
 \
-QUAL PS_CONCAT(TYPE, Array) *PS_CONCAT4(PREFIX,TYPE,Array,New)(int n, /* initial dimension */\
+QUAL PS_CONCAT(TYPE, Array) *PS_CONCAT4(PREFIX,TYPE,Array,Alloc)(int n, /* initial dimension */\
                                                    int s) /* initial number of elements */ \
 { \
@@ -33,5 +33,5 @@
     \
     if (n > s) { \
-	psLogMsg(PS_STRING(TYPE) "ArrayNew", PS_LOG_ERROR, "Too few elements requested in array (%d < %d)\n", s, n); \
+	psLogMsg(PS_STRING(TYPE) "ArrayAlloc", PS_LOG_ERROR, "Too few elements requested in array (%d < %d)\n", s, n); \
 	s = n; \
     } \
@@ -52,5 +52,5 @@
 { \
     if (arr == NULL) { \
-	return PS_CONCAT4(PREFIX,TYPE,Array,New)(n, n); \
+	return PS_CONCAT4(PREFIX,TYPE,Array,Alloc)(n, n); \
     } \
     \
@@ -67,5 +67,5 @@
 } \
 \
-QUAL void PS_CONCAT4(PREFIX,TYPE,Array,Del)(PS_CONCAT(TYPE,Array) *arr) \
+QUAL void PS_CONCAT4(PREFIX,TYPE,Array,Free)(PS_CONCAT(TYPE,Array) *arr) \
 { \
     if (arr == NULL) { \
@@ -88,9 +88,9 @@
     P_PS_CREATE_ARRAY_TYPE(static, my_, P_PS_CONCAT(TYPE, Ptr)) \
     \
-    PS_CONCAT(TYPE, PtrArray) *PS_CONCAT3(TYPE,PtrArray,New)(int n, int s) \
+    PS_CONCAT(TYPE, PtrArray) *PS_CONCAT3(TYPE,PtrArray,Alloc)(int n, int s) \
     { \
-	PS_CONCAT(TYPE, PtrArray) *arr = PS_CONCAT4(my_,TYPE,PtrArray,New)(n, s); \
+	PS_CONCAT(TYPE, PtrArray) *arr = PS_CONCAT4(my_,TYPE,PtrArray,Alloc)(n, s); \
 	for (int i = 0; i < arr->n; i++) { \
-	    arr->arr[i] = psMemIncrRefCounter,(PS_CONCAT(TYPE, New)());\
+	    arr->arr[i] = psMemIncrRefCounter,(PS_CONCAT(TYPE, Alloc)());\
 	} \
         \
@@ -101,5 +101,5 @@
     { \
 	for (int i = n; i < arr->n; i++) { \
-	    PS_CONCAT(TYPE, Del)(psMemDecrRefCounter(arr->arr[i]));\
+	    PS_CONCAT(TYPE, Free)(psMemDecrRefCounter(arr->arr[i]));\
 	} \
         \
@@ -107,11 +107,11 @@
     } \
     \
-    void PS_CONCAT3(TYPE,PtrArray,Del)(PS_CONCAT2(TYPE,PtrArray) *arr) \
+    void PS_CONCAT3(TYPE,PtrArray,Free)(PS_CONCAT2(TYPE,PtrArray) *arr) \
     { \
 	if (arr == NULL) { return; } \
 	for (int i = 0; i < arr->size; i++) { \
-	    PS_CONCAT(TYPE, Del)(psMemDecrRefCounter(arr->arr[i])); \
+	    PS_CONCAT(TYPE, Free)(psMemDecrRefCounter(arr->arr[i])); \
 	} \
-	PS_CONCAT4(my_, TYPE, PtrArray, Del)(arr); \
+	PS_CONCAT4(my_, TYPE, PtrArray, Free)(arr); \
     }
 
@@ -129,8 +129,8 @@
 } psVoidPtrArray;
 
-psVoidPtrArray *psVoidPtrArrayNew(int n, int s);
+psVoidPtrArray *psVoidPtrArrayAlloc(int n, int s);
 psVoidPtrArray *psVoidPtrArrayRealloc(psVoidPtrArray *arr, int n);
-void psVoidPtrArrayDel(psVoidPtrArray *arr,
-		       void (*elemDel)(void *)); // destructor for array data
+void psVoidPtrArrayFree(psVoidPtrArray *arr,
+			void (*elemFree)(void *)); // destructor for array data