This commit was manufactured by cvs2svn to create tag

'Version_1_30_1'. [SVN r19444]
no message
2026-08-06 13:34:14 +02:00 · 2003-08-04 17:55:29 +00:00 · 2003-04-12 08:02:14 +00:00 · 2003-04-11 22:15:04 +00:00 · 2003-03-19 21:25:45 +00:00 · 2003-03-19 12:14:32 +00:00
13 changed files with 643 additions and 596 deletions
@@ -1,90 +1,64 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

 <html>
-  <head>
-    <meta name="generator" content=
-    "Microsoft FrontPage 5.0">
-    <meta http-equiv="Content-Type" content=
-    "text/html; charset=windows-1252">
-    <meta name="GENERATOR" content="Microsoft FrontPage 4.0">
-    <meta name="ProgId" content="FrontPage.Editor.Document">

-    <title>Header boost/cast.hpp Documentation</title>
-  </head>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Header boost/cast.hpp Documentation</title>
+</head>

-  <body bgcolor="#FFFFFF" text="#000000">
-    <h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align=
-    "middle" width="277" height="86">Header <a href=
-    "../../boost/cast.hpp">boost/cast.hpp</a></h1>
+<body bgcolor="#FFFFFF" text="#000000">

-    <h2><a name="Cast Functions">Cast Functions</a></h2>
+<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="middle" width="277" height="86">Header
+<a href="../../boost/cast.hpp">boost/cast.hpp</a></h1>

-    <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
-    complement the C++ built-in casts.</p>
+<h2><a name="Cast Functions">Cast Functions</a></h2>

-    <p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
-    verify these function templates work as expected.</p>
+<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>

