mathcalls.h: remove tons of redundant semicolons; better comment about macros

math.h: make macro machinery a bit more understandable

No code changes (verified with objdump)

2 files changed, 96 insertions, 91 deletions

diff --git a/include/math.h b/include/math.h
index 8225e571b..a8f06082c 100644
--- a/include/math.h
+++ b/include/math.h
@@ -63,7 +63,7 @@ __BEGIN_DECLS
 
 #define __MATHDECLX(type,function,suffix,args,attrib) \
   __MATHDECL_1(type,function,suffix,args) __attribute__ (attrib); \
-  __MATHDECLI_MAINVARIANT(function)
+  __MATH_maybe_libm_hidden_proto(function)
 
 #define __MATHCALLX(function,suffix,args,attrib)	\
   __MATHDECLX(_Mdouble_,function,suffix,args,attrib)
@@ -73,7 +73,7 @@ __BEGIN_DECLS
    for the {l,f} variants.  */
 #define __MATHDECLI(type,function,suffix,args) \
   __MATHDECL_1(type,function,suffix,args); \
-  __MATHDECLI_MAINVARIANT(function)
+  __MATH_maybe_libm_hidden_proto(function)
 
 #define __MATHCALLI(function,suffix,args)	\
   __MATHDECLI(_Mdouble_,function,suffix,args)
@@ -93,9 +93,9 @@ __BEGIN_DECLS
 /* Include the file of declarations, declaring double versions */
 
 #if defined _LIBC
-# define __MATHDECLI_MAINVARIANT(x) libm_hidden_proto(x)
+# define __MATH_maybe_libm_hidden_proto(x) libm_hidden_proto(x)
 #else
-# define __MATHDECLI_MAINVARIANT(x)
+# define __MATH_maybe_libm_hidden_proto(x)
 #endif
 #define _Mdouble_		 double
 #define __MATH_PRECNAME(name,r)  __CONCAT(name,r)
@@ -106,8 +106,7 @@ __BEGIN_DECLS
 #undef _Mdouble_BEGIN_NAMESPACE
 #undef _Mdouble_END_NAMESPACE
 #undef __MATH_PRECNAME
-#undef __MATHDECLI_MAINVARIANT
-#define __MATHDECLI_MAINVARIANT(x)
+#undef __MATH_maybe_libm_hidden_proto
 
 
 #if defined __USE_MISC || defined __USE_ISOC99
@@ -115,6 +114,7 @@ __BEGIN_DECLS
 /* Include the file of declarations again, this time using `float'
    instead of `double' and appending f to each function name.  */
 
+# define __MATH_maybe_libm_hidden_proto(x)
 # ifndef _Mfloat_
 #  define _Mfloat_		float
 # endif
@@ -131,6 +131,7 @@ __BEGIN_DECLS
 # undef _Mdouble_BEGIN_NAMESPACE
 # undef _Mdouble_END_NAMESPACE
 # undef	__MATH_PRECNAME
+# undef __MATH_maybe_libm_hidden_proto
 
 
 # if (defined __STDC__ || defined __GNUC__) \
