Merge c:/dyninst/pc_bluegene/dyninst into dyn_pc_integration
[dyninst.git] / external / boost / functional / detail / float_functions.hpp
1
2 // Copyright 2005-2008 Daniel James.
3 // Distributed under the Boost Software License, Version 1.0. (See accompanying
4 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
5
6 #if !defined(BOOST_FUNCTIONAL_DETAIL_FLOAT_FUNCTIONS_HPP)
7 #define BOOST_FUNCTIONAL_DETAIL_FLOAT_FUNCTIONS_HPP
8
9 #include <boost/config/no_tr1/cmath.hpp>
10
11 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
12 # pragma once
13 #endif
14
15 // The C++ standard requires that the C float functions are overloarded
16 // for float, double and long double in the std namespace, but some of the older
17 // library implementations don't support this. On some that don't, the C99
18 // float functions (frexpf, frexpl, etc.) are available.
19 //
20 // Some of this is based on guess work. If I don't know any better I assume that
21 // the standard C++ overloaded functions are available. If they're not then this
22 // means that the argument is cast to a double and back, which is inefficient
23 // and will give pretty bad results for long doubles - so if you know better
24 // let me know.
25
26 // STLport:
27 #if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
28 #  if (defined(__GNUC__) && __GNUC__ < 3 && (defined(linux) || defined(__linux) || defined(__linux__))) || defined(__DMC__)
29 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS
30 #  elif defined(BOOST_MSVC) && BOOST_MSVC < 1300
31 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS
32 #  else
33 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
34 #  endif
35
36 // Roguewave:
37 //
38 // On borland 5.51, with roguewave 2.1.1 the standard C++ overloads aren't
39 // defined, but for the same version of roguewave on sunpro they are.
40 #elif defined(_RWSTD_VER)
41 #  if defined(__BORLANDC__)
42 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS
43 #    define BOOST_HASH_C99_NO_FLOAT_FUNCS
44 #  elif defined(__DECCXX)
45 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS
46 #  else
47 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
48 #  endif
49
50 // libstdc++ (gcc 3.0 onwards, I think)
51 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
52 #  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
53
54 // SGI:
55 #elif defined(__STL_CONFIG_H)
56 #  if defined(linux) || defined(__linux) || defined(__linux__)
57 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS
58 #  else
59 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
60 #  endif
61
62 // Dinkumware.
63 #elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
64 // Some versions of Visual C++ don't seem to have the C++ overloads but they
65 // all seem to have the c99 float overloads
66 #  if defined(BOOST_MSVC)
67 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS
68 // On other platforms the C++ overloads seem to have been introduced sometime
69 // before 402.
70 #  elif defined(_CPPLIB_VER) && (_CPPLIB_VER >= 402)
71 #    define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
72 #  else
73 #    define BOOST_HASH_USE_C99_FLOAT_FUNCS
74 #  endif
75
76 // Digital Mars
77 #elif defined(__DMC__)
78 #  define BOOST_HASH_USE_C99_FLOAT_FUNCS
79
80 // Use overloaded float functions by default.
81 #else
82 #  define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
83 #endif
84
85 namespace boost
86 {
87     namespace hash_detail
88     {
89
90         inline float call_ldexp(float v, int exp)
91         {
92             using namespace std;
93 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS) || \
94     defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)
95             return ldexp(v, exp);
96 #else
97             return ldexpf(v, exp);
98 #endif
99         }
100
101         inline double call_ldexp(double v, int exp)
102         {
103             using namespace std;
104             return ldexp(v, exp);
105         }
106
107         inline long double call_ldexp(long double v, int exp)
108         {
109             using namespace std;
110 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)
111             return ldexp(v, exp);
112 #else
113             return ldexpl(v, exp);
114 #endif
115         }
116
117         inline float call_frexp(float v, int* exp)
118         {
119             using namespace std;
120 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS) || \
121     defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)
122             return frexp(v, exp);
123 #else
124             return frexpf(v, exp);
125 #endif
126         }
127
128         inline double call_frexp(double v, int* exp)
129         {
130             using namespace std;
131             return frexp(v, exp);
132         }
133
134         inline long double call_frexp(long double v, int* exp)
135         {
136             using namespace std;
137 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)
138             return frexp(v, exp);
139 #else
140             return frexpl(v, exp);
141 #endif
142         }
143     }
144 }
145
146 #if defined(BOOST_HASH_USE_C99_FLOAT_FUNCS)
147 #undef BOOST_HASH_USE_C99_FLOAT_FUNCS
148 #endif
149
150 #if defined(BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS)
151 #undef BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
152 #endif
153
154 #if defined(BOOST_HASH_C99_NO_FLOAT_FUNCS)
155 #undef BOOST_HASH_C99_NO_FLOAT_FUNCS
156 #endif
157
158 #endif