Convert DEFUNs to standard C.

* src/alloc.c: Convert DEFUNs to standard C.
* src/buffer.c:
* src/bytecode.c:
* src/callint.c:
* src/callproc.c:
* src/casefiddle.c:
* src/casetab.c:
* src/category.c:
* src/character.c:
* src/charset.c:
* src/chartab.c:
* src/cmds.c:
* src/coding.c:
* src/composite.c:
* src/data.c:
* src/dbusbind.c:
* src/dired.c:
* src/dispnew.c:
* src/doc.c:
* src/dosfns.c:
* src/editfns.c:
* src/emacs.c:
* src/eval.c:
* src/fileio.c:
* src/filelock.c:
* src/floatfns.c:
* src/fns.c:
* src/font.c:
* src/fontset.c:
* src/frame.c:
* src/fringe.c:
* src/image.c:
* src/indent.c:
* src/insdel.c:
* src/keyboard.c:
* src/keymap.c:
* src/lread.c:
* src/macros.c:
* src/marker.c:
* src/menu.c:
* src/minibuf.c:
* src/msdos.c:
* src/nsfns.m:
* src/nsmenu.m:
* src/nsselect.m:
* src/print.c:
* src/process.c:
* src/search.c:
* src/sound.c:
* src/syntax.c:
* src/term.c:
* src/terminal.c:
* src/textprop.c:
* src/undo.c:
* src/w16select.c:
* src/w32console.c:
* src/w32fns.c:
* src/w32font.c:
* src/w32menu.c:
* src/w32proc.c:
* src/w32select.c:
* src/window.c:
* src/xdisp.c:
* src/xfaces.c:
* src/xfns.c:
* src/xmenu.c:
* src/xselect.c:
* src/xsettings.c:
* src/xsmfns.c: Likewise.

1 files changed, 42 insertions, 84 deletions

diff --git a/src/floatfns.c b/src/floatfns.c
index 96a89337c75..64dc308c7dd 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -206,8 +206,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 +219,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 +236,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 +253,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 +262,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 +271,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 +286,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 +295,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 +318,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 +336,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 +347,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 +356,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 +366,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 +377,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 +386,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 +396,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 +411,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 +420,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 +429,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 +438,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 +456,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 +472,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 +530,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 +558,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 +571,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 +586,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 +603,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 +616,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 +633,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 +646,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 +659,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 +669,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 +683,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 +696,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;
@@ -891,8 +857,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");
 }
@@ -901,8 +866,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");
 }
@@ -915,8 +879,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");
 }
@@ -925,8 +888,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");
@@ -956,8 +918,7 @@ fmod_float (Lisp_Object x, Lisp_Object 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);
@@ -967,8 +928,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);
@@ -977,8 +937,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);
@@ -988,8 +947,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)