[ceph.git] / ceph / src / boost / boost / spirit / home / support / detail / math / detail / fp_traits.hpp

// fp_traits.hpp

#ifndef BOOST_SPIRIT_MATH_FP_TRAITS_HPP
#define BOOST_SPIRIT_MATH_FP_TRAITS_HPP

// Copyright (c) 2006 Johan Rade

// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
#   error The VAX floating point mode on VMS is not supported.
#endif

#if defined(_MSC_VER)
#pragma once
#endif

#include <cstring>

#include <boost/assert.hpp>
#include <boost/cstdint.hpp>
#include <boost/detail/endian.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_floating_point.hpp>

//------------------------------------------------------------------------------

namespace boost {
namespace spirit {
namespace math {
namespace detail {

//------------------------------------------------------------------------------

/*
Most processors support three different floating point precisions:
single precision (32 bits), double precision (64 bits)
and extended double precision (>64 bits)

Note that the C++ type long double can be implemented
both as double precision and extended double precision.
*/

struct single_precision_tag {};
struct double_precision_tag {};
struct extended_double_precision_tag {};

//------------------------------------------------------------------------------

/*
template<class T, class U> struct fp_traits_impl;

  This is traits class that describes the binary structure of floating
  point numbers of C++ type T and precision U

Requirements: 

  T = float, double or long double
  U = single_precision_tag, double_precision_tag
      or extended_double_precision_tag

Typedef members:

  bits -- the target type when copying the leading bytes of a floating
      point number. It is a typedef for uint32_t or uint64_t.

  coverage -- tells us whether all bytes are copied or not.
      It is a typedef for all_bits or not_all_bits.

Static data members:

  sign, exponent, flag, mantissa -- bit masks that give the meaning of the bits
      in the leading bytes.

Static function members:

  init() -- initializes the static data members, if needed.
            (Is a no-op in the specialized versions of the template.)

  get_bits(), set_bits() -- provide access to the leading bytes.
*/

struct all_bits {};
struct not_all_bits {};

// Generic version -------------------------------------------------------------

// The generic version uses run time initialization to determine the floating
// point format. It is capable of handling most formats,
// but not the Motorola 68K extended double precision format.

// Currently the generic version is used only for extended double precision
// on Itanium. In all other cases there are specializations of the template
// that use compile time initialization.

template<class T> struct uint32_t_coverage
{
    typedef not_all_bits type;
};

template<> struct uint32_t_coverage<single_precision_tag>
{
    typedef all_bits type;
};

template<class T, class U> struct fp_traits_impl
{
    typedef uint32_t bits;
    typedef BOOST_DEDUCED_TYPENAME uint32_t_coverage<U>::type coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
    static uint32_t exponent;
    static uint32_t flag;
    static uint32_t mantissa;

    static void init()
    {
        if(is_init_) return;
        do_init_();
        is_init_ = true;
    }

    static void get_bits(T x, uint32_t& a)
    {
        memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
    }

    static void set_bits(T& x, uint32_t a)
    {
        memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
    }

private:
    static size_t offset_;
    static bool is_init_;
    static void do_init_();
};

//..............................................................................

template<class T, class U> uint32_t fp_traits_impl<T,U>::exponent;
template<class T, class U> uint32_t fp_traits_impl<T,U>::flag;
template<class T, class U> uint32_t fp_traits_impl<T,U>::mantissa;
template<class T, class U> size_t   fp_traits_impl<T,U>::offset_;
template<class T, class U> bool     fp_traits_impl<T,U>::is_init_;

// In a single-threaded program, do_init will be called exactly once.
// In a multi-threaded program, do_init may be called simultaneously
// by more then one thread. That should not be a problem.

//..............................................................................

template<class T, class U> void fp_traits_impl<T,U>::do_init_()
{
    T x = static_cast<T>(3) / static_cast<T>(4);
    // sign bit = 0
    // exponent: first and last bit = 0, all other bits  = 1
    // flag bit (if present) = 1
    // mantissa: first bit = 1, all other bits = 0

    uint32_t a;

    for(size_t k = 0; k <= sizeof(T) - 4; ++k) {

        memcpy(&a, reinterpret_cast<unsigned char*>(&x) + k, 4);

        switch(a) {

        case 0x3f400000:      // IEEE single precision format

            offset_  = k;      
            exponent = 0x7f800000;
            flag     = 0x00000000;
            mantissa = 0x007fffff;
            return;

        case 0x3fe80000:      // IEEE double precision format 
                              // and PowerPC extended double precision format
            offset_  = k;      
            exponent = 0x7ff00000;
            flag     = 0x00000000;
            mantissa = 0x000fffff;
            return;

        case 0x3ffe0000:      // Motorola extended double precision format

            // Must not get here. Must be handled by specialization.
            // To get accurate cutoff between normals and subnormals
            // we must use the flag bit that is in the 5th byte.
            // Otherwise this cutoff will be off by a factor 2.
            // If we do get here, then we have failed to detect the Motorola
            // processor at compile time.

            BOOST_ASSERT(false && 
                "Failed to detect the Motorola processor at compile time");        
            return;

        case 0x3ffe8000:      // IEEE extended double precision format
                              // with 15 exponent bits
            offset_  = k;      
            exponent = 0x7fff0000;
            flag     = 0x00000000;
            mantissa = 0x0000ffff;
            return;

        case 0x3ffec000:      // Intel extended double precision format

            offset_  = k;
            exponent = 0x7fff0000;
            flag     = 0x00008000;
            mantissa = 0x00007fff;
            return;

        default:
            continue;
        }
    }

    BOOST_ASSERT(false); 

    // Unknown format.
}


// float (32 bits) -------------------------------------------------------------

template<> struct fp_traits_impl<float, single_precision_tag>
{
    typedef uint32_t bits;
    typedef all_bits coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
    BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7f800000);
    BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00000000);
    BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x007fffff);

