Index: trunk/archive/pslib/src/Utils/Makefile
===================================================================
--- trunk/archive/pslib/src/Utils/Makefile	(revision 709)
+++ trunk/archive/pslib/src/Utils/Makefile	(revision 753)
@@ -2,5 +2,5 @@
 CFLAGS = -Wall -g -I$(PSLIB_DIR)/include -I$(FFTW_DIR)/include
 DYLIB = dylib
-DYLIB_LDFLAGS = "-undefined suppress -flat_namespace -dynamiclib";
+DYLIB_LDFLAGS = -undefined suppress -flat_namespace -dynamiclib -shared
 
 PSLIB_DIR = ../..
Index: trunk/archive/pslib/src/Utils/dlist.c
===================================================================
--- trunk/archive/pslib/src/Utils/dlist.c	(revision 709)
+++ trunk/archive/pslib/src/Utils/dlist.c	(revision 753)
@@ -317,6 +317,5 @@
     psDlistElem *ptr = dlist->head;
     for (int i = 0, n = dlist->n; i < n; i++) {
-	arr->arr.arr_v[i] = ptr->data;
-
+	arr->data.V[i] = ptr->data;
 	ptr->data = NULL;
 	ptr = ptr->next;
@@ -339,6 +338,6 @@
     for (int i = 0, n = arr->n; i < n; i++) {
 	psDlistAppend(list,
-		      psMemDecrRefCounter(arr->arr.arr_v[i])); // it\'s already Incr
-	arr->arr.arr_v[i] = NULL;
+		      psMemDecrRefCounter(arr->data.V[i])); // it\'s already Incr
+	arr->data.V[i] = NULL;
     }
 
