Fixed formatting that was messed up by the conversion uint->int.

Ensure that iodims etc are kosher.
Oaksta85 · Jan 15, 2003 · 91f5030 · 91f5030
1 parent e013a32
commit 91f5030
Show file tree

Hide file tree

Showing 93 changed files with 522 additions and 483 deletions.
diff --git a/api/api.h b/api/api.h
@@ -35,26 +35,33 @@ struct X(plan_s) {
 };
 
 /* shorthand */
-typedef struct X (plan_s) apiplan;
+typedef struct X(plan_s) apiplan;
 
 /* complex type for internal use */
 typedef R C[2];
 
-void X(extract_reim) (int sign, C *c, R **r, R **i);
-tensor *X(mktensor_rowmajor) (int rnk, const int *n,
-			      const int *niphys, const int *nophys,
-			      int is, int os);
-tensor *X(mktensor_iodims) (int rank, const X(iodim) * dims);
-const int *X(rdft2_pad) (int rnk, const int *n, const int *nembed,
-			 int inplace, int cmplx, int **nfree);
+void X(extract_reim)(int sign, C *c, R **r, R **i);
 
-printer *X(mkprinter_file) (FILE * f);
+tensor *X(mktensor_rowmajor)(int rnk, const int *n,
+			     const int *niphys, const int *nophys,
+			     int is, int os);
 
-planner *X(the_planner) (void);
-void X(configure_planner) (planner *plnr);
+tensor *X(mktensor_iodims)(int rank, const X(iodim) *dims);
+const int *X(rdft2_pad)(int rnk, const int *n, const int *nembed,
+			int inplace, int cmplx, int **nfree);
 
-void X(mapflags) (planner *, int);
+int X(many_kosherp)(int rnk, const int *n, int howmany);
+int X(guru_kosherp)(int rank, const X(iodim) *dims,
+		    int howmany_rank, const X(iodim) *howmany_dims);
 
-apiplan *X(mkapiplan) (int flags, problem *prb);
+
+printer *X(mkprinter_file)(FILE *f);
+
+planner *X(the_planner)(void);
+void X(configure_planner)(planner *plnr);
+
+void X(mapflags)(planner *, int);
+
+apiplan *X(mkapiplan)(int flags, problem *prb);
 
 #endif				/* __API_H__ */
diff --git a/api/apiplan.c b/api/apiplan.c
@@ -20,14 +20,14 @@
 
 #include "api.h"
 
-apiplan *X(mkapiplan) (int flags, problem *prb)
+apiplan *X(mkapiplan)(int flags, problem *prb)
 {
      plan *pln, *pln0;
      apiplan *p = 0;
-     planner *plnr = X(the_planner) ();
+     planner *plnr = X(the_planner)();
 
      /* map API flags into FFTW flags */
-     X(mapflags) (plnr, flags);
+     X(mapflags)(plnr, flags);
 
      /* create plan */
      plnr->planner_flags &= ~BLESSING;
@@ -44,9 +44,9 @@ apiplan *X(mkapiplan) (int flags, problem *prb)
           /* blessing protocol */
           plnr->planner_flags |= BLESSING;
           pln0 = plnr->adt->mkplan(plnr, prb);
-          X(plan_destroy_internal) (pln0);
+          X(plan_destroy_internal)(pln0);
      } else {
-          X(problem_destroy) (prb);
+          X(problem_destroy)(prb);
      }
 
      /* discard all information not necessary to reconstruct the
@@ -56,12 +56,12 @@ apiplan *X(mkapiplan) (int flags, problem *prb)
      return p;
 }
 
-void X(destroy_plan) (X(plan) p)
+void X(destroy_plan)(X(plan) p)
 {
      if (p) {
           AWAKE(p->pln, 0);
-          X(plan_destroy_internal) (p->pln);
-          X(problem_destroy) (p->prb);
-          X(ifree) (p);
+          X(plan_destroy_internal)(p->pln);
+          X(problem_destroy)(p->prb);
+          X(ifree)(p);
      }
 }
diff --git a/api/configure.c b/api/configure.c
@@ -24,10 +24,10 @@
 #include "reodft.h"
 #include "threads.h"
 
-void X(configure_planner) (planner *plnr)
+void X(configure_planner)(planner *plnr)
 {
-     X(dft_conf_standard) (plnr);
-     X(rdft_conf_standard) (plnr);
-     X(reodft_conf_standard) (plnr);
-     X(threads_conf_standard) (plnr);
+     X(dft_conf_standard)(plnr);
+     X(rdft_conf_standard)(plnr);
+     X(reodft_conf_standard)(plnr);
+     X(threads_conf_standard)(plnr);
 }
diff --git a/api/dfthelp.c b/api/dfthelp.c
@@ -25,7 +25,7 @@
    Flip real and imaginary if there the sign does not match
    FFTW's idea of what the sign should be */
 
