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 < 1300 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 { BOOST_PREVENT_MACRO_SUBSTITUTIONboost::detail::signed_numeric_limits86 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); BOOST_PREVENT_MACRO_SUBSTITUTIONboost::detail::fixed_numeric_limits_base118 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 BOOST_PREVENT_MACRO_SUBSTITUTIONboost::detail::fixed_numeric_limits_base127 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); BOOST_PREVENT_MACRO_SUBSTITUTIONboost::detail::fixed_numeric_limits_base142 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 BOOST_PREVENT_MACRO_SUBSTITUTIONboost::detail::fixed_numeric_limits_base151 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> checkboost::less_than_type_min169 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> checkboost::less_than_type_min177 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> checkboost::less_than_type_min185 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> checkboost::greater_than_type_max205 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> checkboost::greater_than_type_max215 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 < 1300 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> checkboost::greater_than_type_max241 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> checkboost::greater_than_type_max251 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 { BOOST_PREVENT_MACRO_SUBSTITUTIONboost::detail::fixed_numeric_limits271 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> numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET)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 340