@@ -162,6 +163,7 @@ extern long double __REDIRECT_NTH (nexttowardl,
   __MATHDECL_2(type,function,suffix,args,__CONCAT(function,suffix))
 #  endif
 
+#  define __MATH_maybe_libm_hidden_proto(x)
 #  ifndef _Mlong_double_
 #   define _Mlong_double_	long double
 #  endif
@@ -178,6 +180,7 @@ extern long double __REDIRECT_NTH (nexttowardl,
 #  undef _Mdouble_BEGIN_NAMESPACE
 #  undef _Mdouble_END_NAMESPACE
 #  undef __MATH_PRECNAME
+#  undef __MATH_maybe_libm_hidden_proto
 
 # endif /* __STDC__ || __GNUC__ */
 
diff --git a/libc/sysdeps/linux/common/bits/mathcalls.h b/libc/sysdeps/linux/common/bits/mathcalls.h
index c2e062714..811738238 100644
--- a/libc/sysdeps/linux/common/bits/mathcalls.h
+++ b/libc/sysdeps/linux/common/bits/mathcalls.h
@@ -24,7 +24,7 @@
    This file provides prototype declarations for the math functions.
    Most functions are declared using the macro:
 
-   __MATHCALL (NAME,[_r], (ARGS...));
+   __MATHCALL (NAME,[_r], (ARGS...))
 
    This means there is a function `NAME' returning `double' and a function
    `NAMEf' returning `float'.  Each place `_Mdouble_' appears in the
@@ -34,7 +34,7 @@
 
    Functions returning other types like `int' are declared using the macro:
 
-   __MATHDECL (TYPE, NAME,[_r], (ARGS...));
+   __MATHDECL (TYPE, NAME,[_r], (ARGS...))
 
    This is just like __MATHCALL but for a function returning `TYPE'
    instead of `_Mdouble_'.  In all of these cases, there is still
@@ -48,10 +48,11 @@
 #endif
 
 
-/* __MATHCALLX includes libm_hidden_def
- * __MATHCALLI includes libm_hidden_def too
- * __MATHCALL  does not
- * __MATHDECL_PRIV includes libm_hidden_def and declared only __foo, not foo
+/* __MATHCALLX and __MATHCALLI include libm_hidden_def
+ * (for "double" versions only, xxxf and xxxl do not get this treatment).
+ * __MATHCALL does not.
+ * __MATHDECL_PRIV includes libm_hidden_def (always)
+ * and declares __foo, not foo.
  */
 
 
@@ -59,45 +60,45 @@
 
 _Mdouble_BEGIN_NAMESPACE
 /* Arc cosine of X.  */
-__MATHCALLI (acos,, (_Mdouble_ __x));
+__MATHCALLI (acos,, (_Mdouble_ __x))
 /* Arc sine of X.  */
-__MATHCALLI (asin,, (_Mdouble_ __x));
+__MATHCALLI (asin,, (_Mdouble_ __x))
 /* Arc tangent of X.  */
-__MATHCALLI (atan,, (_Mdouble_ __x));
+__MATHCALLI (atan,, (_Mdouble_ __x))
 /* Arc tangent of Y/X.  */
-__MATHCALLI (atan2,, (_Mdouble_ __y, _Mdouble_ __x));
+__MATHCALLI (atan2,, (_Mdouble_ __y, _Mdouble_ __x))
 
 /* Cosine of X.  */
-__MATHCALLI (cos,, (_Mdouble_ __x));
+__MATHCALLI (cos,, (_Mdouble_ __x))
 /* Sine of X.  */
-__MATHCALLI (sin,, (_Mdouble_ __x));
+__MATHCALLI (sin,, (_Mdouble_ __x))
 /* Tangent of X.  */
-__MATHCALLI (tan,, (_Mdouble_ __x));
+__MATHCALLI (tan,, (_Mdouble_ __x))
 
 /* Hyperbolic functions.  */
 
 /* Hyperbolic cosine of X.  */
-__MATHCALLI (cosh,, (_Mdouble_ __x));
+__MATHCALLI (cosh,, (_Mdouble_ __x))
 /* Hyperbolic sine of X.  */
-__MATHCALLI (sinh,, (_Mdouble_ __x));
+__MATHCALLI (sinh,, (_Mdouble_ __x))
 /* Hyperbolic tangent of X.  */
-__MATHCALLI (tanh,, (_Mdouble_ __x));
+__MATHCALLI (tanh,, (_Mdouble_ __x))
 _Mdouble_END_NAMESPACE
 
 #if 0 /*def __USE_GNU*/
 /* Cosine and sine of X.  */
 __MATHDECL (void,sincos,,
-	    (_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx));
+	    (_Mdouble_ __x, _Mdouble_ *__sinx, _Mdouble_ *__cosx))
 #endif
 
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Hyperbolic arc cosine of X.  */
-__MATHCALLI (acosh,, (_Mdouble_ __x));
+__MATHCALLI (acosh,, (_Mdouble_ __x))
 /* Hyperbolic arc sine of X.  */
-__MATHCALLI (asinh,, (_Mdouble_ __x));
+__MATHCALLI (asinh,, (_Mdouble_ __x))
 /* Hyperbolic arc tangent of X.  */
-__MATHCALLI (atanh,, (_Mdouble_ __x));
+__MATHCALLI (atanh,, (_Mdouble_ __x))
 __END_NAMESPACE_C99
 #endif
 
@@ -105,51 +106,51 @@ __END_NAMESPACE_C99
 
 _Mdouble_BEGIN_NAMESPACE
 /* Exponential function of X.  */
-__MATHCALLI (exp,, (_Mdouble_ __x));
+__MATHCALLI (exp,, (_Mdouble_ __x))
 
 /* Break VALUE into a normalized fraction and an integral power of 2.  */
-__MATHCALLI (frexp,, (_Mdouble_ __x, int *__exponent));
+__MATHCALLI (frexp,, (_Mdouble_ __x, int *__exponent))
 
 /* X times (two to the EXP power).  */
-__MATHCALLI (ldexp,, (_Mdouble_ __x, int __exponent));
+__MATHCALLI (ldexp,, (_Mdouble_ __x, int __exponent))
 
 /* Natural logarithm of X.  */
-__MATHCALLI (log,, (_Mdouble_ __x));
+__MATHCALLI (log,, (_Mdouble_ __x))
 
 /* Base-ten logarithm of X.  */
-__MATHCALLI (log10,, (_Mdouble_ __x));
+__MATHCALLI (log10,, (_Mdouble_ __x))
 
 /* Break VALUE into integral and fractional parts.  */
-__MATHCALLI (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr));
+__MATHCALLI (modf,, (_Mdouble_ __x, _Mdouble_ *__iptr))
 _Mdouble_END_NAMESPACE
 
 #if 0 /*def __USE_GNU*/
 /* A function missing in all standards: compute exponent to base ten.  */
-__MATHCALL (exp10,, (_Mdouble_ __x));
+__MATHCALL (exp10,, (_Mdouble_ __x))
 /* Another name occasionally used.  */
-__MATHCALL (pow10,, (_Mdouble_ __x));
+__MATHCALL (pow10,, (_Mdouble_ __x))
 #endif
 
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return exp(X) - 1.  */
-__MATHCALLI (expm1,, (_Mdouble_ __x));
+__MATHCALLI (expm1,, (_Mdouble_ __x))
 
 /* Return log(1 + X).  */
-__MATHCALLI (log1p,, (_Mdouble_ __x));
+__MATHCALLI (log1p,, (_Mdouble_ __x))
 
 /* Return the base 2 signed integral exponent of X.  */
-__MATHCALLI (logb,, (_Mdouble_ __x));
+__MATHCALLI (logb,, (_Mdouble_ __x))
 __END_NAMESPACE_C99
 #endif
 
 #ifdef __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Compute base-2 exponential of X.  */
-__MATHCALLI (exp2,, (_Mdouble_ __x));
+__MATHCALLI (exp2,, (_Mdouble_ __x))
 
 /* Compute base-2 logarithm of X.  */
-__MATHCALL (log2,, (_Mdouble_ __x));
+__MATHCALL (log2,, (_Mdouble_ __x))
 __END_NAMESPACE_C99
 #endif
 
@@ -158,23 +159,23 @@ __END_NAMESPACE_C99
 
 _Mdouble_BEGIN_NAMESPACE
 /* Return X to the Y power.  */
-__MATHCALLI (pow,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALLI (pow,, (_Mdouble_ __x, _Mdouble_ __y))
 
 /* Return the square root of X.  */
-__MATHCALLI (sqrt,, (_Mdouble_ __x));
+__MATHCALLI (sqrt,, (_Mdouble_ __x))
 _Mdouble_END_NAMESPACE
 
 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return `sqrt(X*X + Y*Y)'.  */
-__MATHCALLI (hypot,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALLI (hypot,, (_Mdouble_ __x, _Mdouble_ __y))
 __END_NAMESPACE_C99
 #endif
 
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return the cube root of X.  */
-__MATHCALLI (cbrt,, (_Mdouble_ __x));
+__MATHCALLI (cbrt,, (_Mdouble_ __x))
 __END_NAMESPACE_C99
 #endif
 
@@ -183,101 +184,102 @@ __END_NAMESPACE_C99
 
 _Mdouble_BEGIN_NAMESPACE
 /* Smallest integral value not less than X.  */
-__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__));
+__MATHCALLX (ceil,, (_Mdouble_ __x), (__const__))
 
 /* Absolute value of X.  */
-__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__));
+__MATHCALLX (fabs,, (_Mdouble_ __x), (__const__))
 
 /* Largest integer not greater than X.  */
