This is the mail archive of the gcc-bugs@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

c++/2364: long long and templates



>Number:         2364
>Category:       c++
>Synopsis:       long long and templates
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          ice-on-legal-code
>Submitter-Id:   net
>Arrival-Date:   Fri Mar 23 09:46:00 PST 2001
>Closed-Date:
>Last-Modified:
>Originator:     Peter Schmid
>Release:        3.0 20010321 (prerelease)
>Organization:
TU Darmstadt
>Environment:
System: Linux kiste 2.4.2 #34 Sun Feb 25 20:03:34 CET 2001 i686 unknown
Architecture: i686
SuSE 7.1
Glibc 2.2
GNU ld version 2.11.90.0.1 (with BFD 2.11.90.0.1)
host: i686-pc-linux-gnu
build: i686-pc-linux-gnu
target: i686-pc-linux-gnu
configured with: ../gcc/configure --enable-shared --disable-nls --enable-threads=posix --enable-long-long --enable-languages=c,c++,f77,objc
>Description:
The following legal source code tll1.C causes an internal compiler
error. It seems that the long long type support for templates is not fully
operating. The code is extracted from the file
boost/integer_traits.hpp from boost version 1.21.1.  
   
>How-To-Repeat:
source code tll1.C

#include <limits>
#include <limits.h>

namespace boost {
template<class T>
class integer_traits : public std::numeric_limits<T>
{
public:
  static const bool is_integral = false;
};

namespace detail {
template<class T, T min_val, T max_val>
class integer_traits_base
{
public:
  static const bool is_integral = true;
  static const T const_min = min_val;
  static const T const_max = max_val;
};
} // namespace detail

template<>
class integer_traits<long long>
  : public std::numeric_limits<long long>,
    public detail::integer_traits_base<long long, LONG_LONG_MIN, LONG_LONG_MAX>
{ };

} // namespace boost



Compiling tll1.C
g++ -v -c tll1.C -W -Wall
Reading specs from /usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/specs
Configured with: ../gcc/configure --enable-shared --disable-nls --enable-threads=posix --enable-long-long --enable-languages=c,c++,f77,objc
gcc version 3.0 20010321 (prerelease)
 /usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/cc1plus -v -D__GNUC__=3 -D__GNUC_MINOR__=0 -D__GNUC_PATCHLEVEL__=0 -D__ELF__ -Dunix -Dlinux -D__ELF__ -D__unix__ -D__linux__ -D__unix -D__linux -Asystem=posix -D__STDC_HOSTED__=1 -W -Wall -Acpu=i386 -Amachine=i386 -Di386 -D__i386 -D__i386__ -D__tune_i686__ -D__tune_pentiumpro__ tll1.C -D__GNUG__=3 -D_GNU_SOURCE -D__EXCEPTIONS -D__GXX_ABI_VERSION=100 -quiet -dumpbase tll1.C -W -Wall -version -o /tmp/ccpl0vRm.s
GNU CPP version 3.0 20010321 (prerelease) (cpplib) (i386 Linux/ELF)
GNU C++ version 3.0 20010321 (prerelease) (i686-pc-linux-gnu)
	compiled by GNU C version 3.0 20010321 (prerelease).
#include "..." search starts here:
#include <...> search starts here:
 /usr/local/include/g++-v3
 /usr/local/include/g++-v3/i686-pc-linux-gnu
 /usr/local/include
 /usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include
 /usr/local/i686-pc-linux-gnu/include
 /usr/include
End of search list.
tll1.C:27: Internal compiler error in tree_low_cst, at tree.c:3424
Please submit a full bug report, with preprocessed source if appropriate.
See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.

Preprocessed source code tll1.ii

# 1 "tll1.C"
# 1 "/usr/local/include/g++-v3/limits" 1 3

# 1 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/std_limits.h" 1 3
# 45 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/std_limits.h" 3
# 1 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 1 3
# 34 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 3
# 1 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/os_defines.h" 1 3
# 43 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3
# 283 "/usr/include/features.h" 3
# 1 "/usr/include/sys/cdefs.h" 1 3
# 284 "/usr/include/features.h" 2 3
# 311 "/usr/include/features.h" 3
# 1 "/usr/include/gnu/stubs.h" 1 3
# 312 "/usr/include/features.h" 2 3
# 44 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/os_defines.h" 2 3
# 35 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/c++config.h" 2 3
# 46 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/std_limits.h" 2 3
# 1 "/usr/local/include/g++-v3/bits/std_cfloat.h" 1 3
# 40 "/usr/local/include/g++-v3/bits/std_cfloat.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/float.h" 1 3
# 41 "/usr/local/include/g++-v3/bits/std_cfloat.h" 2 3
# 47 "/usr/local/include/g++-v3/i686-pc-linux-gnu/bits/std_limits.h" 2 3