    static void init() {}
    static void get_bits(float x, uint32_t& a) { memcpy(&a, &x, 4); }
    static void set_bits(float& x, uint32_t a) { memcpy(&x, &a, 4); }
};


// double (64 bits) ------------------------------------------------------------

#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)

template<> struct fp_traits_impl<double, double_precision_tag>
{
    typedef uint32_t bits;
    typedef not_all_bits coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
    BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
    BOOST_STATIC_CONSTANT(uint32_t, flag     = 0);
    BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);

    static void init() {}

    static void get_bits(double x, uint32_t& a)
    {
        memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
    }

    static void set_bits(double& x, uint32_t a)
    {
        memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
    }

private:

#if defined(BOOST_BIG_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif defined(BOOST_LITTLE_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 4);
#else
    BOOST_STATIC_ASSERT(false);
#endif
};

//..............................................................................

#else

template<> struct fp_traits_impl<double, double_precision_tag>
{
    typedef uint64_t bits;
    typedef all_bits coverage;

    static const uint64_t sign     = (uint64_t)0x80000000 << 32;
    static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
    static const uint64_t flag     = 0;
    static const uint64_t mantissa
        = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;

    static void init() {}
    static void get_bits(double x, uint64_t& a) { memcpy(&a, &x, 8); }
    static void set_bits(double& x, uint64_t a) { memcpy(&x, &a, 8); }
};

#endif


// long double (64 bits) -------------------------------------------------------

#if defined(BOOST_NO_INT64_T) || defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)

template<> struct fp_traits_impl<long double, double_precision_tag>
{
    typedef uint32_t bits;
    typedef not_all_bits coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
    BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
    BOOST_STATIC_CONSTANT(uint32_t, flag     = 0);
    BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);

    static void init() {}

    static void get_bits(long double x, uint32_t& a)
    {
        memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
    }

    static void set_bits(long double& x, uint32_t a)
    {
        memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
    }

private:

#if defined(BOOST_BIG_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif defined(BOOST_LITTLE_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 4);
#else
    BOOST_STATIC_ASSERT(false);
#endif
};

//..............................................................................

#else

template<> struct fp_traits_impl<long double, double_precision_tag>
{
    typedef uint64_t bits;
    typedef all_bits coverage;

    static const uint64_t sign     = (uint64_t)0x80000000 << 32;
    static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
    static const uint64_t flag     = 0;
    static const uint64_t mantissa
        = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;

    static void init() {}
    static void get_bits(long double x, uint64_t& a) { memcpy(&a, &x, 8); }
    static void set_bits(long double& x, uint64_t a) { memcpy(&x, &a, 8); }
};

#endif


// long double (>64 bits), x86 and x64 -----------------------------------------

#if defined(__i386) || defined(__i386__) || defined(_M_IX86) \
    || defined(__amd64) || defined(__amd64__)  || defined(_M_AMD64) \
    || defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)

