Index: /trunk/archive/pslib/include/psStdArrays.h
===================================================================
--- /trunk/archive/pslib/include/psStdArrays.h	(revision 372)
+++ /trunk/archive/pslib/include/psStdArrays.h	(revision 373)
@@ -74,5 +74,5 @@
 typedef struct {
     psType type;			///< Type of data.  THIS STRUCT ELEMENT MUST BE FIRST IN THE STRUCT!
-    int size;				///< Total number of elements available
+    int nalloc;				///< Total number of elements available
     int n;				///< Number of elements in use
     float *arr;				///< The array data
@@ -80,14 +80,15 @@
 
 /** Constructor \ingroup DataGroup */
-psFloatArray *psFloatArrayAlloc(int s,	///< Total number of elements to make available
-				int n	///< Number of elements that will be used
-    );
+psFloatArray *psFloatArrayAlloc(int nalloc)	///< Total number of elements to make available
+;
+
 /** Reallocator \ingroup DataGroup */
 psFloatArray *psFloatArrayRealloc(psFloatArray *myArray, ///< Array to reallocate
-				  int s	///< Total number of elements to make available
-    );
-/** Destructor \ingroup DataGroup */
-void psFloatArrayFree(psFloatArray *restrict myArray ///< Array to free
-    );
+				  int nalloc) ///< Total number of elements to make available
+;
+
+/** Destructor \ingroup DataGroup */
+void psFloatArrayFree(psFloatArray *restrict myArray) ///< Array to free
+;
 
 /************************************************************************************************************/
@@ -95,12 +96,12 @@
 /** Define a vector as an array of real numbers */
 typedef psFloatArray psVector;
-#define psVectorAlloc(S,N) psFloatArrayAlloc(S,N) ///< Constructor
-#define psVectorRealloc(A,S) psFloatArrayRealloc(A,S) ///< Reallocator
+#define psVectorAlloc(N) psFloatArrayAlloc(N) ///< Constructor
+#define psVectorRealloc(A,N) psFloatArrayRealloc(A,N) ///< Reallocator
 #define psVectorFree(A) psFloatArrayFree(A) ///< Destructor
 
 /** Transpose a vector.  Changes the type to a PS_DIMEN_TRANSV */
 psVector *psVectorTranspose(psVector *out, ///< Output vector, or NULL
-			    psVector *myVector ///< Vector to be transposed
-    );
+			    psVector *myVector) ///< Vector to be transposed
+;
 
 /************************************************************************************************************/
@@ -109,5 +110,5 @@
 typedef struct {
     psType type;			///< Type of data.  THIS STRUCT ELEMENT MUST BE FIRST IN THE STRUCT!
-    int size;				///< Total number of elements available
+    int nalloc;				///< Total number of elements available
     int n;				///< Number of elements in use
     complex float *arr;			///< The array data
@@ -115,14 +116,15 @@
 
 /** Constructor \ingroup DataGroup */
-psComplexArray *psComplexArrayAlloc(int s, ///< Total number of elements to make available
-				    int n	///< Number of elements that will be used
-    );
+psComplexArray *psComplexArrayAlloc(int nalloc) ///< Total number of elements to make available
+;
+
 /** Reallocator \ingroup DataGroup */
 psComplexArray *psComplexArrayRealloc(psComplexArray *myArray, ///< Array to reallocate
-				      int s	///< Total number of elements to make available
-    );
-/** Destructor \ingroup DataGroup */
-void psComplexArrayFree(psComplexArray *restrict myArray ///< Array to free
-    );
+				      int nalloc)	///< Total number of elements to make available
+;
+
+/** Destructor \ingroup DataGroup */
+void psComplexArrayFree(psComplexArray *restrict myArray) ///< Array to free
+;
 
 /************************************************************************************************************/
@@ -131,5 +133,5 @@
 typedef struct {
     psType type;			///< Type of data.  THIS STRUCT ELEMENT MUST BE FIRST IN THE STRUCT!
-    int size;				///< Total number of elements available
+    int nalloc;				///< Total number of elements available
     int n;				///< Number of elements in use
     int *arr;				///< The array data
@@ -137,14 +139,15 @@
 
 /** Constructor \ingroup DataGroup */
-psIntArray *psIntArrayAlloc(int s,	///< Total number of elements to make available
-			    int n	///< Number of elements that will be used
-    );
+psIntArray *psIntArrayAlloc(int nalloc)	///< Total number of elements to make available
+;
+
 /** Reallocator \ingroup DataGroup */
 psIntArray *psIntArrayRealloc(psIntArray *myArray, ///< Array to reallocate
-			      int s	///< Total number of elements to make available
-    );
-/** Destructor \ingroup DataGroup */
-void psIntArrayFree(psIntArray *restrict myArray ///< Array to free
-    );
+			      int nalloc)	///< Total number of elements to make available
+;
+
+/** Destructor \ingroup DataGroup */
+void psIntArrayFree(psIntArray *restrict myArray) ///< Array to free
+;
 
 /************************************************************************************************************/