-__MATHCALLX (floor,, (_Mdouble_ __x), (__const__));
+__MATHCALLX (floor,, (_Mdouble_ __x), (__const__))
 
 /* Floating-point modulo remainder of X/Y.  */
-__MATHCALLI (fmod,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALLI (fmod,, (_Mdouble_ __x, _Mdouble_ __y))
 
 
 /* Return 0 if VALUE is finite or NaN, +1 if it
    is +Infinity, -1 if it is -Infinity.  */
-__MATHDECL_PRIV (int,isinf,, (_Mdouble_ __value), (__const__));
+__MATHDECL_PRIV (int,isinf,, (_Mdouble_ __value), (__const__))
 
 /* Return nonzero if VALUE is finite and not NaN.  */
-__MATHDECL_PRIV (int,finite,, (_Mdouble_ __value), (__const__));
+__MATHDECL_PRIV (int,finite,, (_Mdouble_ __value), (__const__))
 _Mdouble_END_NAMESPACE
 
 #ifdef __USE_MISC
 #if 0
 /* Return 0 if VALUE is finite or NaN, +1 if it
    is +Infinity, -1 if it is -Infinity.  */
-__MATHDECL_PRIV (int,isinf,, (_Mdouble_ __value), (__const__));
+__MATHDECL_PRIV (int,isinf,, (_Mdouble_ __value), (__const__))
 
 /* Return nonzero if VALUE is finite and not NaN.  */
-__MATHDECL_PRIV (int,finite,, (_Mdouble_ __value), (__const__));
+__MATHDECL_PRIV (int,finite,, (_Mdouble_ __value), (__const__))
 #endif
 /* Return the remainder of X/Y.  */
-__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALL (drem,, (_Mdouble_ __x, _Mdouble_ __y))
 
 
 /* Return the fractional part of X after dividing out `ilogb (X)'.  */
-__MATHCALL (significand,, (_Mdouble_ __x));
+__MATHCALL (significand,, (_Mdouble_ __x))
 #endif /* Use misc.  */
 
 #if defined __USE_MISC || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return X with its signed changed to Y's.  */
-__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
+__MATHCALLX (copysign,, (_Mdouble_ __x, _Mdouble_ __y), (__const__))
 __END_NAMESPACE_C99
 #endif
 
 #ifdef __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Return representation of NaN for double type.  */
-__MATHCALLX (nan,, (__const char *__tagb), (__const__));
+__MATHCALLX (nan,, (__const char *__tagb), (__const__))
 __END_NAMESPACE_C99
 #endif
 
 
 /* Return nonzero if VALUE is not a number.  */
-__MATHDECL_PRIV (int,__isnan,, (_Mdouble_ __value), (__const__));
+/* DELETE? __MATHDECL_PRIV adds another "__": so this is "____isnan"???! */
+/*__MATHDECL_PRIV (int,__isnan,, (_Mdouble_ __value), (__const__))*/
 
 #if defined __USE_MISC || defined __USE_XOPEN
 /* Return nonzero if VALUE is not a number.  */
-__MATHDECL_PRIV (int,isnan,, (_Mdouble_ __value), (__const__));
+__MATHDECL_PRIV (int,isnan,, (_Mdouble_ __value), (__const__))
 
 /* Bessel functions.  */
-__MATHCALL (j0,, (_Mdouble_));
-__MATHCALL (j1,, (_Mdouble_));
-__MATHCALL (jn,, (int, _Mdouble_));
-__MATHCALL (y0,, (_Mdouble_));
-__MATHCALL (y1,, (_Mdouble_));
-__MATHCALL (yn,, (int, _Mdouble_));
+__MATHCALL (j0,, (_Mdouble_))
+__MATHCALL (j1,, (_Mdouble_))
+__MATHCALL (jn,, (int, _Mdouble_))
+__MATHCALL (y0,, (_Mdouble_))
+__MATHCALL (y1,, (_Mdouble_))
+__MATHCALL (yn,, (int, _Mdouble_))
 #endif
 
 
 #if defined __USE_MISC || defined __USE_XOPEN || defined __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* Error and gamma functions.  */
-__MATHCALLI (erf,, (_Mdouble_));
-__MATHCALLI (erfc,, (_Mdouble_));
-__MATHCALLI (lgamma,, (_Mdouble_));
+__MATHCALLI (erf,, (_Mdouble_))
+__MATHCALLI (erfc,, (_Mdouble_))
+__MATHCALLI (lgamma,, (_Mdouble_))
 __END_NAMESPACE_C99
 #endif
 
 #ifdef __USE_ISOC99
 __BEGIN_NAMESPACE_C99
 /* True gamma function.  */
-__MATHCALLI (tgamma,, (_Mdouble_));
+__MATHCALLI (tgamma,, (_Mdouble_))
 __END_NAMESPACE_C99
 #endif
 
 #if defined __USE_MISC || defined __USE_XOPEN
 /* Obsolete alias for `lgamma'.  */
-__MATHCALL (gamma,, (_Mdouble_));
+__MATHCALL (gamma,, (_Mdouble_))
 #endif
 
 #ifdef __USE_MISC
 /* Reentrant version of lgamma.  This function uses the global variable
    `signgam'.  The reentrant version instead takes a pointer and stores
    the value through it.  */
-__MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp));
+__MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp))
 #endif
 
 
