This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'. [SVN r26264]
This commit was manufactured by cvs2svn to create branch 'RC_1_32_0'.
2026-08-07 14:04:20 +02:00 · 2004-11-19 19:19:18 +00:00 · 2004-10-20 08:26:43 +00:00
10 changed files with 572 additions and 284 deletions
@@ -3,7 +3,7 @@
 <html>
  <head>
    <meta name="generator" content=
-    "Microsoft FrontPage 5.0">
+    "HTML Tidy for Cygwin (vers 1st April 2002), see www.w3.org">
    <meta http-equiv="Content-Type" content=
    "text/html; charset=windows-1252">
    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
@@ -19,9 +19,10 @@

    <h2><a name="Cast Functions">Cast Functions</a></h2>

-    <p>The header <a href="../../boost/cast.hpp">boost/cast.hpp</a> provides <code>
-    <a href="#Polymorphic_cast">polymorphic_cast</a> and</code> <a href=
-    "#Polymorphic_cast"><code>polymorphic_downcast</code></a> function templates designed to
+    <p>The header <a href="../../boost/cast.hpp">boost/cast.hpp</a> provides
+    <a href="#Polymorphic_cast"><b>polymorphic_cast</b></a>, <a href=
+    "#Polymorphic_cast"><b>polymorphic_downcast</b></a>, and <a href=
+    "#numeric_cast"><b>numeric_cast</b></a> function templates designed to
    complement the C++ built-in casts.</p>

    <p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
@@ -33,50 +34,43 @@
    least one virtual function) are sometimes downcast or crosscast.
    Downcasting means casting from a base class to a derived class.
    Crosscasting means casting across an inheritance hierarchy diagram, such
-    as from one base to the other in a <code>Y</code> diagram hierarchy.</p>
+    as from one base to the other in a <b>Y</b> diagram hierarchy.</p>

    <p>Such casts can be done with old-style casts, but this approach is
    never to be recommended. Old-style casts are sorely lacking in type
    safety, suffer poor readability, and are difficult to locate with search
    tools.</p>

-    <p>The C++ built-in <code>static_cast</code> can be used for efficiently
+    <p>The C++ built-in <b>static_cast</b> can be used for efficiently
    downcasting pointers to polymorphic objects, but provides no error
    detection for the case where the pointer being cast actually points to
-    the wrong derived class. The <code>polymorphic_downcast</code> template retains
-    the efficiency of <code>static_cast</code> for non-debug compilations, but for
-    debug compilations adds safety via an assert() that a <code>dynamic_cast</code>
+    the wrong derived class. The <b>polymorphic_downcast</b> template retains
+    the efficiency of <b>static_cast</b> for non-debug compilations, but for
+    debug compilations adds safety via an assert() that a <b>dynamic_cast</b>
    succeeds.</p>

-    <p>The C++ built-in <code>dynamic_cast</code> can be used for downcasts and
+    <p>The C++ built-in <b>dynamic_cast</b> can be used for downcasts and
    crosscasts of pointers to polymorphic objects, but error notification in
    the form of a returned value of 0 is inconvenient to test, or worse yet,
-    easy to forget to test. The throwing form of <code>dynamic_cast</code>, which
+    easy to forget to test. The throwing form of <b>dynamic_cast</b>, which
    works on references, can be used on pointers through the ugly expression
    &amp;<code>dynamic_cast&lt;T&amp;&gt;(*p)</code>, which causes undefined
-    behavior if <code>p</code> is <code>0</code>. The <code>polymorphic_cast</code>
-    template performs a <code>dynamic_cast</code> on a pointer, and throws an
-    exception if the <code>dynamic_cast</code> returns 0.</p>
+    behavior if <code>p</code> is <code>0</code>. The <b>polymorphic_cast</b>
+    template performs a <b>dynamic_cast</b> on a pointer, and throws an
+    exception if the <b>dynamic_cast</b> returns 0.</p>

