acinclude.m4 (GLIBCPP_ENABLE_LONG_DOUBLE): Remove.

2000-10-26  Benjamin Kosnik  <bkoz@redhat.com>

	* acinclude.m4 (GLIBCPP_ENABLE_LONG_DOUBLE): Remove.
	* aclocal.m4: Regenerate.
	* configure.in: Remove GLIBCPP_ENABLE_LONG_DOUBLE.
	* configure: Regenerate.
	* docs/configopts.html: Remove.
	* src/complexl.cc: Revert.
	* config.h.in: Remove.
	* include/c_std/bits/std_cmath.h: Remove guards based on
	_GLIBCPP_USE_LONG_DOUBLE.
	* include/c/bits/std_cmath.h: Same. Format. Match c_std behavior
	with respect to long double signatures.

	* config/os/aix/bits/ctype_noninline.h (ctype): Remove throw
	specification.
	* config/os/newlib/bits/ctype_noninline.h (ctype): And here.
	* config/os/solaris/solaris2.6/bits/ctype_noninline.h (ctype): Same.
	* config/os/solaris/solaris2.5/bits/ctype_noninline.h (ctype): Same.
	* config/os/generic/bits/ctype_noninline.h (ctype): Same.
	* config/os/bsd/bits/ctype_noninline.h (ctype): Same.

From-SVN: r37073

1 files changed, 320 insertions, 243 deletions

