Index: trunk/psLib/src/imageops/psImageBinning.c
===================================================================
--- trunk/psLib/src/imageops/psImageBinning.c	(revision 23444)
+++ trunk/psLib/src/imageops/psImageBinning.c	(revision 23486)
@@ -31,5 +31,5 @@
 }
 
-psImageBinning *psImageBinningAlloc() {
+psImageBinning *psImageBinningAlloc(void) {
     psImageBinning *binning = (psImageBinning*)psAlloc(sizeof(psImageBinning));
     psMemSetDeallocator(binning, (psFreeFunc)psImageBinningFree);
Index: trunk/psLib/src/imageops/psImageBinning.h
===================================================================
--- trunk/psLib/src/imageops/psImageBinning.h	(revision 23444)
+++ trunk/psLib/src/imageops/psImageBinning.h	(revision 23486)
@@ -42,5 +42,5 @@
 
 
-psImageBinning *psImageBinningAlloc() PS_ATTR_MALLOC;
+psImageBinning *psImageBinningAlloc(void) PS_ATTR_MALLOC;
 bool psMemCheckBinning(psPtr ptr);
 
Index: trunk/psLib/src/jpeg/psImageJpeg.c
===================================================================
--- trunk/psLib/src/jpeg/psImageJpeg.c	(revision 23444)
+++ trunk/psLib/src/jpeg/psImageJpeg.c	(revision 23486)
@@ -35,5 +35,5 @@
 }
 
-psImageJpegColormap *psImageJpegColormapAlloc ()
+psImageJpegColormap *psImageJpegColormapAlloc(void)
 {
     psImageJpegColormap *map = psAlloc(sizeof(psImageJpegColormap));
Index: trunk/psLib/src/jpeg/psImageJpeg.h
===================================================================
--- trunk/psLib/src/jpeg/psImageJpeg.h	(revision 23444)
+++ trunk/psLib/src/jpeg/psImageJpeg.h	(revision 23486)
@@ -1,5 +1,5 @@
 /* @file  psImageJpeg.h
  * @brief functions to generate JPEG images from psImage
- * 
+ *
  * @author EAM
  * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
@@ -28,5 +28,5 @@
 
 // allocate a colormap (does not define the map values)
-psImageJpegColormap *psImageJpegColormapAlloc() PS_ATTR_MALLOC;
+psImageJpegColormap *psImageJpegColormapAlloc(void) PS_ATTR_MALLOC;
 
 // set the colormap values using the supplied name
Index: trunk/psLib/src/math/psMinimizeLMM.c
===================================================================
--- trunk/psLib/src/math/psMinimizeLMM.c	(revision 23444)
+++ trunk/psLib/src/math/psMinimizeLMM.c	(revision 23486)
@@ -95,8 +95,8 @@
     // check for non-finite entries in result
     for (int i = 0; i < Beta->n; i++) {
-	if (!isfinite(Beta->data.F32[i])) {
-	    // psError(PS_ERR_BAD_PARAMETER_VALUE, 3, "Fit value diverges: vector[%d] is %.2f\n", i, Beta->data.F32[i]);
-	    return false;
-	}
+        if (!isfinite(Beta->data.F32[i])) {
+            // psError(PS_ERR_BAD_PARAMETER_VALUE, 3, "Fit value diverges: vector[%d] is %.2f\n", i, Beta->data.F32[i]);
+            return false;
+        }
     }
 
@@ -104,8 +104,8 @@
     // (we must do this before truncating Beta below)
     if (dLinear) {
-	*dLinear = psMinLM_dLinear(Beta, beta, lambda);
-    }
-
-    // full-length Beta for checkLimits functions 
+        *dLinear = psMinLM_dLinear(Beta, beta, lambda);
+    }
+
+    // full-length Beta for checkLimits functions
     psVector *tmpBeta = psVectorAlloc(params->n, PS_TYPE_F32);
     psVectorInit (tmpBeta, 0.0);
@@ -113,7 +113,7 @@
     // set tmpBeta values which are not masked
     for (int j = 0, n = 0; j < params->n; j++) {
-	if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
-	tmpBeta->data.F32[j] = Beta->data.F32[n];
-	n++;
+        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
+        tmpBeta->data.F32[j] = Beta->data.F32[n];
+        n++;
     }
 
@@ -127,5 +127,5 @@
         if (checkLimits) {
             checkLimits (PS_MINIMIZE_BETA_LIMIT, j, Params->data.F32, tmpBeta->data.F32);
-	}
+        }
 
         Params->data.F32[j] = params->data.F32[j] - tmpBeta->data.F32[j];
@@ -135,12 +135,12 @@
             checkLimits (PS_MINIMIZE_PARAM_MIN,  j, Params->data.F32, tmpBeta->data.F32);
             checkLimits (PS_MINIMIZE_PARAM_MAX,  j, Params->data.F32, tmpBeta->data.F32);
-	}
+        }
     }
 
     // apply tmpBeta after limits have been checked
     for (int j = 0, n = 0; j < params->n; j++) {
-	if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
-	Beta->data.F32[n] = tmpBeta->data.F32[j];
-	n++;
+        if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
+        Beta->data.F32[n] = tmpBeta->data.F32[j];
+        n++;
     }
 
@@ -169,5 +169,5 @@
     // if none are available, return false
     if (!psMinLM_AllocAB (&Alpha, &Beta, params, paramMask)) {
-	return false;
+        return false;
     }
 
@@ -241,7 +241,7 @@
     // beta only counts unmasked parameters
     for (int i = 0; i < beta->n; i++) {
-	dh = lambda*B[i] + b[i];
-	sh = 0.5*B[i]*dh;
-	Sh += sh;
+        dh = lambda*B[i] + b[i];
+        sh = 0.5*B[i]*dh;
+        Sh += sh;
         dLinear += lambda*PS_SQR(B[i]) + B[i]*b[i];
     }
@@ -295,5 +295,5 @@
         assert (!isnan(chisq));
 
-	// we track alpha,beta and params,deriv separately
+        // we track alpha,beta and params,deriv separately
         for (int j = 0, J = 0; j < params->n; j++) {
             if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) continue;
@@ -304,8 +304,8 @@
                 if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
                 alpha->data.F32[J][K] += weight * deriv->data.F32[k];
-		K++;
+                K++;
             }
             beta->data.F32[J] += weight * delta;
-	    J++;
+            J++;
         }
     }
@@ -328,5 +328,5 @@
 between that function at the specified coords and the specified value at those
 coords.
- 
+
 This requires F32 input data; all internal calls use F32.
 XXX Make an F64 version?
@@ -386,7 +386,7 @@
     // Alpha & Beta only contain elements to represent the unmasked parameters
     if (!psMinLM_AllocAB (&Alpha, &Beta, params, paramMask)) {
-	psAbort ("programming error: no unmasked parameters to be fit\n");
-    }
-    
+        psAbort ("programming error: no unmasked parameters to be fit\n");
+    }
+
     psImage *alpha   = psImageAlloc(Alpha->numCols, Alpha->numRows, PS_TYPE_F32);
     psVector *beta   = psVectorAlloc(Beta->n, PS_TYPE_F32);
@@ -490,18 +490,18 @@
             psTrace ("psLib.math", 5, "failure to calculate covariance matrix\n");
         }
-	// set covar values which are not masked
-	psImageInit (covar, 0.0);
-	for (int j = 0, J = 0; j < params->n; j++) {
-	    if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
-		covar->data.F32[j][j] = 1.0;
-		continue;
-	    }
-	    for (int k = 0, K = 0; k < params->n; k++) {
-		if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
-		covar->data.F32[j][k] = Alpha->data.F32[J][K];
-		K++;
-	    }
-	    J++;
-	}
+        // set covar values which are not masked
+        psImageInit (covar, 0.0);
+        for (int j = 0, J = 0; j < params->n; j++) {
+            if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[j])) {
+                covar->data.F32[j][j] = 1.0;
+                continue;
+            }
+            for (int k = 0, K = 0; k < params->n; k++) {
+                if (paramMask && (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[k])) continue;
+                covar->data.F32[j][k] = Alpha->data.F32[J][K];
+                K++;
+            }
+            J++;
+        }
     }
 
@@ -533,13 +533,13 @@
     // count unmasked parameters
     if (paramMask) {
-	nParams = 0;
-	for (int i = 0; i < paramMask->n; i++) {
-	    if (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
-	    nParams ++;
-	}
-    }
-
-    if (nParams == 0) { 
-	return false;
+        nParams = 0;
+        for (int i = 0; i < paramMask->n; i++) {
+            if (paramMask->data.PS_TYPE_VECTOR_MASK_DATA[i]) continue;
+            nParams ++;
+        }
+    }
+
+    if (nParams == 0) {
+        return false;
     }
 
@@ -585,5 +585,5 @@
 }
 
-psMinConstraint* psMinConstraintAlloc()
+psMinConstraint* psMinConstraintAlloc(void)
 {
     psMinConstraint *tmp = psAlloc(sizeof(psMinConstraint));
Index: trunk/psLib/src/math/psMinimizeLMM.h
===================================================================
--- trunk/psLib/src/math/psMinimizeLMM.h	(revision 23444)
+++ trunk/psLib/src/math/psMinimizeLMM.h	(revision 23486)
@@ -94,5 +94,5 @@
 psMinConstraint;
 
-psMinConstraint *psMinConstraintAlloc() PS_ATTR_MALLOC;
+psMinConstraint *psMinConstraintAlloc(void) PS_ATTR_MALLOC;
 
 /** Allocates a psMinimization structure.
@@ -174,5 +174,5 @@
     psF32 lambda);
 
-// allocate alpha and beta for unmasked parameters only 
+// allocate alpha and beta for unmasked parameters only
 bool psMinLM_AllocAB (psImage **Alpha, psVector **Beta, const psVector *params, const psVector *paramMask);
 
Index: trunk/psLib/src/math/psSpline.c
===================================================================
--- trunk/psLib/src/math/psSpline.c	(revision 23444)
+++ trunk/psLib/src/math/psSpline.c	(revision 23486)
@@ -103,16 +103,16 @@
 tabulated function at n points, this routine calculates the second
 derivatives of the interpolating cubic splines at those n points.
- 
+
 The first and second derivatives at the endpoints were previously undefined in
 the SDR.  From bugzilla #???, they are required to be 0.0, implementing natural
 splines.
- 
+
 Endpoints are defined by
     PS_LEFT_SPLINE_DERIV
     PS_RIGHT_SPLINE_DERIV
- 
+
 This routine assumes that vectors x and y are of the appropriate types/sizes
 (F32).
- 
+
 XXX: use recycled vectors for internal data.
 XXX: do an F64 version?
@@ -177,5 +177,5 @@
 }
 
-psSpline1D *psSpline1DAlloc()
+psSpline1D *psSpline1DAlloc(void)
 {
     psSpline1D *tmpSpline = (psSpline1D *) psAlloc(sizeof(psSpline1D));
@@ -192,5 +192,5 @@
 psVectorFitSpline1D(): given a set of x/y vectors, this routine generates the
 linear or cublic splines which satisfy those data points.
- 
+
 The formula for calculating the spline polynomials is derived from Numerical
 Recipes in C.  The basic idea is that the polynomial is
@@ -206,5 +206,5 @@
 into a polynomial in terms of x, and then saving the coefficients of the
 powers of x in the spline polynomials.  This gets pretty complicated.
- 
+
 XXX: What types must be supported?
  *****************************************************************************/
@@ -354,8 +354,8 @@
 (vectorBinDisectF32()).  Then it evaluates the spline at that x location
 by a call to the 1D polynomial functions.
- 
+
 XXX: The spline eval functions require input and output to be F32.  however
      the spline fit functions require F32 and F64.
- 
+
 XXX: This only works if spline->knots if psF32.  Must we add support for psU32 and
 psF64?
Index: trunk/psLib/src/math/psSpline.h
===================================================================
--- trunk/psLib/src/math/psSpline.h	(revision 23444)
+++ trunk/psLib/src/math/psSpline.h	(revision 23486)
@@ -46,5 +46,5 @@
  *  @return psSpline1D*    new 1-D spline struct
  */
-psSpline1D *psSpline1DAlloc() PS_ATTR_MALLOC;
+psSpline1D *psSpline1DAlloc(void) PS_ATTR_MALLOC;
 
 /** Evaluates 1-D spline polynomials at a specific coordinate.
Index: trunk/psLib/src/sys/psError.c
===================================================================
--- trunk/psLib/src/sys/psError.c	(revision 23444)
+++ trunk/psLib/src/sys/psError.c	(revision 23486)
@@ -146,10 +146,10 @@
 
 psErrorCode p_psErrorV(const char* filename,
-		       unsigned int lineno,
-		       const char* func,
-		       psErrorCode code,
-		       bool new,
-		       const char* format,
-		       va_list ap)
+                       unsigned int lineno,
+                       const char* func,
+                       psErrorCode code,
+                       bool new,
+                       const char* format,
+                       va_list ap)
 {
   char errMsg[MAX_STRING_LENGTH];
@@ -245,5 +245,5 @@
 }
 
-long psErrorGetStackSize()
+long psErrorGetStackSize(void)
 {
     psArray *errorStack = psErrorStackGet();
Index: trunk/psLib/src/sys/psError.h
===================================================================
--- trunk/psLib/src/sys/psError.h	(revision 23444)
+++ trunk/psLib/src/sys/psError.h	(revision 23486)
@@ -87,5 +87,5 @@
  *  @return int The number of items on the error stack
  */
-long psErrorGetStackSize();
+long psErrorGetStackSize(void);
 
 
Index: trunk/psLib/src/sys/psLogMsg.c
===================================================================
--- trunk/psLib/src/sys/psLogMsg.c	(revision 23444)
+++ trunk/psLib/src/sys/psLogMsg.c	(revision 23486)
@@ -76,5 +76,5 @@
 }
 
-int psLogGetLevel()
+int psLogGetLevel(void)
 {
     return globalLogLevel;
Index: trunk/psLib/src/sys/psLogMsg.h
===================================================================
--- trunk/psLib/src/sys/psLogMsg.h	(revision 23444)
+++ trunk/psLib/src/sys/psLogMsg.h	(revision 23486)
@@ -63,5 +63,5 @@
  *  @return int:        The current file descriptor.
  */
-int psLogGetDestination();
+int psLogGetDestination(void);
 
 
@@ -83,5 +83,5 @@
  *  @return int:        The current logging level.
  */
-int psLogGetLevel();
+int psLogGetLevel(void);
 
 /** This procedure sets the log format for future log messages.  The argument