-    <p>A <code>polymorphic_downcast</code> should be used for
-    downcasts that you are certain should succeed.  Error checking is
-    only performed in translation units where <code>NDEBUG</code> is
-    not defined, via
-<pre>  assert( dynamic_cast&lt;Derived&gt;(x) == x )
-</pre> where <code>x</code> is the source pointer.  This approach
-    ensures that not only is a non-zero pointer returned, but also
-    that it is correct in the presence of multiple inheritance.
-    Attempts to crosscast using <code>polymorphic_downcast</code> will
-    fail to compile.
-    <b>Warning:</b> Because <code>polymorphic_downcast</code> uses assert(), it
-    violates the One Definition Rule (ODR) if NDEBUG is inconsistently
-    defined across translation units. [See ISO Std 3.2]
-</p><p>
-    For crosscasts, or when the success of a cast can only be known at
-    runtime, or when efficiency is not important,
-    <code>polymorphic_cast</code> is preferred. </p>
+    <p>A <b>polymorphic_downcast</b> is preferred when debug-mode tests will
+    cover 100% of the object types possibly cast and when non-debug-mode
+    efficiency is an issue. If these two conditions are not present,
+    <b>polymorphic_cast</b> is preferred. It must also be used for
+    crosscasts. It does an assert( dynamic_cast&lt;Derived&gt;(x) == x )
+    where x is the base pointer, ensuring that not only is a non-zero pointer
+    returned, but also that it correct in the presence of multiple
+    inheritance. <b>Warning:</b>: Because <b>polymorphic_downcast</b> uses
+    assert(), it violates the one definition rule (ODR) if NDEBUG is
+    inconsistently defined across translation units. [See ISO Std 3.2]</p>

-    <p>The C++ built-in <code>dynamic_cast</code> must be used to cast references
+    <p>The C++ built-in <b>dynamic_cast</b> must be used to cast references
    rather than pointers. It is also the only cast that can be used to check
    whether a given interface is supported; in that case a return of 0 isn't
    an error condition.</p>
@@ -84,7 +78,8 @@
    <h3>polymorphic_cast and polymorphic_downcast synopsis</h3>

    <blockquote>