// Intel extended double precision format (80 bits)

template<> struct fp_traits_impl<long double, extended_double_precision_tag>
{
    typedef uint32_t bits;
    typedef not_all_bits coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
    BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
    BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00008000);
    BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);

    static void init() {}

    static void get_bits(long double x, uint32_t& a)
    {
        memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
    }

    static void set_bits(long double& x, uint32_t a)
    {
        memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
    }
};


// long double (>64 bits), Itanium ---------------------------------------------

#elif defined(__ia64) || defined(__ia64__) || defined(_M_IA64)

// The floating point format is unknown at compile time
// No template specialization is provided.
// The generic definition is used.

// The Itanium supports both
// the Intel extended double precision format (80 bits) and
// the IEEE extended double precision format with 15 exponent bits (128 bits).


// long double (>64 bits), PowerPC ---------------------------------------------

#elif defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__) \
    || defined(__ppc) || defined(__ppc__) || defined(__PPC__)

// PowerPC extended double precision format (128 bits)

template<> struct fp_traits_impl<long double, extended_double_precision_tag>
{
    typedef uint32_t bits;
    typedef not_all_bits coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
    BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
    BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00000000);
    BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);

    static void init() {}

    static void get_bits(long double x, uint32_t& a)
    {
        memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
    }

    static void set_bits(long double& x, uint32_t a)
    {
        memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
    }

private:

#if defined(BOOST_BIG_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif defined(BOOST_LITTLE_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 12);
#else
    BOOST_STATIC_ASSERT(false);
#endif
};


// long double (>64 bits), Motorola 68K ----------------------------------------

#elif defined(__m68k) || defined(__m68k__) \
    || defined(__mc68000) || defined(__mc68000__) \

// Motorola extended double precision format (96 bits)

// It is the same format as the Intel extended double precision format,
// except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and
// 3) the flag bit is not set for infinity

template<> struct fp_traits_impl<long double, extended_double_precision_tag>
{
    typedef uint32_t bits;
    typedef not_all_bits coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
    BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
    BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00008000);
    BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);

    static void init() {}

    // copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding.

    static void get_bits(long double x, uint32_t& a)
    {
        memcpy(&a, &x, 2);
        memcpy(reinterpret_cast<unsigned char*>(&a) + 2,
               reinterpret_cast<const unsigned char*>(&x) + 4, 2);
    }

    static void set_bits(long double& x, uint32_t a)
    {
        memcpy(&x, &a, 2);
        memcpy(reinterpret_cast<unsigned char*>(&x) + 4,
               reinterpret_cast<const unsigned char*>(&a) + 2, 2);
    }
};


// long double (>64 bits), All other processors --------------------------------

#else

// IEEE extended double precision format with 15 exponent bits (128 bits)

template<> struct fp_traits_impl<long double, extended_double_precision_tag>
{
    typedef uint32_t bits;
    typedef not_all_bits coverage;

    BOOST_STATIC_CONSTANT(uint32_t, sign     = 0x80000000);
    BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
    BOOST_STATIC_CONSTANT(uint32_t, flag     = 0x00000000);
    BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x0000ffff);

    static void init() {}

    static void get_bits(long double x, uint32_t& a)
    {
        memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
    }

    static void set_bits(long double& x, uint32_t a)
    {
        memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
    }

private:

#if defined(BOOST_BIG_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 0);
#elif defined(BOOST_LITTLE_ENDIAN)
    BOOST_STATIC_CONSTANT(int, offset_ = 12);
#else
    BOOST_STATIC_ASSERT(false);
#endif
};

#endif


//------------------------------------------------------------------------------

// size_to_precision is a type switch for converting a C++ floating point type
// to the corresponding precision type.

template<int n> struct size_to_precision;

template<> struct size_to_precision<4>
{
    typedef single_precision_tag type;
};

template<> struct size_to_precision<8>
{
    typedef double_precision_tag type;
};

template<> struct size_to_precision<10>
{
    typedef extended_double_precision_tag type;
};

template<> struct size_to_precision<12>
{
    typedef extended_double_precision_tag type;
};

template<> struct size_to_precision<16>
{
    typedef extended_double_precision_tag type;
};

// fp_traits is a type switch that selects the right fp_traits_impl

template<class T> struct fp_traits
{
    BOOST_STATIC_ASSERT(boost::is_floating_point<T>::value);
    typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T)>::type precision;
    typedef fp_traits_impl<T, precision> type;
};