Index: trunk/archive/pslib/src/Utils/error.c
===================================================================
--- trunk/archive/pslib/src/Utils/error.c	(revision 709)
+++ trunk/archive/pslib/src/Utils/error.c	(revision 753)
@@ -76,8 +76,8 @@
 int psError(const char *name,		// category of code that caused the error
 	    psErrorCode code,		// code of error (equivalent to errno)
-	    psErrorStatus status,	// is this a new error?
+	    int new,			// is this a new error?
 	    const char *fmt, ...)	// format and possible extra arguments
 {
-    if (code == PS_ERR_NONE || status == PS_NEW_ERROR) { // free old error stack
+    if (code == PS_ERR_NONE || new) { // free old error stack
 	errStack *eptr = errorStack;
 
@@ -99,5 +99,5 @@
 	
 	va_start(ap, fmt);
-	p_psLogVMsg(name, PS_LOG_ERROR, fmt, ap);
+	psLogMsgV(name, PS_LOG_ERROR, fmt, ap);
 	va_end(ap);
     }
@@ -210,5 +210,5 @@
     }
 
-    psErrorVStackPrint(fd, fmt, ap);
+    psErrorStackPrintV(fd, fmt, ap);
 
     if (fmt != NULL) {
@@ -217,5 +217,5 @@
 }
 
-void psErrorVStackPrint(FILE *fd,	// write to this file descriptor
+void psErrorStackPrintV(FILE *fd,	// write to this file descriptor
 			const char *fmt,// format for any header information; may be NULL
 			va_list ap)	// arguments for format
Index: trunk/archive/pslib/src/Utils/logmsg.c
===================================================================
--- trunk/archive/pslib/src/Utils/logmsg.c	(revision 709)
+++ trunk/archive/pslib/src/Utils/logmsg.c	(revision 753)
@@ -110,5 +110,5 @@
 #endif
 
-void p_psLogVMsg(const char *name, int level, const char *fmt, va_list ap)
+void psLogMsgV(const char *name, int level, const char *fmt, va_list ap)
 {
     static int first = 1;
@@ -224,5 +224,5 @@
     va_start(ap, fmt);
 
-    p_psLogVMsg(name, level, fmt, ap);
+    psLogVMsg(name, level, fmt, ap);
     va_end(ap);
 }
Index: trunk/archive/pslib/src/Utils/memory.c
===================================================================
--- trunk/archive/pslib/src/Utils/memory.c	(revision 709)
+++ trunk/archive/pslib/src/Utils/memory.c	(revision 753)
@@ -48,15 +48,15 @@
  * First the I-can't-get-the-memory callback
  */
-static void *memExhaustedCB0(size_t size)
+static void *memExhaustedCallback0(size_t size)
 {
     return NULL;
 }
-static psMemExhaustedCB memExhaustedCB = memExhaustedCB0;
-
-psMemExhaustedCB psMemExhaustedCBSet(psMemExhaustedCB func)
-{
-    psMemExhaustedCB old = memExhaustedCB;
-
-    memExhaustedCB = (func != NULL) ? func : memExhaustedCB0;
+static psMemExhaustedCallback memExhaustedCallback = memExhaustedCallback0;
+
+psMemExhaustedCallback psMemExhaustedCallbackSet(psMemExhaustedCallback func)
+{
+    psMemExhaustedCallback old = memExhaustedCallback;
+
+    memExhaustedCallback = (func != NULL) ? func : memExhaustedCallback0;
 
     return old;
@@ -65,5 +65,5 @@
  * then the I-have-detected-a-problem callback
  */
-static void memProblemCB0(const psMemBlock *ptr,
+static void memProblemCallback0(const psMemBlock *ptr,
 			  const char *file, int lineno)
 {
@@ -76,9 +76,9 @@
 	fprintf(stderr, "\n");
     } else if (ptr->refCounter <= 0) {
-	psError(__func__, PS_ERR_BADFREE, PS_NEW_ERROR,
+	psError(__func__, PS_ERR_BADFREE, 1,
 		"Block %ld allocated at %s:%d freed more than once at %s:%d\n",
 		ptr->id, ptr->file, ptr->lineno, file, lineno);
     } else if (ptr->refCounter > 1) {
-	psError(__func__,  PS_ERR_BADFREE, PS_NEW_ERROR,
+	psError(__func__,  PS_ERR_BADFREE, 1,
 		"Block %ld allocated at %s:%d freed while still referenced at %s:%d\n",
 		ptr->id, ptr->file, ptr->lineno, file, lineno);
@@ -89,11 +89,11 @@
     }
 }
-static psMemProblemCB memProblemCB = memProblemCB0;
-
-psMemProblemCB psMemProblemCBSet(psMemProblemCB func)
-{
-    psMemProblemCB old = memProblemCB;
-
-    memProblemCB = (func != NULL) ? func : memProblemCB0;
+static psMemProblemCallback memProblemCallback = memProblemCallback0;
+
+psMemProblemCallback psMemProblemCallbackSet(psMemProblemCallback func)
+{
+    psMemProblemCallback old = memProblemCallback;
+
+    memProblemCallback = (func != NULL) ? func : memProblemCallback0;
 
     return old;
@@ -129,5 +129,5 @@
  * isn't resignalled)
  */
-static long memAllocateCB0(const psMemBlock *ptr)
+static long memAllocateCallback0(const psMemBlock *ptr)
 {
     static int incr = 0;		// "p_psMemAllocateID += incr"
@@ -138,5 +138,5 @@
 }
 
-static long memFreeCB0(const psMemBlock *ptr)
+static long memFreeCallback0(const psMemBlock *ptr)
 {
     static int incr = 0;		// "p_psMemFreeID += incr"
@@ -150,21 +150,21 @@
  * The default callbacks, and the routines to change them
  */
-static psMemAllocateCB memAllocateCB = memAllocateCB0;
-static psMemFreeCB memFreeCB = memFreeCB0;
-
-psMemAllocateCB psMemAllocateCBSet(psMemAllocateCB func)
-{
-    psMemAllocateCB old = memAllocateCB;
-
-    memAllocateCB = (func != NULL) ? func : memAllocateCB0;
-
-    return old;
-}
-
-psMemFreeCB psMemFreeCBSet(psMemFreeCB func)
-{
-    psMemFreeCB old = memFreeCB;
-
-    memFreeCB = (func != NULL) ? func : memFreeCB0;
+static psMemAllocateCallback memAllocateCallback = memAllocateCallback0;
+static psMemFreeCallback memFreeCallback = memFreeCallback0;
+
+psMemAllocateCallback psMemAllocateCallbackSet(psMemAllocateCallback func)
+{
+    psMemAllocateCallback old = memAllocateCallback;
+
+    memAllocateCallback = (func != NULL) ? func : memAllocateCallback0;
+
+    return old;
+}
+
+psMemFreeCallback psMemFreeCallbackSet(psMemFreeCallback func)
+{
+    psMemFreeCallback old = memFreeCallback;
+
+    memFreeCallback = (func != NULL) ? func : memFreeCallback0;
 
     return old;
@@ -194,5 +194,5 @@
     if (m == NULL) {
 	if (!quiet) {
-	    psError(__func__,  PS_ERR_MEMORY_CORRUPTION, PS_NEW_ERROR,
+	    psError(__func__,  PS_ERR_MEMORY_CORRUPTION, 1,
 		    "psMemCheckCorruption: NULL memory block\n");
 	}
@@ -202,5 +202,5 @@
     if (!ALIGNED(m)) {
 	if (!quiet) {
-	    psError(__func__,  PS_ERR_MEMORY_CORRUPTION, PS_NEW_ERROR,
+	    psError(__func__,  PS_ERR_MEMORY_CORRUPTION, 1,
 		    "psMemCheckCorruption: non-aligned memory block\n");
 	}
@@ -210,5 +210,5 @@
     if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) {
 	if (!quiet) {
-	    psError(__func__, PS_ERR_MEMORY_CORRUPTION, PS_NEW_ERROR,
+	    psError(__func__, PS_ERR_MEMORY_CORRUPTION, 1,
 		    "psMemCheckCorruption: memory block %ld is corrupted\n", m->id);
 	}
@@ -232,5 +232,5 @@
 		nbad++;
 
-		memProblemCB(memBlocks[i], "(psMemCheckCorruption)", 0);
+		memProblemCallback(memBlocks[i], "(psMemCheckCorruption)", 0);
 		
 		if (abort_on_error) {
@@ -251,5 +251,5 @@
 
     if (ptr == NULL) {
-	ptr = memExhaustedCB(size);
+	ptr = memExhaustedCallback(size);
 	if (ptr == NULL) {
 	    psAbort(__func__, "Failed to allocate %ld bytes at %s:%d",
@@ -270,5 +270,5 @@
     
     if (ptr->id == p_psMemAllocateID && p_psMemAllocateID > 0) {
-	p_psMemAllocateID += memAllocateCB(ptr);	
+	p_psMemAllocateID += memAllocateCallback(ptr);	
     }
     /*
@@ -310,12 +310,12 @@
      */
     if (ptr->id == p_psMemFreeID && p_psMemFreeID > 0) {
-	p_psMemFreeID += memFreeCB(ptr);	
+	p_psMemFreeID += memFreeCallback(ptr);	
     }
 
     if (bad_memblock(ptr, 0)) {
-	memProblemCB(ptr, file, lineno); // we may not own this block; don't free it
+	memProblemCallback(ptr, file, lineno); // we may not own this block; don't free it
     } else {
 	if (ptr->refCounter != 1) {
-	    memProblemCB(ptr, file, lineno);
+	    memProblemCallback(ptr, file, lineno);
 	}
 	ptr->refCounter--;
@@ -396,5 +396,5 @@
 
     if (bad_memblock(ptr, 0)) {
-	memProblemCB(ptr, "(psMemGetRefCounter)", -1);
+	memProblemCallback(ptr, "(psMemGetRefCounter)", -1);
     }
 
@@ -411,5 +411,5 @@
 
     if (bad_memblock(ptr, 0)) {
-	memProblemCB(ptr, "(psMemIncrRefCounter)", -1);
+	memProblemCallback(ptr, "(psMemIncrRefCounter)", -1);
     }
 
@@ -428,5 +428,5 @@
 
     if (bad_memblock(ptr, 0)) {
-	memProblemCB(ptr, "(psMemDecrRefCounter)", -1);
+	memProblemCallback(ptr, "(psMemDecrRefCounter)", -1);
     }
 
Index: trunk/archive/pslib/src/Utils/misc.c
===================================================================
--- trunk/archive/pslib/src/Utils/misc.c	(revision 709)
+++ trunk/archive/pslib/src/Utils/misc.c	(revision 753)
@@ -29,5 +29,5 @@
 
     va_start(ap, fmt);
-    p_psLogVMsg(name, PS_LOG_ABORT, fmt, ap);
+    psLogMsgV(name, PS_LOG_ABORT, fmt, ap);
     va_end(ap);
     
Index: trunk/archive/pslib/src/Utils/vector.c
===================================================================
--- trunk/archive/pslib/src/Utils/vector.c	(revision 709)
+++ trunk/archive/pslib/src/Utils/vector.c	(revision 753)
@@ -16,5 +16,5 @@
 
    *(int *)&vec->n = *(int *)&vec->nalloc = nalloc;
-   vec->arr.arr_v = psAlloc(nalloc*sizeof(void **));
+   vec->data.V = psAlloc(nalloc*sizeof(void **));
 
    return vec;
@@ -34,12 +34,12 @@
 
    if (elemFree != NULL && vec->nalloc > 0) {
-      assert (vec->arr.arr != NULL);	/* choose any member of the union */
+      assert (vec->data.V != NULL);	/* choose any member of the union */
       const int n = vec->nalloc;
       for (int i = 0; i < n; i++) {
-	 elemFree(vec->arr.arr_v[i]);
+	 elemFree(vec->data.V[i]);
       }
    }
 
-   psFree(vec->arr.arr_v);
+   psFree(vec->data.V);
    psFree(vec);
 }