Merge pull request #418 from gruenich/feature/c-23

Make compatible with C23

Author: rjonaitis

src/GFIR/corrections.c

@@ -26,8 +26,7 @@
 /* ************************************************************ */
 /* Inverse sinc function to correct DAC sinc envelope 		*/
 /* ************************************************************ */
-double InvSinc(x)
-double x;
+double InvSinc(double x)
 {
 	if(fpclassify(x) == FP_ZERO) return(1.0);
 	return(fabs((M_PI*x)/(sin(M_PI*x) + DELTA)));
@@ -36,8 +35,7 @@ double x;
 /* ************************************************************ */
 /* Invsinc function shifted into lower frequency stage.		*/
 /* ************************************************************ */
-double InvSincS(x, k, x0)
-double x, k, x0;
+double InvSincS(double x, double k, double x0)
 {
 	double xin;
 
@@ -49,8 +47,7 @@ double x, k, x0;
 /* ************************************************************ */
 /* Unity function, no correction is envolved.			*/
 /* ************************************************************ */
-double One(x)
-double x;
+double One(double x)
 {
 	return(1.0);
-}
+}

src/GFIR/dfilter.h

@@ -21,4 +21,4 @@ struct dfilter {
 	double phase[POINTS];
 	double logamp[POINTS];		/* Amplitude in log scale */
 	double max;			/* Maximum of amplitude */
-};
+};

src/GFIR/gfir_lms.c

@@ -21,13 +21,12 @@
 #define CSDPREC		16	/* CSD Coefficients precision */
 
 /* *********************************************************************** */