//------------------------------------------------------------------------------

}   // namespace detail
}   // namespace math
}   // namespace spirit
}   // namespace boost

#endif
Commit	Line	Data
7c673cae FG	1	// fp_traits.hpp
	2
	3	#ifndef BOOST_SPIRIT_MATH_FP_TRAITS_HPP
	4	#define BOOST_SPIRIT_MATH_FP_TRAITS_HPP
	5
	6	// Copyright (c) 2006 Johan Rade
	7
	8	// Distributed under the Boost Software License, Version 1.0.
	9	// (See accompanying file LICENSE_1_0.txt
	10	// or copy at http://www.boost.org/LICENSE_1_0.txt)
	11
	12	#if defined(__vms) && defined(__DECCXX) && !__IEEE_FLOAT
	13	# error The VAX floating point mode on VMS is not supported.
	14	#endif
	15
	16	#if defined(_MSC_VER)
	17	#pragma once
	18	#endif
	19
	20	#include <cstring>
	21
	22	#include <boost/assert.hpp>
	23	#include <boost/cstdint.hpp>
	24	#include <boost/detail/endian.hpp>
	25	#include <boost/static_assert.hpp>
	26	#include <boost/type_traits/is_floating_point.hpp>
	27
	28	//------------------------------------------------------------------------------
	29
	30	namespace boost {
	31	namespace spirit {
	32	namespace math {
	33	namespace detail {
	34
	35	//------------------------------------------------------------------------------
	36
	37	/*
	38	Most processors support three different floating point precisions:
	39	single precision (32 bits), double precision (64 bits)
	40	and extended double precision (>64 bits)
	41
	42	Note that the C++ type long double can be implemented
	43	both as double precision and extended double precision.
	44	*/
	45
	46	struct single_precision_tag {};
	47	struct double_precision_tag {};
	48	struct extended_double_precision_tag {};
	49
	50	//------------------------------------------------------------------------------
	51
	52	/*
	53	template<class T, class U> struct fp_traits_impl;
	54
	55	This is traits class that describes the binary structure of floating
	56	point numbers of C++ type T and precision U
	57
	58	Requirements:
	59
	60	T = float, double or long double
	61	U = single_precision_tag, double_precision_tag
	62	or extended_double_precision_tag
	63
	64	Typedef members:
65
66	bits -- the target type when copying the leading bytes of a floating
67	point number. It is a typedef for uint32_t or uint64_t.
68
69	coverage -- tells us whether all bytes are copied or not.
70	It is a typedef for all_bits or not_all_bits.
71
72	Static data members:
73
74	sign, exponent, flag, mantissa -- bit masks that give the meaning of the bits
75	in the leading bytes.
76
77	Static function members:
78
79	init() -- initializes the static data members, if needed.
80	(Is a no-op in the specialized versions of the template.)
81
82	get_bits(), set_bits() -- provide access to the leading bytes.
83	*/
84
85	struct all_bits {};
86	struct not_all_bits {};
87
88	// Generic version -------------------------------------------------------------
89
90	// The generic version uses run time initialization to determine the floating
91	// point format. It is capable of handling most formats,
92	// but not the Motorola 68K extended double precision format.
93
94	// Currently the generic version is used only for extended double precision
95	// on Itanium. In all other cases there are specializations of the template
96	// that use compile time initialization.
97
98	template<class T> struct uint32_t_coverage
99	{
100	typedef not_all_bits type;
101	};
102
103	template<> struct uint32_t_coverage<single_precision_tag>
104	{
105	typedef all_bits type;
106	};
107
108	template<class T, class U> struct fp_traits_impl
109	{
110	typedef uint32_t bits;
111	typedef BOOST_DEDUCED_TYPENAME uint32_t_coverage<U>::type coverage;
112
113	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
114	static uint32_t exponent;
115	static uint32_t flag;
116	static uint32_t mantissa;
117
118	static void init()
119	{
120	if(is_init_) return;
121	do_init_();
122	is_init_ = true;
123	}
124
125	static void get_bits(T x, uint32_t& a)
126	{
127	memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
128	}
129
130	static void set_bits(T& x, uint32_t a)
131	{
132	memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
133	}
134
135	private:
136	static size_t offset_;
137	static bool is_init_;
138	static void do_init_();
139	};
140
141	//..............................................................................
142
143	template<class T, class U> uint32_t fp_traits_impl<T,U>::exponent;
144	template<class T, class U> uint32_t fp_traits_impl<T,U>::flag;
145	template<class T, class U> uint32_t fp_traits_impl<T,U>::mantissa;
146	template<class T, class U> size_t fp_traits_impl<T,U>::offset_;
147	template<class T, class U> bool fp_traits_impl<T,U>::is_init_;
148
149	// In a single-threaded program, do_init will be called exactly once.
150	// In a multi-threaded program, do_init may be called simultaneously
151	// by more then one thread. That should not be a problem.
152
153	//..............................................................................
154
155	template<class T, class U> void fp_traits_impl<T,U>::do_init_()
156	{
157	T x = static_cast<T>(3) / static_cast<T>(4);
158	// sign bit = 0
159	// exponent: first and last bit = 0, all other bits = 1
160	// flag bit (if present) = 1
161	// mantissa: first bit = 1, all other bits = 0
162
163	uint32_t a;
164
165	for(size_t k = 0; k <= sizeof(T) - 4; ++k) {
166
167	memcpy(&a, reinterpret_cast<unsigned char*>(&x) + k, 4);
168
169	switch(a) {
170
171	case 0x3f400000: // IEEE single precision format
172
173	offset_ = k;
174	exponent = 0x7f800000;
175	flag = 0x00000000;
176	mantissa = 0x007fffff;
177	return;
178
179	case 0x3fe80000: // IEEE double precision format
180	// and PowerPC extended double precision format
181	offset_ = k;
182	exponent = 0x7ff00000;
183	flag = 0x00000000;
184	mantissa = 0x000fffff;
185	return;
186
187	case 0x3ffe0000: // Motorola extended double precision format
188
189	// Must not get here. Must be handled by specialization.
190	// To get accurate cutoff between normals and subnormals
191	// we must use the flag bit that is in the 5th byte.
192	// Otherwise this cutoff will be off by a factor 2.
193	// If we do get here, then we have failed to detect the Motorola
194	// processor at compile time.
195
196	BOOST_ASSERT(false &&
197	"Failed to detect the Motorola processor at compile time");
198	return;
199
200	case 0x3ffe8000: // IEEE extended double precision format
201	// with 15 exponent bits
202	offset_ = k;
203	exponent = 0x7fff0000;
204	flag = 0x00000000;
205	mantissa = 0x0000ffff;
206	return;
207
208	case 0x3ffec000: // Intel extended double precision format
209
210	offset_ = k;
211	exponent = 0x7fff0000;
212	flag = 0x00008000;
213	mantissa = 0x00007fff;
214	return;
215
216	default:
217	continue;
218	}
219	}
220
221	BOOST_ASSERT(false);
222
223	// Unknown format.
224	}
225
226
227	// float (32 bits) -------------------------------------------------------------
228
229	template<> struct fp_traits_impl<float, single_precision_tag>
230	{
231	typedef uint32_t bits;
232	typedef all_bits coverage;
233
234	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
235	BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7f800000);
236	BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
237	BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x007fffff);
238
239	static void init() {}
240	static void get_bits(float x, uint32_t& a) { memcpy(&a, &x, 4); }
241	static void set_bits(float& x, uint32_t a) { memcpy(&x, &a, 4); }
242	};
243
244
245	// double (64 bits) ------------------------------------------------------------
246
247	#if defined(BOOST_NO_INT64_T) \|\| defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
248
249	template<> struct fp_traits_impl<double, double_precision_tag>
250	{
251	typedef uint32_t bits;
252	typedef not_all_bits coverage;
253
254	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
255	BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
256	BOOST_STATIC_CONSTANT(uint32_t, flag = 0);
257	BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
258
259	static void init() {}
260
261	static void get_bits(double x, uint32_t& a)
262	{
263	memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
264	}
265
266	static void set_bits(double& x, uint32_t a)
267	{
268	memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
269	}
270
271	private:
272
273	#if defined(BOOST_BIG_ENDIAN)
274	BOOST_STATIC_CONSTANT(int, offset_ = 0);
275	#elif defined(BOOST_LITTLE_ENDIAN)
276	BOOST_STATIC_CONSTANT(int, offset_ = 4);
277	#else
278	BOOST_STATIC_ASSERT(false);
279	#endif
280	};
281
282	//..............................................................................
283
284	#else
285
286	template<> struct fp_traits_impl<double, double_precision_tag>
287	{
288	typedef uint64_t bits;
289	typedef all_bits coverage;
290
291	static const uint64_t sign = (uint64_t)0x80000000 << 32;
292	static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
293	static const uint64_t flag = 0;
294	static const uint64_t mantissa
295	= ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;
296
297	static void init() {}
298	static void get_bits(double x, uint64_t& a) { memcpy(&a, &x, 8); }
299	static void set_bits(double& x, uint64_t a) { memcpy(&x, &a, 8); }
300	};
301
302	#endif
303
304
305	// long double (64 bits) -------------------------------------------------------
306
307	#if defined(BOOST_NO_INT64_T) \|\| defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
308
309	template<> struct fp_traits_impl<long double, double_precision_tag>
310	{
311	typedef uint32_t bits;
312	typedef not_all_bits coverage;
313
314	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
315	BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
316	BOOST_STATIC_CONSTANT(uint32_t, flag = 0);
317	BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
318
319	static void init() {}
320
321	static void get_bits(long double x, uint32_t& a)
322	{
323	memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
324	}
325
326	static void set_bits(long double& x, uint32_t a)
327	{
328	memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
329	}
330
331	private:
332
333	#if defined(BOOST_BIG_ENDIAN)
334	BOOST_STATIC_CONSTANT(int, offset_ = 0);
335	#elif defined(BOOST_LITTLE_ENDIAN)
336	BOOST_STATIC_CONSTANT(int, offset_ = 4);
337	#else
338	BOOST_STATIC_ASSERT(false);
339	#endif
340	};
341
342	//..............................................................................
343
344	#else
345
346	template<> struct fp_traits_impl<long double, double_precision_tag>
347	{
348	typedef uint64_t bits;
349	typedef all_bits coverage;
350
351	static const uint64_t sign = (uint64_t)0x80000000 << 32;
352	static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
353	static const uint64_t flag = 0;
354	static const uint64_t mantissa
355	= ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffff;
356
357	static void init() {}
358	static void get_bits(long double x, uint64_t& a) { memcpy(&a, &x, 8); }
359	static void set_bits(long double& x, uint64_t a) { memcpy(&x, &a, 8); }
360	};
361
362	#endif
363
364
365	// long double (>64 bits), x86 and x64 -----------------------------------------
366
367	#if defined(__i386) \|\| defined(__i386__) \|\| defined(_M_IX86) \
368	\|\| defined(__amd64) \|\| defined(__amd64__) \|\| defined(_M_AMD64) \
369	\|\| defined(__x86_64) \|\| defined(__x86_64__) \|\| defined(_M_X64)
370
371	// Intel extended double precision format (80 bits)
372
373	template<> struct fp_traits_impl<long double, extended_double_precision_tag>
374	{
375	typedef uint32_t bits;
376	typedef not_all_bits coverage;
377
378	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
379	BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
380	BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000);
381	BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);
382
383	static void init() {}
384
385	static void get_bits(long double x, uint32_t& a)
386	{
387	memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
388	}
389
390	static void set_bits(long double& x, uint32_t a)
391	{
392	memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
393	}
394	};
395
396
397	// long double (>64 bits), Itanium ---------------------------------------------
398
399	#elif defined(__ia64) \|\| defined(__ia64__) \|\| defined(_M_IA64)
400
401	// The floating point format is unknown at compile time
402	// No template specialization is provided.
403	// The generic definition is used.
404
405	// The Itanium supports both
406	// the Intel extended double precision format (80 bits) and
407	// the IEEE extended double precision format with 15 exponent bits (128 bits).
408
409
410	// long double (>64 bits), PowerPC ---------------------------------------------
411
412	#elif defined(__powerpc) \|\| defined(__powerpc__) \|\| defined(__POWERPC__) \
413	\|\| defined(__ppc) \|\| defined(__ppc__) \|\| defined(__PPC__)
414
415	// PowerPC extended double precision format (128 bits)
416
417	template<> struct fp_traits_impl<long double, extended_double_precision_tag>
418	{
419	typedef uint32_t bits;
420	typedef not_all_bits coverage;
421
422	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
423	BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7ff00000);
424	BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
425	BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x000fffff);
426
427	static void init() {}
428
429	static void get_bits(long double x, uint32_t& a)
430	{
431	memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
432	}
433
434	static void set_bits(long double& x, uint32_t a)
435	{
436	memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
437	}
438
439	private:
440
441	#if defined(BOOST_BIG_ENDIAN)
442	BOOST_STATIC_CONSTANT(int, offset_ = 0);
443	#elif defined(BOOST_LITTLE_ENDIAN)
444	BOOST_STATIC_CONSTANT(int, offset_ = 12);
445	#else
446	BOOST_STATIC_ASSERT(false);
447	#endif
448	};
449
450
451	// long double (>64 bits), Motorola 68K ----------------------------------------
452
453	#elif defined(__m68k) \|\| defined(__m68k__) \
454	\|\| defined(__mc68000) \|\| defined(__mc68000__) \
455
456	// Motorola extended double precision format (96 bits)
457
458	// It is the same format as the Intel extended double precision format,
459	// except that 1) it is big-endian, 2) the 3rd and 4th byte are padding, and
460	// 3) the flag bit is not set for infinity
461
462	template<> struct fp_traits_impl<long double, extended_double_precision_tag>
463	{
464	typedef uint32_t bits;
465	typedef not_all_bits coverage;
466
467	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
468	BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
469	BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00008000);
470	BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x00007fff);
471
472	static void init() {}
473
474	// copy 1st, 2nd, 5th and 6th byte. 3rd and 4th byte are padding.
475
476	static void get_bits(long double x, uint32_t& a)
477	{
478	memcpy(&a, &x, 2);
479	memcpy(reinterpret_cast<unsigned char*>(&a) + 2,
480	reinterpret_cast<const unsigned char*>(&x) + 4, 2);
481	}
482
483	static void set_bits(long double& x, uint32_t a)
484	{
485	memcpy(&x, &a, 2);
486	memcpy(reinterpret_cast<unsigned char*>(&x) + 4,
487	reinterpret_cast<const unsigned char*>(&a) + 2, 2);
488	}
489	};
490
491
492	// long double (>64 bits), All other processors --------------------------------
493
494	#else
495
496	// IEEE extended double precision format with 15 exponent bits (128 bits)
497
498	template<> struct fp_traits_impl<long double, extended_double_precision_tag>
499	{
500	typedef uint32_t bits;
501	typedef not_all_bits coverage;
502
503	BOOST_STATIC_CONSTANT(uint32_t, sign = 0x80000000);
504	BOOST_STATIC_CONSTANT(uint32_t, exponent = 0x7fff0000);
505	BOOST_STATIC_CONSTANT(uint32_t, flag = 0x00000000);
506	BOOST_STATIC_CONSTANT(uint32_t, mantissa = 0x0000ffff);
507
508	static void init() {}
509
510	static void get_bits(long double x, uint32_t& a)
511	{
512	memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
513	}
514
515	static void set_bits(long double& x, uint32_t a)
516	{
517	memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
518	}
519
520	private:
521
522	#if defined(BOOST_BIG_ENDIAN)
523	BOOST_STATIC_CONSTANT(int, offset_ = 0);
524	#elif defined(BOOST_LITTLE_ENDIAN)
525	BOOST_STATIC_CONSTANT(int, offset_ = 12);
526	#else
527	BOOST_STATIC_ASSERT(false);
528	#endif
529	};
530
531	#endif
532
533
534	//------------------------------------------------------------------------------
535
536	// size_to_precision is a type switch for converting a C++ floating point type
537	// to the corresponding precision type.
538
539	template<int n> struct size_to_precision;
540
541	template<> struct size_to_precision<4>
542	{
543	typedef single_precision_tag type;
544	};
545
546	template<> struct size_to_precision<8>
547	{
548	typedef double_precision_tag type;
549	};
550
551	template<> struct size_to_precision<10>
552	{
553	typedef extended_double_precision_tag type;
554	};
555
556	template<> struct size_to_precision<12>
557	{
558	typedef extended_double_precision_tag type;
559	};
560
561	template<> struct size_to_precision<16>
562	{
563	typedef extended_double_precision_tag type;
564	};
565
566	// fp_traits is a type switch that selects the right fp_traits_impl
567
568	template<class T> struct fp_traits
569	{
570	BOOST_STATIC_ASSERT(boost::is_floating_point<T>::value);
571	typedef BOOST_DEDUCED_TYPENAME size_to_precision<sizeof(T)>::type precision;
572	typedef fp_traits_impl<T, precision> type;
573	};
574
575
576	//------------------------------------------------------------------------------
577
578	} // namespace detail
579	} // namespace math
580	} // namespace spirit
581	} // namespace boost
582
583	#endif