1 files changed, 58 insertions, 110 deletions

diff --git a/src/floatfns.c b/src/floatfns.c
index 5cd996d033c..4c1548cfd8f 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -70,7 +70,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* This declaration is omitted on some systems, like Ultrix.  */
 #if !defined (HPUX) && defined (HAVE_LOGB) && !defined (logb)
-extern double logb ();
+extern double logb (double);
 #endif /* not HPUX and HAVE_LOGB and no logb macro */
 
 #if defined(DOMAIN) && defined(SING) && defined(OVERFLOW)
@@ -192,8 +192,7 @@ static char *float_error_fn_name;
 /* Extract a Lisp number as a `double', or signal an error.  */
 
 double
-extract_float (num)
-     Lisp_Object num;
+extract_float (Lisp_Object num)
 {
   CHECK_NUMBER_OR_FLOAT (num);
 
@@ -206,8 +205,7 @@ extract_float (num)
 
 DEFUN ("acos", Facos, Sacos, 1, 1, 0,
        doc: /* Return the inverse cosine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -220,8 +218,7 @@ DEFUN ("acos", Facos, Sacos, 1, 1, 0,
 
 DEFUN ("asin", Fasin, Sasin, 1, 1, 0,
        doc: /* Return the inverse sine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -238,8 +235,7 @@ If only one argument Y is given, return the inverse tangent of Y.
 If two arguments Y and X are given, return the inverse tangent of Y
 divided by X, i.e. the angle in radians between the vector (X, Y)
 and the x-axis.  */)
-     (y, x)
-     register Lisp_Object y, x;
+  (register Lisp_Object y, Lisp_Object x)
 {
   double d = extract_float (y);
 
@@ -256,8 +252,7 @@ and the x-axis.  */)
 
 DEFUN ("cos", Fcos, Scos, 1, 1, 0,
        doc: /* Return the cosine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = cos (d), "cos", arg);
@@ -266,8 +261,7 @@ DEFUN ("cos", Fcos, Scos, 1, 1, 0,
 
 DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
        doc: /* Return the sine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = sin (d), "sin", arg);
@@ -276,8 +270,7 @@ DEFUN ("sin", Fsin, Ssin, 1, 1, 0,
 
 DEFUN ("tan", Ftan, Stan, 1, 1, 0,
        doc: /* Return the tangent of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   double c = cos (d);
@@ -292,8 +285,7 @@ DEFUN ("tan", Ftan, Stan, 1, 1, 0,
 #if defined HAVE_ISNAN && defined HAVE_COPYSIGN
 DEFUN ("isnan", Fisnan, Sisnan, 1, 1, 0,
        doc: /* Return non nil iff argument X is a NaN.  */)
-     (x)
-     Lisp_Object x;
+  (Lisp_Object x)
 {
   CHECK_FLOAT (x);
   return isnan (XFLOAT_DATA (x)) ? Qt : Qnil;
@@ -302,8 +294,7 @@ DEFUN ("isnan", Fisnan, Sisnan, 1, 1, 0,
 DEFUN ("copysign", Fcopysign, Scopysign, 1, 2, 0,
        doc: /* Copy sign of X2 to value of X1, and return the result.
 Cause an error if X1 or X2 is not a float.  */)
-     (x1, x2)
-     Lisp_Object x1, x2;
+  (Lisp_Object x1, Lisp_Object x2)
 {
   double f1, f2;
 
@@ -326,8 +317,7 @@ and an integral exponent EXP for 2, such that:
 
 The function returns the cons cell (SGNFCAND . EXP).
 If X is zero, both parts (SGNFCAND and EXP) are zero.  */)
-     (x)
-     Lisp_Object x;
+  (Lisp_Object x)
 {
   double f = XFLOATINT (x);
 
@@ -345,8 +335,7 @@ DEFUN ("ldexp", Fldexp, Sldexp, 1, 2, 0,
        doc: /* Construct number X from significand SGNFCAND and exponent EXP.
 Returns the floating point value resulting from multiplying SGNFCAND
 (the significand) by 2 raised to the power of EXP (the exponent).   */)
-     (sgnfcand, exp)
-     Lisp_Object sgnfcand, exp;
+  (Lisp_Object sgnfcand, Lisp_Object exp)
 {
   CHECK_NUMBER (exp);
   return make_float (ldexp (XFLOATINT (sgnfcand), XINT (exp)));
@@ -357,8 +346,7 @@ Returns the floating point value resulting from multiplying SGNFCAND
 
 DEFUN ("bessel-j0", Fbessel_j0, Sbessel_j0, 1, 1, 0,
        doc: /* Return the bessel function j0 of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = j0 (d), "bessel-j0", arg);
@@ -367,8 +355,7 @@ DEFUN ("bessel-j0", Fbessel_j0, Sbessel_j0, 1, 1, 0,
 
 DEFUN ("bessel-j1", Fbessel_j1, Sbessel_j1, 1, 1, 0,
        doc: /* Return the bessel function j1 of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = j1 (d), "bessel-j1", arg);
@@ -378,8 +365,7 @@ DEFUN ("bessel-j1", Fbessel_j1, Sbessel_j1, 1, 1, 0,
 DEFUN ("bessel-jn", Fbessel_jn, Sbessel_jn, 2, 2, 0,
        doc: /* Return the order N bessel function output jn of ARG.
 The first arg (the order) is truncated to an integer.  */)
-     (n, arg)
-     register Lisp_Object n, arg;
+  (register Lisp_Object n, Lisp_Object arg)
 {
   int i1 = extract_float (n);
   double f2 = extract_float (arg);
@@ -390,8 +376,7 @@ The first arg (the order) is truncated to an integer.  */)
 
 DEFUN ("bessel-y0", Fbessel_y0, Sbessel_y0, 1, 1, 0,
        doc: /* Return the bessel function y0 of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = y0 (d), "bessel-y0", arg);
@@ -400,8 +385,7 @@ DEFUN ("bessel-y0", Fbessel_y0, Sbessel_y0, 1, 1, 0,
 
 DEFUN ("bessel-y1", Fbessel_y1, Sbessel_y1, 1, 1, 0,
        doc: /* Return the bessel function y1 of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = y1 (d), "bessel-y0", arg);
@@ -411,8 +395,7 @@ DEFUN ("bessel-y1", Fbessel_y1, Sbessel_y1, 1, 1, 0,
 DEFUN ("bessel-yn", Fbessel_yn, Sbessel_yn, 2, 2, 0,
        doc: /* Return the order N bessel function output yn of ARG.
 The first arg (the order) is truncated to an integer.  */)
-     (n, arg)
-     register Lisp_Object n, arg;
+  (register Lisp_Object n, Lisp_Object arg)
 {
   int i1 = extract_float (n);
   double f2 = extract_float (arg);
@@ -427,8 +410,7 @@ The first arg (the order) is truncated to an integer.  */)
 
 DEFUN ("erf", Ferf, Serf, 1, 1, 0,
        doc: /* Return the mathematical error function of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = erf (d), "erf", arg);
@@ -437,8 +419,7 @@ DEFUN ("erf", Ferf, Serf, 1, 1, 0,
 
 DEFUN ("erfc", Ferfc, Serfc, 1, 1, 0,
        doc: /* Return the complementary error function of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = erfc (d), "erfc", arg);
@@ -447,8 +428,7 @@ DEFUN ("erfc", Ferfc, Serfc, 1, 1, 0,
 
 DEFUN ("log-gamma", Flog_gamma, Slog_gamma, 1, 1, 0,
        doc: /* Return the log gamma of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = lgamma (d), "log-gamma", arg);
@@ -457,8 +437,7 @@ DEFUN ("log-gamma", Flog_gamma, Slog_gamma, 1, 1, 0,
 
 DEFUN ("cube-root", Fcube_root, Scube_root, 1, 1, 0,
        doc: /* Return the cube root of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef HAVE_CBRT
@@ -476,8 +455,7 @@ DEFUN ("cube-root", Fcube_root, Scube_root, 1, 1, 0,
 
 DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
        doc: /* Return the exponential base e of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -493,8 +471,7 @@ DEFUN ("exp", Fexp, Sexp, 1, 1, 0,
 
 DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
        doc: /* Return the exponential ARG1 ** ARG2.  */)
-     (arg1, arg2)
-     register Lisp_Object arg1, arg2;
+  (register Lisp_Object arg1, Lisp_Object arg2)
 {
   double f1, f2, f3;
 
@@ -552,8 +529,7 @@ DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
 DEFUN ("log", Flog, Slog, 1, 2, 0,
        doc: /* Return the natural logarithm of ARG.
 If the optional argument BASE is given, return log ARG using that base.  */)
-     (arg, base)
-     register Lisp_Object arg, base;
+  (register Lisp_Object arg, Lisp_Object base)
 {
   double d = extract_float (arg);
 
@@ -581,8 +557,7 @@ If the optional argument BASE is given, return log ARG using that base.  */)
 
 DEFUN ("log10", Flog10, Slog10, 1, 1, 0,
        doc: /* Return the logarithm base 10 of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -595,8 +570,7 @@ DEFUN ("log10", Flog10, Slog10, 1, 1, 0,
 
 DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
        doc: /* Return the square root of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -611,8 +585,7 @@ DEFUN ("sqrt", Fsqrt, Ssqrt, 1, 1, 0,
 
 DEFUN ("acosh", Facosh, Sacosh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic cosine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -629,8 +602,7 @@ DEFUN ("acosh", Facosh, Sacosh, 1, 1, 0,
 
 DEFUN ("asinh", Fasinh, Sasinh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic sine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef HAVE_INVERSE_HYPERBOLIC
@@ -643,8 +615,7 @@ DEFUN ("asinh", Fasinh, Sasinh, 1, 1, 0,
 
 DEFUN ("atanh", Fatanh, Satanh, 1, 1, 0,
        doc: /* Return the inverse hyperbolic tangent of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -661,8 +632,7 @@ DEFUN ("atanh", Fatanh, Satanh, 1, 1, 0,
 
 DEFUN ("cosh", Fcosh, Scosh, 1, 1, 0,
        doc: /* Return the hyperbolic cosine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -675,8 +645,7 @@ DEFUN ("cosh", Fcosh, Scosh, 1, 1, 0,
 
 DEFUN ("sinh", Fsinh, Ssinh, 1, 1, 0,
        doc: /* Return the hyperbolic sine of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
 #ifdef FLOAT_CHECK_DOMAIN
@@ -689,8 +658,7 @@ DEFUN ("sinh", Fsinh, Ssinh, 1, 1, 0,
 
 DEFUN ("tanh", Ftanh, Stanh, 1, 1, 0,
        doc: /* Return the hyperbolic tangent of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = tanh (d), "tanh", arg);
@@ -700,8 +668,7 @@ DEFUN ("tanh", Ftanh, Stanh, 1, 1, 0,
 
 DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
        doc: /* Return the absolute value of ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   CHECK_NUMBER_OR_FLOAT (arg);
 
@@ -715,8 +682,7 @@ DEFUN ("abs", Fabs, Sabs, 1, 1, 0,
 
 DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
        doc: /* Return the floating point number equal to ARG.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   CHECK_NUMBER_OR_FLOAT (arg);
 
@@ -729,8 +695,7 @@ DEFUN ("float", Ffloat, Sfloat, 1, 1, 0,
 DEFUN ("logb", Flogb, Slogb, 1, 1, 0,
        doc: /* Returns largest integer <= the base 2 log of the magnitude of ARG.
 This is the same as the exponent of a float.  */)
-     (arg)
-     Lisp_Object arg;
+  (Lisp_Object arg)
 {
   Lisp_Object val;
   EMACS_INT value;
@@ -778,11 +743,10 @@ This is the same as the exponent of a float.  */)
 /* the rounding functions  */
 
 static Lisp_Object
-rounding_driver (arg, divisor, double_round, int_round2, name)
-     register Lisp_Object arg, divisor;
-     double (*double_round) ();
-     EMACS_INT (*int_round2) ();
-     char *name;
+rounding_driver (Lisp_Object arg, Lisp_Object divisor,
+                 double (*double_round) (double),
+                 EMACS_INT (*int_round2) (EMACS_INT, EMACS_INT),
+                 char *name)
 {
   CHECK_NUMBER_OR_FLOAT (arg);
 
@@ -832,8 +796,7 @@ rounding_driver (arg, divisor, double_round, int_round2, name)
    integer functions.  */
 
 static EMACS_INT
-ceiling2 (i1, i2)
-     EMACS_INT i1, i2;
+ceiling2 (EMACS_INT i1, EMACS_INT i2)
 {
   return (i2 < 0
           ? (i1 < 0  ?  ((-1 - i1) / -i2) + 1  :  - (i1 / -i2))
@@ -841,8 +804,7 @@ ceiling2 (i1, i2)
 }
 
 static EMACS_INT
-floor2 (i1, i2)
-     EMACS_INT i1, i2;
+floor2 (EMACS_INT i1, EMACS_INT i2)
 {
   return (i2 < 0
           ? (i1 <= 0  ?  -i1 / -i2  :  -1 - ((i1 - 1) / -i2))
@@ -850,8 +812,7 @@ floor2 (i1, i2)
 }
 
 static EMACS_INT
-truncate2 (i1, i2)
-     EMACS_INT i1, i2;
+truncate2 (EMACS_INT i1, EMACS_INT i2)
 {
   return (i2 < 0
           ? (i1 < 0  ?  -i1 / -i2  :  - (i1 / -i2))
@@ -859,8 +820,7 @@ truncate2 (i1, i2)
 }
 
 static EMACS_INT
-round2 (i1, i2)
-     EMACS_INT i1, i2;
+round2 (EMACS_INT i1, EMACS_INT i2)
 {
   /* The C language's division operator gives us one remainder R, but
      we want the remainder R1 on the other side of 0 if R1 is closer
@@ -880,16 +840,14 @@ round2 (i1, i2)
 #define emacs_rint rint
 #else
 static double
-emacs_rint (d)
-     double d;
+emacs_rint (double d)
 {
   return floor (d + 0.5);
 }
 #endif
 
 static double
-double_identity (d)
-     double d;
+double_identity (double d)
 {
   return d;
 }
@@ -898,8 +856,7 @@ DEFUN ("ceiling", Fceiling, Sceiling, 1, 2, 0,
        doc: /* Return the smallest integer no less than ARG.
 This rounds the value towards +inf.
 With optional DIVISOR, return the smallest integer no less than ARG/DIVISOR.  */)
-     (arg, divisor)
-     Lisp_Object arg, divisor;
+  (Lisp_Object arg, Lisp_Object divisor)
 {
   return rounding_driver (arg, divisor, ceil, ceiling2, "ceiling");
 }
@@ -908,8 +865,7 @@ DEFUN ("floor", Ffloor, Sfloor, 1, 2, 0,
        doc: /* Return the largest integer no greater than ARG.
 This rounds the value towards -inf.
 With optional DIVISOR, return the largest integer no greater than ARG/DIVISOR.  */)
-     (arg, divisor)
-     Lisp_Object arg, divisor;
+  (Lisp_Object arg, Lisp_Object divisor)
 {
   return rounding_driver (arg, divisor, floor, floor2, "floor");
 }
@@ -922,8 +878,7 @@ Rounding a value equidistant between two integers may choose the
 integer closer to zero, or it may prefer an even integer, depending on
 your machine.  For example, \(round 2.5\) can return 3 on some
 systems, but 2 on others.  */)
-     (arg, divisor)
-     Lisp_Object arg, divisor;
+  (Lisp_Object arg, Lisp_Object divisor)
 {
   return rounding_driver (arg, divisor, emacs_rint, round2, "round");
 }
@@ -932,8 +887,7 @@ DEFUN ("truncate", Ftruncate, Struncate, 1, 2, 0,
        doc: /* Truncate a floating point number to an int.
 Rounds ARG toward zero.
 With optional DIVISOR, truncate ARG/DIVISOR.  */)
-     (arg, divisor)
-     Lisp_Object arg, divisor;
+  (Lisp_Object arg, Lisp_Object divisor)
 {
   return rounding_driver (arg, divisor, double_identity, truncate2,
                           "truncate");
@@ -941,8 +895,7 @@ With optional DIVISOR, truncate ARG/DIVISOR.  */)
 
 
 Lisp_Object
-fmod_float (x, y)
-     register Lisp_Object x, y;
+fmod_float (Lisp_Object x, Lisp_Object y)
 {
   double f1, f2;
 
@@ -964,8 +917,7 @@ fmod_float (x, y)
 DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
        doc: /* Return the smallest integer no less than ARG, as a float.
 \(Round toward +inf.\)  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = ceil (d), "fceiling", arg);
@@ -975,8 +927,7 @@ DEFUN ("fceiling", Ffceiling, Sfceiling, 1, 1, 0,
 DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
        doc: /* Return the largest integer no greater than ARG, as a float.
 \(Round towards -inf.\)  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = floor (d), "ffloor", arg);
@@ -985,8 +936,7 @@ DEFUN ("ffloor", Fffloor, Sffloor, 1, 1, 0,
 
 DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
        doc: /* Return the nearest integer to ARG, as a float.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   IN_FLOAT (d = emacs_rint (d), "fround", arg);
@@ -996,8 +946,7 @@ DEFUN ("fround", Ffround, Sfround, 1, 1, 0,
 DEFUN ("ftruncate", Fftruncate, Sftruncate, 1, 1, 0,
        doc: /* Truncate a floating point number to an integral float value.
 Rounds the value toward zero.  */)
-     (arg)
-     register Lisp_Object arg;
+  (register Lisp_Object arg)
 {
   double d = extract_float (arg);
   if (d >= 0.0)
@@ -1035,8 +984,7 @@ float_error (signo)
 
 #ifdef HAVE_MATHERR
 int
-matherr (x)
-     struct exception *x;
+matherr (struct exception *x)
 {
   Lisp_Object args;
   if (! in_float)
@@ -1064,7 +1012,7 @@ matherr (x)
 #endif /* HAVE_MATHERR */
 
 void
-init_floatfns ()
+init_floatfns (void)
 {
 #ifdef FLOAT_CATCH_SIGILL
   signal (SIGILL, float_error);
@@ -1073,7 +1021,7 @@ init_floatfns ()
 }
 
 void
-syms_of_floatfns ()
+syms_of_floatfns (void)
 {
   defsubr (&Sacos);
   defsubr (&Sasin);