namespace std {

    enum float_round_style {
        round_indeterminate = -1,
        round_toward_zero = 0,
        round_to_nearest = 1,
        round_toward_infinity = 2,
        round_toward_neg_infinity = 3
    };

    enum float_denorm_style {
        denorm_indeterminate = -1,
        denorm_absent = 0,
        denorm_present = 1
    };

    template<typename _Tp> struct numeric_limits {
        static const bool is_specialized = false;

        static _Tp min() throw() { return static_cast<_Tp>(0); }
        static _Tp max() throw() { return static_cast<_Tp>(0); }

        static const int digits = 0;
        static const int digits10 = 0;
        static const bool is_signed = false;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 0;

        static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
        static _Tp round_error() throw() { return static_cast<_Tp>(0); }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static _Tp infinity() throw() { return static_cast<_Tp>(0); }
        static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
        static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
        static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = false;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<typename _Tp> _Tp __limits_infinity();
    template<typename _Tp> _Tp __limits_quiet_NaN();
    template<typename _Tp> _Tp __limits_signaling_NaN();
    template<typename _Tp> _Tp __limits_denorm_min();

    template<> struct numeric_limits<bool> {
        static const bool is_specialized = true;

        static bool min() throw()
        { return false; }
        static bool max() throw()
        { return true; }

        static const int digits = 8;
        static const int digits10 = 2;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static bool epsilon() throw()
        { return 0; }
        static bool round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static bool infinity() throw()
        { return static_cast<bool>(0); }
        static bool quiet_NaN() throw()
        { return static_cast<bool>(0); }
        static bool signaling_NaN() throw()
        { return static_cast<bool>(0); }
        static bool denorm_min() throw()
        { return static_cast<bool>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<char> {
        static const bool is_specialized = true;

        static char min() throw()
        { return (-128); }
        static char max() throw()
        { return 127; }

        static const int digits = 7;
        static const int digits10 = 2;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static char epsilon() throw()
        { return 0; }
        static char round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static char infinity() throw()
        { return static_cast<char>(0); }
        static char quiet_NaN() throw()
        { return static_cast<char>(0); }
        static char signaling_NaN() throw()
        { return static_cast<char>(0); }
        static char denorm_min() throw()
        { return static_cast<char>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<signed char> {
        static const bool is_specialized = true;

        static signed char min() throw()
        { return (-128); }
        static signed char max() throw()
        { return 127; }

        static const int digits = 7;
        static const int digits10 = 2;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static signed char epsilon() throw()
        { return 0; }
        static signed char round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static signed char infinity() throw()
        { return static_cast<signed char>(0); }
        static signed char quiet_NaN() throw()
        { return static_cast<signed char>(0); }
        static signed char signaling_NaN() throw()
        { return static_cast<signed char>(0); }
        static signed char denorm_min() throw()
        { return static_cast<signed char>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned char> {
        static const bool is_specialized = true;

        static unsigned char min() throw()
        { return 0; }
        static unsigned char max() throw()
        { return 255; }

        static const int digits = 8;
        static const int digits10 = 2;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned char epsilon() throw()
        { return 0; }
        static unsigned char round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned char infinity() throw()
        { return static_cast<unsigned char>(0); }
        static unsigned char quiet_NaN() throw()
        { return static_cast<unsigned char>(0); }
        static unsigned char signaling_NaN() throw()
        { return static_cast<unsigned char>(0); }
        static unsigned char denorm_min() throw()
        { return static_cast<unsigned char>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<short> {
        static const bool is_specialized = true;

        static short min() throw()
        { return (-32767-1); }
        static short max() throw()
        { return 32767; }

        static const int digits = 15;
        static const int digits10 = 4;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static short epsilon() throw()
        { return 0; }
        static short round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static short infinity() throw()
        { return static_cast<short>(0); }
        static short quiet_NaN() throw()
        { return static_cast<short>(0); }
        static short signaling_NaN() throw()
        { return static_cast<short>(0); }
        static short denorm_min() throw()
        { return static_cast<short>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned short> {
        static const bool is_specialized = true;

        static unsigned short min() throw()
        { return 0; }
        static unsigned short max() throw()
        { return 65535; }

        static const int digits = 16;
        static const int digits10 = 4;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned short epsilon() throw()
        { return 0; }
        static unsigned short round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned short infinity() throw()
        { return static_cast<unsigned short>(0); }
        static unsigned short quiet_NaN() throw()
        { return static_cast<unsigned short>(0); }
        static unsigned short signaling_NaN() throw()
        { return static_cast<unsigned short>(0); }
        static unsigned short denorm_min() throw()
        { return static_cast<unsigned short>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<int> {
        static const bool is_specialized = true;

        static int min() throw()
        { return (-2147483647-1); }
        static int max() throw()
        { return 2147483647; }

        static const int digits = 31;
        static const int digits10 = 9;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static int epsilon() throw()
        { return 0; }
        static int round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static int infinity() throw()
        { return static_cast<int>(0); }
        static int quiet_NaN() throw()
        { return static_cast<int>(0); }
        static int signaling_NaN() throw()
        { return static_cast<int>(0); }
        static int denorm_min() throw()
        { return static_cast<int>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned int> {
        static const bool is_specialized = true;

        static unsigned int min() throw()
        { return 0; }
        static unsigned int max() throw()
        { return (2147483647 * 2U + 1); }

        static const int digits = 32;
        static const int digits10 = 9;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned int epsilon() throw()
        { return 0; }
        static unsigned int round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned int infinity() throw()
        { return static_cast<unsigned int>(0); }
        static unsigned int quiet_NaN() throw()
        { return static_cast<unsigned int>(0); }
        static unsigned int signaling_NaN() throw()
        { return static_cast<unsigned int>(0); }
        static unsigned int denorm_min() throw()
        { return static_cast<unsigned int>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<long> {
        static const bool is_specialized = true;

        static long min() throw()
        { return (-2147483647L-1); }
        static long max() throw()
        { return 2147483647L; }

        static const int digits = 31;
        static const int digits10 = 9;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static long epsilon() throw()
        { return 0; }
        static long round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static long infinity() throw()
        { return static_cast<long>(0); }
        static long quiet_NaN() throw()
        { return static_cast<long>(0); }
        static long signaling_NaN() throw()
        { return static_cast<long>(0); }
        static long denorm_min() throw()
        { return static_cast<long>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned long> {
        static const bool is_specialized = true;

        static unsigned long min() throw()
        { return 0; }
        static unsigned long max() throw()
        { return (2147483647L * 2UL + 1); }

        static const int digits = 32;
        static const int digits10 = 9;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned long epsilon() throw()
        { return 0; }
        static unsigned long round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned long infinity() throw()
        { return static_cast<unsigned long>(0); }
        static unsigned long quiet_NaN() throw()
        { return static_cast<unsigned long>(0); }
        static unsigned long signaling_NaN() throw()
        { return static_cast<unsigned long>(0); }
        static unsigned long denorm_min() throw()
        { return static_cast<unsigned long>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<long long> {
        static const bool is_specialized = true;

        static long long min() throw()
        { return (-9223372036854775807LL-1); }
        static long long max() throw()
        { return 9223372036854775807LL; }

        static const int digits = 63;
        static const int digits10 = 18;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static long long epsilon() throw()
        { return 0; }
        static long long round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static long long infinity() throw()
        { return static_cast<long long>(0); }
        static long long quiet_NaN() throw()
        { return static_cast<long long>(0); }
        static long long signaling_NaN() throw()
        { return static_cast<long long>(0); }
        static long long denorm_min() throw()
        { return static_cast<long long>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned long long> {
        static const bool is_specialized = true;

        static unsigned long long min() throw()
        { return 0; }
        static unsigned long long max() throw()
        { return (9223372036854775807LL * 2ULL + 1); }

        static const int digits = 64;
        static const int digits10 = 19;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned long long epsilon() throw()
        { return 0; }
        static unsigned long long round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned long long infinity() throw()
        { return static_cast<unsigned long long>(0); }
        static unsigned long long quiet_NaN() throw()
        { return static_cast<unsigned long long>(0); }
        static unsigned long long signaling_NaN() throw()
        { return static_cast<unsigned long long>(0); }
        static unsigned long long denorm_min() throw()
        { return static_cast<unsigned long long>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<float> {
        static const bool is_specialized = true;

        static float min() throw()
        { return 1.17549435e-38F; }
        static float max() throw()
        { return 3.40282347e+38F; }

        static const int digits = 24;
        static const int digits10 = 7;
        static const bool is_signed = true;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 2;
        static float epsilon() throw()
        { return 1.19209290e-07F; }
        static float round_error() throw()
        { return 1.0f; }

        static const int min_exponent = -125;
        static const int min_exponent10 = -37;
        static const int max_exponent = 128;
        static const int max_exponent10 = 38;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static float infinity() throw()
        { return static_cast<float>(0); }
        static float quiet_NaN() throw()
        { return static_cast<float>(0); }
        static float signaling_NaN() throw()
        { return static_cast<float>(0); }
        static float denorm_min() throw()
        { return static_cast<float>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<double> {
        static const bool is_specialized = true;

        static double min() throw()
        { return 2.2250738585072014e-308; }
        static double max() throw()
        { return 1.7976931348623157e+308; }

        static const int digits = 53;
        static const int digits10 = 15;
        static const bool is_signed = true;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 2;
        static double epsilon() throw()
        { return 2.2204460492503131e-16; }
        static double round_error() throw()
        { return 1.0; }

        static const int min_exponent = -1021;
        static const int min_exponent10 = -307;
        static const int max_exponent = 1024;
        static const int max_exponent10 = 308;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static double infinity() throw()
        { return static_cast<double>(0); }
        static double quiet_NaN() throw()
        { return static_cast<double>(0); }
        static double signaling_NaN() throw()
        { return static_cast<double>(0); }
        static double denorm_min() throw()
        { return static_cast<double>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<long double> {
        static const bool is_specialized = true;

        static long double min() throw()
        { return 3.36210314311209350626e-4932L; }
        static long double max() throw()
        { return 1.18973149535723176502e+4932L; }

        static const int digits = 64;
        static const int digits10 = 19;
        static const bool is_signed = true;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 2;
        static long double epsilon() throw()
        { return 1.08420217248550443401e-19L; }
        static long double round_error() throw()
        { return 1.0L; }

        static const int min_exponent = -16381;
        static const int min_exponent10 = -4931;
        static const int max_exponent = 16384;
        static const int max_exponent10 = 4932;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static long double infinity() throw()
        { return static_cast<long double>(0); }
        static long double quiet_NaN() throw()
        { return static_cast<long double>(0); }
        static long double signaling_NaN() throw()
        { return static_cast<long double>(0); }
        static long double denorm_min() throw()
        { return static_cast<long double>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

}
# 3 "/usr/local/include/g++-v3/limits" 2 3
# 2 "tll1.C" 2
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/limits.h" 1 3
# 11 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/limits.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/syslimits.h" 1 3






# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/limits.h" 1 3
# 130 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/limits.h" 3
# 1 "/usr/include/limits.h" 1 3
# 26 "/usr/include/limits.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/limits.h" 2 3
# 144 "/usr/include/limits.h" 3
# 1 "/usr/include/bits/posix1_lim.h" 1 3
# 126 "/usr/include/bits/posix1_lim.h" 3
# 1 "/usr/include/bits/local_lim.h" 1 3
# 36 "/usr/include/bits/local_lim.h" 3
# 1 "/usr/include/linux/limits.h" 1 3
# 37 "/usr/include/bits/local_lim.h" 2 3
# 127 "/usr/include/bits/posix1_lim.h" 2 3
# 145 "/usr/include/limits.h" 2 3



# 1 "/usr/include/bits/posix2_lim.h" 1 3
# 149 "/usr/include/limits.h" 2 3



# 1 "/usr/include/bits/xopen_lim.h" 1 3
# 35 "/usr/include/bits/xopen_lim.h" 3
# 1 "/usr/include/bits/stdio_lim.h" 1 3
# 36 "/usr/include/bits/xopen_lim.h" 2 3
# 137 "/usr/include/bits/xopen_lim.h" 3
# 1 "/usr/include/bits/wordsize.h" 1 3
# 138 "/usr/include/bits/xopen_lim.h" 2 3
# 153 "/usr/include/limits.h" 2 3
# 131 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/limits.h" 2 3
# 8 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/syslimits.h" 2 3
# 12 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0/include/limits.h" 2 3
# 3 "tll1.C" 2

namespace boost {
template<class T>
class integer_traits : public std::numeric_limits<T>
{
public:
  static const bool is_integral = false;
};

namespace detail {
template<class T, T min_val, T max_val>
class integer_traits_base
{
public:
  static const bool is_integral = true;
  static const T const_min = min_val;
  static const T const_max = max_val;
};
}

template<>
class integer_traits<long long>
  : public std::numeric_limits<long long>,
    public detail::integer_traits_base<long long, (-9223372036854775807LL -1), 9223372036854775807LL>
{ };

}


>Fix:
	
>Release-Note:
>Audit-Trail:
>Unformatted:


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]