cmath.tcc, [...]: Remove trailing whitespace.

	* include/c_std/cmath.tcc, include/c_std/std_cassert.h,
	include/c_std/std_cctype.h, include/c_std/std_cmath.h,
	include/c_std/std_cstddef.h, include/c_std/std_cstdio.h,
	include/c_std/std_cstdlib.h, include/c_std/std_cstring.h,
	include/c_std/std_cwchar.h, include/c_std/std_cwctype.h:
	Remove trailing whitespace.

From-SVN: r74458

libstdc++-v3/ChangeLog

 2003-12-09  Bernardo Innocenti  <bernie@develer.com>
 
+	* include/c_std/cmath.tcc, include/c_std/std_cassert.h,
+	include/c_std/std_cctype.h, include/c_std/std_cmath.h,
+	include/c_std/std_cstddef.h, include/c_std/std_cstdio.h,
+	include/c_std/std_cstdlib.h, include/c_std/std_cstring.h,
+	include/c_std/std_cwchar.h, include/c_std/std_cwctype.h:
+	Remove trailing whitespace.
+
+2003-12-09  Bernardo Innocenti  <bernie@develer.com>
+
 	* include/c/std_cctype.h, include/c/std_cmath.h,
 	include/c/std_cstdlib.h include/c/std_cwchar.h,
 	include/c/std_cwctype.h: Remove trailing whitespace.

libstdc++-v3/include/c_std/cmath.tcc

@@ -32,7 +32,7 @@
 #ifndef _GLIBCXX_CMATH_TCC
 #define _GLIBCXX_CMATH_TCC 1
 
-namespace std 
+namespace std
 {
   template<typename _Tp>
     _Tp

libstdc++-v3/include/c_std/std_cassert.h

 // -*- C++ -*- forwarding header.
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free

libstdc++-v3/include/c_std/std_cctype.h

@@ -80,4 +80,4 @@ namespace std
   using ::toupper;
 }
 
-#endif 
+#endif

libstdc++-v3/include/c_std/std_cmath.h

@@ -78,7 +78,7 @@
 #undef tanh
 
 