-int gfir_lms(hr, hi, hcsd, n, w1, w2, a1, a2, cprec, csdprec, correction)
-  struct dfilter *hr, *hi, *hcsd;
-int n;
-double w1, w2, a1, a2;
-int cprec;
-int csdprec;
-double (*correction)();
+int gfir_lms(struct dfilter *hr, struct dfilter *hi, struct dfilter *hcsd,
+             int n,
+             double w1, double w2, double a1, double a2,
+             int cprec,
+             int csdprec,
+             double (*correction)(double x))
 {
   double *weights, *desired, *w;
   int i, points;

src/GFIR/lms.c

@@ -24,9 +24,9 @@
 #define ODD     1
 
 /* Declare functions from Numerical Recipes that are used here */
-double  *vector();
-int  *ivector();
-double  **matrix();
+double  *vector(int nl, int nh);
+int  *ivector(int nl, int nh);
+double  **matrix(int nrl, int nrh, int ncl, int nch);
 
 /* ************************************************************************ 
  *  Trigonometric functions for CASE1, CASE2, CASE3 and CASE4 filters
@@ -78,18 +78,10 @@ double Case4F(double w, int i)
  *	0			- if everything is OK
  *	-1			- otherwise
  * ************************************************************************ */
-int lms(hr, hi, hcsd, n, w, des, weight, p, cprec, csdprec, symmetry,
-	bincode, csdcode, csdcoder)
-double *hr, *hi, *hcsd;
-int n;
-double *w;
-double *des;
-double *weight;
-int p;
-int cprec;
-int csdprec;
-int symmetry;
-int **bincode, **csdcode, **csdcoder;
+int lms(double *hr, double *hi, double *hcsd,
+        int n, double *w, double *des, double *weight,
+        int p, int cprec, int csdprec, int symmetry,
+        int **bincode, int **csdcode, int **csdcoder)
 {
 
 	/* All this is for  solving a linear system */
@@ -100,7 +92,7 @@ int **bincode, **csdcode, **csdcoder;
 	/* Parameters of real function Hr(w) */
 	double *a; 		/* Coefficients */
 	int L;			/* Number of terms in Hr(w) sum */
-	double (*f)();		/* Trigonometric function in Hr(w) */
+	double (*f)(double w, int i);		/* Trigonometric function in Hr(w) */
 
 	int parity;		/* Parity of the filter (ODD or EVEN) */
 	int i, j, k;		/* Loop counters */

src/GFIR/lms.h

@@ -21,9 +21,9 @@
 #define LMS_POINTS 4000
 
 /* Amplitude correction functions */
-double InvSinc();
-double InvSincS();
-double One();
+double InvSinc(double x);
+double InvSincS(double x);
+double One(double x);
 
 /* Amplitude correction functions we can support */
 #define NONE		One		/* Constant */

src/GFIR/recipes.c

@@ -57,8 +57,7 @@ void nrerror(char * error_text);
 /*****************************************************/
 /*** Allocates a double vector with range [nl..nh]. ***/
 /*****************************************************/
-double  *vector(nl,nh)
-int    nl,nh;
+double  *vector(int nl, int nh)
 {
 	double *v;
 
@@ -70,8 +69,7 @@ int    nl,nh;
 /*****************************************************/
 /*** Allocates an int vector with range [nl..nh].  ***/
 /*****************************************************/
-int  *ivector(nl,nh)
-int  nl,nh;
+int  *ivector(int nl, int nh)
 {
 	int *v;
 
@@ -83,19 +81,15 @@ int  nl,nh;
 /****************************************************/
 /*** Frees a double vector allocated by vector().  ***/
 /****************************************************/
-void free_vector(v,nl,nh)
-double *v;
-int   nl,nh;
+void free_vector(double *v, int nl, int nh)
 {
 	free((char*) (v+nl));
 }
 
 /****************************************************/
 /*** Frees an int vector allocated by ivector().  ***/
 /****************************************************/
-void free_ivector(v,nl,nh)
-int *v;
-int   nl,nh;
+void free_ivector(int *v, int nl, int nh)
 {
 	free((char*) (v+nl));
 }
@@ -104,8 +98,7 @@ int   nl,nh;
 /****  Allocates a double matrix with    ****/
 /****  range [nrl..nrh] [ncl..nch].     ****/
 /*******************************************/
-double  **matrix(nrl,nrh,ncl,nch)
-int  nrl,nrh,ncl,nch;
+double  **matrix(int nrl, int nrh, int ncl, int nch)
 {
 	int    i;
 	double  **m;
@@ -129,9 +122,7 @@ int  nrl,nrh,ncl,nch;
 /****   Frees a matrix allocated by ... ***/
 /****   matrix().                       ***/
 /******************************************/
-void free_matrix(m,nrl,nrh,ncl,nch)
-double **m;
-int   nrl,nrh,ncl,nch;
+void free_matrix(double **m, int nrl, int nrh, int ncl, int nch)
 {
 	int i;
 
@@ -142,11 +133,8 @@ int   nrl,nrh,ncl,nch;
 /*************************************************/
 /*** Numerical Recipes standard error handler. ***/
 /*************************************************/
-void nrerror(error_text)
-char error_text[];
+void nrerror(char error_text[])
 {
-	void exit();
-
 	fprintf(stderr,"Numerical Recipes run-time error...\n");
 	fprintf(stderr,"%s\n",error_text);
 	fprintf(stderr,"Forced to exit.\n");
@@ -160,14 +148,11 @@ char error_text[];
 /*	indx[1:n]		temporary storage,			*/
 /*	d			temporary storage.			*/
 /* ******************************************************************** */
-int ludcmp(a,n,indx,d)
-int n, *indx;
-double **a,*d;
+int ludcmp(double **a, int n, int *indx, double *d)
 {
 	int i,imax,j,k;
 	double big,dum,sum,temp;
-	double *vv,*vector();
-	void free_vector();
+	double *vv;
 
 	imax = 0; 
 
@@ -223,9 +208,7 @@ double **a,*d;
 /* ******************************************************************** */
 /* Solve system of equation						*/
 /* ******************************************************************** */
-void lubksb(a,n,indx,b)
-double **a,b[];
-int n,indx[];
+void lubksb(double **a, int n, int indx[], double b[])
 {
 	int i,ii=0,ip,j;
 	double sum;

src/GFIR/rounding.c

@@ -17,9 +17,7 @@ int csd2int(int cprec, int *code);
 
 /* ************************************************************************ 
    ************************************************************************ */
-void round2int(a, b, n, cprec)
-double *a, *b;
-int n, cprec;
+void round2int(double *a, double *b, int n, int cprec)
 {
 	int i,k;
 
@@ -32,10 +30,8 @@ int n, cprec;
 
 /* ************************************************************************ 
    ************************************************************************ */
-void round2csd(a, b, n, cprec, csdprec, bincode, csdcode, csdcoder)
-double *a, *b;
-int n, cprec, csdprec;
-int **bincode, **csdcode, **csdcoder;
+void round2csd(double *a, double *b, int n, int cprec, int csdprec,
+               int **bincode, int **csdcode, int **csdcoder)
 {
 	int i,k, ia;
 
@@ -118,8 +114,7 @@ void printcode(int ** code, int n, int cprec)
 /* ************************************************************************ 
    Print CSD code in the form of two common sub-expressions sharing 
    ************************************************************************ */
-void print_cses_code(xpx, xmx, x, n, cprec)
-int **xpx, **xmx, **x, n, cprec;
+void print_cses_code(int **xpx, int **xmx, int **x, int n, int cprec)
 {
 	int i, j;
 	int symmetry;
@@ -193,14 +188,14 @@ int **xpx, **xmx, **x, n, cprec;
 }
 
 /* ************************************************************************ 
+ * int a		Input integer to be converted into CSD code
+ * int cprec	Integer precision
+ * int csdprec	CSD precistion
+ * int *bincode	Binary code
+ * int *csdcode	CSD code
+ * int *csdcoder	CSD code rounded to 'csdprec' nonzero bits
    ************************************************************************ */
-void int2csd(a, cprec, csdprec, bincode, csdcode, csdcoder)
-int a;		/* Input integer to be converted into CSD code */
-int cprec;	/* Integer precision */
-int csdprec;	/* CSD precistion */
-int *bincode;	/* Binary code */
-int *csdcode;	/* CSD code */
-int *csdcoder;	/* CSD code rounded to 'csdprec' nonzero bits */
+void int2csd(int a, int cprec, int csdprec, int *bincode, int *csdcode, int *csdcoder)
 {
 	int i, sign, ci, ci1, nzeroes;
 
@@ -243,8 +238,7 @@ int *csdcoder;	/* CSD code rounded to 'csdprec' nonzero bits */
 
 /* ************************************************************************ 
    ************************************************************************ */
-int csd2int(cprec, code)
-int cprec, *code;
+int csd2int(int cprec, int *code)
 {
 	int i, a;
 
@@ -257,9 +251,7 @@ int cprec, *code;
 /* ************************************************************************ 
 	Extract x+x>>2 and x-x>>2 subexpressions from the CSD code
    ************************************************************************ */
-void csesh(code, n, cprec, xpx, xmx, x )
-int n, cprec;
-int **code, **xpx, **xmx, **x;
+void csesh(int **code, int n, int cprec, int **xpx, int **xmx, int **x)
 {
 	int i, k;