-<pre>namespace boost {
+<pre>
+namespace boost {

 template &lt;class Derived, class Base&gt;
 inline Derived polymorphic_cast(Base* x);
@@ -103,7 +98,8 @@ inline Derived polymorphic_downcast(Base* x);
    <h3>polymorphic_downcast example</h3>

    <blockquote>
-<pre>#include &lt;boost/cast.hpp&gt;
+<pre>
+#include &lt;boost/cast.hpp&gt;
 ...
 class Fruit { public: virtual ~Fruit(){}; ... };
 class Banana : public Fruit { ... };
@@ -115,20 +111,85 @@ void f( Fruit * fruit ) {
 </pre>
    </blockquote>

+    <h3><a name="numeric_cast">numeric_cast</a></h3>
+
+    <p>A <b>static_cast</b> or implicit conversion will not detect failure to
+    preserve range for numeric casts. The <b>numeric_cast</b> function
+    templates are similar to <b>static_cast</b> and certain (dubious)
+    implicit conversions in this respect, except that they detect loss of
+    numeric range. An exception is thrown when a runtime value-preservation
+    check fails.</p>
+
+    <p>The requirements on the argument and result types are:</p>
+
+    <blockquote>
+      <ul>
+        <li>Both argument and result types are CopyConstructible [ISO Std
+        20.1.3].</li>
+
+        <li>Both argument and result types are Numeric, defined by
+        <code>std::numeric_limits&lt;&gt;::is_specialized</code> being
+        true.</li>
+
+        <li>The argument can be converted to the result type using
+        <b>static_cast</b>.</li>
+      </ul>
+    </blockquote>
+
+    <h3>numeric_cast synopsis</h3>
+
+    <blockquote>
+<pre>
+namespace boost {
+
+class bad_numeric_cast : public std::bad_cast {...};
+
+template&lt;typename Target, typename Source&gt;
+  inline Target numeric_cast(Source arg);
+    // Throws:  bad_numeric_cast unless, in converting arg from Source to Target,
+    //          there is no loss of negative range, and no underflow, and no
+    //          overflow, as determined by std::numeric_limits
+    // Returns: static_cast&lt;Target&gt;(arg)
+
+}
+</pre>
+    </blockquote>
+
+    <h3>numeric_cast example</h3>
+
+    <blockquote>
+<pre>
+#include &lt;boost/cast.hpp&gt;
+using namespace boost::cast;
+
+void ariane(double vx)
+{
+    ...
+    unsigned short dx = numeric_cast&lt;unsigned short&gt;(vx);
+    ...
+}
+</pre>
+    </blockquote>
+
+    <h3>numeric_cast rationale</h3>
+
+    <p>The form of the throws condition is specified so that != is not a
+    required operation.</p>
+
    <h3>History</h3>

-    <p><code>polymorphic_cast</code> was suggested by Bjarne Stroustrup in "The C++
+    <p><b>polymorphic_cast</b> was suggested by Bjarne Stroustrup in "The C++
    Programming Language".<br>
-     <code>polymorphic_downcast</code> was contributed by <a href=
-    "../../people/dave_abrahams.htm">Dave Abrahams</a>.<code><br>
-     An old
-     numeric_cast</code> that was contributed by <a href=
-    "../../people/kevlin_henney.htm">Kevlin Henney</a> is now superseeded by the <a href="../numeric/conversion/doc/index.html">Boost Numeric Conversion Library</a></p>
+     <b>polymorphic_downcast</b> was contributed by <a href=
+    "../../people/dave_abrahams.htm">Dave Abrahams</a>.<b><br>
+     numeric_cast</b> was contributed by <a href=
+    "../../people/kevlin_henney.htm">Kevlin Henney</a>.</p>
    <hr>

-    <p>Revised
+    <p>Revised 
    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
-                    -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348"
+                    -->06 January, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="38320"
                    --></p>

    <p>&copy; Copyright boost.org 1999. Permission to copy, use, modify, sell
@@ -137,4 +198,5 @@ void f( Fruit * fruit ) {
    or implied warranty, and with no claim as to its suitability for any
    purpose.</p>
  </body>
-</html>
+</html>
+
@@ -1,6 +1,6 @@
 //  boost cast.hpp header file  ----------------------------------------------//

-//  (C) Copyright Kevlin Henney and Dave Abrahams 1999.
+//  (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)
@@ -8,10 +8,9 @@
 //  See http://www.boost.org/libs/conversion for Documentation.

 //  Revision History
-//  23 JUn 05  numeric_cast removed and redirected to the new verion (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
+//  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
@@ -27,14 +26,14 @@
 //             (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
+//  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.
+//             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.
@@ -44,7 +43,7 @@
 #define BOOST_CAST_HPP

 # include <boost/config.hpp>
-# include <boost/assert.hpp>
+# include <cassert>
 # include <typeinfo>
 # include <boost/type.hpp>
 # include <boost/limits.hpp>
@@ -55,7 +54,7 @@
 //  appear in the function's argument list.
 //
 //  TODO: Add this to config.hpp?
-# if defined(BOOST_MSVC) && BOOST_MSVC < 1300
+# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // 1200 = VC6
 #  define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type<Target>* = 0
 # else
 #  define BOOST_EXPLICIT_DEFAULT_TARGET
@@ -69,7 +68,7 @@ namespace boost
 //  polymorphic_cast  --------------------------------------------------------//

    //  Runtime checked polymorphic downcasts and crosscasts.
-    //  Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup,
+    //  Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup, 
    //  section 15.8 exercise 1, page 425.

    template <class Target, class Source>
@@ -82,26 +81,304 @@ namespace boost

 //  polymorphic_downcast  ----------------------------------------------------//

-    //  BOOST_ASSERT() checked polymorphic downcast.  Crosscasts prohibited.
+    //  assert() checked polymorphic downcast.  Crosscasts prohibited.

-    //  WARNING: Because this cast uses BOOST_ASSERT(), it violates
-    //  the One Definition Rule if used in multiple translation units
-    //  where BOOST_DISABLE_ASSERTS, BOOST_ENABLE_ASSERT_HANDLER
-    //  NDEBUG are defined inconsistently.
+    //  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)
    {
-        BOOST_ASSERT( dynamic_cast<Target>(x) == x );  // detect logic error
+        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 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 <= 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 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

-# include <boost/numeric/conversion/cast.hpp>
-
 #endif  // BOOST_CAST_HPP
@@ -23,6 +23,12 @@ inline T implicit_cast (typename mpl::identity<T>::type x) {
 //template <typename T>
 //void implicit_cast (...);

+// Macro for when you need a constant expression (Gennaro Prota)
+#define BOOST_IMPLICIT_CAST(dst_type, expr)           \
+          ( sizeof( implicit_cast<dst_type>(expr) )   \
+                     ,                                \
+            static_cast<dst_type>(expr)               \
+          )

 } // namespace boost

@@ -12,9 +12,8 @@
 //        with additional fixes and suggestions from Gennaro Prota,
 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
 //        and other Boosters
-// when:  November 2000, March 2003, June 2005
+// when:  November 2000, March 2003

-#include <cstddef>
 #include <string>
 #include <typeinfo>
 #include <boost/config.hpp>
@@ -30,7 +29,8 @@

 #if defined(BOOST_NO_STRINGSTREAM) || \
    defined(BOOST_NO_STD_WSTRING) || \
-    defined(BOOST_NO_STD_LOCALE) 
+    defined(BOOST_NO_STD_LOCALE) || \
+    defined(BOOST_NO_INTRINSIC_WCHAR_T)
 #define DISABLE_WIDE_CHAR_SUPPORT
 #endif

@@ -45,9 +45,9 @@ namespace boost
        {
        }
        bad_lexical_cast(
-            const std::type_info &source_type,
-            const std::type_info &target_type) :
-            source(&source_type), target(&target_type)
+            const std::type_info &s,
+            const std::type_info &t) :
+            source(&s), target(&t)
        {
        }
        const std::type_info &source_type() const
@@ -80,13 +80,11 @@ namespace boost
        };

        #ifndef DISABLE_WIDE_CHAR_SUPPORT
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
        template<>
        struct stream_char<wchar_t>
        {
            typedef wchar_t type;
        };
-#endif

        template<>
        struct stream_char<wchar_t *>
@@ -125,11 +123,6 @@ namespace boost
        template<typename Target, typename Source>
        class lexical_stream
        {
-        private:
-            typedef typename widest_char<
-                typename stream_char<Target>::type,
-                typename stream_char<Source>::type>::type char_type;
-
        public:
            lexical_stream()
            {
@@ -155,16 +148,7 @@ namespace boost
            {
                return !is_pointer<InputStreamable>::value &&
                       stream >> output &&
-                       stream.get() ==
-#if defined(__GNUC__) && (__GNUC__<3) && defined(BOOST_NO_STD_WSTRING)
-// GCC 2.9x lacks std::char_traits<>::eof().
-// We use BOOST_NO_STD_WSTRING to filter out STLport and libstdc++-v3
-// configurations, which do provide std::char_traits<>::eof().
-    
-                           EOF;
-#else
-                           std::char_traits<char_type>::eof();
-#endif
+                       (stream >> std::ws).eof();
            }
            bool operator>>(std::string &output)
            {
@@ -182,6 +166,10 @@ namespace boost
            }
            #endif
        private:
+            typedef typename widest_char<
+                typename stream_char<Target>::type,
+                typename stream_char<Source>::type>::type char_type;
+
            #if defined(BOOST_NO_STRINGSTREAM)
            std::strstream stream;
            #elif defined(BOOST_NO_STD_LOCALE)
@@ -192,42 +180,6 @@ namespace boost
        };
    }

-    #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-    // call-by-const reference version
-
-    namespace detail
-    {
-        template<class T>
-        struct array_to_pointer_decay
-        {
-            typedef T type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_to_pointer_decay<T[N]>
-        {
-            typedef const T * type;
-        };
-    }
-
-    template<typename Target, typename Source>
-    Target lexical_cast(const Source &arg)
-    {
-        typedef typename detail::array_to_pointer_decay<Source>::type NewSource;
-
-        detail::lexical_stream<Target, NewSource> interpreter;
-        Target result;
-
-        if(!(interpreter << arg && interpreter >> result))
-            throw_exception(bad_lexical_cast(typeid(NewSource), typeid(Target)));
-        return result;
-    }
-
-    #else
-
-    // call-by-value fallback version (deprecated)
-
    template<typename Target, typename Source>
    Target lexical_cast(Source arg)
    {
@@ -235,14 +187,12 @@ namespace boost
        Target result;

        if(!(interpreter << arg && interpreter >> result))
-            throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));
+            throw_exception(bad_lexical_cast(typeid(Target), typeid(Source)));
        return result;
    }
-
-    #endif
 }

-// Copyright Kevlin Henney, 2000-2005. All rights reserved.
+// Copyright Kevlin Henney, 2000-2003. All rights reserved.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -250,3 +200,4 @@ namespace boost

 #undef DISABLE_WIDE_CHAR_SUPPORT
 #endif
+
@@ -3,7 +3,7 @@
 <head>
 <meta http-equiv="Content-Language" content="en-us">
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Boost Conversion Library</title>
 </head>
@@ -22,7 +22,8 @@ supplied by several headers:</p>
 <ul>
  <li>The <a href="cast.htm">boost/cast</a> header provides <b>polymorphic_cast&lt;&gt;</b>
    and <b>polymorphic_downcast&lt;&gt;</b> to perform safe casting between
-  polymorphic types.<br>
+    polymorphic types, and <b> numeric_cast</b><i>&lt;&gt;</i> to perform safe casting
+    between numeric types.<br>
  </li>
  <li>The <a href="lexical_cast.htm">boost/lexical_cast</a> header provides <b>lexical_cast&lt;&gt;</b>
    general literal text conversions, such as an <code>int</code> represented as
@@ -30,9 +31,9 @@ supplied by several headers:</p>
 </ul>
 <hr>
 <p>Revised <!--webbot bot="Timestamp" S-Type="EDITED"
-S-Format="%d %B, %Y" startspan -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348" -->
+S-Format="%d %B, %Y" startspan -->06 January, 2001<!--webbot bot="Timestamp" endspan i-checksum="38320" -->
 </p>

 </body>

-</html>
+</html>
@@ -4,7 +4,7 @@
 	<head>
 		<title>lexical_cast</title>
 		<meta name="author" content="Kevlin Henney, mailto:kevlin@curbralan.com">
-		<meta name="generator" content="Microsoft FrontPage 5.0">
+		<meta name="generator" content="Microsoft FrontPage 4.0">
 	</head>
 	<body bgcolor="#FFFFFF" text="#000000">
 		<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" width="277" height="86">Header
@@ -77,7 +77,7 @@
 			conversions, such as where precision or formatting need tighter control than is 
 			offered by the default behavior of <code>lexical_cast</code>, the conventional <code>
 				stringstream</code> approach is recommended. Where the conversions are 
-			numeric to numeric, <code><a href="../numeric/conversion/doc/numeric_cast.html">numeric_cast</a></code>
+			numeric to numeric, <code><a href="cast.htm#numeric_cast">numeric_cast</a></code>
 			may offer more reasonable behavior than <code>lexical_cast</code>.
 		<p>
 			For a good discussion of the options and issues involved in string-based 
@@ -89,7 +89,8 @@
 			<h2><a name="examples">Examples</a></h2>
 			The following example treats command line arguments as a sequence of numeric 
 			data: <blockquote>
-				<pre>int main(int argc, char * argv[])
+				<pre>
+int main(int argc, char * argv[])
 {
    using boost::lexical_cast;
    using boost::bad_lexical_cast;
@@ -111,7 +112,8 @@
 }
 </pre>
 			</blockquote>The following example uses numeric data in a string expression: <blockquote>
-				<pre>void log_message(const std::string &amp;);
+				<pre>
+void log_message(const std::string &amp;);

 void log_errno(int yoko)
 {
@@ -123,11 +125,12 @@ void log_errno(int yoko)
 			<h2><a name="synopsis">Synopsis</a></h2>
 			Library features defined in <a href="../../boost/lexical_cast.hpp"><code>&quot;boost/lexical_cast.hpp&quot;</code></a>:
 			<blockquote>
-				<pre>namespace boost
+				<pre>
+namespace boost
 {
    class <a href="#bad_lexical_cast">bad_lexical_cast</a>;
    template&lt;typename Target, typename Source&gt;
-      Target <a href="#lexical_cast">lexical_cast</a>(const Source&amp; arg);
+      Target <a href="#lexical_cast">lexical_cast</a>(Source arg);
 }
 </pre>
 			</blockquote>Unit test defined in <a href="lexical_cast_test.cpp"><code>&quot;lexical_cast_test.cpp&quot;</code></a>.
@@ -135,8 +138,9 @@ void log_errno(int yoko)
 			<hr>
 			<h2><a name="lexical_cast"><code>lexical_cast</code></a></h2>
 			<blockquote>
-				<pre>template&lt;typename Target, typename Source&gt;
-  Target lexical_cast(const Source&amp; arg);
+				<pre>
+template&lt;typename Target, typename Source&gt;
+  Target lexical_cast(Source arg);
 </pre>
 			</blockquote>Returns the result of streaming <code>arg</code> into a
 			standard library string-based stream and then out as a <code>Target</code> object.
@@ -182,7 +186,8 @@ void log_errno(int yoko)
 			<hr>
 			<h2><a name="bad_lexical_cast"><code>bad_lexical_cast</code></a></h2>
 			<blockquote>
-				<pre>class bad_lexical_cast : public std::bad_cast
+				<pre>
+class bad_lexical_cast : public std::bad_cast
 {
 public:
    ... // <i>same member function interface as</i> std::exception
@@ -191,44 +196,28 @@ public:
 			</blockquote>Exception used to indicate runtime <a href="#lexical_cast"><code>lexical_cast</code></a>
 		failure.
 			<hr>
-		
-<h2><a name="changes">Changes</a></h2>
-<h3>June 2005:</h3>
-<ul type="square">
-  <li>Call-by-const reference for the parameters. This requires partial specialization 
-    of class templates, so it doesn't work for MSVC 6, and it uses the original 
-    pass by value there.<br>
-  </li>
-  <li>The MSVC 6 support is deprecated, and will be removed in a future Boost 
-    version. </li>
-</ul>
-<h3>Earlier:</h3>
-	
-<ul type="square">
-  <li>The previous version of <code>lexical_cast</code> used the default stream 
-    precision for reading and writing floating-point numbers. For numerics that 
-    have a corresponding specialization of <code>std::numeric_limits</code>, the 
-    current version now chooses a precision to match. <br>
-  <li>The previous version of <code>lexical_cast</code> did not support conversion 
-    to or from any wide-character-based types. For compilers with full language 
-    and library support for wide characters, <code>lexical_cast</code> now supports 
-    conversions from <code>wchar_t</code>, <code>wchar_t *</code>, and <code>std::wstring</code> 
-    and to <code>wchar_t</code> and <code>std::wstring</code>. <br>
-  <li>The previous version of <code>lexical_cast</code> assumed that the conventional 
-    stream extractor operators were sufficient for reading values. However, string 
-    I/O is asymmetric, with the result that spaces play the role of I/O separators 
-    rather than string content. The current version fixes this error for <code>std::string</code> 
-    and, where supported, <code>std::wstring</code>: <code>lexical_cast&lt;std::string&gt;("Hello, 
-    World")</code> succeeds instead of failing with a <code>bad_lexical_cast</code> 
-    exception. <br>
-  <li>The previous version of <code>lexical_cast</code> allowed unsafe and meaningless 
-    conversions to pointers. The current version now throws a <code>bad_lexical_cast</code> 
-    for conversions to pointers: <code>lexical_cast&lt;char *&gt;("Goodbye, World")</code> 
-    now throws an exception instead of causing undefined behavior. 
-</ul>
+		<h2><a name="changes">Changes</a></h2>
+	<ul type="square">
+	<li>The previous version of <code>lexical_cast</code> used the default stream precision for reading
+	and writing floating-point numbers. For numerics that have a corresponding specialization of
+	<code>std::numeric_limits</code>, the current version now chooses a precision to match.
+	<li>The previous version of <code>lexical_cast</code> did not support conversion to or from any
+	wide-character-based types. For compilers with full language and library support for wide characters,
+	<code>lexical_cast</code> now supports conversions from <code>wchar_t</code>, <code>wchar_t *</code>,
+	and <code>std::wstring</code> and to <code>wchar_t</code> and <code>std::wstring</code>.
+	<li>The previous version of <code>lexical_cast</code> assumed that the conventional stream extractor
+	operators were sufficient for reading values. However, string I/O is asymmetric, with the result
+	that spaces play the role of I/O separators rather than string content. The current version fixes
+	this error for <code>std::string</code> and, where supported, <code>std::wstring</code>:
+	<code>lexical_cast&lt;std::string&gt;("Hello, World")</code> succeeds instead of failing with
+	a <code>bad_lexical_cast</code> exception.
+	<li>The previous version of <code>lexical_cast</code> allowed unsafe and meaningless conversions to
+	pointers. The current version now throws a <code>bad_lexical_cast</code> for conversions to pointers:
+	<code>lexical_cast&lt;char *&gt;("Goodbye, World")</code> now throws an exception instead of
+	causing undefined behavior.
+	</ul>
 	<p>
 			<hr>
-			
-<div align="right"><small><i>&copy; Copyright Kevlin Henney, 2000&#150;2005</i></small></div>
+			<div align="right"><small><i>&copy; Copyright Kevlin Henney, 2000&#150;2003</i></small></div>
 	</body>
-</html>
+</html>
@@ -2,13 +2,11 @@
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
-//  Copyright Terje Slettebø and Kevlin Henney, 2005.
+//  Copyright Terje Slettebø and Kevlin Henney, 2003.
 //
 //  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).
-//
-// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.

 #include <boost/config.hpp>

@@ -19,13 +17,13 @@
 #endif

 #include <boost/lexical_cast.hpp>
-
-#include <boost/test/unit_test.hpp>
 #include <boost/test/floating_point_comparison.hpp>
+#include <boost/test/included/unit_test_framework.hpp>

 #if defined(BOOST_NO_STRINGSTREAM) || \
    defined(BOOST_NO_STD_WSTRING) || \
-    defined(BOOST_NO_STD_LOCALE)
+    defined(BOOST_NO_STD_LOCALE) || \
+    defined(BOOST_NO_INTRINSIC_WCHAR_T)
 #define DISABLE_WIDE_CHAR_SUPPORT
 #endif

@@ -42,10 +40,8 @@ void test_conversion_from_wchar_t();
 void test_conversion_to_wchar_t();
 void test_conversion_from_wstring();
 void test_conversion_to_wstring();
-void test_bad_lexical_cast();
-void test_no_whitespace_stripping();

-unit_test::test_suite *init_unit_test_suite(int, char *[])
+unit_test_framework::test_suite *init_unit_test_suite(int, char **)
 {
    unit_test_framework::test_suite *suite =
        BOOST_TEST_SUITE("lexical_cast unit test");
@@ -62,8 +58,6 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
    suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
    suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
    #endif
-    suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
-    suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
    return suite;
 }

@@ -73,96 +67,99 @@ void test_conversion_to_char()
    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
    BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
-    BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char>(123), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
    BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
    BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
    BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
-    BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char>(""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char>("Test"), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
    BOOST_CHECK_THROW(
-        lexical_cast<char>(std::string("")), bad_lexical_cast);
+        lexical_cast<char>(std::string("")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<char>(std::string("Test")), bad_lexical_cast);
+        lexical_cast<char>(std::string("Test")), boost::bad_lexical_cast);
 }

 void test_conversion_to_int()
 {
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
-    BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
-    BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
+    BOOST_CHECK_EQUAL(1,lexical_cast<int>('1'));
+    BOOST_CHECK_EQUAL(0,lexical_cast<int>('0'));
+    BOOST_CHECK_THROW(lexical_cast<int>('A'),boost::bad_lexical_cast);
+    BOOST_CHECK_EQUAL(1,lexical_cast<int>(1));
    BOOST_CHECK_EQUAL(
        (std::numeric_limits<int>::max)(),
        lexical_cast<int>((std::numeric_limits<int>::max)()));
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
+    BOOST_CHECK_EQUAL(1,lexical_cast<int>(1.0));

-    BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(1.23), boost::bad_lexical_cast);

-    BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(1e20), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
    BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
    BOOST_CHECK_THROW(
-        lexical_cast<int>(" 123"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
+        lexical_cast<int>(" 123"), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>("Test"), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
+    BOOST_CHECK_EQUAL(123,lexical_cast<int>(std::string("123")));
    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
+        lexical_cast<int>(std::string(" 123")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string("")), bad_lexical_cast);
+        lexical_cast<int>(std::string("")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::string("Test")), bad_lexical_cast);
+        lexical_cast<int>(std::string("Test")), boost::bad_lexical_cast);
 }

 void test_conversion_to_double()
 {
-    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
-    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE(1.234567890, 1.234567890, std::numeric_limits<double>::epsilon());
-    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
-    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
+    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>('1'));
+    BOOST_CHECK_THROW(lexical_cast<double>('A'), boost::bad_lexical_cast);
+    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(1));
+    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(1.23));
+    BOOST_CHECK_CLOSE(
+        (std::numeric_limits<double>::max)() / 2,
+        lexical_cast<double>((std::numeric_limits<double>::max)() / 2),
+        std::numeric_limits<double>::epsilon());
+    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(true));
+    BOOST_CHECK_EQUAL(0.0, lexical_cast<double>(false));
+    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>("1.23"));
+    BOOST_CHECK_THROW(lexical_cast<double>(""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>("Test"), boost::bad_lexical_cast);
+    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(std::string("1.23")));
    BOOST_CHECK_THROW(
-        lexical_cast<double>(std::string("")), bad_lexical_cast);
+        lexical_cast<double>(std::string("")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<double>(std::string("Test")), bad_lexical_cast);
+        lexical_cast<double>(std::string("Test")), boost::bad_lexical_cast);
 }

 void test_conversion_to_bool()
 {
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>('A'), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
-    BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(123), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
-    BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::string("")), bad_lexical_cast);
+        lexical_cast<bool>(std::string("")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
+        lexical_cast<bool>(std::string("Test")), boost::bad_lexical_cast);
 }

 void test_conversion_to_string()