@@ -153,5 +156,5 @@
 typedef struct {
     psType type;			///< Type of data.  THIS STRUCT ELEMENT MUST BE FIRST IN THE STRUCT!
-    int size;				///< Total number of elements available
+    int nalloc;				///< Total number of elements available
     int n;				///< Number of elements in use
     double *arr;			///< The array data
@@ -159,14 +162,15 @@
 
 /** Constructor \ingroup DataGroup */
-psDoubleArray *psDoubleArrayAlloc(int s, ///< Total number of elements to make available
-				  int n	///< Number of elements that will be used
-    );
+psDoubleArray *psDoubleArrayAlloc(int nalloc) ///< Total number of elements to make available
+;
+
 /** Reallocator \ingroup DataGroup */
 psDoubleArray *psDoubleArrayRealloc(psDoubleArray *myArray, ///< Array to reallocate
-				    int s	///< Total number of elements to make available
-    );
-/** Destructor \ingroup DataGroup */
-void psDoubleArrayFree(psDoubleArray *restrict myArray ///< Array to free
-    );
+				    int nalloc)	///< Total number of elements to make available
+;
+
+/** Destructor \ingroup DataGroup */
+void psDoubleArrayFree(psDoubleArray *restrict myArray) ///< Array to free
+;
 
 /************************************************************************************************************/
@@ -175,5 +179,5 @@
 typedef struct {
     psType type;			///< Type of data.  THIS STRUCT ELEMENT MUST BE FIRST IN THE STRUCT!
-    int size;				///< Total number of elements available
+    int nalloc;				///< Total number of elements available
     int n;				///< Number of elements in use
     psFloatArray *arr;			///< The array data
@@ -181,14 +185,15 @@
 
 /** Constructor \ingroup DataGroup */
-psVectorArray *psVectorArrayAlloc(int s, ///< Total number of elements to make available
-				  int n	///< Number of elements that will be used
-    );
-/** Reallocator \ingroup DataGroup */
-psVectorArray *psVectorArrayRealloc(psVectorArray *myArray, ///< Array to reallocate
-				    int s	///< Total number of elements to make available
-    );
-/** Destructor \ingroup DataGroup */
-void psVectorArrayFree(psVectorArray *restrict myArray ///< Array to free
-    );
+psVectorArray *psVectorArrayAlloc(int nalloc) ///< Total number of elements to make available
+;
+
+/** Reallocator \ingroup DataGroup */
+psVectorArray *psVectorArrayRealloc(psVectorArray *myArray ///< Array to reallocate
+				    int nalloc)	///< Total number of elements to make available
+;
+
+/** Destructor \ingroup DataGroup */
+void psVectorArrayFree(psVectorArray *restrict myArray) ///< Array to free
+;
 
 /************************************************************************************************************/
@@ -201,21 +206,21 @@
 typedef struct {
     int n;				///< Number of elements in use 
-    int size;				///< Number of total elements
+    int nalloc;				///< Number of total elements
     void **arr;				///< The elements
 } psVoidPtrArray;
 
 /** Constructor \ingroup DataGroup */
-psVoidPtrArray *psVoidPtrArrayAlloc(int n, ///< Number of elements to use
-				    int s ///< Total number of elements
-				    );
+psVoidPtrArray *psVoidPtrArrayAlloc(int nalloc) ///< Number of elements to use
+;
+
 /** Reallocate \ingroup DataGroup */
 psVoidPtrArray *psVoidPtrArrayRealloc(psVoidPtrArray *arr, ///< Array to reallocate
-				      int n ///< Number of elements
-				      );
+				      int nalloc) ///< Number of elements
+;
+
 /** Destructor \ingroup DataGroup */
 void psVoidPtrArrayFree(psVoidPtrArray *arr, ///< array to destroy
-			void (*elemFree)(void *) ///< destructor for array data
-			);
-
+			void (*elemFree)(void *)) ///< destructor for array data
+;
 
 #endif