@@ -285,80 +287,80 @@ __MATHCALL (lgamma,_r, (_Mdouble_, int *__signgamp));
 __BEGIN_NAMESPACE_C99
 /* Return the integer nearest X in the direction of the
    prevailing rounding mode.  */
-__MATHCALLI (rint,, (_Mdouble_ __x));
+__MATHCALLI (rint,, (_Mdouble_ __x))
 
 /* Return X + epsilon if X < Y, X - epsilon if X > Y.  */
-__MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__));
+__MATHCALLX (nextafter,, (_Mdouble_ __x, _Mdouble_ __y), (__const__))
 # if defined __USE_ISOC99 && !defined __LDBL_COMPAT
-__MATHCALLX (nexttoward,, (_Mdouble_ __x, long double __y), (__const__));
+__MATHCALLX (nexttoward,, (_Mdouble_ __x, long double __y), (__const__))
 # endif
 
 /* Return the remainder of integer divison X / Y with infinite precision.  */
-__MATHCALLI (remainder,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALLI (remainder,, (_Mdouble_ __x, _Mdouble_ __y))
 
 # if defined __USE_MISC || defined __USE_ISOC99
 /* Return X times (2 to the Nth power).  */
-__MATHCALLI (scalbn,, (_Mdouble_ __x, int __n));
+__MATHCALLI (scalbn,, (_Mdouble_ __x, int __n))
 # endif
 
 /* Return the binary exponent of X, which must be nonzero.  */
-__MATHDECLI (int,ilogb,, (_Mdouble_ __x));
+__MATHDECLI (int,ilogb,, (_Mdouble_ __x))
 #endif
 
 #ifdef __USE_ISOC99
 /* Return X times (2 to the Nth power).  */
-__MATHCALLI (scalbln,, (_Mdouble_ __x, long int __n));
+__MATHCALLI (scalbln,, (_Mdouble_ __x, long int __n))
 
 /* Round X to integral value in floating-point format using current
    rounding direction, but do not raise inexact exception.  */
-__MATHCALLI (nearbyint,, (_Mdouble_ __x));
+__MATHCALLI (nearbyint,, (_Mdouble_ __x))
 
 /* Round X to nearest integral value, rounding halfway cases away from
    zero.  */
-__MATHCALLX (round,, (_Mdouble_ __x), (__const__));
+__MATHCALLX (round,, (_Mdouble_ __x), (__const__))
 
 /* Round X to the integral value in floating-point format nearest but
    not larger in magnitude.  */
-__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__));
+__MATHCALLX (trunc,, (_Mdouble_ __x), (__const__))
 
 /* Compute remainder of X and Y and put in *QUO a value with sign of x/y
    and magnitude congruent `mod 2^n' to the magnitude of the integral
    quotient x/y, with n >= 3.  */