-void X(extract_reim) (int sign, C *c, R **r, R **i)
+void X(extract_reim)(int sign, C *c, R **r, R **i)
 {
      if (sign == FFT_SIGN) {
           *r = c[0] + 0;

diff --git a/api/execute-dft-c2r.c b/api/execute-dft-c2r.c
@@ -22,7 +22,7 @@
 #include "rdft.h"
 
 /* guru interface: requires care in alignment, r - i, etcetera. */
-void X(execute_dft_c2r) (X(plan) p, R *ri, R *ii, R *out)
+void X(execute_dft_c2r)(X(plan) p, R *ri, R *ii, R *out)
 {
      plan_rdft2 *pln = (plan_rdft2 *) p->pln;
      pln->apply((plan *) pln, out, ri, ii);

diff --git a/api/execute-dft-r2c.c b/api/execute-dft-r2c.c
@@ -22,7 +22,7 @@
 #include "rdft.h"
 
 /* guru interface: requires care in alignment, r - i, etcetera. */
-void X(execute_dft_r2c) (X(plan) p, R *in, R *ro, R *io)
+void X(execute_dft_r2c)(X(plan) p, R *in, R *ro, R *io)
 {
      plan_rdft2 *pln = (plan_rdft2 *) p->pln;
      pln->apply((plan *) pln, in, ro, io);

diff --git a/api/execute-dft.c b/api/execute-dft.c
@@ -22,7 +22,7 @@
 #include "dft.h"
 
 /* guru interface: requires care in alignment, r - i, etcetera. */
-void X(execute_dft) (X(plan) p, R *ri, R *ii, R *ro, R *io)
+void X(execute_dft)(X(plan) p, R *ri, R *ii, R *ro, R *io)
 {
      plan_dft *pln = (plan_dft *) p->pln;
      pln->apply((plan *) pln, ri, ii, ro, io);

diff --git a/api/execute-r2r.c b/api/execute-r2r.c
@@ -22,7 +22,7 @@
 #include "rdft.h"
 
 /* guru interface: requires care in alignment, etcetera. */
-void X(execute_r2r) (X(plan) p, R *in, R *out)
+void X(execute_r2r)(X(plan) p, R *in, R *out)
 {
      plan_rdft *pln = (plan_rdft *) p->pln;
      pln->apply((plan *) pln, in, out);

diff --git a/api/execute.c b/api/execute.c
@@ -20,7 +20,7 @@
 
 #include "api.h"
 
-void X(execute) (X(plan) p)
+void X(execute)(X(plan) p)
 {
      plan *pln = p->pln;
      pln->adt->solve(pln, p->prb);

diff --git a/api/export-wisdom-to-file.c b/api/export-wisdom-to-file.c
@@ -20,10 +20,10 @@
 
 #include "api.h"
 
-void X(export_wisdom_to_file) (FILE * output_file)
+void X(export_wisdom_to_file)(FILE *output_file)
 {
-     printer *p = X(mkprinter_file) (output_file);
-     planner *plnr = X(the_planner) ();
+     printer *p = X(mkprinter_file)(output_file);
+     planner *plnr = X(the_planner)();
      plnr->adt->exprt(plnr, p);
-     X(printer_destroy) (p);
+     X(printer_destroy)(p);
 }
diff --git a/api/export-wisdom-to-string.c b/api/export-wisdom-to-string.c
@@ -34,7 +34,7 @@ static void putchr_cnt(printer * p_, char c)
 
 static printer *mkprinter_cnt(int *cnt)
 {
-     P_cnt *p = (P_cnt *) X(mkprinter) (sizeof(P_cnt), putchr_cnt);
+     P_cnt *p = (P_cnt *) X(mkprinter)(sizeof(P_cnt), putchr_cnt);
      p->cnt = cnt;
      *cnt = 0;
      return &p->super;
@@ -54,28 +54,28 @@ static void putchr_str(printer * p_, char c)
 
 static printer *mkprinter_str(char *s)
 {
-     P_str *p = (P_str *) X(mkprinter) (sizeof(P_str), putchr_str);
+     P_str *p = (P_str *) X(mkprinter)(sizeof(P_str), putchr_str);
      p->s = s;
      *s = 0;
      return &p->super;
 }
 
-char *X(export_wisdom_to_string) (void)
+char *X(export_wisdom_to_string)(void)
 {
      printer *p;
-     planner *plnr = X(the_planner) ();
+     planner *plnr = X(the_planner)();
      int cnt;
      char *s;
 
      p = mkprinter_cnt(&cnt);
      plnr->adt->exprt(plnr, p);
-     X(printer_destroy) (p);
+     X(printer_destroy)(p);
 
      s = (char *) NATIVE_MALLOC(sizeof(char) * (cnt + 1), OTHER);
      if (s) {
           p = mkprinter_str(s);
           plnr->adt->exprt(plnr, p);
-          X(printer_destroy) (p);
+          X(printer_destroy)(p);
      }
 
      return s;

diff --git a/api/export-wisdom.c b/api/export-wisdom.c
@@ -22,23 +22,23 @@
 
 typedef struct {
      printer super;
-     void (*absorber) (char c, void *);
+     void (*absorber)(char c, void *);
      void *data;
 } P;
 
 static void putchr_generic(printer * p_, char c)
 {
      P *p = (P *) p_;
-     (p->absorber) (c, p->data);
+     (p->absorber)(c, p->data);
 }
 
-void X(export_wisdom) (void (*absorber) (char c, void *), void *data)
+void X(export_wisdom)(void (*absorber)(char c, void *), void *data)
 {
-     P *p = (P *) X(mkprinter) (sizeof(P), putchr_generic);
-     planner *plnr = X(the_planner) ();
+     P *p = (P *) X(mkprinter)(sizeof(P), putchr_generic);
+     planner *plnr = X(the_planner)();
 
      p->absorber = absorber;
      p->data = data;
      plnr->adt->exprt(plnr, (printer *) p);
-     X(printer_destroy) ((printer *) p);
+     X(printer_destroy)((printer *) p);
 }
diff --git a/api/f77api.c b/api/f77api.c
@@ -52,10 +52,10 @@ static int *reverse_n(fint rnk, const fint *n)
      return nrev;
 }
 
-static X(iodim) * make_dims(fint rnk, const fint *n,
-                            const fint *is, const fint *os)
+static X(iodim) *make_dims(fint rnk, const fint *n,
+			   const fint *is, const fint *os)
 {
-     X(iodim) * dims;
+     X(iodim) *dims;
      fint i;
      A(FINITE_RNK(rnk));
      dims = MALLOC(sizeof(X(iodim)) * rnk, PROBLEMS);
@@ -68,87 +68,75 @@ static X(iodim) * make_dims(fint rnk, const fint *n,
 }
 
 
-void F77(execute, EXECUTE) (X(plan) * p)
+void F77(execute, EXECUTE)(X(plan) *p)
 {
-     X(execute) (*p);
+     X(execute)(*p);
 }
 
-void F77(plan_dft, PLAN_DFT) (X(plan) * p,
-                              fint *rank, const fint *n,
-                              C *in, C *out, fint *sign, fint *flags)
+void F77(plan_dft, PLAN_DFT)(X(plan) *p, fint *rank, const fint *n,
+			     C *in, C *out, fint *sign, fint *flags)
 {
      int *nrev = reverse_n(*rank, n);
-     *p = X(plan_dft) (*rank, nrev, in, out, *sign, *flags);
-     X(ifree0) (nrev);
+     *p = X(plan_dft)(*rank, nrev, in, out, *sign, *flags);
+     X(ifree0)(nrev);
 }
 
-void F77(plan_dft_1d, PLAN_DFT_1D) (X(plan) * p,
-                                    fint *n,
-                                    C *in, C *out, fint *sign,
-                                    fint *flags)
+void F77(plan_dft_1d, PLAN_DFT_1D)(X(plan) *p, fint *n, C *in, C *out,
+				   fint *sign, fint *flags)
 {
-     *p = X(plan_dft_1d) (*n, in, out, *sign, *flags);
+     *p = X(plan_dft_1d)(*n, in, out, *sign, *flags);
 }
 
-void F77(plan_dft_2d, PLAN_DFT_2D) (X(plan) * p,
-                                    fint *nx, fint *ny,
-                                    C *in, C *out, fint *sign,
-                                    fint *flags)
+void F77(plan_dft_2d, PLAN_DFT_2D)(X(plan) *p, fint *nx, fint *ny,
+				   C *in, C *out, fint *sign, fint *flags)
 {
-     *p = X(plan_dft_2d) (*ny, *nx, in, out, *sign, *flags);
+     *p = X(plan_dft_2d)(*ny, *nx, in, out, *sign, *flags);
 }
 
-void F77(plan_dft_3d, PLAN_DFT_3D) (X(plan) * p,
-                                    fint *nx, fint *ny, fint *nz,
-                                    C *in, C *out, fint *sign,
-                                    fint *flags)
+void F77(plan_dft_3d, PLAN_DFT_3D)(X(plan) *p, fint *nx, fint *ny, fint *nz,
+				   C *in, C *out,
+				   fint *sign, fint *flags)
 {
-     *p = X(plan_dft_3d) (*nz, *ny, *nx, in, out, *sign, *flags);
+     *p = X(plan_dft_3d)(*nz, *ny, *nx, in, out, *sign, *flags);
 }
 
-void F77(plan_many_dft, PLAN_MANY_DFT) (X(plan) * p,
-                                        fint *rank, const fint *n,
-                                        fint *howmany,
-                                        C *in, const fint *inembed,
-                                        fint *istride, fint *idist,
-                                        C *out, const fint *onembed,
-                                        fint *ostride, fint *odist,
-                                        fint *sign, fint *flags)
+void F77(plan_many_dft, PLAN_MANY_DFT)(X(plan) *p, fint *rank, const fint *n,
+				       fint *howmany,
+				       C *in, const fint *inembed,
+				       fint *istride, fint *idist,
+				       C *out, const fint *onembed,
+				       fint *ostride, fint *odist,
+				       fint *sign, fint *flags)
 {
      int *nrev = reverse_n(*rank, n);
      int *inembedrev = reverse_n(*rank, inembed);
      int *onembedrev = reverse_n(*rank, onembed);
-     *p = X(plan_many_dft) (*rank, nrev, *howmany,
-                            in, inembedrev, *istride, *idist,
-                            out, onembedrev, *ostride, *odist,
-                            *sign, *flags);
-     X(ifree0) (onembedrev);
-     X(ifree0) (inembedrev);
-     X(ifree0) (nrev);
+     *p = X(plan_many_dft)(*rank, nrev, *howmany,
+			   in, inembedrev, *istride, *idist,
+			   out, onembedrev, *ostride, *odist,
+			   *sign, *flags);
+     X(ifree0)(onembedrev);
+     X(ifree0)(inembedrev);
+     X(ifree0)(nrev);
 }
 
-void F77(plan_guru_dft, PLAN_GURU_DFT) (X(plan) * p,
-                                        fint *rank,
-                                        const fint *n, const fint *is,
-                                        const fint *os,
-                                        fint *howmany_rank,
-                                        const fint *h_n,
-                                        const fint *h_is,
-                                        const fint *h_os, R *ri, R *ii,
-                                        R *ro, R *io, fint *flags)
+void F77(plan_guru_dft, PLAN_GURU_DFT)(X(plan) *p, fint *rank, const fint *n,
+				       const fint *is, const fint *os,
+				       fint *howmany_rank, const fint *h_n,
+				       const fint *h_is, const fint *h_os,
+				       R *ri, R *ii, R *ro, R *io, fint *flags)
 {
-     X(iodim) * dims = make_dims(*rank, n, is, os);
-     X(iodim) * howmany_dims = make_dims(*howmany_rank, h_n, h_is, h_os);
-     *p = X(plan_guru_dft) (*rank, dims, *howmany_rank, howmany_dims,
-                            ri, ii, ro, io, *flags);
-     X(ifree0) (howmany_dims);
-     X(ifree0) (dims);
+     X(iodim) *dims = make_dims(*rank, n, is, os);
+     X(iodim) *howmany_dims = make_dims(*howmany_rank, h_n, h_is, h_os);
+     *p = X(plan_guru_dft)(*rank, dims, *howmany_rank, howmany_dims,
+			   ri, ii, ro, io, *flags);
+     X(ifree0)(howmany_dims);
+     X(ifree0)(dims);
 }
 
-void F77(execute_dft, EXECUTE_DFT) (X(plan) * p, R *ri, R *ii, R *ro,
-                                    R *io)
+void F77(execute_dft, EXECUTE_DFT)(X(plan) *p, R *ri, R *ii, R *ro, R *io)
 {
-     X(execute_dft) (*p, ri, ii, ro, io);
+     X(execute_dft)(*p, ri, ii, ro, io);
 }
 
 #endif				/* F77_FUNC_ */