diff --git a/libstdc++-v3/include/c/bits/std_cmath.h b/libstdc++-v3/include/c/bits/std_cmath.h
index 0db1624..3a8e6e5 100644
--- a/libstdc++-v3/include/c/bits/std_cmath.h
+++ b/libstdc++-v3/include/c/bits/std_cmath.h
@@ -43,466 +43,543 @@
 
 namespace std {
 
-  //
-  // int
-  //
+  inline int 
+  abs(int i) { return i > 0 ? i : -i; }
 
-  inline int abs(int i)
-  { return i > 0 ? i : -i; }
-
-  inline long abs(long i)
-  { return i > 0 ? i : -i; }
-  
-    //
-    // float
-    //
+  inline long 
+  abs(long i) { return i > 0 ? i : -i; }
 
 #if _GLIBCPP_HAVE___BUILTIN_FABSF
-    inline float abs(float __x)
-      { return __builtin_fabsf(__x); }
+  inline float 
+  abs(float __x) { return __builtin_fabsf(__x); }
 #elif _GLIBCPP_HAVE_FABSF
-    inline float abs(float __x)
-      { return ::fabsf(__x); }
+  inline float 
+  abs(float __x) { return ::fabsf(__x); }
 #else
-    inline float abs(float __x)
-      { return ::fabs(static_cast<double>(__x)); }
+  inline float 
+  abs(float __x) { return ::fabs(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ACOSF
-    inline float acos(float __x)
-      { return ::acosf(__x); }
+  inline float 
+  acos(float __x) { return ::acosf(__x); }
 #else
-    inline float acos(float __x)
-      { return ::acos(static_cast<double>(__x)); }
+  inline float 
+  acos(float __x) { return ::acos(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ASINF
-    inline float asin(float __x)
-      { return ::asinf(__x); }
+  inline float 
+  asin(float __x) { return ::asinf(__x); }
 #else
-    inline float asin(float __x)
-      { return ::asin(static_cast<double>(__x)); }
+  inline float 
+  asin(float __x) { return ::asin(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ATANF
-    inline float atan(float __x)
-      { return ::atanf(__x); }
+  inline float 
+  atan(float __x) { return ::atanf(__x); }
 #else
-    inline float atan(float __x)
-      { return ::atan(static_cast<double>(__x)); }
+  inline float 
+  atan(float __x) { return ::atan(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ATAN2F
-    inline float atan2(float __y, float __x)
-      { return ::atan2f(__y, __x); }
+  inline float 
+  atan2(float __y, float __x) { return ::atan2f(__y, __x); }
 #else
-    inline float atan2(float __y, float __x)
-      { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
+  inline float 
+  atan2(float __y, float __x)
+  { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_CEILF
-    inline float ceil(float __x)
-      { return ::ceilf(__x); }
+  inline float 
+  ceil(float __x) { return ::ceilf(__x); }
 #else
-    inline float ceil(float __x)
-      { return ::ceil(static_cast<double>(__x)); }
+  inline float 
+  ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE___BUILTIN_COSF
-    inline float cos(float __x)
-      { return __builtin_cosf(__x); }
+  inline float 
+  cos(float __x) { return __builtin_cosf(__x); }
 #elif _GLIBCPP_HAVE_COSF
-    inline float cos(float __x)
-      { return ::cosf(__x); }
+  inline float 
+  cos(float __x) { return ::cosf(__x); }
 #else
-    inline float cos(float __x)
-      { return ::cos(static_cast<double>(__x)); }
+  inline float 
+  cos(float __x) { return ::cos(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_COSHF
-    inline float cosh(float __x)
-      { return ::coshf(__x); }
+  inline float 
+  cosh(float __x) { return ::coshf(__x); }
 #else
-    inline float cosh(float __x)
-      { return ::cosh(static_cast<double>(__x)); }
+  inline float 
+  cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_EXPF
-    inline float exp(float __x)
-      { return ::expf(__x); }
+  inline float 
+  exp(float __x) { return ::expf(__x); }
 #else
-    inline float exp(float __x)
-      { return ::exp(static_cast<double>(__x)); }
+  inline float 
+  exp(float __x) { return ::exp(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE___BUILTIN_FABSF
-    inline float fabs(float __x)
-      { return __builtin_fabsf(__x); }
+  inline float 
+  fabs(float __x) { return __builtin_fabsf(__x); }
 #elif _GLIBCPP_HAVE_FABSF
-    inline float fabs(float __x)
-      { return ::fabsf(__x); }
+  inline float 
+  fabs(float __x) { return ::fabsf(__x); }
 #else
-    inline float fabs(float __x)
-      { return ::fabs(static_cast<double>(__x)); }
+  inline float 
+  fabs(float __x) { return ::fabs(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_FLOORF
-    inline float floor(float __x)
-      { return ::floorf(__x); }
+  inline float 
+  floor(float __x) { return ::floorf(__x); }
 #else
-    inline float floor(float __x)
-      { return ::floor(static_cast<double>(__x)); }
+  inline float 
+  floor(float __x) { return ::floor(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_FMODF
-    inline float fmod(float __x, float __y)
-      { return ::fmodf(__x, __y); }
+  inline float 
+  fmod(float __x, float __y) { return ::fmodf(__x, __y); }
 #else
-    inline float fmod(float __x, float __y)
-      { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
+  inline float 
+  fmod(float __x, float __y)
+  { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
 #if _GLIBCPP_HAVE_FREXPF
-    inline float frexp(float __x, int* __exp)
-      { return ::frexpf(__x, __exp); }
+  inline float 
+  frexp(float __x, int* __exp) { return ::frexpf(__x, __exp); }
 #else
-    inline float frexp(float __x, int* __exp)
-      { return ::frexp(__x, __exp); }
+  inline float 
+  frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
 #endif
 
 #if _GLIBCPP_HAVE_LDEXPF
-    inline float ldexp(float __x, int __exp)
-      { return ::ldexpf(__x, __exp); }
+  inline float 
+  ldexp(float __x, int __exp) { return ::ldexpf(__x, __exp); }
 #else
-    inline float ldexp(float __x, int __exp)
-      { return ::ldexp(static_cast<double>(__x), __exp); }
+  inline float 
+  ldexp(float __x, int __exp)
+  { return ::ldexp(static_cast<double>(__x), __exp); }
 #endif
 
 #if _GLIBCPP_HAVE_LOGF
-    inline float log(float __x)
-      { return ::logf(__x); }
+  inline float 
+  log(float __x) { return ::logf(__x); }
 #else
-    inline float log(float __x)
-      { return ::log(static_cast<double>(__x)); }
+  inline float log(float __x)
+  { return ::log(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_LOG10F
-    inline float log10(float __x)
-      { return ::log10f(__x); }
+  inline float 
+  log10(float __x) { return ::log10f(__x); }
 #else
-    inline float log10(float __x)
-      { return ::log10(static_cast<double>(__x)); }
+  inline float 
+  log10(float __x) { return ::log10(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_MODFF
-    inline float modf(float __x, float* __iptr)
-      { return ::modff(__x, __iptr); }
+  inline float 
+  modf(float __x, float* __iptr) { return ::modff(__x, __iptr); }
 #else
-    inline float modf(float __x, float* __iptr)
-    {
-       double __tmp;
-       double __res = ::modf(static_cast<double>(__x), &__tmp);
-       *__iptr = static_cast<float> (__tmp);
-       return __res;
-    }
+  inline float 
+  modf(float __x, float* __iptr)
+  {
+    double __tmp;
+    double __res = ::modf(static_cast<double>(__x), &__tmp);
+    *__iptr = static_cast<float>(__tmp);
+    return __res;
+  }
 #endif
 
 #if _GLIBCPP_HAVE_POWF
-    inline float pow(float __x, float __y)
-      { return ::powf(__x, __y); }
+  inline float 
+  pow(float __x, float __y) { return ::powf(__x, __y); }
 #else
-    inline float pow(float __x, float __y)
-      { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
+  inline float 
+  pow(float __x, float __y)
+  { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
-    float pow(float, int);
+  float pow(float, int);
 
 #if _GLIBCPP_HAVE___BUILTIN_SINF
-    inline float sin(float __x)
-      { return __builtin_sinf(__x); }
+  inline float 
+  sin(float __x) { return __builtin_sinf(__x); }
 #elif _GLIBCPP_HAVE_SINF
-    inline float sin(float __x)
-      { return ::sinf(__x); }
+  inline float 
+  sin(float __x) { return ::sinf(__x); }
 #else
-    inline float sin(float __x)
-      { return ::sin(static_cast<double>(__x)); }
+  inline float 
+  sin(float __x) { return ::sin(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_SINHF
-    inline float sinh(float __x)
-      { return ::sinhf(__x); }
+  inline float 
+  sinh(float __x) { return ::sinhf(__x); }
 #else
-    inline float sinh(float __x)
-      { return ::sinh(static_cast<double>(__x)); }
+  inline float 
+  sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE___BUILTIN_SQRTF
-    inline float sqrt(float __x)
-      { return __builtin_sqrtf(__x); }
+  inline float 
+  sqrt(float __x) { return __builtin_sqrtf(__x); }
 #elif _GLIBCPP_HAVE_SQRTF
-    inline float sqrt(float __x)
-      { return ::sqrtf(__x); }
+  inline float 
+  sqrt(float __x) { return ::sqrtf(__x); }
 #else
-    inline float sqrt(float __x)
-      { return ::sqrt(static_cast<double>(__x)); }
+  inline float 
+  sqrt(float __x) { return ::sqrt(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_TANF
-    inline float tan(float __x)
-      { return ::tanf(__x); }
+  inline float 
+  tan(float __x) { return ::tanf(__x); }
 #else
-    inline float tan(float __x)
-      { return ::tan(static_cast<double>(__x)); }
+  inline float 
+  tan(float __x) { return ::tan(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_TANHF
-    inline float tanh(float __x)
-      { return ::tanhf(__x); }
+  inline float 
+  tanh(float __x) { return ::tanhf(__x); }
 #else
-    inline float tanh(float __x)
-      { return ::tanh(static_cast<double>(__x)); }
+  inline float 
+  tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
 #endif
 
-    //
-    // double
-    //
 
 #if _GLIBCPP_HAVE___BUILTIN_FABS
-    inline double abs(double __x)
-      { return __builtin_fabs(__x); }
+  inline double 
+  abs(double __x) { return __builtin_fabs(__x); }
 #else
-    inline double abs(double __x)
-      { return ::fabs(__x); }
+  inline double 
+  abs(double __x) { return ::fabs(__x); }
 #endif
 
-    inline double acos(double __x)
-      { return ::acos(__x); }
+  inline double 
+  acos(double __x) { return ::acos(__x); }
 
-    inline double asin(double __x)
-      { return ::asin(__x); }
+  inline double 
+  asin(double __x) { return ::asin(__x); }
 
-    inline double atan(double __x)
-      { return ::atan(__x); }
+  inline double 
+  atan(double __x) { return ::atan(__x); }
 
-    inline double atan2(double __y, double __x)
-      { return ::atan2(__y, __x); }
+  inline double 
+  atan2(double __y, double __x) { return ::atan2(__y, __x); }
 
-    inline double ceil(double __x)
-      { return ::ceil(__x); }
+  inline double 
+  ceil(double __x) { return ::ceil(__x); }
 
 #if _GLIBCPP_HAVE___BUILTIN_COS
-    inline double cos(double __x)
-      { return __builtin_cos(__x); }
+  inline double 
+  cos(double __x) { return __builtin_cos(__x); }
 #else
-    inline double cos(double __x)
-      { return ::cos(__x); }
+  inline double 
+  cos(double __x) { return ::cos(__x); }
 #endif
 
-    inline double cosh(double __x)
-      { return ::cosh(__x); }
+  inline double cosh(double __x)
+  { return ::cosh(__x); }
 
-    inline double exp(double __x)
-      { return ::exp(__x); }
+  inline double 
+  exp(double __x) { return ::exp(__x); }
 
 
 #if _GLIBCPP_HAVE___BUILTIN_FABS
-    inline double fabs(double __x)
-      { return __builtin_fabs(__x); }
+  inline double 
+  fabs(double __x) { return __builtin_fabs(__x); }
 #else
-    inline double fabs(double __x)
-      { return ::fabs(__x); }
+  inline double 
+  fabs(double __x) { return ::fabs(__x); }
 #endif
 
-    inline double floor(double __x)
-      { return ::floor(__x); }
+  inline double 
+  floor(double __x) { return ::floor(__x); }
 
-    inline double fmod(double __x, double __y)
-      { return ::fmod(__x, __y); }
+  inline double 
+  fmod(double __x, double __y) { return ::fmod(__x, __y); }
 
-    inline double frexp(double __x, int* __exp)
-      { return ::frexp(__x, __exp); }
+  inline double 
+  frexp(double __x, int* __exp) { return ::frexp(__x, __exp); }
 
-    inline double ldexp(double __x, int __exp)
-      { return ::ldexp(__x, __exp); }
+  inline double 
+  ldexp(double __x, int __exp) { return ::ldexp(__x, __exp); }
 
-    inline double log(double __x)
-      { return ::log(__x); }
+  inline double 
+  log(double __x) { return ::log(__x); }
 
-    inline double log10(double __x)
-      { return ::log10(__x); }
+  inline double 
+  log10(double __x) { return ::log10(__x); }
 
-    inline double modf(double __x, double* __iptr)
-      { return ::modf(__x, __iptr); }
+  inline double 
+  modf(double __x, double* __iptr) { return ::modf(__x, __iptr); }
 
-    inline double pow(double __x, double __y)
-      { return ::pow(__x, __y); }
+  inline double 
+  pow(double __x, double __y) { return ::pow(__x, __y); }
 
-    double pow (double, int);
+  double pow (double, int);
 
 #if _GLIBCPP_HAVE___BUILTIN_SIN
-    inline double sin(double __x)
-      { return __builtin_sin(__x); }
+  inline double 
+  sin(double __x) { return __builtin_sin(__x); }
 #else
-    inline double sin(double __x)
-      { return ::sin(__x); }
+  inline double 
+  sin(double __x) { return ::sin(__x); }
 #endif
 
-    inline double sinh(double __x)
-      { return ::sinh(__x); }
+  inline double 
+  sinh(double __x) { return ::sinh(__x); }
 
 #if _GLIBCPP_HAVE___BUILTIN_SQRT
-    inline double sqrt(double __x)
-      { return __builtin_fsqrt(__x); }
+  inline double 
+  sqrt(double __x) { return __builtin_fsqrt(__x); }
 #else
-    inline double sqrt(double __x)
-      { return ::sqrt(__x); }
+  inline double 
+  sqrt(double __x) { return ::sqrt(__x); }
 #endif
 
-    inline double tan(double __x)
-      { return ::tan(__x); }
+  inline double 
+  tan(double __x) { return ::tan(__x); }
+
+  inline double 
+  tanh(double __x) { return ::tanh(__x); }
 
-    inline double tanh(double __x)
-      { return ::tanh(__x); }
 
-    //
-    // long double
-    //
-#ifdef _GLIBCPP_USE_LONG_DOUBLE
 #if _GLIBCPP_HAVE___BUILTIN_FABSL
-    inline long double abs(long double __x)
-      { return __builtin_fabsl(__x); }
+  inline long double 
+  abs(long double __x) { return __builtin_fabsl(__x); }
 #elif _GLIBCPP_HAVE_FABSL
-    inline long double abs(long double __x)
-      { return ::fabsl(__x); }
+  inline long double 
+  abs(long double __x) { return ::fabsl(__x); }
+#else
+  inline long double 
+  abs(long double __x) { return fabs(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ACOSL
-    inline long double acos(long double __x)
-      { return ::acosl(__x); }
+  inline long double 
+  acos(long double __x) { return ::acosl(__x); }
+#else
+  inline long double 
+  acos(long double __x) { return ::acos(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ASINL
-    inline long double asin(long double __x)
-      { return ::asinl(__x); }
+  inline long double 
+  asin(long double __x) { return ::asinl(__x); }
+#else
+  inline long double 
+  asin(long double __x) { return ::asin(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ATANL
-    inline long double atan(long double __x)
-      { return ::atanl(__x); }
+  inline long double 
+  atan(long double __x) { return ::atanl(__x); }
+#else
+  inline long double 
+  atan(long double __x) { return ::atan(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_ATAN2L
-    inline long double atan2(long double __y, long double __x)
-      { return ::atan2l(__y, __x); }
+  inline long double 
+  atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
+#else
+  inline long double 
+  atan2(long double __y, long double __x) 
+  { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_CEILL
-    inline long double ceil(long double __x)
-      { return ::ceill(__x); }
+  inline long double 
+  ceil(long double __x) { return ::ceill(__x); }
+#else
+  inline long double 
+  ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE___BUILTIN_COSL
-    inline long double cos(long double __x)
-      { return __builtin_cosl(__x); }
+  inline long double 
+  cos(long double __x) { return __builtin_cosl(__x); }
 #elif _GLIBCPP_HAVE_COSL
-    inline long double cos(long double __x)
-      { return ::cosl(__x); }
+  inline long double 
+  cos(long double __x) { return ::cosl(__x); }
+#else
+  inline long double 
+  cos(long double __x) { return ::cos(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_COSHL
-    inline long double cosh(long double __x)
-      { return ::coshl(__x); }
+  inline long double 
+  cosh(long double __x) { return ::coshl(__x); }
+#else
+  inline long double 
+  cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_EXPL
-    inline long double exp(long double __x)
-      { return ::expl(__x); }
+  inline long double 
+  exp(long double __x) { return ::expl(__x); }
+#else
+  inline long double 
+  exp(long double __x) { return ::exp(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE___BUILTIN_FABSL
-    inline long double fabs(long double __x)
-      { return __builtin_fabsl(__x); }
+  inline long double 
+  fabs(long double __x) { return __builtin_fabsl(__x); }
 #elif _GLIBCPP_HAVE_FABSL
-    inline long double fabs(long double __x)
-      { return ::fabsl(__x); }
+  inline long double 
+  fabs(long double __x) { return ::fabsl(__x); }
+#else
+  inline long double 
+  fabs(long double __x) { return ::fabs(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_FLOORL
-    inline long double floor(long double __x)
-      { return ::floorl(__x); }
+  inline long double 
+  floor(long double __x) { return ::floorl(__x); }
+#else
+  inline long double 
+  floor(long double __x) { return ::floor(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_FMODL
-    inline long double fmod(long double __x, long double __y)
-      { return ::fmodl(__x, __y); }
+  inline long double 
+  fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
+#else
+  inline long double 
+  fmod(long double __x, long double __y) 
+  { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
 #if _GLIBCPP_HAVE_FREXPL
-    inline long double frexp(long double __x, int* __exp)
-      { return ::frexpl(__x, __exp); }
+  inline long double 
+  frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
+#else
+  inline long double 
+  frexp(long double __x, int* __exp) 
+  { return ::frexp(static_cast<double>(__x), __exp); }
 #endif
 
 #if _GLIBCPP_HAVE_LDEXPL
-    inline long double ldexp(long double __x, int __exp)
-      { return ::ldexpl(__x, __exp); }
+  inline long double 
+  ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
+#else
+  inline long double 
+  ldexp(long double __x, int __exp) 
+  { return ::ldexp(static_cast<double>(__x), __exp); }
 #endif
 
 #if _GLIBCPP_HAVE_LOGL
-    inline long double log(long double __x)
-      { return ::logl(__x); }
+  inline long double 
+  log(long double __x) { return ::logl(__x); }
+#else
+  inline long double 
+  log(long double __x) { return ::log(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_LOG10L
-    inline long double log10(long double __x)
-      { return ::log10l(__x); }
+  inline long double 
+  log10(long double __x) { return ::log10l(__x); }
+#else
+  inline long double 
+  log10(long double __x) { return ::log10(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_MODFL
-    inline long double modf(long double __x, long double* __iptr)
-      { return ::modfl(__x, __iptr); }
+  inline long double 
+  modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
+#else
+  inline long double 
+  modf(long double __x, long double* __iptr) 
+  { 
+    double __tmp;
+    double __res = ::modf(static_cast<double>(__x), &__tmp);
+    * __iptr = static_cast<long double>(__tmp);
+    return __res;
+  }
 #endif
 
 #if _GLIBCPP_HAVE_POWL
-    inline long double pow(long double __x, long double __y)
-      { return ::powl(__x, __y); }
+  inline long double 
+  pow(long double __x, long double __y) { return ::powl(__x, __y); }
+#else
+  inline long double 
+  pow(long double __x, long double __y) 
+  { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
 #endif
 
-    long double pow(long double, int);
+  long double 
+  pow(long double, int);
 
 #if _GLIBCPP_HAVE___BUILTIN_SINL
-    inline long double sin(long double __x)
-      { return __builtin_sinl(__x); }
+  inline long double 
+  sin(long double __x) { return __builtin_sinl(__x); }
 #elif _GLIBCPP_HAVE_SINL
-    inline long double sin(long double __x)
-      { return ::sinl(__x); }
+  inline long double 
+  sin(long double __x) { return ::sinl(__x); }
+#else
+  inline long double 
+  sin(long double __x) { return ::sin(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_SINHL
-    inline long double sinh(long double __x)
-      { return ::sinhl(__x); }
+  inline long double 
+  sinh(long double __x) { return ::sinhl(__x); }
+#else
+  inline long double 
+  sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE___BUILTIN_SQRTL
-    inline long double sqrt(long double __x)
-      { return __builtin_sqrtl(__x); }
+  inline long double 
+  sqrt(long double __x) { return __builtin_sqrtl(__x); }
 #elif _GLIBCPP_HAVE_SQRTL
-    inline long double sqrt(long double __x)
-      { return ::sqrtl(__x); }
+  inline long double 
+  sqrt(long double __x) { return ::sqrtl(__x); }
+#else
+  inline long double 
+  sqrt(long double __x) { return ::sqrt(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_TANL
-    inline long double tan(long double __x)
-      { return ::tanl(__x); }
+  inline long double 
+  tan(long double __x) { return ::tanl(__x); }
+#else
+  inline long double 
+  tan(long double __x) { return ::tan(static_cast<double>(__x)); }
 #endif
 
 #if _GLIBCPP_HAVE_TANHL
-    inline long double tanh(long double __x)
-      { return ::tanhl(__x); }
+  inline long double 
+  tanh(long double __x) { return ::tanhl(__x); }
+#else
+  inline long double 
+  tanh(long double __x) { return ::tanh(static_cast<double>(__x)); }
 #endif
-
-#endif // _GLIBCPP_USE_LONG_DOUBLE
 } // std
 
 #endif // _CPP_CMATH
 
 
+
+
+
+
+
+
+