@@ -172,8 +169,8 @@ void test_conversion_to_string()
    BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
    BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
    BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
-    BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
-    BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
+    BOOST_CHECK_EQUAL("1",lexical_cast<std::string>(true));
+    BOOST_CHECK_EQUAL("0",lexical_cast<std::string>(false));
    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
@@ -195,51 +192,45 @@ void test_conversion_from_to_wchar_t_alias()

 void test_conversion_to_pointer()
 {
-    BOOST_CHECK_THROW(lexical_cast<char *>("Test"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<char *>("Test"), boost::bad_lexical_cast);
    #ifndef DISABLE_WIDE_CHAR_SUPPORT
-    BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), boost::bad_lexical_cast);
    #endif
 }

 void test_conversion_from_wchar_t()
 {
-#ifndef DISABLE_WIDE_CHAR_SUPPORT
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    #ifndef DISABLE_WIDE_CHAR_SUPPORT
    BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
-#endif
+    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), boost::bad_lexical_cast);

    BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
-    BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(L""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), boost::bad_lexical_cast);

-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
-#endif
+    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), boost::bad_lexical_cast);

    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
-    BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(L""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), boost::bad_lexical_cast);

-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
-#endif
+    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
-#endif
+    BOOST_CHECK_THROW(lexical_cast<bool>(L""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), boost::bad_lexical_cast);
+    #endif
 }

 void test_conversion_to_wchar_t()
 {
-#if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    #ifndef DISABLE_WIDE_CHAR_SUPPORT
    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
@@ -248,14 +239,14 @@ void test_conversion_to_wchar_t()
    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), boost::bad_lexical_cast);
    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
    BOOST_CHECK_THROW(
-        lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
+        lexical_cast<wchar_t>(std::wstring(L"")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
+        lexical_cast<wchar_t>(std::wstring(L"Test")), boost::bad_lexical_cast);
    #endif
 }

