mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-11-27 11:52:25 +00:00
e1644a68eb
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@6319 a592a061-630c-0410-9148-cb99ea01b6c8
386 lines
13 KiB
C++
386 lines
13 KiB
C++
// boost cast.hpp header file ----------------------------------------------//
|
|
|
|
// (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
|
|
// and distribute this software is granted provided this copyright
|
|
// notice appears in all copies. This software is provided "as is" without
|
|
// express or implied warranty, and with no claim as to its suitability for
|
|
// any purpose.
|
|
|
|
// See http://www.boost.org/libs/conversion for Documentation.
|
|
|
|
// Revision History
|
|
// 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_CAST_HPP
|
|
#define BOOST_CAST_HPP
|
|
|
|
# include <boost/config.hpp>
|
|
# include <cassert>
|
|
# include <typeinfo>
|
|
# include <boost/type.hpp>
|
|
# include <boost/limits.hpp>
|
|
# include <boost/detail/select_type.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?
|
|
# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // 1200 = VC6
|
|
# define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
|
|
# else
|
|
# define BOOST_EXPLICIT_DEFAULT_TARGET
|
|
# endif
|
|
|
|
namespace boost
|
|
{
|
|
// See the documentation for descriptions of how to choose between
|
|
// static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<>
|
|
|
|
// polymorphic_cast --------------------------------------------------------//
|
|
|
|
// Runtime checked polymorphic downcasts and crosscasts.
|
|
// Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup,
|
|
// section 15.8 exercise 1, page 425.
|
|
|
|
template <class Target, class Source>
|
|
inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
|
|
{
|
|
Target tmp = dynamic_cast<Target>(x);
|
|
if ( tmp == 0 ) throw std::bad_cast();
|
|
return tmp;
|
|
}
|
|
|
|
// polymorphic_downcast ----------------------------------------------------//
|
|
|
|
// assert() checked polymorphic downcast. Crosscasts prohibited.
|
|
|
|
// WARNING: Because this cast uses assert(), it violates the One Definition
|
|
// Rule if NDEBUG is inconsistently defined across translation units.
|
|
|
|
// Contributed by Dave Abrahams
|
|
|
|
template <class Target, class Source>
|
|
inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET)
|
|
{
|
|
assert( dynamic_cast<Target>(x) == x ); // detect logic error
|
|
return static_cast<Target>(x);
|
|
}
|
|
|
|
// implicit_cast -----------------------------------------------------------//
|
|
//
|
|
// Removed due to uncertain purpose. Use either numeric_cast (see below)
|
|
// or static_cast according to the need.
|
|
|
|
// numeric_cast and related exception --------------------------------------//
|
|
|
|
// Contributed by Kevlin Henney
|
|
|
|
// bad_numeric_cast --------------------------------------------------------//
|
|
|
|
// exception used to indicate runtime numeric_cast failure
|
|
class bad_numeric_cast : public std::bad_cast
|
|
{
|
|
public:
|
|
// constructors, destructors and assignment operator defaulted
|
|
|
|
// function inlined for brevity and consistency with rest of library
|
|
virtual const char *what() const throw()
|
|
{
|
|
return "bad numeric cast: loss of range in numeric_cast";
|
|
}
|
|
};
|
|
|
|
// 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()
|
|
{
|
|
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<long long, false>
|
|
{
|
|
BOOST_STATIC_CONSTANT(bool, is_specialized = true);
|
|
BOOST_STATIC_CONSTANT(bool, is_signed = true);
|
|
static long long max()
|
|
{
|
|
# ifdef LONGLONG_MAX
|
|
return LONGLONG_MAX;
|
|
# else
|
|
return 9223372036854775807LL; // hope this is portable
|
|
# endif
|
|
}
|
|
|
|
static long long min()
|
|
{
|
|
# ifdef LONGLONG_MIN
|
|
return LONGLONG_MIN;
|
|
# else
|
|
return -9223372036854775808LL; // hope this is portable
|
|
# endif
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct fixed_numeric_limits_base<unsigned long long, false>
|
|
{
|
|
BOOST_STATIC_CONSTANT(bool, is_specialized = true);
|
|
BOOST_STATIC_CONSTANT(bool, is_signed = false);
|
|
static unsigned long long max()
|
|
{
|
|
# ifdef ULONGLONG_MAX
|
|
return ULONGLONG_MAX;
|
|
# else
|
|
return 0xffffffffffffffffULL; // hope this is portable
|
|
# endif
|
|
}
|
|
|
|
static unsigned long long min() { 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 <= 1200
|
|
// 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()
|
|
{
|
|
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_CAST_HPP
|