You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
339 lines
12 KiB
339 lines
12 KiB
// boost cast.hpp header file ----------------------------------------------// |
|
|
|
// (C) Copyright Kevlin Henney and Dave Abrahams 1999. |
|
// 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) |
|
|
|
// See http://www.boost.org/libs/conversion for Documentation. |
|
|
|
// Revision History |
|
// 23 JUN 05 Code extracted from /boost/cast.hpp into this new header. |
|
// Keeps this legacy version of numeric_cast<> for old compilers |
|
// wich can't compile the new version in /boost/numeric/conversion/cast.hpp |
|
// (Fernando Cacciola) |
|
// 02 Apr 01 Removed BOOST_NO_LIMITS workarounds and included |
|
// <boost/limits.hpp> instead (the workaround did not |
|
// actually compile when BOOST_NO_LIMITS was defined in |
|
// any case, so we loose nothing). (John Maddock) |
|
// 21 Jan 01 Undid a bug I introduced yesterday. numeric_cast<> never |
|
// worked with stock GCC; trying to get it to do that broke |
|
// vc-stlport. |
|
// 20 Jan 01 Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp. |
|
// Removed unused BOOST_EXPLICIT_TARGET macro. Moved |
|
// boost::detail::type to boost/type.hpp. Made it compile with |
|
// stock gcc again (Dave Abrahams) |
|
// 29 Nov 00 Remove nested namespace cast, cleanup spacing before Formal |
|
// Review (Beman Dawes) |
|
// 19 Oct 00 Fix numeric_cast for floating-point types (Dave Abrahams) |
|
// 15 Jul 00 Suppress numeric_cast warnings for GCC, Borland and MSVC |
|
// (Dave Abrahams) |
|
// 30 Jun 00 More MSVC6 wordarounds. See comments below. (Dave Abrahams) |
|
// 28 Jun 00 Removed implicit_cast<>. See comment below. (Beman Dawes) |
|
// 27 Jun 00 More MSVC6 workarounds |
|
// 15 Jun 00 Add workarounds for MSVC6 |
|
// 2 Feb 00 Remove bad_numeric_cast ";" syntax error (Doncho Angelov) |
|
// 26 Jan 00 Add missing throw() to bad_numeric_cast::what(0 (Adam Levar) |
|
// 29 Dec 99 Change using declarations so usages in other namespaces work |
|
// correctly (Dave Abrahams) |
|
// 23 Sep 99 Change polymorphic_downcast assert to also detect M.I. errors |
|
// as suggested Darin Adler and improved by Valentin Bonnard. |
|
// 2 Sep 99 Remove controversial asserts, simplify, rename. |
|
// 30 Aug 99 Move to cast.hpp, replace value_cast with numeric_cast, |
|
// place in nested namespace. |
|
// 3 Aug 99 Initial version |
|
|
|
#ifndef BOOST_OLD_NUMERIC_CAST_HPP |
|
#define BOOST_OLD_NUMERIC_CAST_HPP |
|
|
|
# include <boost/config.hpp> |
|
# include <cassert> |
|
# include <typeinfo> |
|
# include <boost/type.hpp> |
|
# include <boost/limits.hpp> |
|
# include <boost/numeric/conversion/converter_policies.hpp> |
|
|
|
// It has been demonstrated numerous times that MSVC 6.0 fails silently at link |
|
// time if you use a template function which has template parameters that don't |
|
// appear in the function's argument list. |
|
// |
|
// TODO: Add this to config.hpp? |
|
// FLC: This macro is repeated in boost/cast.hpp but only locally (is undefined at the bottom) |
|
// so is OK to reproduce it here. |
|
# if defined(BOOST_MSVC) && BOOST_MSVC < 1300 |
|
# define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0 |
|
# else |
|
# define BOOST_EXPLICIT_DEFAULT_TARGET |
|
# endif |
|
|
|
namespace boost |
|
{ |
|
using numeric::bad_numeric_cast; |
|
|
|
// LEGACY numeric_cast [only for some old broken compilers] --------------------------------------// |
|
|
|
// Contributed by Kevlin Henney |
|
|
|
// numeric_cast ------------------------------------------------------------// |
|
|
|
#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_SGI_CPP_LIMITS) |
|
|
|
namespace detail |
|
{ |
|
template <class T> |
|
struct signed_numeric_limits : std::numeric_limits<T> |
|
{ |
|
static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION () |
|
{ |
|
return (std::numeric_limits<T>::min)() >= 0 |
|
// unary minus causes integral promotion, thus the static_cast<> |
|
? static_cast<T>(-(std::numeric_limits<T>::max)()) |
|
: (std::numeric_limits<T>::min)(); |
|
}; |
|
}; |
|
|
|
// Move to namespace boost in utility.hpp? |
|
template <class T, bool specialized> |
|
struct fixed_numeric_limits_base |
|
: public if_true< std::numeric_limits<T>::is_signed > |
|
::BOOST_NESTED_TEMPLATE then< signed_numeric_limits<T>, |
|
std::numeric_limits<T> |
|
>::type |
|
{}; |
|
|
|
template <class T> |
|
struct fixed_numeric_limits |
|
: fixed_numeric_limits_base<T,(std::numeric_limits<T>::is_specialized)> |
|
{}; |
|
|
|
# ifdef BOOST_HAS_LONG_LONG |
|
// cover implementations which supply no specialization for long |
|
// long / unsigned long long. Not intended to be full |
|
// numeric_limits replacements, but good enough for numeric_cast<> |
|
template <> |
|
struct fixed_numeric_limits_base< ::boost::long_long_type, false> |
|
{ |
|
BOOST_STATIC_CONSTANT(bool, is_specialized = true); |
|
BOOST_STATIC_CONSTANT(bool, is_signed = true); |
|
static ::boost::long_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION () |
|
{ |
|
# ifdef LONGLONG_MAX |
|
return LONGLONG_MAX; |
|
# else |
|
return 9223372036854775807LL; // hope this is portable |
|
# endif |
|
} |
|
|
|
static ::boost::long_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION () |
|
{ |
|
# ifdef LONGLONG_MIN |
|
return LONGLONG_MIN; |
|
# else |
|
return -( 9223372036854775807LL )-1; // hope this is portable |
|
# endif |
|
} |
|
}; |
|
|
|
template <> |
|
struct fixed_numeric_limits_base< ::boost::ulong_long_type, false> |
|
{ |
|
BOOST_STATIC_CONSTANT(bool, is_specialized = true); |
|
BOOST_STATIC_CONSTANT(bool, is_signed = false); |
|
static ::boost::ulong_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION () |
|
{ |
|
# ifdef ULONGLONG_MAX |
|
return ULONGLONG_MAX; |
|
# else |
|
return 0xffffffffffffffffULL; // hope this is portable |
|
# endif |
|
} |
|
|
|
static ::boost::ulong_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; } |
|
}; |
|
# endif |
|
} // namespace detail |
|
|
|
// less_than_type_min - |
|
// x_is_signed should be numeric_limits<X>::is_signed |
|
// y_is_signed should be numeric_limits<Y>::is_signed |
|
// y_min should be numeric_limits<Y>::min() |
|
// |
|
// check(x, y_min) returns true iff x < y_min without invoking comparisons |
|
// between signed and unsigned values. |
|
// |
|
// "poor man's partial specialization" is in use here. |
|
template <bool x_is_signed, bool y_is_signed> |
|
struct less_than_type_min |
|
{ |
|
template <class X, class Y> |
|
static bool check(X x, Y y_min) |
|
{ return x < y_min; } |
|
}; |
|
|
|
template <> |
|
struct less_than_type_min<false, true> |
|
{ |
|
template <class X, class Y> |
|
static bool check(X, Y) |
|
{ return false; } |
|
}; |
|
|
|
template <> |
|
struct less_than_type_min<true, false> |
|
{ |
|
template <class X, class Y> |
|
static bool check(X x, Y) |
|
{ return x < 0; } |
|
}; |
|
|
|
// greater_than_type_max - |
|
// same_sign should be: |
|
// numeric_limits<X>::is_signed == numeric_limits<Y>::is_signed |
|
// y_max should be numeric_limits<Y>::max() |
|
// |
|
// check(x, y_max) returns true iff x > y_max without invoking comparisons |
|
// between signed and unsigned values. |
|
// |
|
// "poor man's partial specialization" is in use here. |
|
template <bool same_sign, bool x_is_signed> |
|
struct greater_than_type_max; |
|
|
|
template<> |
|
struct greater_than_type_max<true, true> |
|
{ |
|
template <class X, class Y> |
|
static inline bool check(X x, Y y_max) |
|
{ return x > y_max; } |
|
}; |
|
|
|
template <> |
|
struct greater_than_type_max<false, true> |
|
{ |
|
// What does the standard say about this? I think it's right, and it |
|
// will work with every compiler I know of. |
|
template <class X, class Y> |
|
static inline bool check(X x, Y) |
|
{ return x >= 0 && static_cast<X>(static_cast<Y>(x)) != x; } |
|
|
|
# if defined(BOOST_MSVC) && BOOST_MSVC < 1300 |
|
// MSVC6 can't static_cast unsigned __int64 -> floating types |
|
# define BOOST_UINT64_CAST(src_type) \ |
|
static inline bool check(src_type x, unsigned __int64) \ |
|
{ \ |
|
if (x < 0) return false; \ |
|
unsigned __int64 y = static_cast<unsigned __int64>(x); \ |
|
bool odd = y & 0x1; \ |
|
__int64 div2 = static_cast<__int64>(y >> 1); \ |
|
return ((static_cast<src_type>(div2) * 2.0) + odd) != x; \ |
|
} |
|
|
|
BOOST_UINT64_CAST(long double); |
|
BOOST_UINT64_CAST(double); |
|
BOOST_UINT64_CAST(float); |
|
# undef BOOST_UINT64_CAST |
|
# endif |
|
}; |
|
|
|
template<> |
|
struct greater_than_type_max<true, false> |
|
{ |
|
template <class X, class Y> |
|
static inline bool check(X x, Y y_max) |
|
{ return x > y_max; } |
|
}; |
|
|
|
template <> |
|
struct greater_than_type_max<false, false> |
|
{ |
|
// What does the standard say about this? I think it's right, and it |
|
// will work with every compiler I know of. |
|
template <class X, class Y> |
|
static inline bool check(X x, Y) |
|
{ return static_cast<X>(static_cast<Y>(x)) != x; } |
|
}; |
|
|
|
#else // use #pragma hacks if available |
|
|
|
namespace detail |
|
{ |
|
# if BOOST_MSVC |
|
# pragma warning(push) |
|
# pragma warning(disable : 4018) |
|
# pragma warning(disable : 4146) |
|
#elif defined(__BORLANDC__) |
|
# pragma option push -w-8041 |
|
# endif |
|
|
|
// Move to namespace boost in utility.hpp? |
|
template <class T> |
|
struct fixed_numeric_limits : public std::numeric_limits<T> |
|
{ |
|
static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION () |
|
{ |
|
return std::numeric_limits<T>::is_signed && (std::numeric_limits<T>::min)() >= 0 |
|
? T(-(std::numeric_limits<T>::max)()) : (std::numeric_limits<T>::min)(); |
|
} |
|
}; |
|
|
|
# if BOOST_MSVC |
|
# pragma warning(pop) |
|
#elif defined(__BORLANDC__) |
|
# pragma option pop |
|
# endif |
|
} // namespace detail |
|
|
|
#endif |
|
|
|
template<typename Target, typename Source> |
|
inline Target numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET) |
|
{ |
|
// typedefs abbreviating respective trait classes |
|
typedef detail::fixed_numeric_limits<Source> arg_traits; |
|
typedef detail::fixed_numeric_limits<Target> result_traits; |
|
|
|
#if defined(BOOST_STRICT_CONFIG) \ |
|
|| (!defined(__HP_aCC) || __HP_aCC > 33900) \ |
|
&& (!defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) \ |
|
|| defined(BOOST_SGI_CPP_LIMITS)) |
|
// typedefs that act as compile time assertions |
|
// (to be replaced by boost compile time assertions |
|
// as and when they become available and are stable) |
|
typedef bool argument_must_be_numeric[arg_traits::is_specialized]; |
|
typedef bool result_must_be_numeric[result_traits::is_specialized]; |
|
|
|
const bool arg_is_signed = arg_traits::is_signed; |
|
const bool result_is_signed = result_traits::is_signed; |
|
const bool same_sign = arg_is_signed == result_is_signed; |
|
|
|
if (less_than_type_min<arg_is_signed, result_is_signed>::check(arg, (result_traits::min)()) |
|
|| greater_than_type_max<same_sign, arg_is_signed>::check(arg, (result_traits::max)()) |
|
) |
|
|
|
#else // We need to use #pragma hacks if available |
|
|
|
# if BOOST_MSVC |
|
# pragma warning(push) |
|
# pragma warning(disable : 4018) |
|
#elif defined(__BORLANDC__) |
|
#pragma option push -w-8012 |
|
# endif |
|
if ((arg < 0 && !result_traits::is_signed) // loss of negative range |
|
|| (arg_traits::is_signed && arg < (result_traits::min)()) // underflow |
|
|| arg > (result_traits::max)()) // overflow |
|
# if BOOST_MSVC |
|
# pragma warning(pop) |
|
#elif defined(__BORLANDC__) |
|
#pragma option pop |
|
# endif |
|
#endif |
|
{ |
|
throw bad_numeric_cast(); |
|
} |
|
return static_cast<Target>(arg); |
|
} // numeric_cast |
|
|
|
# undef BOOST_EXPLICIT_DEFAULT_TARGET |
|
|
|
} // namespace boost |
|
|
|
#endif // BOOST_OLD_NUMERIC_CAST_HPP
|
|
|