[857] | 1 | // boost cast.hpp header file ----------------------------------------------//
|
---|
| 2 |
|
---|
| 3 | // (C) Copyright Kevlin Henney and Dave Abrahams 1999.
|
---|
| 4 | // Distributed under the Boost
|
---|
| 5 | // Software License, Version 1.0. (See accompanying file
|
---|
| 6 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
---|
| 7 |
|
---|
| 8 | // See http://www.boost.org/libs/conversion for Documentation.
|
---|
| 9 |
|
---|
| 10 | // Revision History
|
---|
| 11 | // 23 JUN 05 Code extracted from /boost/cast.hpp into this new header.
|
---|
| 12 | // Keeps this legacy version of numeric_cast<> for old compilers
|
---|
| 13 | // wich can't compile the new version in /boost/numeric/conversion/cast.hpp
|
---|
| 14 | // (Fernando Cacciola)
|
---|
| 15 | // 02 Apr 01 Removed BOOST_NO_LIMITS workarounds and included
|
---|
| 16 | // <boost/limits.hpp> instead (the workaround did not
|
---|
| 17 | // actually compile when BOOST_NO_LIMITS was defined in
|
---|
| 18 | // any case, so we loose nothing). (John Maddock)
|
---|
| 19 | // 21 Jan 01 Undid a bug I introduced yesterday. numeric_cast<> never
|
---|
| 20 | // worked with stock GCC; trying to get it to do that broke
|
---|
| 21 | // vc-stlport.
|
---|
| 22 | // 20 Jan 01 Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp.
|
---|
| 23 | // Removed unused BOOST_EXPLICIT_TARGET macro. Moved
|
---|
| 24 | // boost::detail::type to boost/type.hpp. Made it compile with
|
---|
| 25 | // stock gcc again (Dave Abrahams)
|
---|
| 26 | // 29 Nov 00 Remove nested namespace cast, cleanup spacing before Formal
|
---|
| 27 | // Review (Beman Dawes)
|
---|
| 28 | // 19 Oct 00 Fix numeric_cast for floating-point types (Dave Abrahams)
|
---|
| 29 | // 15 Jul 00 Suppress numeric_cast warnings for GCC, Borland and MSVC
|
---|
| 30 | // (Dave Abrahams)
|
---|
| 31 | // 30 Jun 00 More MSVC6 wordarounds. See comments below. (Dave Abrahams)
|
---|
| 32 | // 28 Jun 00 Removed implicit_cast<>. See comment below. (Beman Dawes)
|
---|
| 33 | // 27 Jun 00 More MSVC6 workarounds
|
---|
| 34 | // 15 Jun 00 Add workarounds for MSVC6
|
---|
| 35 | // 2 Feb 00 Remove bad_numeric_cast ";" syntax error (Doncho Angelov)
|
---|
| 36 | // 26 Jan 00 Add missing throw() to bad_numeric_cast::what(0 (Adam Levar)
|
---|
| 37 | // 29 Dec 99 Change using declarations so usages in other namespaces work
|
---|
| 38 | // correctly (Dave Abrahams)
|
---|
| 39 | // 23 Sep 99 Change polymorphic_downcast assert to also detect M.I. errors
|
---|
| 40 | // as suggested Darin Adler and improved by Valentin Bonnard.
|
---|
| 41 | // 2 Sep 99 Remove controversial asserts, simplify, rename.
|
---|
| 42 | // 30 Aug 99 Move to cast.hpp, replace value_cast with numeric_cast,
|
---|
| 43 | // place in nested namespace.
|
---|
| 44 | // 3 Aug 99 Initial version
|
---|
| 45 |
|
---|
| 46 | #ifndef BOOST_OLD_NUMERIC_CAST_HPP
|
---|
| 47 | #define BOOST_OLD_NUMERIC_CAST_HPP
|
---|
| 48 |
|
---|
| 49 | # include <boost/config.hpp>
|
---|
| 50 | # include <cassert>
|
---|
| 51 | # include <typeinfo>
|
---|
| 52 | # include <boost/type.hpp>
|
---|
| 53 | # include <boost/limits.hpp>
|
---|
| 54 | # include <boost/numeric/conversion/converter_policies.hpp>
|
---|
| 55 |
|
---|
| 56 | // It has been demonstrated numerous times that MSVC 6.0 fails silently at link
|
---|
| 57 | // time if you use a template function which has template parameters that don't
|
---|
| 58 | // appear in the function's argument list.
|
---|
| 59 | //
|
---|
| 60 | // TODO: Add this to config.hpp?
|
---|
| 61 | // FLC: This macro is repeated in boost/cast.hpp but only locally (is undefined at the bottom)
|
---|
| 62 | // so is OK to reproduce it here.
|
---|
| 63 | # if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // 1200 = VC6
|
---|
| 64 | # define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
|
---|
| 65 | # else
|
---|
| 66 | # define BOOST_EXPLICIT_DEFAULT_TARGET
|
---|
| 67 | # endif
|
---|
| 68 |
|
---|
| 69 | namespace boost
|
---|
| 70 | {
|
---|
| 71 | using numeric::bad_numeric_cast;
|
---|
| 72 |
|
---|
| 73 | // LEGACY numeric_cast [only for some old broken compilers] --------------------------------------//
|
---|
| 74 |
|
---|
| 75 | // Contributed by Kevlin Henney
|
---|
| 76 |
|
---|
| 77 | // numeric_cast ------------------------------------------------------------//
|
---|
| 78 |
|
---|
| 79 | #if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_SGI_CPP_LIMITS)
|
---|
| 80 |
|
---|
| 81 | namespace detail
|
---|
| 82 | {
|
---|
| 83 | template <class T>
|
---|
| 84 | struct signed_numeric_limits : std::numeric_limits<T>
|
---|
| 85 | {
|
---|
| 86 | static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
---|
| 87 | {
|
---|
| 88 | return (std::numeric_limits<T>::min)() >= 0
|
---|
| 89 | // unary minus causes integral promotion, thus the static_cast<>
|
---|
| 90 | ? static_cast<T>(-(std::numeric_limits<T>::max)())
|
---|
| 91 | : (std::numeric_limits<T>::min)();
|
---|
| 92 | };
|
---|
| 93 | };
|
---|
| 94 |
|
---|
| 95 | // Move to namespace boost in utility.hpp?
|
---|
| 96 | template <class T, bool specialized>
|
---|
| 97 | struct fixed_numeric_limits_base
|
---|
| 98 | : public if_true< std::numeric_limits<T>::is_signed >
|
---|
| 99 | ::BOOST_NESTED_TEMPLATE then< signed_numeric_limits<T>,
|
---|
| 100 | std::numeric_limits<T>
|
---|
| 101 | >::type
|
---|
| 102 | {};
|
---|
| 103 |
|
---|
| 104 | template <class T>
|
---|
| 105 | struct fixed_numeric_limits
|
---|
| 106 | : fixed_numeric_limits_base<T,(std::numeric_limits<T>::is_specialized)>
|
---|
| 107 | {};
|
---|
| 108 |
|
---|
| 109 | # ifdef BOOST_HAS_LONG_LONG
|
---|
| 110 | // cover implementations which supply no specialization for long
|
---|
| 111 | // long / unsigned long long. Not intended to be full
|
---|
| 112 | // numeric_limits replacements, but good enough for numeric_cast<>
|
---|
| 113 | template <>
|
---|
| 114 | struct fixed_numeric_limits_base< ::boost::long_long_type, false>
|
---|
| 115 | {
|
---|
| 116 | BOOST_STATIC_CONSTANT(bool, is_specialized = true);
|
---|
| 117 | BOOST_STATIC_CONSTANT(bool, is_signed = true);
|
---|
| 118 | static ::boost::long_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
---|
| 119 | {
|
---|
| 120 | # ifdef LONGLONG_MAX
|
---|
| 121 | return LONGLONG_MAX;
|
---|
| 122 | # else
|
---|
| 123 | return 9223372036854775807LL; // hope this is portable
|
---|
| 124 | # endif
|
---|
| 125 | }
|
---|
| 126 |
|
---|
| 127 | static ::boost::long_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
---|
| 128 | {
|
---|
| 129 | # ifdef LONGLONG_MIN
|
---|
| 130 | return LONGLONG_MIN;
|
---|
| 131 | # else
|
---|
| 132 | return -( 9223372036854775807LL )-1; // hope this is portable
|
---|
| 133 | # endif
|
---|
| 134 | }
|
---|
| 135 | };
|
---|
| 136 |
|
---|
| 137 | template <>
|
---|
| 138 | struct fixed_numeric_limits_base< ::boost::ulong_long_type, false>
|
---|
| 139 | {
|
---|
| 140 | BOOST_STATIC_CONSTANT(bool, is_specialized = true);
|
---|
| 141 | BOOST_STATIC_CONSTANT(bool, is_signed = false);
|
---|
| 142 | static ::boost::ulong_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
---|
| 143 | {
|
---|
| 144 | # ifdef ULONGLONG_MAX
|
---|
| 145 | return ULONGLONG_MAX;
|
---|
| 146 | # else
|
---|
| 147 | return 0xffffffffffffffffULL; // hope this is portable
|
---|
| 148 | # endif
|
---|
| 149 | }
|
---|
| 150 |
|
---|
| 151 | static ::boost::ulong_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
|
---|
| 152 | };
|
---|
| 153 | # endif
|
---|
| 154 | } // namespace detail
|
---|
| 155 |
|
---|
| 156 | // less_than_type_min -
|
---|
| 157 | // x_is_signed should be numeric_limits<X>::is_signed
|
---|
| 158 | // y_is_signed should be numeric_limits<Y>::is_signed
|
---|
| 159 | // y_min should be numeric_limits<Y>::min()
|
---|
| 160 | //
|
---|
| 161 | // check(x, y_min) returns true iff x < y_min without invoking comparisons
|
---|
| 162 | // between signed and unsigned values.
|
---|
| 163 | //
|
---|
| 164 | // "poor man's partial specialization" is in use here.
|
---|
| 165 | template <bool x_is_signed, bool y_is_signed>
|
---|
| 166 | struct less_than_type_min
|
---|
| 167 | {
|
---|
| 168 | template <class X, class Y>
|
---|
| 169 | static bool check(X x, Y y_min)
|
---|
| 170 | { return x < y_min; }
|
---|
| 171 | };
|
---|
| 172 |
|
---|
| 173 | template <>
|
---|
| 174 | struct less_than_type_min<false, true>
|
---|
| 175 | {
|
---|
| 176 | template <class X, class Y>
|
---|
| 177 | static bool check(X, Y)
|
---|
| 178 | { return false; }
|
---|
| 179 | };
|
---|
| 180 |
|
---|
| 181 | template <>
|
---|
| 182 | struct less_than_type_min<true, false>
|
---|
| 183 | {
|
---|
| 184 | template <class X, class Y>
|
---|
| 185 | static bool check(X x, Y)
|
---|
| 186 | { return x < 0; }
|
---|
| 187 | };
|
---|
| 188 |
|
---|
| 189 | // greater_than_type_max -
|
---|
| 190 | // same_sign should be:
|
---|
| 191 | // numeric_limits<X>::is_signed == numeric_limits<Y>::is_signed
|
---|
| 192 | // y_max should be numeric_limits<Y>::max()
|
---|
| 193 | //
|
---|
| 194 | // check(x, y_max) returns true iff x > y_max without invoking comparisons
|
---|
| 195 | // between signed and unsigned values.
|
---|
| 196 | //
|
---|
| 197 | // "poor man's partial specialization" is in use here.
|
---|
| 198 | template <bool same_sign, bool x_is_signed>
|
---|
| 199 | struct greater_than_type_max;
|
---|
| 200 |
|
---|
| 201 | template<>
|
---|
| 202 | struct greater_than_type_max<true, true>
|
---|
| 203 | {
|
---|
| 204 | template <class X, class Y>
|
---|
| 205 | static inline bool check(X x, Y y_max)
|
---|
| 206 | { return x > y_max; }
|
---|
| 207 | };
|
---|
| 208 |
|
---|
| 209 | template <>
|
---|
| 210 | struct greater_than_type_max<false, true>
|
---|
| 211 | {
|
---|
| 212 | // What does the standard say about this? I think it's right, and it
|
---|
| 213 | // will work with every compiler I know of.
|
---|
| 214 | template <class X, class Y>
|
---|
| 215 | static inline bool check(X x, Y)
|
---|
| 216 | { return x >= 0 && static_cast<X>(static_cast<Y>(x)) != x; }
|
---|
| 217 |
|
---|
| 218 | # if defined(BOOST_MSVC) && BOOST_MSVC <= 1200
|
---|
| 219 | // MSVC6 can't static_cast unsigned __int64 -> floating types
|
---|
| 220 | # define BOOST_UINT64_CAST(src_type) \
|
---|
| 221 | static inline bool check(src_type x, unsigned __int64) \
|
---|
| 222 | { \
|
---|
| 223 | if (x < 0) return false; \
|
---|
| 224 | unsigned __int64 y = static_cast<unsigned __int64>(x); \
|
---|
| 225 | bool odd = y & 0x1; \
|
---|
| 226 | __int64 div2 = static_cast<__int64>(y >> 1); \
|
---|
| 227 | return ((static_cast<src_type>(div2) * 2.0) + odd) != x; \
|
---|
| 228 | }
|
---|
| 229 |
|
---|
| 230 | BOOST_UINT64_CAST(long double);
|
---|
| 231 | BOOST_UINT64_CAST(double);
|
---|
| 232 | BOOST_UINT64_CAST(float);
|
---|
| 233 | # undef BOOST_UINT64_CAST
|
---|
| 234 | # endif
|
---|
| 235 | };
|
---|
| 236 |
|
---|
| 237 | template<>
|
---|
| 238 | struct greater_than_type_max<true, false>
|
---|
| 239 | {
|
---|
| 240 | template <class X, class Y>
|
---|
| 241 | static inline bool check(X x, Y y_max)
|
---|
| 242 | { return x > y_max; }
|
---|
| 243 | };
|
---|
| 244 |
|
---|
| 245 | template <>
|
---|
| 246 | struct greater_than_type_max<false, false>
|
---|
| 247 | {
|
---|
| 248 | // What does the standard say about this? I think it's right, and it
|
---|
| 249 | // will work with every compiler I know of.
|
---|
| 250 | template <class X, class Y>
|
---|
| 251 | static inline bool check(X x, Y)
|
---|
| 252 | { return static_cast<X>(static_cast<Y>(x)) != x; }
|
---|
| 253 | };
|
---|
| 254 |
|
---|
| 255 | #else // use #pragma hacks if available
|
---|
| 256 |
|
---|
| 257 | namespace detail
|
---|
| 258 | {
|
---|
| 259 | # if BOOST_MSVC
|
---|
| 260 | # pragma warning(push)
|
---|
| 261 | # pragma warning(disable : 4018)
|
---|
| 262 | # pragma warning(disable : 4146)
|
---|
| 263 | #elif defined(__BORLANDC__)
|
---|
| 264 | # pragma option push -w-8041
|
---|
| 265 | # endif
|
---|
| 266 |
|
---|
| 267 | // Move to namespace boost in utility.hpp?
|
---|
| 268 | template <class T>
|
---|
| 269 | struct fixed_numeric_limits : public std::numeric_limits<T>
|
---|
| 270 | {
|
---|
| 271 | static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
---|
| 272 | {
|
---|
| 273 | return std::numeric_limits<T>::is_signed && (std::numeric_limits<T>::min)() >= 0
|
---|
| 274 | ? T(-(std::numeric_limits<T>::max)()) : (std::numeric_limits<T>::min)();
|
---|
| 275 | }
|
---|
| 276 | };
|
---|
| 277 |
|
---|
| 278 | # if BOOST_MSVC
|
---|
| 279 | # pragma warning(pop)
|
---|
| 280 | #elif defined(__BORLANDC__)
|
---|
| 281 | # pragma option pop
|
---|
| 282 | # endif
|
---|
| 283 | } // namespace detail
|
---|
| 284 |
|
---|
| 285 | #endif
|
---|
| 286 |
|
---|
| 287 | template<typename Target, typename Source>
|
---|
| 288 | inline Target numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET)
|
---|
| 289 | {
|
---|
| 290 | // typedefs abbreviating respective trait classes
|
---|
| 291 | typedef detail::fixed_numeric_limits<Source> arg_traits;
|
---|
| 292 | typedef detail::fixed_numeric_limits<Target> result_traits;
|
---|
| 293 |
|
---|
| 294 | #if defined(BOOST_STRICT_CONFIG) \
|
---|
| 295 | || (!defined(__HP_aCC) || __HP_aCC > 33900) \
|
---|
| 296 | && (!defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) \
|
---|
| 297 | || defined(BOOST_SGI_CPP_LIMITS))
|
---|
| 298 | // typedefs that act as compile time assertions
|
---|
| 299 | // (to be replaced by boost compile time assertions
|
---|
| 300 | // as and when they become available and are stable)
|
---|
| 301 | typedef bool argument_must_be_numeric[arg_traits::is_specialized];
|
---|
| 302 | typedef bool result_must_be_numeric[result_traits::is_specialized];
|
---|
| 303 |
|
---|
| 304 | const bool arg_is_signed = arg_traits::is_signed;
|
---|
| 305 | const bool result_is_signed = result_traits::is_signed;
|
---|
| 306 | const bool same_sign = arg_is_signed == result_is_signed;
|
---|
| 307 |
|
---|
| 308 | if (less_than_type_min<arg_is_signed, result_is_signed>::check(arg, (result_traits::min)())
|
---|
| 309 | || greater_than_type_max<same_sign, arg_is_signed>::check(arg, (result_traits::max)())
|
---|
| 310 | )
|
---|
| 311 |
|
---|
| 312 | #else // We need to use #pragma hacks if available
|
---|
| 313 |
|
---|
| 314 | # if BOOST_MSVC
|
---|
| 315 | # pragma warning(push)
|
---|
| 316 | # pragma warning(disable : 4018)
|
---|
| 317 | #elif defined(__BORLANDC__)
|
---|
| 318 | #pragma option push -w-8012
|
---|
| 319 | # endif
|
---|
| 320 | if ((arg < 0 && !result_traits::is_signed) // loss of negative range
|
---|
| 321 | || (arg_traits::is_signed && arg < (result_traits::min)()) // underflow
|
---|
| 322 | || arg > (result_traits::max)()) // overflow
|
---|
| 323 | # if BOOST_MSVC
|
---|
| 324 | # pragma warning(pop)
|
---|
| 325 | #elif defined(__BORLANDC__)
|
---|
| 326 | #pragma option pop
|
---|
| 327 | # endif
|
---|
| 328 | #endif
|
---|
| 329 | {
|
---|
| 330 | throw bad_numeric_cast();
|
---|
| 331 | }
|
---|
| 332 | return static_cast<Target>(arg);
|
---|
| 333 | } // numeric_cast
|
---|
| 334 |
|
---|
| 335 | # undef BOOST_EXPLICIT_DEFAULT_TARGET
|
---|
| 336 |
|
---|
| 337 | } // namespace boost
|
---|
| 338 |
|
---|
| 339 | #endif // BOOST_OLD_NUMERIC_CAST_HPP
|
---|