diff options
Diffstat (limited to '3rdParty/Boost/boost/numeric/conversion/detail/old_numeric_cast.hpp')
-rw-r--r-- | 3rdParty/Boost/boost/numeric/conversion/detail/old_numeric_cast.hpp | 339 |
1 files changed, 339 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/numeric/conversion/detail/old_numeric_cast.hpp b/3rdParty/Boost/boost/numeric/conversion/detail/old_numeric_cast.hpp new file mode 100644 index 0000000..47b86d2 --- /dev/null +++ b/3rdParty/Boost/boost/numeric/conversion/detail/old_numeric_cast.hpp @@ -0,0 +1,339 @@ +// 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 |