-namespace std 
+namespace std
 {
   // Forward declaration of a helper function.  This really should be
   // an `exported' forward declaration.
@@ -112,14 +112,14 @@ namespace std
     {
       return __builtin_acos(__x);
     }
-  
+
   using ::asin;
 
-  inline float 
+  inline float
   asin(float __x)
   { return __builtin_asinf(__x); }
 
-  inline long double 
+  inline long double
   asin(long double __x)
   { return __builtin_asinl(__x); }
 
@@ -130,11 +130,11 @@ namespace std
 
   using ::atan;
 
-  inline float 
+  inline float
   atan(float __x)
   { return __builtin_atanf(__x); }
 
-  inline long double 
+  inline long double
   atan(long double __x)
   { return __builtin_atanl(__x); }
 
@@ -142,14 +142,14 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     atan(_Tp __x)
     { return __builtin_atan(__x); }
-  
+
   using ::atan2;
 
-  inline float 
+  inline float
   atan2(float __y, float __x)
   { return __builtin_atan2f(__y, __x); }
 
-  inline long double 
+  inline long double
   atan2(long double __y, long double __x)
   { return __builtin_atan2l(__y, __x); }
 
@@ -161,11 +161,11 @@ namespace std
 
   using ::ceil;
 
-  inline float 
+  inline float
   ceil(float __x)
   { return __builtin_ceilf(__x); }
 
-  inline long double 
+  inline long double
   ceil(long double __x)
   { return __builtin_ceill(__x); }
 
@@ -173,7 +173,7 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     ceil(_Tp __x)
     { return __builtin_ceil(__x); }
-  
+
   using ::cos;
 
   inline float
@@ -191,11 +191,11 @@ namespace std
 
   using ::cosh;
 
-  inline float 
+  inline float
   cosh(float __x)
   { return __builtin_coshf(__x); }
 
-  inline long double 
+  inline long double
   cosh(long double __x)
   { return __builtin_coshl(__x); }
 
@@ -206,11 +206,11 @@ namespace std
 
   using ::exp;
 
-  inline float 
+  inline float
   exp(float __x)
   { return __builtin_expf(__x); }
 
-  inline long double 
+  inline long double
   exp(long double __x)
   { return __builtin_expl(__x); }
 
@@ -218,7 +218,7 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     exp(_Tp __x)
     { return __builtin_exp(__x); }
-  
+
   using ::fabs;
 
   inline float
@@ -236,11 +236,11 @@ namespace std
 
   using ::floor;
 
-  inline float 
+  inline float
   floor(float __x)
   { return __builtin_floorf(__x); }
 
-  inline long double 
+  inline long double
   floor(long double __x)
   { return __builtin_floorl(__x); }
 
@@ -248,24 +248,24 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     floor(_Tp __x)
     { return __builtin_floor(__x); }
-  
+
   using ::fmod;
 
-  inline float 
+  inline float
   fmod(float __x, float __y)
   { return __builtin_fmodf(__x, __y); }
 
-  inline long double 
+  inline long double
   fmod(long double __x, long double __y)
   { return __builtin_fmodl(__x, __y); }
 
   using ::frexp;
 
-  inline float 
+  inline float
   frexp(float __x, int* __exp)
   { return __builtin_frexpf(__x, __exp); }
 
-  inline long double 
+  inline long double
   frexp(long double __x, int* __exp)
   { return __builtin_frexpl(__x, __exp); }
 
@@ -273,14 +273,14 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     frexp(_Tp __x, int* __exp)
     { return __builtin_frexp(__x, __exp); }
-  
+
   using ::ldexp;
 
-  inline float 
+  inline float
   ldexp(float __x, int __exp)
   { return __builtin_ldexpf(__x, __exp); }
 
-  inline long double 
+  inline long double
   ldexp(long double __x, int __exp)
   { return __builtin_ldexpl(__x, __exp); }
 
@@ -291,11 +291,11 @@ namespace std
 
   using ::log;
 
-  inline float 
+  inline float
   log(float __x)
   { return __builtin_logf(__x); }
 
-  inline long double 
+  inline long double
   log(long double __x)
   { return __builtin_logl(__x); }
 
@@ -303,14 +303,14 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     log(_Tp __x)
     { return __builtin_log(__x); }
-  
+
   using ::log10;
 
-  inline float 
+  inline float
   log10(float __x)
   { return __builtin_log10f(__x); }
 
-  inline long double 
+  inline long double
   log10(long double __x)
   { return __builtin_log10l(__x); }
 
@@ -318,14 +318,14 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     log10(_Tp __x)
     { return __builtin_log10(__x); }
-  
+
   using ::modf;
 
-  inline float 
+  inline float
   modf(float __x, float* __iptr)
   { return __builtin_modff(__x, __iptr); }
 
-  inline long double 
+  inline long double
   modf(long double __x, long double* __iptr)
   { return __builtin_modfl(__x, __iptr); }
 
@@ -340,23 +340,23 @@ namespace std
 
   using ::pow;
 
-  inline float 
+  inline float
   pow(float __x, float __y)
   { return __builtin_powf(__x, __y); }
 
-  inline long double 
+  inline long double
   pow(long double __x, long double __y)
   { return __builtin_powl(__x, __y); }
 
-  inline double 
+  inline double
   pow(double __x, int __i)
   { return __pow_helper(__x, __i); }
 
-  inline float 
+  inline float
   pow(float __x, int __n)
   { return __pow_helper(__x, __n); }
 
-  inline long double 
+  inline long double
   pow(long double __x, int __n)
   { return __pow_helper(__x, __n); }
 
@@ -377,11 +377,11 @@ namespace std
 
   using ::sinh;
 
-  inline float 
+  inline float
   sinh(float __x)
   { return __builtin_sinhf(__x); }
 
-  inline long double 
+  inline long double
   sinh(long double __x)
   { return __builtin_sinhl(__x); }
 
@@ -389,7 +389,7 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     sinh(_Tp __x)
     { return __builtin_sinh(__x); }
-  
+
   using ::sqrt;
 
   inline float
@@ -404,14 +404,14 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     sqrt(_Tp __x)
     { return __builtin_sqrt(__x); }
-  
+
   using ::tan;
 
-  inline float 
+  inline float
   tan(float __x)
   { return __builtin_tanf(__x); }
 
-  inline long double 
+  inline long double
   tan(long double __x)
   { return __builtin_tanl(__x); }
 
@@ -419,14 +419,14 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     tan(_Tp __x)
     { return __builtin_tan(__x); }
-  
+
   using ::tanh;
 
-  inline float 
+  inline float
   tanh(float __x)
   { return __builtin_tanhf(__x); }
 
-  inline long double 
+  inline long double
   tanh(long double __x)
   { return __builtin_tanhl(__x); }
 
@@ -434,67 +434,67 @@ namespace std
     inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
     tanh(_Tp __x)
     { return __builtin_tanh(__x); }
-} 
+}
 
 
 #if _GLIBCXX_USE_C99
 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
 // These are possible macros imported from C99-land. For strict
 // conformance, remove possible C99-injected names from the global
