+2010-02-25 Ed Smith-Rowland <3dw4rd@verizon.net>
+
+ * include/std/limits (__numeric_limits_base::max_digits10,
+ numeric_limits<>::max_digits10, numeric_limits<>::lowest): Add.
+ * src/limits.cc: Define max_digits10.
+ * config/abi/pre/gnu.ver: Adjust.
+ * testsuite/18_support/numeric_limits/dr559.cc: Test max_digits10
+ and lowest too.
+ * testsuite/18_support/numeric_limits/lowest.cc: New.
+ * testsuite/18_support/numeric_limits/max_digits10.cc: New.
+
2010-02-25 Paolo Carlini <paolo.carlini@oracle.com>
* include/bits/functional_hash.h (__hash_combine): Remove.
std::_List_node_base::reverse*;
std::_List_node_base::transfer*;
std::__timepunct*;
- std::__numeric_limits_base*;
+# std::__numeric_limits_base*;
std::__num_base::_S_format_float*;
std::__num_base::_S_format_int*;
std::__num_base::_S_atoms_in;
_ZNSt15time_put_byname*;
# std::numeric_limits
- _ZNSt14numeric_limitsI[^g]E*;
+ _ZNSt21__numeric_limits_base[5-9]*;
+ _ZNSt21__numeric_limits_base1[0-7][hirt]*;
+ _ZNSt21__numeric_limits_base1[0-7]mi*;
+ _ZNSt21__numeric_limits_base1[0-7]max_e*;
+
+ _ZNSt14numeric_limitsI[^g]E[5-9]*;
+ _ZNSt14numeric_limitsI[^g]E1[0-7][hirt]*;
+ _ZNSt14numeric_limitsI[^g]E1[0-7]mi*;
+ _ZNSt14numeric_limitsI[^g]E1[0-7]max_e*;
# std::_Rb_tree
_ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base;
_ZSt20__throw_system_errori;
# char16_t and char32_t
- _ZNSt14numeric_limitsIDiE*;
- _ZNSt14numeric_limitsIDsE*;
+ _ZNSt14numeric_limitsIDiE[5-9]*;
+ _ZNSt14numeric_limitsIDsE[5-9]*;
+ _ZNSt14numeric_limitsIDiE1[0-7][hirt]*;
+ _ZNSt14numeric_limitsIDsE1[0-7][hirt]*;
+ _ZNSt14numeric_limitsIDiE1[0-7]mi*;
+ _ZNSt14numeric_limitsIDsE1[0-7]mi*;
+ _ZNSt14numeric_limitsIDiE1[0-7]max_e*;
+ _ZNSt14numeric_limitsIDsE1[0-7]max_e*;
# chrono
_ZNSt6chrono12system_clock12is_monotonicE;
_ZNSt9__cxx199815_List_node_base9_M_unhookEv;
_ZNSt9__cxx199815_List_node_base10_M_reverseEv;
_ZNSt9__cxx199815_List_node_base11_M_transfer*;
+
+ # std::numeric_limits::max_digits10
+ _ZNSt21__numeric_limits_base12max_digits10E;
+ _ZNSt14numeric_limitsI[^g]E12max_digits10E;
+ _ZNSt14numeric_limitsID[is]E12max_digits10E;
+
} GLIBCXX_3.4.13;
+
# Symbols in the support library (libsupc++) have their own tag.
CXXABI_1.3 {
#define __glibcxx_digits10(T) \
(__glibcxx_digits (T) * 643 / 2136)
+#define __glibcxx_max_digits10(T) \
+ (2 + (T) * 643 / 2136)
_GLIBCXX_BEGIN_NAMESPACE(std)
static const int digits = 0;
/** The number of base 10 digits that can be represented without change. */
static const int digits10 = 0;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /** The number of base 10 digits required to ensure that values which
+ differ are always differentiated. */
+ static const int max_digits10 = 0;
+#endif
/** True if the type is signed. */
static const bool is_signed = false;
/** True if the type is integer.
- * Is this supposed to be <em>if the type is integral?</em>
- */
+ * Is this supposed to be <em>if the type is integral?</em> */
static const bool is_integer = false;
/** True if the type uses an exact representation. <em>All integer types are
exact, but not all exact types are integer. For example, rational and
static _Tp min() throw() { return static_cast<_Tp>(0); }
/** The maximum finite value. */
static _Tp max() throw() { return static_cast<_Tp>(0); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ /** A finite value x such that there is no other finite value y
+ * where y < x. */
+ static _Tp lowest() throw() { return static_cast<_Tp>(0); }
+#endif
/** The @e machine @e epsilon: the difference between 1 and the least
value greater than 1 that is representable. */
static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
{ return false; }
static bool max() throw()
{ return true; }
-
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static bool lowest() throw()
+ { return min(); }
+#endif
static const int digits = 1;
static const int digits10 = 0;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
{ return __glibcxx_min(char); }
static char max() throw()
{ return __glibcxx_max(char); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static char lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (char);
static const int digits10 = __glibcxx_digits10 (char);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = __glibcxx_signed (char);
static const bool is_integer = true;
static const bool is_exact = true;
{ return -__SCHAR_MAX__ - 1; }
static signed char max() throw()
{ return __SCHAR_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static signed char lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (signed char);
static const int digits10 = __glibcxx_digits10 (signed char);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
{ return 0; }
static unsigned char max() throw()
{ return __SCHAR_MAX__ * 2U + 1; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static unsigned char lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (unsigned char);
static const int digits10 = __glibcxx_digits10 (unsigned char);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
{ return __glibcxx_min (wchar_t); }
static wchar_t max() throw()
{ return __glibcxx_max (wchar_t); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static wchar_t lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (wchar_t);
static const int digits10 = __glibcxx_digits10 (wchar_t);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = __glibcxx_signed (wchar_t);
static const bool is_integer = true;
static const bool is_exact = true;
{ return __glibcxx_min (char16_t); }
static char16_t max() throw()
{ return __glibcxx_max (char16_t); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static char16_t lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (char16_t);
static const int digits10 = __glibcxx_digits10 (char16_t);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = __glibcxx_signed (char16_t);
static const bool is_integer = true;
static const bool is_exact = true;
{ return __glibcxx_min (char32_t); }
static char32_t max() throw()
{ return __glibcxx_max (char32_t); }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static char32_t lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (char32_t);
static const int digits10 = __glibcxx_digits10 (char32_t);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = __glibcxx_signed (char32_t);
static const bool is_integer = true;
static const bool is_exact = true;
{ return -__SHRT_MAX__ - 1; }
static short max() throw()
{ return __SHRT_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static short lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (short);
static const int digits10 = __glibcxx_digits10 (short);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
{ return 0; }
static unsigned short max() throw()
{ return __SHRT_MAX__ * 2U + 1; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static unsigned short lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (unsigned short);
static const int digits10 = __glibcxx_digits10 (unsigned short);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
{ return -__INT_MAX__ - 1; }
static int max() throw()
{ return __INT_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static int lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (int);
static const int digits10 = __glibcxx_digits10 (int);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
{ return 0; }
static unsigned int max() throw()
{ return __INT_MAX__ * 2U + 1; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static unsigned int lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (unsigned int);
static const int digits10 = __glibcxx_digits10 (unsigned int);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
{ return -__LONG_MAX__ - 1; }
static long max() throw()
{ return __LONG_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static long lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (long);
static const int digits10 = __glibcxx_digits10 (long);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
{ return 0; }
static unsigned long max() throw()
{ return __LONG_MAX__ * 2UL + 1; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static unsigned long lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (unsigned long);
static const int digits10 = __glibcxx_digits10 (unsigned long);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
{ return -__LONG_LONG_MAX__ - 1; }
static long long max() throw()
{ return __LONG_LONG_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static long long lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (long long);
static const int digits10 = __glibcxx_digits10 (long long);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = true;
static const bool is_integer = true;
static const bool is_exact = true;
{ return 0; }
static unsigned long long max() throw()
{ return __LONG_LONG_MAX__ * 2ULL + 1; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static unsigned long long lowest() throw()
+ { return min(); }
+#endif
static const int digits = __glibcxx_digits (unsigned long long);
static const int digits10 = __glibcxx_digits10 (unsigned long long);
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10 = 0;
+#endif
static const bool is_signed = false;
static const bool is_integer = true;
static const bool is_exact = true;
{ return __FLT_MIN__; }
static float max() throw()
{ return __FLT_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static float lowest() throw()
+ { return -__FLT_MAX__; }
+#endif
static const int digits = __FLT_MANT_DIG__;
static const int digits10 = __FLT_DIG__;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10
+ = __glibcxx_max_digits10 (__FLT_MANT_DIG__);
+#endif
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
{ return __DBL_MIN__; }
static double max() throw()
{ return __DBL_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static double lowest() throw()
+ { return -__DBL_MAX__; }
+#endif
static const int digits = __DBL_MANT_DIG__;
static const int digits10 = __DBL_DIG__;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10
+ = __glibcxx_max_digits10 (__DBL_MANT_DIG__);
+#endif
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
{ return __LDBL_MIN__; }
static long double max() throw()
{ return __LDBL_MAX__; }
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static long double lowest() throw()
+ { return -__LDBL_MAX__; }
+#endif
static const int digits = __LDBL_MANT_DIG__;
static const int digits10 = __LDBL_DIG__;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ static const int max_digits10
+ = __glibcxx_max_digits10 (__LDBL_MANT_DIG__);
+#endif
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
#undef __glibcxx_max
#undef __glibcxx_digits
#undef __glibcxx_digits10
+#undef __glibcxx_max_digits10
#endif // _GLIBCXX_NUMERIC_LIMITS
const bool __numeric_limits_base::is_specialized;
const int __numeric_limits_base::digits;
const int __numeric_limits_base::digits10;
+ const int __numeric_limits_base::max_digits10;
const bool __numeric_limits_base::is_signed;
const bool __numeric_limits_base::is_integer;
const bool __numeric_limits_base::is_exact;
const bool numeric_limits<bool>::is_specialized;
const int numeric_limits<bool>::digits;
const int numeric_limits<bool>::digits10;
+ const int numeric_limits<bool>::max_digits10;
const bool numeric_limits<bool>::is_signed;
const bool numeric_limits<bool>::is_integer;
const bool numeric_limits<bool>::is_exact;
const bool numeric_limits<char>::is_specialized;
const int numeric_limits<char>::digits;
const int numeric_limits<char>::digits10;
+ const int numeric_limits<char>::max_digits10;
const bool numeric_limits<char>::is_signed;
const bool numeric_limits<char>::is_integer;
const bool numeric_limits<char>::is_exact;
const bool numeric_limits<signed char>::is_specialized;
const int numeric_limits<signed char>::digits;
const int numeric_limits<signed char>::digits10;
+ const int numeric_limits<signed char>::max_digits10;
const bool numeric_limits<signed char>::is_signed;
const bool numeric_limits<signed char>::is_integer;
const bool numeric_limits<signed char>::is_exact;
const bool numeric_limits<unsigned char>::is_specialized;
const int numeric_limits<unsigned char>::digits;
const int numeric_limits<unsigned char>::digits10;
+ const int numeric_limits<unsigned char>::max_digits10;
const bool numeric_limits<unsigned char>::is_signed;
const bool numeric_limits<unsigned char>::is_integer;
const bool numeric_limits<unsigned char>::is_exact;
const bool numeric_limits<wchar_t>::is_specialized;
const int numeric_limits<wchar_t>::digits;
const int numeric_limits<wchar_t>::digits10;
+ const int numeric_limits<wchar_t>::max_digits10;
const bool numeric_limits<wchar_t>::is_signed;
const bool numeric_limits<wchar_t>::is_integer;
const bool numeric_limits<wchar_t>::is_exact;
const bool numeric_limits<short>::is_specialized;
const int numeric_limits<short>::digits;
const int numeric_limits<short>::digits10;
+ const int numeric_limits<short>::max_digits10;
const bool numeric_limits<short>::is_signed;
const bool numeric_limits<short>::is_integer;
const bool numeric_limits<short>::is_exact;
const bool numeric_limits<unsigned short>::is_specialized;
const int numeric_limits<unsigned short>::digits;
const int numeric_limits<unsigned short>::digits10;
+ const int numeric_limits<unsigned short>::max_digits10;
const bool numeric_limits<unsigned short>::is_signed;
const bool numeric_limits<unsigned short>::is_integer;
const bool numeric_limits<unsigned short>::is_exact;
const bool numeric_limits<int>::is_specialized;
const int numeric_limits<int>::digits;
const int numeric_limits<int>::digits10;
+ const int numeric_limits<int>::max_digits10;
const bool numeric_limits<int>::is_signed;
const bool numeric_limits<int>::is_integer;
const bool numeric_limits<int>::is_exact;
const bool numeric_limits<unsigned int>::is_specialized;
const int numeric_limits<unsigned int>::digits;
const int numeric_limits<unsigned int>::digits10;
+ const int numeric_limits<unsigned int>::max_digits10;
const bool numeric_limits<unsigned int>::is_signed;
const bool numeric_limits<unsigned int>::is_integer;
const bool numeric_limits<unsigned int>::is_exact;
const bool numeric_limits<long>::is_specialized;
const int numeric_limits<long>::digits;
const int numeric_limits<long>::digits10;
+ const int numeric_limits<long>::max_digits10;
const bool numeric_limits<long>::is_signed;
const bool numeric_limits<long>::is_integer;
const bool numeric_limits<long>::is_exact;
const bool numeric_limits<unsigned long>::is_specialized;
const int numeric_limits<unsigned long>::digits;
const int numeric_limits<unsigned long>::digits10;
+ const int numeric_limits<unsigned long>::max_digits10;
const bool numeric_limits<unsigned long>::is_signed;
const bool numeric_limits<unsigned long>::is_integer;
const bool numeric_limits<unsigned long>::is_exact;
const bool numeric_limits<long long>::is_specialized;
const int numeric_limits<long long>::digits;
const int numeric_limits<long long>::digits10;
+ const int numeric_limits<long long>::max_digits10;
const bool numeric_limits<long long>::is_signed;
const bool numeric_limits<long long>::is_integer;
const bool numeric_limits<long long>::is_exact;
const bool numeric_limits<unsigned long long>::is_specialized;
const int numeric_limits<unsigned long long>::digits;
const int numeric_limits<unsigned long long>::digits10;
+ const int numeric_limits<unsigned long long>::max_digits10;
const bool numeric_limits<unsigned long long>::is_signed;
const bool numeric_limits<unsigned long long>::is_integer;
const bool numeric_limits<unsigned long long>::is_exact;
const bool numeric_limits<float>::is_specialized;
const int numeric_limits<float>::digits;
const int numeric_limits<float>::digits10;
+ const int numeric_limits<float>::max_digits10;
const bool numeric_limits<float>::is_signed;
const bool numeric_limits<float>::is_integer;
const bool numeric_limits<float>::is_exact;
const bool numeric_limits<double>::is_specialized;
const int numeric_limits<double>::digits;
const int numeric_limits<double>::digits10;
+ const int numeric_limits<double>::max_digits10;
const bool numeric_limits<double>::is_signed;
const bool numeric_limits<double>::is_integer;
const bool numeric_limits<double>::is_exact;
const bool numeric_limits<long double>::is_specialized;
const int numeric_limits<long double>::digits;
const int numeric_limits<long double>::digits10;
+ const int numeric_limits<long double>::max_digits10;
const bool numeric_limits<long double>::is_signed;
const bool numeric_limits<long double>::is_integer;
const bool numeric_limits<long double>::is_exact;
const bool numeric_limits<char16_t>::is_specialized;
const int numeric_limits<char16_t>::digits;
const int numeric_limits<char16_t>::digits10;
+ const int numeric_limits<char16_t>::max_digits10;
const bool numeric_limits<char16_t>::is_signed;
const bool numeric_limits<char16_t>::is_integer;
const bool numeric_limits<char16_t>::is_exact;
const bool numeric_limits<char32_t>::is_specialized;
const int numeric_limits<char32_t>::digits;
const int numeric_limits<char32_t>::digits10;
+ const int numeric_limits<char32_t>::max_digits10;
const bool numeric_limits<char32_t>::is_signed;
const bool numeric_limits<char32_t>::is_integer;
const bool numeric_limits<char32_t>::is_exact;
VERIFY( cv_limits::is_specialized == limits::is_specialized );
VERIFY( cv_limits::min() == limits::min() );
VERIFY( cv_limits::max() == limits::max() );
+ VERIFY( cv_limits::lowest() == limits::lowest() );
VERIFY( cv_limits::digits == limits::digits );
VERIFY( cv_limits::digits10 == limits::digits10 );
+ VERIFY( cv_limits::max_digits10 == limits::max_digits10 );
VERIFY( cv_limits::is_signed == limits::is_signed );
VERIFY( cv_limits::is_integer == limits::is_integer );
VERIFY( cv_limits::is_exact == limits::is_exact );
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-add-options ieee }
+
+// 2010-02-25 Ed Smith-Rowland
+
+// Copyright (C) 2010 Free Software Foundation
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <type_traits>
+#include <testsuite_hooks.h>
+
+template<typename T>
+ void
+ do_test(std::true_type)
+ {
+ bool test __attribute__((unused)) = true;
+ T limits_min = std::numeric_limits<T>::min();
+ VERIFY( std::numeric_limits<T>::lowest() == limits_min );
+ }
+
+template<typename T>
+ void
+ do_test(std::false_type)
+ {
+ bool test __attribute__((unused)) = true;
+ T limits_max = std::numeric_limits<T>::max();
+ VERIFY( std::numeric_limits<T>::lowest() == -limits_max );
+ }
+
+template<typename Tp>
+ void
+ do_test()
+ { do_test<Tp>(typename std::is_integral<Tp>::type()); }
+
+void test01()
+{
+ do_test<char>();
+ do_test<signed char>();
+ do_test<unsigned char>();
+ do_test<wchar_t>();
+ do_test<char16_t>();
+ do_test<char32_t>();
+
+ do_test<short>();
+ do_test<unsigned short>();
+
+ do_test<int>();
+ do_test<unsigned int>();
+
+ do_test<long>();
+ do_test<unsigned long>();
+
+ do_test<long long>();
+ do_test<unsigned long long>();
+
+ do_test<float>();
+ do_test<double>();
+ do_test<long double>();
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
--- /dev/null
+// { dg-options "-std=gnu++0x" }
+// { dg-add-options ieee }
+
+// 2010-02-25 Ed Smith-Rowland
+
+// Copyright (C) 2010 Free Software Foundation
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// 18.2.1.1 template class numeric_limits
+
+#include <limits>
+#include <cmath>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ bool test __attribute__((unused)) = true;
+
+ VERIFY( std::numeric_limits<bool>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<char>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<signed char>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<unsigned char>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<wchar_t>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<short>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<unsigned short>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<int>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<unsigned int>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<long>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<unsigned long>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<long long>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<unsigned long long>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<char16_t>::max_digits10 == 0 );
+ VERIFY( std::numeric_limits<char32_t>::max_digits10 == 0 );
+
+ const int f_max_digits10 = (2 + std::numeric_limits<float>::digits
+ * 643 / 2136);
+ VERIFY( std::numeric_limits<float>::max_digits10 == f_max_digits10 );
+
+ const int d_max_digits10 = (2 + std::numeric_limits<double>::digits
+ * 643 / 2136);
+ VERIFY( std::numeric_limits<double>::max_digits10 == d_max_digits10 );
+
+ const int ld_max_digits10 = (2 + std::numeric_limits<long double>::digits
+ * 643 / 2136);
+ VERIFY( std::numeric_limits<long double>::max_digits10 == ld_max_digits10 );
+}
+
+int main()
+{
+ test01();
+ return 0;
+}
projects / platform / upstream / gcc.git / commitdiff