@@ -264,16 +255,16 @@ void test_conversion_from_wstring()
    #ifndef DISABLE_WIDE_CHAR_SUPPORT
    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
+        lexical_cast<int>(std::wstring(L"")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
+        lexical_cast<int>(std::wstring(L"Test")), boost::bad_lexical_cast);

    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
+        lexical_cast<bool>(std::wstring(L"")), boost::bad_lexical_cast);
    BOOST_CHECK_THROW(
-        lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
+        lexical_cast<bool>(std::wstring(L"Test")), boost::bad_lexical_cast);
    #endif
 }

@@ -285,10 +276,8 @@ void test_conversion_to_wstring()
    BOOST_CHECK(L"1.111111111" == lexical_cast<std::wstring>(1.111111111));
    BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
    BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
    BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
-#endif
    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
    BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
@@ -297,24 +286,3 @@ void test_conversion_to_wstring()
    BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
    #endif
 }
-
-void test_bad_lexical_cast()
-{
-    try
-    {
-        lexical_cast<int>(std::string("Test"));
-
-        BOOST_CHECK(false); // Exception expected
-    }
-    catch(const bad_lexical_cast &e)
-    {
-        BOOST_CHECK(e.source_type() == typeid(std::string));
-        BOOST_CHECK(e.target_type() == typeid(int));
-    }
-}
-
-void test_no_whitespace_stripping()
-{
-    BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
-}
@@ -0,0 +1,34 @@
+# Signals library
+
+# Copyright (C) 2001-2003 Douglas Gregor
+
+# Permission to copy, use, sell and distribute this software is granted
+# provided this copyright notice appears in all copies. Permission to modify
+# the code and to distribute modified code is granted provided this copyright
+# notice appears in all copies, and a notice that the code was modified is
+# included with the copyright notice. This software is provided "as is"
+# without express or implied warranty, and with no claim as to its suitability
+# for any purpose.
+
+# For more information, see http://www.boost.org/
+
+
+# Testing Jamfile autogenerated from XML source
+subproject libs/conversion/test ;
+
+# bring in rules for testing
+import testing ;
+
+# Make tests run by default.
+DEPENDS all : test ;
+
+{
+  test-suite conversion
+      : [ run implicit_cast.cpp ]
+        [ compile-fail implicit_cast_fail.cpp ]
+        [ run ../cast_test.cpp ]
+        [ run ../numeric_cast_test.cpp ]
+        [ run ../lexical_cast_test.cpp ]
+      ;
+}
+      
@@ -19,8 +19,7 @@ test-suite conversion
  : [ run implicit_cast.cpp ]
    [ compile-fail implicit_cast_fail.cpp ]
    [ run ../cast_test.cpp ]