-// namespace, and sequester them in the __gnu_cxx extension namespace. 
+// namespace, and sequester them in the __gnu_cxx extension namespace.
 namespace __gnu_cxx
 {
   template<typename _Tp>
-    int 
+    int
     __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
 
   template<typename _Tp>
-    int 
+    int
     __capture_isfinite(_Tp __f) { return isfinite(__f); }
 
   template<typename _Tp>
-    int 
+    int
     __capture_isinf(_Tp __f) { return isinf(__f); }
 
   template<typename _Tp>
-    int 
+    int
     __capture_isnan(_Tp __f) { return isnan(__f); }
 
   template<typename _Tp>
-    int 
+    int
     __capture_isnormal(_Tp __f) { return isnormal(__f); }
 
   template<typename _Tp>
-    int 
+    int
     __capture_signbit(_Tp __f) { return signbit(__f); }
 
   template<typename _Tp>
-    int 
+    int
     __capture_isgreater(_Tp __f1, _Tp __f2)
     { return isgreater(__f1, __f2); }
 
   template<typename _Tp>
-     int 
-     __capture_isgreaterequal(_Tp __f1, _Tp __f2) 
+     int
+     __capture_isgreaterequal(_Tp __f1, _Tp __f2)
      { return isgreaterequal(__f1, __f2); }
 
   template<typename _Tp>
-     int 
+     int
      __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
 
   template<typename _Tp>
-     int 
-     __capture_islessequal(_Tp __f1, _Tp __f2) 
+     int
+     __capture_islessequal(_Tp __f1, _Tp __f2)
      { return islessequal(__f1, __f2); }
 
   template<typename _Tp>
-     int 
-     __capture_islessgreater(_Tp __f1, _Tp __f2) 
+     int
+     __capture_islessgreater(_Tp __f1, _Tp __f2)
      { return islessgreater(__f1, __f2); }
 
   template<typename _Tp>
-     int 
-     __capture_isunordered(_Tp __f1, _Tp __f2) 
+     int
+     __capture_isunordered(_Tp __f1, _Tp __f2)
      { return isunordered(__f1, __f2); }
 }
 
@@ -527,47 +527,47 @@ namespace __gnu_cxx
     isfinite(_Tp __f) { return __capture_isfinite(__f); }
 
   template<typename _Tp>
-    int 
+    int
     isinf(_Tp __f) { return __capture_isinf(__f); }
 
   template<typename _Tp>
-    int 
+    int
     isnan(_Tp __f) { return __capture_isnan(__f); }
 
   template<typename _Tp>
-    int 
+    int
     isnormal(_Tp __f) { return __capture_isnormal(__f); }
 
   template<typename _Tp>
