STDCALL needs to go after return type for MSVC++; thanks to Dave Katz for the bug...

darcs-hash:20100617155009-c8de0-a0de840fc8e724787c233ceeb367925776201937.gz

diff --git a/api/deprecated.c b/api/deprecated.c
index 50b69a33220e98fe09ef38c72586dcd133bd1e9d..54da189970625c7da09f2901d5db5d239d4749da 100644 (file)
--- a/api/deprecated.c
+++ b/api/deprecated.c
@@ -28,8 +28,8 @@ nlopt_algorithm nlopt_local_search_alg_deriv = NLOPT_LD_MMA;
 nlopt_algorithm nlopt_local_search_alg_nonderiv = NLOPT_LN_COBYLA;
 int nlopt_local_search_maxeval = -1; /* no maximum by default */
 
-NLOPT_STDCALL
-void nlopt_get_local_search_algorithm(nlopt_algorithm *deriv,
+void
+NLOPT_STDCALL nlopt_get_local_search_algorithm(nlopt_algorithm *deriv,
                                      nlopt_algorithm *nonderiv,
                                      int *maxeval)
 {
@@ -38,8 +38,8 @@ void nlopt_get_local_search_algorithm(nlopt_algorithm *deriv,
      *maxeval = nlopt_local_search_maxeval;
 }
 
-NLOPT_STDCALL
-void nlopt_set_local_search_algorithm(nlopt_algorithm deriv,
+void
+NLOPT_STDCALL nlopt_set_local_search_algorithm(nlopt_algorithm deriv,
                                      nlopt_algorithm nonderiv,
                                      int maxeval)
 {
@@ -52,17 +52,17 @@ void nlopt_set_local_search_algorithm(nlopt_algorithm deriv,
 
 int nlopt_stochastic_population = 0;
 
-NLOPT_STDCALL
-int nlopt_get_stochastic_population(void) { 
+int
+NLOPT_STDCALL nlopt_get_stochastic_population(void) { 
      return nlopt_stochastic_population; }
-NLOPT_STDCALL
-void nlopt_set_stochastic_population(int pop) { 
+void
+NLOPT_STDCALL nlopt_set_stochastic_population(int pop) { 
      nlopt_stochastic_population = pop <= 0 ? 0 : (unsigned) pop; }
 
 /*************************************************************************/
 
-NLOPT_STDCALL
-nlopt_result nlopt_minimize_econstrained(
+nlopt_result
+NLOPT_STDCALL nlopt_minimize_econstrained(
      nlopt_algorithm algorithm,
      int n, nlopt_func_old f, void *f_data,
      int m, nlopt_func_old fc, void *fc_data_, ptrdiff_t fc_datum_size,
@@ -134,8 +134,8 @@ nlopt_result nlopt_minimize_econstrained(
      return ret;
 }
 
-NLOPT_STDCALL
-nlopt_result nlopt_minimize_constrained(
+nlopt_result
+NLOPT_STDCALL nlopt_minimize_constrained(
      nlopt_algorithm algorithm,
      int n, nlopt_func_old f, void *f_data,
      int m, nlopt_func_old fc, void *fc_data, ptrdiff_t fc_datum_size,
@@ -153,8 +153,8 @@ nlopt_result nlopt_minimize_constrained(
          xtol_rel, xtol_abs, ftol_rel, ftol_abs, maxeval, maxtime);
 }
 
-NLOPT_STDCALL
-nlopt_result nlopt_minimize(
+nlopt_result
+NLOPT_STDCALL nlopt_minimize(
      nlopt_algorithm algorithm,
      int n, nlopt_func_old f, void *f_data,
      const double *lb, const double *ub, /* bounds */

diff --git a/api/general.c b/api/general.c
index 2e8eefadc082353a6018b714fe55eb3f7ea91014..08e2304e562dcc5bbd42fda2cd5b086ae42b0ba5 100644 (file)
--- a/api/general.c
+++ b/api/general.c
@@ -36,7 +36,7 @@ int nlopt_isinf(double x) {
 }
 /*************************************************************************/
 
-NLOPT_STDCALL void nlopt_version(int *major, int *minor, int *bugfix)
+void NLOPT_STDCALL nlopt_version(int *major, int *minor, int *bugfix)
 {
      *major = MAJOR_VERSION;
      *minor = MINOR_VERSION;
@@ -126,12 +126,12 @@ const char *nlopt_algorithm_name(nlopt_algorithm a)
 /*************************************************************************/
 
 static THREADLOCAL int nlopt_srand_called = 0;
-NLOPT_STDCALL void nlopt_srand(unsigned long seed) {
+void NLOPT_STDCALL nlopt_srand(unsigned long seed) {
      nlopt_srand_called = 1;
      nlopt_init_genrand(seed);
 }
 
-NLOPT_STDCALL void nlopt_srand_time(void) {
+void NLOPT_STDCALL nlopt_srand_time(void) {
      nlopt_srand(nlopt_time_seed() + my_gettid() * 314159);
 }
 

diff --git a/api/nlopt.h b/api/nlopt.h
index 41e3991854fa0d73b65a7b36c8ead7267533aef2..29b7d1869edc462a0b2a31cd4383aca067025c15 100644 (file)
--- a/api/nlopt.h
+++ b/api/nlopt.h
@@ -45,9 +45,9 @@
    Windows importing nonsense. */
 #if defined(NLOPT_DLL) && (defined(_WIN32) || defined(__WIN32__))
 /* annoying Windows syntax for calling functions in a DLL */
-#  define NLOPT_EXTERN extern __declspec(dllimport) NLOPT_STDCALL
+#  define NLOPT_EXTERN(T) extern __declspec(dllimport) T NLOPT_STDCALL
 #else
-#  define NLOPT_EXTERN extern NLOPT_STDCALL
+#  define NLOPT_EXTERN(T) extern T NLOPT_STDCALL
 #endif
 
 #ifdef __cplusplus
@@ -153,10 +153,10 @@ typedef enum {
 
 #define NLOPT_MINF_MAX_REACHED NLOPT_STOPVAL_REACHED
 
-NLOPT_EXTERN void nlopt_srand(unsigned long seed);
-NLOPT_EXTERN void nlopt_srand_time(void);
+NLOPT_EXTERN(void) nlopt_srand(unsigned long seed);
+NLOPT_EXTERN(void) nlopt_srand_time(void);
 
-NLOPT_EXTERN void nlopt_version(int *major, int *minor, int *bugfix);
+NLOPT_EXTERN(void) nlopt_version(int *major, int *minor, int *bugfix);
 
 /*************************** OBJECT-ORIENTED API **************************/
 /* The style here is that we create an nlopt_opt "object" (an opaque pointer),
@@ -172,87 +172,87 @@ typedef struct nlopt_opt_s *nlopt_opt;
 /* the only immutable parameters of an optimization are the algorithm and
    the dimension n of the problem, since changing either of these could
    have side-effects on lots of other parameters */
-NLOPT_EXTERN nlopt_opt nlopt_create(nlopt_algorithm algorithm, unsigned n);
-NLOPT_EXTERN void nlopt_destroy(nlopt_opt opt);
-NLOPT_EXTERN nlopt_opt nlopt_copy(const nlopt_opt opt);
+NLOPT_EXTERN(nlopt_opt) nlopt_create(nlopt_algorithm algorithm, unsigned n);
+NLOPT_EXTERN(void) nlopt_destroy(nlopt_opt opt);
+NLOPT_EXTERN(nlopt_opt) nlopt_copy(const nlopt_opt opt);
 
-NLOPT_EXTERN nlopt_result nlopt_optimize(nlopt_opt opt, double *x,
+NLOPT_EXTERN(nlopt_result) nlopt_optimize(nlopt_opt opt, double *x,
                                         double *opt_f);
 
-NLOPT_EXTERN nlopt_result nlopt_set_min_objective(nlopt_opt opt, nlopt_func f, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_min_objective(nlopt_opt opt, nlopt_func f, 
                                                  void *f_data);
-NLOPT_EXTERN nlopt_result nlopt_set_max_objective(nlopt_opt opt, nlopt_func f, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_max_objective(nlopt_opt opt, nlopt_func f, 
                                                  void *f_data);
 
-NLOPT_EXTERN nlopt_algorithm nlopt_get_algorithm(const nlopt_opt opt);
-NLOPT_EXTERN unsigned nlopt_get_dimension(const nlopt_opt opt);
+NLOPT_EXTERN(nlopt_algorithm) nlopt_get_algorithm(const nlopt_opt opt);
+NLOPT_EXTERN(unsigned) nlopt_get_dimension(const nlopt_opt opt);
 
 /* constraints: */
 
-NLOPT_EXTERN nlopt_result nlopt_set_lower_bounds(nlopt_opt opt, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_lower_bounds(nlopt_opt opt, 
                                                 const double *lb);
-NLOPT_EXTERN nlopt_result nlopt_set_lower_bounds1(nlopt_opt opt, double lb);
-NLOPT_EXTERN nlopt_result nlopt_get_lower_bounds(const nlopt_opt opt, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_lower_bounds1(nlopt_opt opt, double lb);
+NLOPT_EXTERN(nlopt_result) nlopt_get_lower_bounds(const nlopt_opt opt, 
                                                 double *lb);
-NLOPT_EXTERN nlopt_result nlopt_set_upper_bounds(nlopt_opt opt, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_upper_bounds(nlopt_opt opt, 
                                                 const double *ub);
-NLOPT_EXTERN nlopt_result nlopt_set_upper_bounds1(nlopt_opt opt, double ub);
-NLOPT_EXTERN nlopt_result nlopt_get_upper_bounds(const nlopt_opt opt,
+NLOPT_EXTERN(nlopt_result) nlopt_set_upper_bounds1(nlopt_opt opt, double ub);
+NLOPT_EXTERN(nlopt_result) nlopt_get_upper_bounds(const nlopt_opt opt,
                                                 double *ub);
 
-NLOPT_EXTERN nlopt_result nlopt_remove_inequality_constraints(nlopt_opt opt);
-NLOPT_EXTERN nlopt_result nlopt_add_inequality_constraint(nlopt_opt opt,
+NLOPT_EXTERN(nlopt_result) nlopt_remove_inequality_constraints(nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_add_inequality_constraint(nlopt_opt opt,
                                                          nlopt_func fc,
                                                          void *fc_data,
                                                          double tol);
 
-NLOPT_EXTERN nlopt_result nlopt_remove_equality_constraints(nlopt_opt opt);
-NLOPT_EXTERN nlopt_result nlopt_add_equality_constraint(nlopt_opt opt,
+NLOPT_EXTERN(nlopt_result) nlopt_remove_equality_constraints(nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_add_equality_constraint(nlopt_opt opt,
                                                        nlopt_func h,
                                                        void *h_data,
                                                        double tol);
 
 /* stopping criteria: */
 
-NLOPT_EXTERN nlopt_result nlopt_set_stopval(nlopt_opt opt, double stopval);
-NLOPT_EXTERN double nlopt_get_stopval(const nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_stopval(nlopt_opt opt, double stopval);
+NLOPT_EXTERN(double) nlopt_get_stopval(const nlopt_opt opt);
 
-NLOPT_EXTERN nlopt_result nlopt_set_ftol_rel(nlopt_opt opt, double tol);
-NLOPT_EXTERN double nlopt_get_ftol_rel(const nlopt_opt opt);
-NLOPT_EXTERN nlopt_result nlopt_set_ftol_abs(nlopt_opt opt, double tol);
-NLOPT_EXTERN double nlopt_get_ftol_abs(const nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_ftol_rel(nlopt_opt opt, double tol);
+NLOPT_EXTERN(double) nlopt_get_ftol_rel(const nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_ftol_abs(nlopt_opt opt, double tol);
+NLOPT_EXTERN(double) nlopt_get_ftol_abs(const nlopt_opt opt);
 
-NLOPT_EXTERN nlopt_result nlopt_set_xtol_rel(nlopt_opt opt, double tol);
-NLOPT_EXTERN double nlopt_get_xtol_rel(const nlopt_opt opt);
-NLOPT_EXTERN nlopt_result nlopt_set_xtol_abs1(nlopt_opt opt, double tol);
-NLOPT_EXTERN nlopt_result nlopt_set_xtol_abs(nlopt_opt opt, const double *tol);
-NLOPT_EXTERN nlopt_result nlopt_get_xtol_abs(const nlopt_opt opt,
+NLOPT_EXTERN(nlopt_result) nlopt_set_xtol_rel(nlopt_opt opt, double tol);
+NLOPT_EXTERN(double) nlopt_get_xtol_rel(const nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_xtol_abs1(nlopt_opt opt, double tol);
+NLOPT_EXTERN(nlopt_result) nlopt_set_xtol_abs(nlopt_opt opt, const double *tol);
+NLOPT_EXTERN(nlopt_result) nlopt_get_xtol_abs(const nlopt_opt opt,
                                             double *tol);
 
-NLOPT_EXTERN nlopt_result nlopt_set_maxeval(nlopt_opt opt, int maxeval);
-NLOPT_EXTERN int nlopt_get_maxeval(nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_maxeval(nlopt_opt opt, int maxeval);
+NLOPT_EXTERN(int) nlopt_get_maxeval(nlopt_opt opt);
 
-NLOPT_EXTERN nlopt_result nlopt_set_maxtime(nlopt_opt opt, double maxtime);
-NLOPT_EXTERN double nlopt_get_maxtime(nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_maxtime(nlopt_opt opt, double maxtime);
+NLOPT_EXTERN(double) nlopt_get_maxtime(nlopt_opt opt);
 
-NLOPT_EXTERN nlopt_result nlopt_force_stop(nlopt_opt opt);
-NLOPT_EXTERN nlopt_result nlopt_set_force_stop(nlopt_opt opt, int val);
-NLOPT_EXTERN int nlopt_get_force_stop(nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_force_stop(nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_force_stop(nlopt_opt opt, int val);
+NLOPT_EXTERN(int) nlopt_get_force_stop(nlopt_opt opt);
 
 /* more algorithm-specific parameters */
 
-NLOPT_EXTERN nlopt_result nlopt_set_local_optimizer(nlopt_opt opt, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_local_optimizer(nlopt_opt opt, 
                                                    const nlopt_opt local_opt);
 
-NLOPT_EXTERN nlopt_result nlopt_set_population(nlopt_opt opt, unsigned pop);
-NLOPT_EXTERN unsigned nlopt_get_population(const nlopt_opt opt);
+NLOPT_EXTERN(nlopt_result) nlopt_set_population(nlopt_opt opt, unsigned pop);
+NLOPT_EXTERN(unsigned) nlopt_get_population(const nlopt_opt opt);
 
-NLOPT_EXTERN nlopt_result nlopt_set_default_initial_step(nlopt_opt opt, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_default_initial_step(nlopt_opt opt, 
                                                         const double *x);
-NLOPT_EXTERN nlopt_result nlopt_set_initial_step(nlopt_opt opt, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_initial_step(nlopt_opt opt, 
                                                 const double *dx);
-NLOPT_EXTERN nlopt_result nlopt_set_initial_step1(nlopt_opt opt, double dx);
-NLOPT_EXTERN nlopt_result nlopt_get_initial_step(const nlopt_opt opt, 
+NLOPT_EXTERN(nlopt_result) nlopt_set_initial_step1(nlopt_opt opt, double dx);
+NLOPT_EXTERN(nlopt_result) nlopt_get_initial_step(const nlopt_opt opt, 
                                                 const double *x, double *dx);
 
 /* the following are functions mainly designed to be used internally
@@ -260,7 +260,7 @@ NLOPT_EXTERN nlopt_result nlopt_get_initial_step(const nlopt_opt opt,
    nlopt_copy to do something to the f_data pointers (e.g. free or
    duplicate them, respectively) */
 typedef void* (*nlopt_munge)(void *p);
-NLOPT_EXTERN void nlopt_set_munge(nlopt_opt opt,
+NLOPT_EXTERN(void) nlopt_set_munge(nlopt_opt opt,
                                  nlopt_munge munge_on_destroy,
                                  nlopt_munge munge_on_copy);
 
@@ -282,7 +282,7 @@ typedef double (*nlopt_func_old)(int n, const double *x,
                                 double *gradient, /* NULL if not needed */
                                 void *func_data);
 
-NLOPT_EXTERN nlopt_result nlopt_minimize(
+NLOPT_EXTERN(nlopt_result) nlopt_minimize(
      nlopt_algorithm algorithm,
      int n, nlopt_func_old f, void *f_data,
      const double *lb, const double *ub, /* bounds */
@@ -292,7 +292,7 @@ NLOPT_EXTERN nlopt_result nlopt_minimize(
      double xtol_rel, const double *xtol_abs,
      int maxeval, double maxtime) NLOPT_DEPRECATED;
 
-NLOPT_EXTERN nlopt_result nlopt_minimize_constrained(
+NLOPT_EXTERN(nlopt_result) nlopt_minimize_constrained(
      nlopt_algorithm algorithm,
      int n, nlopt_func_old f, void *f_data,
      int m, nlopt_func_old fc, void *fc_data, ptrdiff_t fc_datum_size,
@@ -303,7 +303,7 @@ NLOPT_EXTERN nlopt_result nlopt_minimize_constrained(
      double xtol_rel, const double *xtol_abs,
      int maxeval, double maxtime) NLOPT_DEPRECATED;
 
-NLOPT_EXTERN nlopt_result nlopt_minimize_econstrained(
+NLOPT_EXTERN(nlopt_result) nlopt_minimize_econstrained(
      nlopt_algorithm algorithm,
      int n, nlopt_func_old f, void *f_data,
      int m, nlopt_func_old fc, void *fc_data, ptrdiff_t fc_datum_size,
@@ -316,15 +316,15 @@ NLOPT_EXTERN nlopt_result nlopt_minimize_econstrained(
      double htol_rel, double htol_abs,
      int maxeval, double maxtime) NLOPT_DEPRECATED;
 
-NLOPT_EXTERN void nlopt_get_local_search_algorithm(nlopt_algorithm *deriv,
+NLOPT_EXTERN(void) nlopt_get_local_search_algorithm(nlopt_algorithm *deriv,
                                             nlopt_algorithm *nonderiv,
                                             int *maxeval) NLOPT_DEPRECATED;
-NLOPT_EXTERN void nlopt_set_local_search_algorithm(nlopt_algorithm deriv,
+NLOPT_EXTERN(void) nlopt_set_local_search_algorithm(nlopt_algorithm deriv,
                                             nlopt_algorithm nonderiv,
                                             int maxeval) NLOPT_DEPRECATED;
 
-NLOPT_EXTERN int nlopt_get_stochastic_population(void) NLOPT_DEPRECATED;
-NLOPT_EXTERN void nlopt_set_stochastic_population(int pop) NLOPT_DEPRECATED;
+NLOPT_EXTERN(int) nlopt_get_stochastic_population(void) NLOPT_DEPRECATED;
+NLOPT_EXTERN(void) nlopt_set_stochastic_population(int pop) NLOPT_DEPRECATED;
 
 /*********************************************************************/
 

diff --git a/api/optimize.c b/api/optimize.c
index 387301314003d9f410c6f2f865193c6e6f546b46..2c169b173fc6c9278d179e506bd00309674929e8 100644 (file)
--- a/api/optimize.c
+++ b/api/optimize.c
@@ -543,8 +543,8 @@ static double f_max(unsigned n, const double *x, double *grad, void *data)
      return -val;
 }
 
-NLOPT_STDCALL 
-nlopt_result nlopt_optimize(nlopt_opt opt, double *x, double *opt_f)
+nlopt_result 
+NLOPT_STDCALL nlopt_optimize(nlopt_opt opt, double *x, double *opt_f)
 {
      nlopt_func f; void *f_data;
      f_max_data fmd;

diff --git a/api/options.c b/api/options.c
index 5e7038ce762af73f4304369dd658bb14c404b449..c3ae1b46dc3fd3572e63900fc432caf7acc68840 100644 (file)
--- a/api/options.c
+++ b/api/options.c
@@ -30,7 +30,7 @@
 
 /*************************************************************************/
 
-NLOPT_STDCALL void nlopt_destroy(nlopt_opt opt)
+void NLOPT_STDCALL nlopt_destroy(nlopt_opt opt)
 {
      if (opt) {
          if (opt->munge_on_destroy) {
@@ -52,7 +52,7 @@ NLOPT_STDCALL void nlopt_destroy(nlopt_opt opt)
      }
 }
 
-NLOPT_STDCALL nlopt_opt nlopt_create(nlopt_algorithm algorithm, unsigned n)
+nlopt_opt NLOPT_STDCALL nlopt_create(nlopt_algorithm algorithm, unsigned n)
 {
      nlopt_opt opt;
 
@@ -105,7 +105,7 @@ oom:
      return NULL;
 }
 
-NLOPT_STDCALL nlopt_opt nlopt_copy(const nlopt_opt opt)
+nlopt_opt NLOPT_STDCALL nlopt_copy(const nlopt_opt opt)
 {
      nlopt_opt nopt = NULL;
      if (opt) {
@@ -184,7 +184,8 @@ oom:
 
 /*************************************************************************/
 
-NLOPT_STDCALL nlopt_result nlopt_set_min_objective(nlopt_opt opt, nlopt_func f, void *f_data)
+nlopt_result NLOPT_STDCALL nlopt_set_min_objective(nlopt_opt opt,
+                                                  nlopt_func f, void *f_data)
 {
      if (opt) {
          opt->f = f; opt->f_data = f_data;
@@ -196,7 +197,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_min_objective(nlopt_opt opt, nlopt_func f,
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_set_max_objective(nlopt_opt opt, nlopt_func f, void *f_data)
+nlopt_result NLOPT_STDCALL nlopt_set_max_objective(nlopt_opt opt, 
+                                                  nlopt_func f, void *f_data)
 {
      if (opt) {
          opt->f = f; opt->f_data = f_data;
@@ -210,7 +212,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_max_objective(nlopt_opt opt, nlopt_func f,
 
 /*************************************************************************/
 
-NLOPT_STDCALL nlopt_result nlopt_set_lower_bounds(nlopt_opt opt, const double *lb)
+nlopt_result
+NLOPT_STDCALL nlopt_set_lower_bounds(nlopt_opt opt, const double *lb)
 {
      if (opt && (opt->n == 0 || lb)) {
          memcpy(opt->lb, lb, sizeof(double) * (opt->n));
@@ -219,7 +222,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_lower_bounds(nlopt_opt opt, const double *l
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_set_lower_bounds1(nlopt_opt opt, double lb)
+nlopt_result
+NLOPT_STDCALL nlopt_set_lower_bounds1(nlopt_opt opt, double lb)
 {
      if (opt) {
          unsigned i;
@@ -230,7 +234,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_lower_bounds1(nlopt_opt opt, double lb)
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_get_lower_bounds(nlopt_opt opt, double *lb)
+nlopt_result
+NLOPT_STDCALL nlopt_get_lower_bounds(nlopt_opt opt, double *lb)
 {
      if (opt && (opt->n == 0 || lb)) {
          memcpy(lb, opt->lb, sizeof(double) * (opt->n));
@@ -239,7 +244,8 @@ NLOPT_STDCALL nlopt_result nlopt_get_lower_bounds(nlopt_opt opt, double *lb)
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_set_upper_bounds(nlopt_opt opt, const double *ub)
+nlopt_result
+NLOPT_STDCALL nlopt_set_upper_bounds(nlopt_opt opt, const double *ub)
 {
      if (opt && (opt->n == 0 || ub)) {
          memcpy(opt->ub, ub, sizeof(double) * (opt->n));
@@ -248,7 +254,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_upper_bounds(nlopt_opt opt, const double *u
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_set_upper_bounds1(nlopt_opt opt, double ub)
+nlopt_result
+NLOPT_STDCALL nlopt_set_upper_bounds1(nlopt_opt opt, double ub)
 {
      if (opt) {
          unsigned i;
@@ -259,7 +266,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_upper_bounds1(nlopt_opt opt, double ub)
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_get_upper_bounds(nlopt_opt opt, double *ub)
+nlopt_result
+NLOPT_STDCALL nlopt_get_upper_bounds(nlopt_opt opt, double *ub)
 {
      if (opt && (opt->n == 0 || ub)) {
          memcpy(ub, opt->ub, sizeof(double) * (opt->n));
@@ -277,7 +285,8 @@ NLOPT_STDCALL nlopt_result nlopt_get_upper_bounds(nlopt_opt opt, double *ub)
                       (a) == NLOPT_LD_AUGLAG ||        \
                       (a) == NLOPT_LD_AUGLAG_EQ)
 
-NLOPT_STDCALL nlopt_result nlopt_remove_inequality_constraints(nlopt_opt opt)
+nlopt_result
+NLOPT_STDCALL nlopt_remove_inequality_constraints(nlopt_opt opt)
 {
      if (!opt) return NLOPT_INVALID_ARGS;
      if (opt->munge_on_destroy) {
@@ -291,7 +300,7 @@ NLOPT_STDCALL nlopt_result nlopt_remove_inequality_constraints(nlopt_opt opt)
      return NLOPT_SUCCESS;
 }
 
-NLOPT_STDCALL static nlopt_result add_constraint(unsigned *m, unsigned *m_alloc,
+static nlopt_result add_constraint(unsigned *m, unsigned *m_alloc,
                                   nlopt_constraint **c,
                                   nlopt_func fc, void *fc_data,
                                   double tol)
@@ -316,9 +325,10 @@ NLOPT_STDCALL static nlopt_result add_constraint(unsigned *m, unsigned *m_alloc,
      return NLOPT_SUCCESS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_add_inequality_constraint(nlopt_opt opt,
-                                            nlopt_func fc, void *fc_data,
-                                            double tol)
+nlopt_result
+NLOPT_STDCALL nlopt_add_inequality_constraint(nlopt_opt opt,
+                                             nlopt_func fc, void *fc_data,
+                                             double tol)
 {
      if (opt && fc && tol >= 0) {
          /* nonlinear constraints are only supported with some algorithms */
@@ -335,7 +345,8 @@ NLOPT_STDCALL nlopt_result nlopt_add_inequality_constraint(nlopt_opt opt,
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_remove_equality_constraints(nlopt_opt opt)
+nlopt_result
+NLOPT_STDCALL nlopt_remove_equality_constraints(nlopt_opt opt)
 {
      if (!opt) return NLOPT_INVALID_ARGS;
      if (opt->munge_on_destroy) {
@@ -349,9 +360,10 @@ NLOPT_STDCALL nlopt_result nlopt_remove_equality_constraints(nlopt_opt opt)
      return NLOPT_SUCCESS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_add_equality_constraint(nlopt_opt opt,
-                                          nlopt_func h, void *h_data,
-                                          double tol)
+nlopt_result
+NLOPT_STDCALL nlopt_add_equality_constraint(nlopt_opt opt,
+                                           nlopt_func h, void *h_data,
+                                           double tol)
 {
      if (opt && h && tol >= 0) {
          /* equality constraints (h(x) = 0) only via some algorithms */
@@ -366,7 +378,7 @@ NLOPT_STDCALL nlopt_result nlopt_add_equality_constraint(nlopt_opt opt,
 /*************************************************************************/
 
 #define SET(param, T, arg)                                             \
-   NLOPT_STDCALL nlopt_result nlopt_set_##param(nlopt_opt opt, T arg)  \
+   nlopt_result NLOPT_STDCALL nlopt_set_##param(nlopt_opt opt, T arg)  \
    {                                                                   \
        if (opt) {                                                      \
             opt->arg = arg;                                            \
@@ -376,8 +388,8 @@ NLOPT_STDCALL nlopt_result nlopt_add_equality_constraint(nlopt_opt opt,
    }
 
 
-#define GET(param, T, arg) NLOPT_STDCALL       \
-   T nlopt_get_##param(const nlopt_opt opt) {  \
+#define GET(param, T, arg) T NLOPT_STDCALL     \
+   nlopt_get_##param(const nlopt_opt opt) {    \
         return opt->arg;                       \
    }
 
@@ -389,7 +401,8 @@ GETSET(ftol_rel, double, ftol_rel)
 GETSET(ftol_abs, double, ftol_abs)
 GETSET(xtol_rel, double, xtol_rel)
 
-NLOPT_STDCALL nlopt_result nlopt_set_xtol_abs(nlopt_opt opt, const double *xtol_abs)
+nlopt_result
+NLOPT_STDCALL nlopt_set_xtol_abs(nlopt_opt opt, const double *xtol_abs)
 {
      if (opt) {
          memcpy(opt->xtol_abs, xtol_abs, opt->n & sizeof(double));
@@ -398,7 +411,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_xtol_abs(nlopt_opt opt, const double *xtol_
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_set_xtol_abs1(nlopt_opt opt, const double xtol_abs)
+nlopt_result
+NLOPT_STDCALL nlopt_set_xtol_abs1(nlopt_opt opt, const double xtol_abs)
 {
      if (opt) {
          unsigned i;
@@ -409,7 +423,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_xtol_abs1(nlopt_opt opt, const double xtol_
      return NLOPT_INVALID_ARGS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_get_xtol_abs(const nlopt_opt opt, double *xtol_abs)
+nlopt_result
+NLOPT_STDCALL nlopt_get_xtol_abs(const nlopt_opt opt, double *xtol_abs)
 {
      memcpy(xtol_abs, opt->xtol_abs, opt->n & sizeof(double));
      return NLOPT_SUCCESS;
@@ -421,7 +436,8 @@ GETSET(maxtime, double, maxtime)
 
 /*************************************************************************/
 
-NLOPT_STDCALL nlopt_result nlopt_set_force_stop(nlopt_opt opt, int force_stop)
+nlopt_result
+NLOPT_STDCALL nlopt_set_force_stop(nlopt_opt opt, int force_stop)
 {
      if (opt) {
          opt->force_stop = force_stop;
@@ -433,7 +449,7 @@ NLOPT_STDCALL nlopt_result nlopt_set_force_stop(nlopt_opt opt, int force_stop)
 }
 
 GET(force_stop, int, force_stop)
-NLOPT_STDCALL nlopt_result nlopt_force_stop(nlopt_opt opt) { 
+nlopt_result NLOPT_STDCALL nlopt_force_stop(nlopt_opt opt) { 
      return nlopt_set_force_stop(opt, 1); 
 }
 
@@ -444,8 +460,9 @@ GET(dimension, unsigned, n)
 
 /*************************************************************************/
 
-NLOPT_STDCALL nlopt_result nlopt_set_local_optimizer(nlopt_opt opt,
-                                      const nlopt_opt local_opt)
+nlopt_result
+NLOPT_STDCALL nlopt_set_local_optimizer(nlopt_opt opt,
+                                       const nlopt_opt local_opt)
 {
      if (opt) {
          if (local_opt && local_opt->n != opt->n) return NLOPT_INVALID_ARGS;
@@ -471,7 +488,7 @@ GETSET(population, unsigned, stochastic_population)
 
 /*************************************************************************/
 
-NLOPT_STDCALL nlopt_result nlopt_set_initial_step1(nlopt_opt opt, double dx)
+nlopt_result NLOPT_STDCALL nlopt_set_initial_step1(nlopt_opt opt, double dx)
 {
      unsigned i;
      if (!opt || dx == 0) return NLOPT_INVALID_ARGS;
@@ -483,7 +500,8 @@ NLOPT_STDCALL nlopt_result nlopt_set_initial_step1(nlopt_opt opt, double dx)
      return NLOPT_SUCCESS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_set_initial_step(nlopt_opt opt, const double *dx)
+nlopt_result
+NLOPT_STDCALL nlopt_set_initial_step(nlopt_opt opt, const double *dx)
 {
      unsigned i;
      if (!opt) return NLOPT_INVALID_ARGS;
@@ -498,8 +516,9 @@ NLOPT_STDCALL nlopt_result nlopt_set_initial_step(nlopt_opt opt, const double *d
      return NLOPT_SUCCESS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_get_initial_step(const nlopt_opt opt, const double *x, 
-                                   double *dx)
+nlopt_result
+NLOPT_STDCALL nlopt_get_initial_step(const nlopt_opt opt, const double *x, 
+                                    double *dx)
 {
      if (!opt) return NLOPT_INVALID_ARGS;
      if (!opt->n) return NLOPT_SUCCESS;
@@ -515,7 +534,8 @@ NLOPT_STDCALL nlopt_result nlopt_get_initial_step(const nlopt_opt opt, const dou
      return NLOPT_SUCCESS;
 }
 
-NLOPT_STDCALL nlopt_result nlopt_set_default_initial_step(nlopt_opt opt, const double *x)
+nlopt_result
+NLOPT_STDCALL nlopt_set_default_initial_step(nlopt_opt opt, const double *x)
 {
      const double *lb, *ub;
      unsigned i;
@@ -561,9 +581,9 @@ NLOPT_STDCALL nlopt_result nlopt_set_default_initial_step(nlopt_opt opt, const d
 
 /*************************************************************************/
 
-NLOPT_STDCALL void nlopt_set_munge(nlopt_opt opt,
-                    nlopt_munge munge_on_destroy,
-                    nlopt_munge munge_on_copy) {
+void NLOPT_STDCALL nlopt_set_munge(nlopt_opt opt,
+                                  nlopt_munge munge_on_destroy,
+                                  nlopt_munge munge_on_copy) {
      if (opt) {
          opt->munge_on_destroy = munge_on_destroy;
          opt->munge_on_copy = munge_on_copy;