boost/numeric/conversion/detail/old_numeric_cast.hpp

   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       {
  86              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);
 118           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
 127           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);
 142           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
 151           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>
 169         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>
 177         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>
 185         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>
 205         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>
 215         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>
 241         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>
 251         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        {
 271            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>
 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