-    <h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
-
-    <p>Pointers to polymorphic objects (objects of classes which define at
-    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>
-
-    <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
-    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>
-    succeeds.</p>
-
-    <p>The C++ built-in <code>dynamic_cast</code> 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
-    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>
-
-    <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>The C++ built-in <code>dynamic_cast</code> 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>
-
-    <h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
-
-    <blockquote>
-<pre>namespace boost {
+<p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
+verify these function templates work as expected.</p>
+<h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
+<p>Pointers to polymorphic objects (objects of classes which define at 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
+<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 <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 <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 <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 <b>polymorphic_cast</b> template performs a <b>dynamic_cast</b>,
+and throws an exception if the <b>dynamic_cast</b> returns 0.</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 <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>
+<h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
+<blockquote>
+  <pre>namespace boost {

 template &lt;class Derived, class Base&gt;
 inline Derived polymorphic_cast(Base* x);
@@ -96,14 +70,11 @@ inline Derived polymorphic_downcast(Base* x);
 // Effects: assert( dynamic_cast&lt;Derived&gt;(x) == x );
 // Returns: static_cast&lt;Derived&gt;(x)

-}
-</pre>
-    </blockquote>
-
-    <h3>polymorphic_downcast example</h3>
-
-    <blockquote>
-<pre>#include &lt;boost/cast.hpp&gt;
+}</pre>
+</blockquote>
+<h3>polymorphic_downcast example</h3>
+<blockquote>
+  <pre>#include &lt;boost/cast.hpp&gt;
 ...
 class Fruit { public: virtual ~Fruit(){}; ... };
 class Banana : public Fruit { ... };
@@ -111,30 +82,69 @@ class Banana : public Fruit { ... };
 void f( Fruit * fruit ) {
 // ... logic which leads us to believe it is a Banana
  Banana * banana = boost::polymorphic_downcast&lt;Banana*&gt;(fruit);
-  ...
-</pre>
-    </blockquote>
+  ...</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 {

-    <h3>History</h3>
+class bad_numeric_cast : public std::bad_cast {...};

-    <p><code>polymorphic_cast</code> 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>
-    <hr>
+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)

-    <p>Revised
-    <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
-                    -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348"
-                    --></p>
+}</pre>
+</blockquote>
+<h3>numeric_cast example</h3>
+<blockquote>
+  <pre>#include &lt;boost/cast.hpp&gt;
+using namespace boost::cast;

-    <p>&copy; Copyright boost.org 1999. Permission to copy, use, modify, sell
-    and distribute this document is granted provided this copyright notice
-    appears in all copies. This document is provided "as is" without express
-    or implied warranty, and with no claim as to its suitability for any
-    purpose.</p>
-  </body>
-</html>
+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><b>polymorphic_cast</b> was suggested by Bjarne Stroustrup in &quot;The C++
+Programming Language&quot;.<br>
+<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 <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
+-->06 January, 2001<!--webbot bot="Timestamp" endspan i-checksum="38320"
+--></p>
+<p>© Copyright boost.org 1999. Permission to copy, use, modify, sell and
+distribute this document is granted provided this copyright notice appears in
+all copies. This document is provided &quot;as is&quot; without express or
+implied warranty, and with no claim as to its suitability for any purpose.</p>
+
+</body>
+
+</html>
@@ -1,13 +1,14 @@
 //  boost utility cast test program  -----------------------------------------//

-//  (C) Copyright Beman Dawes, 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)
+//  (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 for most recent version including documentation.

 //  Revision History
-//   28 Set 04  factored out numeric_cast<> test (Fernando Cacciola)
 //   20 Jan 01  removed use of <limits> for portability to raw GCC (David Abrahams)
 //   28 Jun 00  implicit_cast removed (Beman Dawes)
 //   30 Aug 99  value_cast replaced by numeric_cast
@@ -20,7 +21,7 @@

 #  if SCHAR_MAX == LONG_MAX
 #      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
-#  endif
+#  endif 

 using namespace boost;
 using std::cout;
@@ -28,34 +29,39 @@ using std::cout;
 namespace
 {
    struct Base
-    {
+    { 
        virtual char kind() { return 'B'; }
    };
-
+    
    struct Base2
-    {
+    { 
        virtual char kind2() { return '2'; }
    };
-
+    
    struct Derived : public Base, Base2
    {
        virtual char kind() { return 'D'; }
-    };
-}
+    }; 
+}   


 int main( int argc, char * argv[] )
 {
+    cout << "Usage: test_casts [n], where n omitted or is:\n"
+            "  1 = execute #1 assert failure (#ifndef NDEBUG)\n"
+            "  2 = execute #2 assert failure (#ifndef NDEBUG)\n"
+            "Example: test_casts 2\n\n";
+
 #   ifdef NDEBUG
        cout << "NDEBUG is defined\n";
 #   else
        cout << "NDEBUG is not defined\n";
 #   endif

-    cout << "\nBeginning tests...\n";
+    cout << "\nBeginning tests...\n";        

 //  test polymorphic_cast  ---------------------------------------------------//
-
+    
    //  tests which should succeed
    Base *    base = new Derived;
    Base2 *   base2 = 0;
@@ -85,6 +91,63 @@ int main( int argc, char * argv[] )
    //  the following is just so generated code can be inspected
    if ( derived->kind() == 'B' ) ++err_count;

+//  test implicit_cast and numeric_cast  -------------------------------------//
+    
+    //  tests which should succeed
+    long small_value = 1;
+    long small_negative_value = -1;
+    long large_value = LONG_MAX;
+    long large_negative_value = LONG_MIN;
+    signed char c = 0;
+
+    c = large_value;  // see if compiler generates warning
+
+    c = numeric_cast<signed char>( small_value );
+    assert( c == 1 );
+    c = 0;
+    c = numeric_cast<signed char>( small_value );
+    assert( c == 1 );
+    c = 0;
+    c = numeric_cast<signed char>( small_negative_value );
+    assert( c == -1 );
+
+    // These tests courtesy of Joe R NWP Swatosh<joe.r.swatosh@usace.army.mil>
+    assert( 0.0f == numeric_cast<float>( 0.0 ) );
+    assert( 0.0 == numeric_cast<double>( 0.0 ) );
+    
+    //  tests which should result in errors being detected
+
+    caught_exception = false;
+    try { c = numeric_cast<signed char>( large_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
+    if ( !caught_exception ) ++err_count;
+
+    caught_exception = false;
+    try { c = numeric_cast<signed char>( large_negative_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
+    if ( !caught_exception ) ++err_count;
+
+    unsigned long ul;
+    caught_exception = false;
+    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
+    if ( !caught_exception ) ++err_count;
+
+    caught_exception = false;
+    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
+    if ( !caught_exception ) ++err_count;
+
+    caught_exception = false;
+    try { numeric_cast<int>( DBL_MAX ); }
+    catch (bad_numeric_cast)
+        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
+    if ( !caught_exception ) ++err_count;
+
    cout << err_count << " errors detected\nTest "
         << (err_count==0 ? "passed\n" : "failed\n");
    return err_count;
@@ -1,17 +1,17 @@
 //  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)
+//  (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
-//  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 +27,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 +44,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 +55,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 +69,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 +82,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()
+         {
+             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

-# include <boost/numeric/conversion/cast.hpp>
-
 #endif  // BOOST_CAST_HPP
@@ -1,29 +0,0 @@
-// Copyright David Abrahams 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)
-#ifndef IMPLICIT_CAST_DWA200356_HPP
-# define IMPLICIT_CAST_DWA200356_HPP
-
-# include <boost/mpl/identity.hpp>
-
-namespace boost {
-
-// implementation originally suggested by C. Green in
-// http://lists.boost.org/MailArchives/boost/msg00886.php
-
-// The use of identity creates a non-deduced form, so that the
-// explicit template argument must be supplied
-template <typename T>
-inline T implicit_cast (typename mpl::identity<T>::type x) {
-    return x;
-}
-
-// incomplete return type now is here
-//template <typename T>
-//void implicit_cast (...);
-
-
-} // namespace boost
-
-#endif // IMPLICIT_CAST_DWA200356_HPP
@@ -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,18 +187,19 @@ 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
-// http://www.boost.org/LICENSE_1_0.txt)
+// Permission to use, copy, modify, and distribute this software for any
+// purpose is hereby granted without fee, provided that this copyright and
+// permissions notice appear in all copies and derivatives.
+//
+// This software is provided "as is" without express or implied warranty.

 #undef DISABLE_WIDE_CHAR_SUPPORT
 #endif
+
@@ -3,14 +3,14 @@
 <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>

 <body bgcolor="#FFFFFF" text="#000000">

-<h1><img border="0" src="../../boost.png" align="center" width="277" height="86">Boost
+<h1><img border="0" src="../../c++boost.gif" align="center" width="277" height="86">Boost
 Conversion Library</h1>

 <p>The Conversion Library improves program safety and clarity by performing
@@ -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,10 +4,10 @@
 	<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
+		<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
 			<a href="../../boost/lexical_cast.hpp">boost/lexical_cast.hpp</a></h1>
 		<ul type="square">
 			<li>
@@ -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>
@@ -1,14 +1,14 @@
-//  Unit test for boost::lexical_cast.
+// Unit test for boost::lexical_cast.
 //
-//  See http://www.boost.org for most recent version, including documentation.
+// 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).
+// Permission to use, copy, modify, and distribute this software for any
+// purpose is hereby granted without fee, provided that this copyright and
+// permissions notice appear in all copies and derivatives.
 //
-// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
+// This software is provided "as is" without express or implied warranty.

 #include <boost/config.hpp>

@@ -19,13 +19,14 @@
 #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_CWCHAR) || \
+    defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
 #define DISABLE_WIDE_CHAR_SUPPORT
 #endif

@@ -36,16 +37,13 @@ void test_conversion_to_int();
 void test_conversion_to_double();
 void test_conversion_to_bool();
 void test_conversion_to_string();
-void test_conversion_from_to_wchar_t_alias();
 void test_conversion_to_pointer();
 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");
@@ -53,7 +51,6 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
    suite->add(BOOST_TEST_CASE(test_conversion_to_int));
    suite->add(BOOST_TEST_CASE(test_conversion_to_double));
    suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
-    suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
    suite->add(BOOST_TEST_CASE(test_conversion_to_pointer));
    suite->add(BOOST_TEST_CASE(test_conversion_to_string));
    #ifndef DISABLE_WIDE_CHAR_SUPPORT
@@ -62,8 +59,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 +68,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));
+        std::numeric_limits<int>::max(),
+        lexical_cast<int>(std::numeric_limits<int>::max()));
+    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 +170,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>(""));
@@ -182,64 +180,47 @@ void test_conversion_to_string()
    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
 }

-void test_conversion_from_to_wchar_t_alias()
-{
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
-    BOOST_CHECK_EQUAL(std::string("123"),
-        lexical_cast<std::string>(static_cast<unsigned short>(123)));
-    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
-    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
-}
-
 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 +229,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 +245,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 +266,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 +276,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);
-}
@@ -1,100 +0,0 @@
-//  boost utility cast test program  -----------------------------------------//
-
-//  (C) Copyright Beman Dawes, 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 for most recent version including documentation.
-
-//  Revision History
-//   28 Set 04  factored out numeric_cast<> test (Fernando Cacciola)
-//   20 Jan 01  removed use of <limits> for portability to raw GCC (David Abrahams)
-//   28 Jun 00  implicit_cast removed (Beman Dawes)
-//   30 Aug 99  value_cast replaced by numeric_cast
-//    3 Aug 99  Initial Version
-
-#include <iostream>
-#include <climits>
-#include <cfloat>   // for DBL_MAX (Peter Schmid)
-#include <boost/cast.hpp>
-
-#include "boost/test/minimal.hpp"
-
-#  if SCHAR_MAX == LONG_MAX
-#      error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
-#  endif
-
-using namespace boost;
-using std::cout;
-
-
-int test_main( int argc, char * argv[] )
-{
-
-#   ifdef NDEBUG
-        cout << "NDEBUG is defined\n";
-#   else
-        cout << "NDEBUG is not defined\n";
-#   endif
-
-    cout << "\nBeginning tests...\n";
-
-//  test implicit_cast and numeric_cast  -------------------------------------//
-
-    //  tests which should succeed
-    long small_value = 1;
-    long small_negative_value = -1;
-    long large_value = LONG_MAX;
-    long large_negative_value = LONG_MIN;
-    signed char c = 0;
-
-    c = large_value;  // see if compiler generates warning
-
-    c = numeric_cast<signed char>( small_value );
-    BOOST_CHECK( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_value );
-    BOOST_CHECK( c == 1 );
-    c = 0;
-    c = numeric_cast<signed char>( small_negative_value );
-    BOOST_CHECK( c == -1 );
-
-    // These tests courtesy of Joe R NWP Swatosh<joe.r.swatosh@usace.army.mil>
-    BOOST_CHECK( 0.0f == numeric_cast<float>( 0.0 ) );
-    BOOST_CHECK( 0.0 == numeric_cast<double>( 0.0 ) );
-
-    //  tests which should result in errors being detected
-
-    bool caught_exception = false;
-    try { c = numeric_cast<signed char>( large_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
-    BOOST_CHECK ( caught_exception );
-
-    caught_exception = false;
-    try { c = numeric_cast<signed char>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
-    BOOST_CHECK ( caught_exception );
-
-    unsigned long ul;
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( large_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
-    BOOST_CHECK ( caught_exception );
-
-    caught_exception = false;
-    try { ul = numeric_cast<unsigned long>( small_negative_value ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
-    BOOST_CHECK ( caught_exception );
-
-    caught_exception = false;
-    try { numeric_cast<int>( DBL_MAX ); }
-    catch (bad_numeric_cast)
-        { cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
-    BOOST_CHECK ( caught_exception );
-
-    return 0 ;
-}
@@ -303,6 +303,10 @@ namespace test // tester is the driver class for a sequence of tests

 // Copyright Kevlin Henney, 2000. All rights reserved.
 //
-// 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)
+// Permission to use, copy, modify, and distribute this software for any
+// purpose is hereby granted without fee, provided that this copyright and
+// permissions notice appear in all copies and derivatives, and that no
+// charge may be made for the software and its documentation except to cover
+// cost of distribution.
+//
+// This software is provided "as is" without express or implied warranty.
@@ -1,26 +0,0 @@
-# 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/
-
-# bring in rules for testing
-import testing ;
-
-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 ]
-  ;
-
-      
@@ -1,32 +0,0 @@
-// Copyright David Abrahams 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)
-
-#include <boost/implicit_cast.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/type.hpp>
-using boost::implicit_cast;
-using boost::type;
-
-template <class T>
-type<T> check_return(T) { return type<T>(); }
-
-struct foo
-{
-    foo(char const*) {}
-    operator long() const { return 0; }
-};
-
-typedef type<long> long_type;
-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);
-
-    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();
-}
@@ -1,22 +0,0 @@
-// Copyright David Abrahams 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)
-
-#include <boost/implicit_cast.hpp>
-#include <boost/type.hpp>
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-
-using boost::implicit_cast;
-
-struct foo
-{
-    explicit foo(char const*) {}
-};
-
-int test_main(int, char*[])
-{
-    foo x = implicit_cast<foo>("foobar");
-}
Author	SHA1	Message	Date
nobody	f4c8dd464b	This commit was manufactured by cvs2svn to create tag 'Version_1_30_1'. [SVN r19444]	2003-08-04 17:55:29 +00:00
Terje Slettebø	3804825f6c	no message [SVN r18238]	2003-04-12 08:02:14 +00:00
Terje Slettebø	fdd5ca3353	Merged from trunk [SVN r18237]	2003-04-11 22:15:04 +00:00
Terje Slettebø	6e077f97fc	BOOST_MSVC<=1200 fix from Terje [SVN r18019]	2003-03-19 21:25:45 +00:00
Beman Dawes	d9eed4150b	BOOST_MSVC<=1200 fix from Terje [SVN r18002]	2003-03-19 12:14:32 +00:00
Dave Abrahams	62014cf4b6	Commit Terje's changes [SVN r17982]	2003-03-18 23:55:14 +00:00
Terje Slettebø	aad1bfda73	Updated Changes section [SVN r17922]	2003-03-14 20:32:51 +00:00
Terje Slettebø	3f452717cf	no message [SVN r17921]	2003-03-14 20:17:47 +00:00
Beman Dawes	b06d9f5639	overloading fix + less permissive wide character support [SVN r17893]	2003-03-13 17:27:06 +00:00
Beman Dawes	1b796221b4	BOOST_NO_STD_WSTRING [SVN r17872]	2003-03-13 00:36:13 +00:00
Beman Dawes	027afb3a87	update from Kevlin and Terje [SVN r17861]	2003-03-12 21:33:16 +00:00
nobody	07cb73a96c	This commit was manufactured by cvs2svn to create branch 'RC_1_30_0'. [SVN r17693]	2003-03-01 19:43:06 +00:00