-__MATHCALLI (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo));
+__MATHCALLI (remquo,, (_Mdouble_ __x, _Mdouble_ __y, int *__quo))
 
 
 /* Conversion functions.  */
 
 /* Round X to nearest integral value according to current rounding
    direction.  */
-__MATHDECLI (long int,lrint,, (_Mdouble_ __x));
-__MATHDECLI (long long int,llrint,, (_Mdouble_ __x));
+__MATHDECLI (long int,lrint,, (_Mdouble_ __x))
+__MATHDECLI (long long int,llrint,, (_Mdouble_ __x))
 
 /* Round X to nearest integral value, rounding halfway cases away from
    zero.  */
-__MATHDECLI (long int,lround,, (_Mdouble_ __x));
-__MATHDECLI (long long int,llround,, (_Mdouble_ __x));
+__MATHDECLI (long int,lround,, (_Mdouble_ __x))
+__MATHDECLI (long long int,llround,, (_Mdouble_ __x))
 
 
 /* Return positive difference between X and Y.  */
-__MATHCALLI (fdim,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALLI (fdim,, (_Mdouble_ __x, _Mdouble_ __y))
 
 /* Return maximum numeric value from X and Y.  */
-__MATHCALLI (fmax,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALLI (fmax,, (_Mdouble_ __x, _Mdouble_ __y))
 
 /* Return minimum numeric value from X and Y.  */
-__MATHCALLI (fmin,, (_Mdouble_ __x, _Mdouble_ __y));
+__MATHCALLI (fmin,, (_Mdouble_ __x, _Mdouble_ __y))
 
 
 /* Classify given number.  */
-__MATHDECL_PRIV (int, fpclassify,, (_Mdouble_ __value), (__const__));
+__MATHDECL_PRIV (int, fpclassify,, (_Mdouble_ __value), (__const__))
 
 /* Test for negative number.  */
-__MATHDECL_PRIV (int, signbit,, (_Mdouble_ __value), (__const__));
+__MATHDECL_PRIV (int, signbit,, (_Mdouble_ __value), (__const__))
 
 
 /* Multiply-add function computed as a ternary operation.  */
-__MATHCALLI (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z));
+__MATHCALLI (fma,, (_Mdouble_ __x, _Mdouble_ __y, _Mdouble_ __z))
 #endif /* Use ISO C99.  */
 
 #if defined __USE_MISC || defined __USE_XOPEN_EXTENDED || defined __USE_ISOC99
@@ -368,5 +370,5 @@ __END_NAMESPACE_C99
 #if (defined __USE_MISC || defined __USE_XOPEN_EXTENDED) \
 	&& defined __UCLIBC_SUSV3_LEGACY__
 /* Return X times (2 to the Nth power).  */
-__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n));
+__MATHCALL (scalb,, (_Mdouble_ __x, _Mdouble_ __n))
 #endif