-    int 
+    int
     signbit(_Tp __f) { return __capture_signbit(__f); }
 
   template<typename _Tp>
-    int 
+    int
     isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
 
   template<typename _Tp>
-    int 
-    isgreaterequal(_Tp __f1, _Tp __f2) 
+    int
+    isgreaterequal(_Tp __f1, _Tp __f2)
     { return __capture_isgreaterequal(__f1, __f2); }
 
   template<typename _Tp>
-    int 
+    int
     isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
 
   template<typename _Tp>
-    int 
-    islessequal(_Tp __f1, _Tp __f2) 
+    int
+    islessequal(_Tp __f1, _Tp __f2)
     { return __capture_islessequal(__f1, __f2); }
 
   template<typename _Tp>
-    int 
-    islessgreater(_Tp __f1, _Tp __f2) 
+    int
+    islessgreater(_Tp __f1, _Tp __f2)
     { return __capture_islessgreater(__f1, __f2); }
 
   template<typename _Tp>
-    int 
-    isunordered(_Tp __f1, _Tp __f2) 
+    int
+    isunordered(_Tp __f1, _Tp __f2)
     { return __capture_isunordered(__f1, __f2); }
 }
 
@@ -588,7 +588,7 @@ namespace std
 }
 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
 #endif
-  
+
 #ifndef _GLIBCXX_EXPORT_TEMPLATE
 # include <bits/cmath.tcc>
 #endif

libstdc++-v3/include/c_std/std_cstddef.h

@@ -47,7 +47,7 @@
 
 #include <stddef.h>
 
-namespace std 
+namespace std
 {
   using ::ptrdiff_t;
   using ::size_t;

libstdc++-v3/include/c_std/std_cstdio.h

@@ -94,7 +94,7 @@
 #undef vprintf
 #undef vsprintf
 
-namespace std 
+namespace std
 {
   using ::FILE;
   using ::fpos_t;
@@ -180,6 +180,6 @@ namespace std
   using __gnu_cxx::vsnprintf;
   using __gnu_cxx::vsscanf;
 }
-#endif 
+#endif
 
 #endif

libstdc++-v3/include/c_std/std_cstdlib.h

@@ -81,7 +81,7 @@
 #undef wcstombs
 #undef wctomb
 
-namespace std 
+namespace std
 {
   using ::div_t;
   using ::ldiv_t;
@@ -117,14 +117,14 @@ namespace std
 #ifdef _GLIBCXX_USE_WCHAR_T
   using ::wcstombs;
   using ::wctomb;
-#endif // _GLIBCXX_USE_WCHAR_T 
+#endif // _GLIBCXX_USE_WCHAR_T
 
-  inline long 
+  inline long
   abs(long __i) { return labs(__i); }
 
   inline ldiv_t
   div(long __i, long __j) { return ldiv(__i, __j); }
-} 
+}
 
 #if _GLIBCXX_USE_C99
 
@@ -149,18 +149,18 @@ namespace __gnu_cxx
   using ::_Exit;
 #endif
 
-  inline long long 
+  inline long long
   abs(long long __x) { return __x >= 0 ? __x : -__x; }
 
-  inline long long 
+  inline long long
   llabs(long long __x) { return __x >= 0 ? __x : -__x; }
 
 #if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
-  inline lldiv_t 
+  inline lldiv_t
   div(long long __n, long long __d)
   { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
 
-  inline lldiv_t 
+  inline lldiv_t
   lldiv(long long __n, long long __d)
   { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
 #endif
@@ -178,18 +178,18 @@ namespace __gnu_cxx
   using ::strtoull;
 #endif
   using ::strtof;
-  using ::strtold; 
-} 
+  using ::strtold;
+}
 
 namespace std
 {
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC 
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
   using __gnu_cxx::lldiv_t;
 #endif
   using __gnu_cxx::_Exit;
   using __gnu_cxx::abs;
-  using __gnu_cxx::llabs; 
-#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC 
+  using __gnu_cxx::llabs;
+#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC
   using __gnu_cxx::div;
   using __gnu_cxx::lldiv;
 #endif
@@ -201,4 +201,4 @@ namespace std
 }
 #endif
 