-    [ run ../numeric_cast_test.cpp ]    
-    [ run ../lexical_cast_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
+    [ run ../lexical_cast_test.cpp ]
  ;

-      
+      
@@ -4,8 +4,9 @@
 // http://www.boost.org/LICENSE_1_0.txt)

 #include <boost/implicit_cast.hpp>
-#include <boost/detail/lightweight_test.hpp>
+#include <cassert>
 #include <boost/type.hpp>
+
 using boost::implicit_cast;
 using boost::type;

@@ -24,9 +25,9 @@ typedef type<foo> foo_type;
 int main()
 {
    type<long> x = check_return(boost::implicit_cast<long>(1));
-    BOOST_TEST(boost::implicit_cast<long>(1) == 1L);
+    assert(boost::implicit_cast<long>(1) == 1L);

    type<foo> f = check_return(boost::implicit_cast<foo>("hello"));
    type<long> z = check_return(boost::implicit_cast<long>(foo("hello")));
-    return boost::report_errors();
+    return 0;
 }
Author	SHA1	Message	Date
nobody	b3d53db6c5	This commit was manufactured by cvs2svn to create tag 'Version_1_32_0'. [SVN r26264]	2004-11-19 19:19:18 +00:00
nobody	dfca010fb3	This commit was manufactured by cvs2svn to create branch 'RC_1_32_0'. [SVN r25797]	2004-10-20 08:26:43 +00:00