third_party/boost/include/boost/numeric/conversion/detail/old_numeric_cast.hpp - webm/webmlive - Git at Google

 //  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
	// 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