-#endif 
+#endif

libstdc++-v3/include/c_std/std_cstring.h

@@ -74,7 +74,7 @@
 #undef strerror
 #undef strlen
 
-namespace std 
+namespace std
 {
   using ::memcpy;
   using ::memmove;

libstdc++-v3/include/c_std/std_cwchar.h

@@ -57,16 +57,16 @@
 // Need to do a bit of trickery here with mbstate_t as char_traits
 // assumes it is in wchar.h, regardless of wchar_t specializations.
 #ifndef _GLIBCXX_HAVE_MBSTATE_T
-extern "C" 
+extern "C"
 {
-  typedef struct 
+  typedef struct
   {
     int __fill[6];
   } mbstate_t;
 }
 #endif
 
-namespace std 
+namespace std
 {
   using ::mbstate_t;
 }
@@ -94,15 +94,15 @@ namespace std
 #undef vfwprintf
 #if _GLIBCXX_HAVE_VFWSCANF
 # undef vfwscanf
-#endif 
+#endif
 #undef vswprintf
 #if _GLIBCXX_HAVE_VSWSCANF
 # undef vswscanf
-#endif 
+#endif
 #undef vwprintf
 #if _GLIBCXX_HAVE_VWSCANF
 # undef vwscanf
-#endif 
+#endif
 #undef wcrtomb
 #undef wcscat
 #undef wcschr
@@ -123,7 +123,7 @@ namespace std
 #undef wcstod
 #if _GLIBCXX_HAVE_WCSTOF
 # undef wcstof
-#endif 
+#endif
 #undef wcstok
 #undef wcstol
 #undef wcstoul
@@ -164,15 +164,15 @@ namespace std
   using ::vfwprintf;
 #if _GLIBCXX_HAVE_VFWSCANF
   using ::vfwscanf;
-#endif 
+#endif
   using ::vswprintf;
 #if _GLIBCXX_HAVE_VSWSCANF
   using ::vswscanf;
-#endif 
+#endif
   using ::vwprintf;
 #if _GLIBCXX_HAVE_VWSCANF
   using ::vwscanf;
-#endif 
+#endif
   using ::wcrtomb;
   using ::wcscat;
   using ::wcscmp;
@@ -189,7 +189,7 @@ namespace std
   using ::wcstod;
 #if _GLIBCXX_HAVE_WCSTOF
   using ::wcstof;
-#endif 
+#endif
   using ::wcstok;
   using ::wcstol;
   using ::wcstoul;
@@ -270,4 +270,4 @@ namespace std
 
 #endif //_GLIBCXX_USE_WCHAR_T
 
-#endif 
+#endif

libstdc++-v3/include/c_std/std_cwctype.h

@@ -57,7 +57,7 @@
 #undef iswalpha
 #if _GLIBCXX_HAVE_ISWBLANK
 # undef iswblank
-#endif 
+#endif
 #undef iswcntrl
 #undef iswdigit
 #undef iswgraph
@@ -68,7 +68,7 @@
 #undef iswspace
 #undef iswupper
 #undef iswxdigit
-#undef iswctype  
+#undef iswctype
 #undef towlower
 #undef towupper
 #undef towctrans
@@ -78,7 +78,7 @@
 #if _GLIBCXX_USE_WCHAR_T
 namespace std
 {
-  using ::wint_t; 	  // cwchar
+  using ::wint_t;	  // cwchar
 
   using ::wctype_t;
   using ::wctrans_t;
@@ -87,7 +87,7 @@ namespace std
   using ::iswalpha;
 #if _GLIBCXX_HAVE_ISWBLANK
   using ::iswblank;
-#endif 
+#endif
   using ::iswcntrl;
   using ::iswdigit;
   using ::iswgraph;
@@ -107,4 +107,4 @@ namespace std
 }
 #endif //_GLIBCXX_USE_WCHAR_T
 
-#endif 
+#endif