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-06 21:44:08 +02:00 · 2004-11-19 19:19:18 +00:00 · 2004-10-20 08:26:43 +00:00 · 2004-10-05 15:45:52 +00:00 · 2004-09-29 11:44:04 +00:00 · 2004-09-28 21:48:39 +00:00
14 changed files with 1053 additions and 580 deletions
@@ -1,64 +1,85 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

 <html>
+  <head>
+    <meta name="generator" content=
+    "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">
+    <meta name="ProgId" content="FrontPage.Editor.Document">

-<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>
+    <title>Header boost/cast.hpp Documentation</title>
+  </head>

-<body bgcolor="#FFFFFF" text="#000000">
+  <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>

-<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>
+    <h2><a name="Cast Functions">Cast Functions</a></h2>

-<h2><a name="Cast Functions">Cast Functions</a></h2>
+    <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 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
+    verify these function templates work as expected.</p>

-<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 {
+    <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 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 <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 <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);
@@ -70,11 +91,15 @@ 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 { ... };
@@ -82,26 +107,40 @@ 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>
-<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 {
+  ...
+</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 {...};

@@ -112,11 +151,15 @@ template&lt;typename Target, typename Source&gt;
    //          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;
+}
+</pre>
+    </blockquote>
+
+    <h3>numeric_cast example</h3>
+
+    <blockquote>
+<pre>
+#include &lt;boost/cast.hpp&gt;
 using namespace boost::cast;

 void ariane(double vx)
@@ -124,27 +167,36 @@ 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>
+}
+</pre>
+    </blockquote>

-</body>
+    <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 "The C++
+    Programming Language".<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>&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>
+
@@ -1,14 +1,13 @@
 //  boost utility cast test program  -----------------------------------------//

-//  (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.
+//  (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
@@ -21,7 +20,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;
@@ -29,39 +28,34 @@ 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;
@@ -91,63 +85,6 @@ 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,12 +1,11 @@
 //  boost cast.hpp header file  ----------------------------------------------//

-//  (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
-//  and distribute this software is granted provided this copyright
-//  notice appears in all copies. This software is provided "as is" without
-//  express or implied warranty, and with no claim as to its suitability for
-//  any purpose.
+//  (C) Copyright Kevlin Henney and Dave Abrahams 1999. 
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-//  See http://www.boost.org for most recent version including documentation.
+//  See http://www.boost.org/libs/conversion for Documentation.

 //  Revision History
 //  02 Apr 01  Removed BOOST_NO_LIMITS workarounds and included 
@@ -129,12 +128,12 @@ namespace boost
      template <class T>
      struct signed_numeric_limits : std::numeric_limits<T>
      {
-             static inline T min()
+             static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION ()
         {
-             return std::numeric_limits<T>::min() >= 0
+             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();
+                     ? static_cast<T>(-(std::numeric_limits<T>::max)())
+                     : (std::numeric_limits<T>::min)();
         };
      };
   
@@ -142,7 +141,7 @@ namespace boost
      template <class T, bool specialized>
      struct fixed_numeric_limits_base
          : public if_true< std::numeric_limits<T>::is_signed >
-           ::template then< signed_numeric_limits<T>,
+           ::BOOST_NESTED_TEMPLATE then< signed_numeric_limits<T>,
                            std::numeric_limits<T>
                   >::type
      {};
@@ -157,11 +156,11 @@ namespace boost
      // 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>
+      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 long long max()
+          static  ::boost::long_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
          {
 #  ifdef LONGLONG_MAX
              return LONGLONG_MAX;
@@ -170,22 +169,22 @@ namespace boost
 #  endif 
          }

-          static long long min()
+          static  ::boost::long_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
          {
 #  ifdef LONGLONG_MIN
              return LONGLONG_MIN;
 #  else  
-              return -9223372036854775808LL; // hope this is portable
+               return -( 9223372036854775807LL )-1; // hope this is portable
 #  endif 
          }
      };

      template <>
-      struct fixed_numeric_limits_base<unsigned long long, false>
+      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 unsigned long long max()
+          static  ::boost::ulong_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
          {
 #  ifdef ULONGLONG_MAX
              return ULONGLONG_MAX;
@@ -194,7 +193,7 @@ namespace boost
 #  endif 
          }

-          static unsigned long long min() { return 0; }
+          static  ::boost::ulong_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
      };
 # endif 
    } // namespace detail
@@ -314,10 +313,10 @@ namespace boost
       template <class T>
       struct fixed_numeric_limits : public std::numeric_limits<T>
       {
-           static inline T min()
+           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();
+               return std::numeric_limits<T>::is_signed && (std::numeric_limits<T>::min)() >= 0
+                   ? T(-(std::numeric_limits<T>::max)()) : (std::numeric_limits<T>::min)();
           }
       };
  
@@ -337,7 +336,10 @@ namespace boost
        typedef detail::fixed_numeric_limits<Source> arg_traits;
        typedef detail::fixed_numeric_limits<Target> result_traits;
        
-#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_SGI_CPP_LIMITS)
+#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)
@@ -348,8 +350,8 @@ namespace boost
        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())
+        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
@@ -361,8 +363,8 @@ namespace boost
 #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
+             || (arg_traits::is_signed && arg < (result_traits::min)())  // underflow
+             || arg > (result_traits::max)())            // overflow
 # if BOOST_MSVC
 #  pragma warning(pop)
 #elif defined(__BORLANDC__)
@@ -0,0 +1,35 @@
+// 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 (...);
+
+// 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
+
+#endif // IMPLICIT_CAST_DWA200356_HPP
@@ -1,31 +1,38 @@
-//  boost lexical_cast.hpp header  -------------------------------------------//
-
-//  See http://www.boost.org for most recent version including documentation.
-
 #ifndef BOOST_LEXICAL_CAST_INCLUDED
 #define BOOST_LEXICAL_CAST_INCLUDED

+// Boost lexical_cast.hpp header  -------------------------------------------//
+//
+// See http://www.boost.org for most recent version including documentation.
+// See end of this header for rights and permissions.
+//
 // what:  lexical_cast custom keyword cast
-// who:   contributed by Kevlin Henney, with alternative naming, behaviors
-//        and fixes contributed by Dave Abrahams, Daryle Walker and other
-//        Boosters on the list
-// when:  November 2000
-// where: tested with MSVC 6.0, BCC 5.5, and g++ 2.91
+// who:   contributed by Kevlin Henney,
+//        enhanced with contributions from Terje Slettebø,
+//        with additional fixes and suggestions from Gennaro Prota,
+//        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
+//        and other Boosters
+// when:  November 2000, March 2003

+#include <string>
+#include <typeinfo>
 #include <boost/config.hpp>
+#include <boost/limits.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_pointer.hpp>

-// Some sstream implementations are broken for the purposes of lexical cast.
-# if defined(BOOST_NO_STRINGSTREAM)
-#  define BOOST_LEXICAL_CAST_USE_STRSTREAM
-# endif
-
-#ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-# include <strstream>
+#ifdef BOOST_NO_STRINGSTREAM
+#include <strstream>
 #else
-# include <sstream>
+#include <sstream>
 #endif

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

 namespace boost
 {
@@ -33,44 +40,164 @@ namespace boost
    class bad_lexical_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()
+        bad_lexical_cast() :
+        source(&typeid(void)), target(&typeid(void))
+        {
+        }
+        bad_lexical_cast(
+            const std::type_info &s,
+            const std::type_info &t) :
+            source(&s), target(&t)
+        {
+        }
+        const std::type_info &source_type() const
+        {
+            return *source;
+        }
+        const std::type_info &target_type() const
+        {
+            return *target;
+        }
+        virtual const char *what() const throw()
        {
            return "bad lexical cast: "
                   "source type value could not be interpreted as target";
        }
+        virtual ~bad_lexical_cast() throw()
+        {
+        }
+    private:
+        const std::type_info *source;
+        const std::type_info *target;
    };

+    namespace detail // selectors for choosing stream character type
+    {
+        template<typename Type>
+        struct stream_char
+        {
+            typedef char type;
+        };
+
+        #ifndef DISABLE_WIDE_CHAR_SUPPORT
+        template<>
+        struct stream_char<wchar_t>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<const wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<std::wstring>
+        {
+            typedef wchar_t type;
+        };
+        #endif
+
+        template<typename TargetChar, typename SourceChar>
+        struct widest_char
+        {
+            typedef TargetChar type;
+        };
+
+        template<>
+        struct widest_char<char, wchar_t>
+        {
+            typedef wchar_t type;
+        };
+    }
+    
+    namespace detail // stream wrapper for handling lexical conversions
+    {
+        template<typename Target, typename Source>
+        class lexical_stream
+        {
+        public:
+            lexical_stream()
+            {
+                stream.unsetf(std::ios::skipws);
+
+                if(std::numeric_limits<Target>::is_specialized)
+                    stream.precision(std::numeric_limits<Target>::digits10 + 1);
+                else if(std::numeric_limits<Source>::is_specialized)
+                    stream.precision(std::numeric_limits<Source>::digits10 + 1);
+            }
+            ~lexical_stream()
+            {
+                #if defined(BOOST_NO_STRINGSTREAM)
+                stream.freeze(false);
+                #endif
+            }
+            bool operator<<(const Source &input)
+            {
+                return !(stream << input).fail();
+            }
+            template<typename InputStreamable>
+            bool operator>>(InputStreamable &output)
+            {
+                return !is_pointer<InputStreamable>::value &&
+                       stream >> output &&
+                       (stream >> std::ws).eof();
+            }
+            bool operator>>(std::string &output)
+            {
+                #if defined(BOOST_NO_STRINGSTREAM)
+                stream << '\0';
+                #endif
+                output = stream.str();
+                return true;
+            }
+            #ifndef DISABLE_WIDE_CHAR_SUPPORT
+            bool operator>>(std::wstring &output)
+            {
+                output = stream.str();
+                return true;
+            }
+            #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)
+            std::stringstream stream;
+            #else
+            std::basic_stringstream<char_type> stream;
+            #endif
+        };
+    }
+
    template<typename Target, typename Source>
    Target lexical_cast(Source arg)
    {
-# ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-        std::strstream interpreter; // for out-of-the-box g++ 2.95.2
-# else
-        std::stringstream interpreter;
-# endif
+        detail::lexical_stream<Target, Source> interpreter;
        Target result;

-        if(!(interpreter << arg) || !(interpreter >> result) ||
-           !(interpreter >> std::ws).eof())
-            throw bad_lexical_cast();
-
+        if(!(interpreter << arg && interpreter >> result))
+            throw_exception(bad_lexical_cast(typeid(Target), typeid(Source)));
        return result;
    }
 }

-// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
+// Copyright Kevlin Henney, 2000-2003. All rights reserved.
 //
-// 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.
+// 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)

-#ifdef BOOST_LEXICAL_CAST_USE_STRSTREAM
-# undef BOOST_LEXICAL_CAST_USE_STRSTREAM
+#undef DISABLE_WIDE_CHAR_SUPPORT
 #endif

-#endif
@@ -10,7 +10,7 @@

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

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

 <p>The Conversion Library improves program safety and clarity by performing
@@ -1,99 +1,95 @@
+<!-- saved from url=(0022)http://internet.e-mail -->
 <!doctype html public "-//W3C//DTD HTML Transitional 4.0//EN">
 <html>
-<head>
-    <title>lexical_cast</title>
-    <meta name="author" content="Kevlin Henney, mailto:kevlin@curbralan.com">
-    <meta name="generator" content="Microsoft FrontPage 4.0">
-</head>
-
-<body bgcolor="#FFFFFF" text="#000000">
-
-<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>
-    <li><a href="#motivation">Motivation</a></li>
-    <li><a href="#examples">Examples</a></li>
-    <li><a href="#synopsis">Synopsis</a></li>
-    <li><a href="#lexical_cast"><code>lexical_cast</code></a></li>
-    <li><a href="#bad_lexical_cast"><code>bad_lexical_cast</code></a></li>
-    <li><a href="#portability">Portability</a></li>
-    <li><a href="#future">Future directions</a></li>
-</ul>
-
-<hr>
-<h2><a name="motivation">Motivation</a></h2>
-
-Sometimes a value must be converted to a literal text form, such as an
-<code>int</code> represented as a <code>string</code>, or vice-versa, when
-a <code>string</code> is interpreted as an <code>int</code>. Such examples
-are common when converting between data types internal to a program and
-representation external to a program, such as windows and configuration files.
-<p>
-The standard C and C++ libraries offer a number of facilities for performing
-such conversions. However, they vary with their ease of use, extensibility,
-and safety.
-<p>
-For instance, there are a number of limitations with the family of standard C
-functions typified by <code>atoi</code>:
-<ul>
-	<li>
-	    Conversion is supported in one direction only: from text to
-		internal data type. Converting the other way using the C library
-		requires either the inconvenience and compromised safety of the
-		<code>sprintf</code> function, or the loss of portability associated
-		with non-standard functions such as <code>itoa</code>.
-	</li>
-	<li>
-	    The range of types supported is only a subset of the built-in numeric
-	    types, namely <code>int</code>, <code>long</code>,
-		and <code>double</code>.
-	</li>
-	<li>
-	    The range of types cannot be extended in a uniform manner. For
-	    instance, conversion from string representation to
-		<code>complex</code> or <code>rational</code>.
-	</li>
-</ul>
-The standard C functions typified by <code>strtol</code> have the same basic
-limitations, but offer finer control over the conversion process. However, for
-the common case such control is often either not required or not used. The
-<code>scanf</code> family of functions offer even greater control, but also
-lack safety and ease of use.
-<p>
-The standard C++ library offers <code>stringstream</code> for the kind of
-in-core formatting being discussed. It offers a great deal of control over the
-formatting and conversion of I/O to and from arbitrary types through text.
-However, for simple conversions direct use of <code>stringstream</code> can be
-either clumsy (with the introduction of extra local variables and the loss of
-infix-expression convenience) or obscure (where <code>stringstream</code>
-objects are created as temporary objects in an expression). Facets provide a
-comprehensive concept and facility for controlling textual representation, but
-their relatively high entry level requires an extreme degree of involvement
-for simple conversions.
-<p>
-The <code>lexical_cast</code> template function offers a convenient and consistent
-form for supporting common conversions to and from arbitrary types when they are
-represented as text. The simplification it offers is in expression-level
-convenience for such conversions. For more involved 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="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 formatting,
-including comparison of <code>stringstream</code>, <code>lexical_cast</code>, and
-others, see Herb Sutter's article, <a href="http://www.gotw.ca/publications/mill19.htm">
-<i>The String Formatters of Manor Farm</i></a>.
-<p>
-
-<hr>
-<h2><a name="examples">Examples</a></h2>
-
-The following example treats command line arguments as a sequence of numeric data:
-<blockquote>
-<pre>
+	<head>
+		<title>lexical_cast</title>
+		<meta name="author" content="Kevlin Henney, mailto:kevlin@curbralan.com">
+		<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
+			<a href="../../boost/lexical_cast.hpp">boost/lexical_cast.hpp</a></h1>
+		<ul type="square">
+			<li>
+				<a href="#motivation">Motivation</a></li>
+			<li>
+				<a href="#examples">Examples</a></li>
+			<li>
+				<a href="#synopsis">Synopsis</a></li>
+			<li>
+				<a href="#lexical_cast"><code>lexical_cast</code></a></li>
+			<li>
+				<a href="#bad_lexical_cast"><code>bad_lexical_cast</code></a></li>
+			<li>
+				<a href="#changes">Changes</a></li>
+		</ul>
+		<hr>
+		<h2><a name="motivation">Motivation</a></h2>
+		Sometimes a value must be converted to a literal text form, such as an <code>int</code>
+		represented as a <code>string</code>, or vice-versa, when a <code>string</code> 
+		is interpreted as an <code>int</code>. Such examples are common when converting 
+		between data types internal to a program and representation external to a 
+		program, such as windows and configuration files.
+		<p>
+		The standard C and C++ libraries offer a number of facilities for performing 
+		such conversions. However, they vary with their ease of use, extensibility, and 
+		safety.
+		<p>
+			For instance, there are a number of limitations with the family of standard C 
+			functions typified by <code>atoi</code>:
+			<ul type="square">
+				<li>
+					Conversion is supported in one direction only: from text to internal data type. 
+					Converting the other way using the C library requires either the inconvenience 
+					and compromised safety of the <code>sprintf</code> function, or the loss of 
+					portability associated with non-standard functions such as <code>itoa</code>.
+				</li>
+				<li>
+					The range of types supported is only a subset of the built-in numeric types, 
+					namely <code>int</code>, <code>long</code>, and <code>double</code>.
+				</li>
+				<li>
+					The range of types cannot be extended in a uniform manner. For instance, 
+					conversion from string representation to <code>complex</code> or <code>rational</code>.
+				</li>
+			</ul>
+			The standard C functions typified by <code>strtol</code> have the same basic 
+			limitations, but offer finer control over the conversion process. However, for 
+			the common case such control is often either not required or not used. The <code>scanf</code>
+		family of functions offer even greater control, but also lack safety and ease 
+		of use.
+		<p>
+			The standard C++ library offers <code>stringstream</code> for the kind of 
+			in-core formatting being discussed. It offers a great deal of control over the 
+			formatting and conversion of I/O to and from arbitrary types through text. 
+			However, for simple conversions direct use of <code>stringstream</code> can be 
+			either clumsy (with the introduction of extra local variables and the loss of 
+			infix-expression convenience) or obscure (where <code>stringstream</code>
+		objects are created as temporary objects in an expression). Facets provide a 
+		comprehensive concept and facility for controlling textual representation, but 
+		their perceived complexity and high entry level requires an extreme degree of 
+		involvement for simple conversions, and excludes all but a few programmers.
+		<p>
+			The <code>lexical_cast</code> function template offers a convenient and 
+			consistent form for supporting common conversions to and from arbitrary types 
+			when they are represented as text. The simplification it offers is in 
+			expression-level convenience for such conversions. For more involved 
+			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="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 
+			formatting, including comparison of <code>stringstream</code>, <code>lexical_cast</code>, 
+			and others, see Herb Sutter's article, <a href="http://www.gotw.ca/publications/mill19.htm">
+				<i>The String Formatters of Manor Farm</i></a>.
+		<p>
+			<hr>
+			<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[])
 {
    using boost::lexical_cast;
@@ -115,11 +111,8 @@ int main(int argc, char * argv[])
    ...
 }
 </pre>
-</blockquote>
-
-The following example uses numeric data in a string expression:
-<blockquote>
-<pre>
+			</blockquote>The following example uses numeric data in a string expression: <blockquote>
+				<pre>
 void log_message(const std::string &amp;);

 void log_errno(int yoko)
@@ -127,15 +120,12 @@ void log_errno(int yoko)
    log_message(&quot;Error &quot; + boost::lexical_cast&lt;std::string&gt;(yoko) + &quot;: &quot; + strerror(yoko));
 }
 </pre>
-</blockquote>
-
-<hr>
-<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>
+			</blockquote>
+			<hr>
+			<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
 {
    class <a href="#bad_lexical_cast">bad_lexical_cast</a>;
@@ -143,110 +133,91 @@ namespace boost
      Target <a href="#lexical_cast">lexical_cast</a>(Source arg);
 }
 </pre>
-</blockquote>
-
-Test harness defined in <a href="lexical_cast_test.cpp"><code>&quot;lexical_cast_test.cpp&quot;</code></a>.
-<p>
-
-<hr>
-<h2><a name="lexical_cast"><code>lexical_cast</code></a></h2>
-
-<blockquote>
-<pre>
+			</blockquote>Unit test defined in <a href="lexical_cast_test.cpp"><code>&quot;lexical_cast_test.cpp&quot;</code></a>.
+		<p>
+			<hr>
+			<h2><a name="lexical_cast"><code>lexical_cast</code></a></h2>
+			<blockquote>
+				<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 <code>std::stringstream</code> and then
-out as a <code>Target</code> object. If the conversion is unsuccessful, a
-<a href="#bad_lexical_cast"><code>bad_lexical_cast</code></a> exception is thrown.
-<p>
-The requirements on the argument and result types are:
-<ul>
-	<li>
-	    <code>Source</code> is <i>OutputStreamable</i>, meaning that an
-	    <code>operator&lt;&lt;</code> is defined that takes a
-		<code>std::ostream</code> object on the left hand side and an instance
-		of the argument type on the right.
-	</li>
-	<li>
-	    Both <code>Source</code> and <code>Target</code> are <i>CopyConstructible</i> [20.1.3].
-	</li>
-	<li>
-	    <code>Target</code> is <i>InputStreamable</i>, meaning that an
-	    <code>operator&gt;&gt;</code> is defined that takes a
-		<code>std::istream</code> object on the left hand side and an instance
-		of the result type on the right.
-	</li>
-	<li>
-	    <code>Target</code> is <i>DefaultConstructible</i>, meaning that it is
-	    possible to	<i>default-initialize</i> an object of that type [8.5, 20.1.3].
-	</li>
-	<li>
-	    <code>Target</code> is <i>Assignable</i> [23.1].
-	</li>
-</ul>
-<p>
-
-<hr>
-<h2><a name="bad_lexical_cast"><code>bad_lexical_cast</code></a></h2>
-
-<blockquote>
-<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.
+			Where <code>Target</code> is either <code>std::string</code>
+			or <code>std::wstring</code>, stream extraction takes the whole content
+			of the string, including spaces, rather than relying on the default
+			<code>operator&gt;&gt;</code> behavior.
+			If the conversion is unsuccessful, a <a href="#bad_lexical_cast">
+				<code>bad_lexical_cast</code></a> exception is thrown.
+		<p>
+			The requirements on the argument and result types are:
+			<ul type="square">
+				<li>
+					<code>Source</code> is <i>OutputStreamable</i>, meaning that an <code>operator&lt;&lt;</code>
+					is defined that takes a <code>std::ostream</code> or <code>std::wostream</code> object on the
+					left hand side and an instance of the argument type on the right.
+				</li>
+				<li>
+					<code>Target</code> is <i>InputStreamable</i>, meaning that an <code>operator&gt;&gt;</code>
+					is defined that takes a <code>std::istream</code> or <code>std::wistream</code> object on the left hand side 
+					and an instance of the result type on the right.
+				</li>
+				<li>
+					Both <code>Source</code> and <code>Target</code> are <i>CopyConstructible</i> [20.1.3].
+				</li>
+				<li>
+					<code>Target</code> is <i>DefaultConstructible</i>, meaning that it is possible 
+					to <i>default-initialize</i> an object of that type [8.5, 20.1.4].
+				</li>
+			</ul>
+			The character type of the underlying stream is assumed to be <code>char</code> unless
+			either the <code>Source</code> or the <code>Target</code> requires wide-character
+			streaming, in which case the underlying stream uses <code>wchar_t</code>.
+			<code>Source</code> types that require wide-character streaming are <code>wchar_t</code>,
+			<code>wchar_t *</code>, and <code>std::wstring</code>. <code>Target</code> types that
+			require wide-character streaming are <code>wchar_t</code> and <code>std::wstring</code>.
+			<p>
+			Where a higher degree of control is required over conversions, <code>std::stringstream</code>
+			and <code>std::wstringstream</code> offer a more appropriate path. Where non-stream-based conversions are 
+			required, <code>lexical_cast</code>
+		is the wrong tool for the job and is not special-cased for such scenarios.
+		<p>
+			<hr>
+			<h2><a name="bad_lexical_cast"><code>bad_lexical_cast</code></a></h2>
+			<blockquote>
+				<pre>
 class bad_lexical_cast : public std::bad_cast
 {
 public:
-    virtual const char * what() const throw();
+    ... // <i>same member function interface as</i> std::exception
 };
 </pre>
-</blockquote>
-
-Exception used to indicate runtime <a href="#lexical_cast"><code>lexical_cast</code></a> failure.
-<p>
-
-<hr>
-<h2><a name="portability">Portability</a></h2>
-
-To date the code and test harness have been compiled successfully using
-Microsoft Visual C++ 6.0, Borland C++ 5.5, and GNU g++ 2.91. Tests have run successfully for
-Microsoft Visual C++ 6.0 and Borland C++ 5.5. For g++ streams interpret any integer, rather than
-just <code>0</code> and <code>1</code>, as valid for <code>bool</code>; the other tests pass
-without problem. The deprecated standard header <code>&lt;strstream&gt;</code> is used in
-preference to the standard <code>&lt;sstream&gt;</code> header for out-of-the-box g++ support.
-<p>
-
-<hr>
-<h2><a name="future">Future directions</a></h2>
-
-<ul>
-    <li>
-	Improved string handling, correctly accommodating wide character strings, incompatible
-	<code>basic_string</code> types, and empty strings.
-    </li>
-    <li>
-	Optimize the use of a stream away for identity conversions.
-    </li>
-    <li>
-        An <code>interpret_cast</code> that performs a <i>do-something-reasonable</i> conversion between
-        types. It would, for instance, select between <code>numeric_cast</code> and <code>lexical_cast</code>
-        based on <code>std::numeric_limits&lt;&gt;::is_specialized</code>. This would be an interesting
-	project, but there are no concrete plans to pursue this at the moment.
-    </li>
-    <li>
-        It is also worth mentioning future <i>non-directions</i>: anything that involves adding extra
-	arguments for a conversion operation is not being considered. A custom keyword cast, such as
-	<code>lexical_cast</code>, is intended to look like a built-in cast operator: built-in cast operators
-	take only a single operand. Where a higher degree of control is required over conversions, the
-	standard <code>stringstream</code> offers a more appropriate path. Where non-stream-based conversions
-	are required, <code>lexical_cast</code> is the wrong tool for the job, and so it won't be special-cased
-	for such scenarios.
-    </li>
-</ul>
-
-<hr>
-
-<div align="right"><small><i>&copy; Copyright Kevlin Henney, 2000, 2002</i></small></div>
-
-</body>
+			</blockquote>Exception used to indicate runtime <a href="#lexical_cast"><code>lexical_cast</code></a>
+		failure.
+			<hr>
+		<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;2003</i></small></div>
+	</body>
 </html>
@@ -1,149 +1,288 @@
-//  boost lexical_cast_test.cpp program  -------------------------------------//
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  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).

-//  See http://www.boost.org for most recent version including documentation.
+#include <boost/config.hpp>

-// what:  lexical_cast custom keyword cast tests
-// who:   contributed by Kevlin Henney
-// when:  October 2000
-// where: tested with MSVC 6.0 and BCC 5.5
+#if defined(__INTEL_COMPILER)
+#pragma warning(disable: 193 383 488 981 1418 1419)
+#elif defined(BOOST_MSVC)
+#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
+#endif

 #include <boost/lexical_cast.hpp>
-#include "test.hpp"
-#include <complex>
-#include <iostream>
-#include <string>
+#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_INTRINSIC_WCHAR_T)
+#define DISABLE_WIDE_CHAR_SUPPORT
+#endif

 using namespace boost;
-using namespace std;

-typedef test::test<const char *, void (*)()> test_case;
-typedef const test_case * test_case_iterator;
+void test_conversion_to_char();
+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();

-extern const test_case_iterator begin, end;
-
-int main()
+unit_test_framework::test_suite *init_unit_test_suite(int, char **)
 {
-    test::tester<test_case_iterator> test_suite(begin, end);
-    return test_suite() ? EXIT_SUCCESS : EXIT_FAILURE;
+    unit_test_framework::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test");
+    suite->add(BOOST_TEST_CASE(test_conversion_to_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
+    suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
+    suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
+    suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
+    #endif
+    return suite;
 }

-void test_to_string()
+void test_conversion_to_char()
 {
-    test::check_equal(
-        lexical_cast<string>(2001), "2001",
-        "2001 -> \"2001\"");
-    test::check_equal(
-        lexical_cast<string>(2001.0), "2001",
-        "2001.0 ->\"2001\"");
-    test::check_equal(
-        lexical_cast<string>(complex<double>(2000,1)), "(2000,1)",
-        "complex<double>(2000,1) -> \"(2000,1)\"");
+    BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
+    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), 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>(""), 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("")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<char>(std::string("Test")), boost::bad_lexical_cast);
 }

-void test_to_int()
+void test_conversion_to_int()
 {
-    test::check_equal(
-        lexical_cast<int>("2001"), 2001,
-        "\"2001\" -> 2001");
-    test::check_equal(
-        lexical_cast<int>("    2001"), 2001,
-        "\"    2001\" -> 2001");
-    test::check_equal(
-        lexical_cast<int>("2001    "), 2001,
-        "\"2001    \" -> 2001");
-    TEST_CHECK_THROW(
-        lexical_cast<int>("Two thousand and one"),
-        bad_lexical_cast,
-        "\"Two thousand and one\"");
-    TEST_CHECK_THROW(
-        lexical_cast<int>("2001: A Space Odyssey"),
-        bad_lexical_cast,
-        "\"2001: A Space Odyssey\"");
-    TEST_CHECK_THROW(
-        lexical_cast<int>(200.1),
-        bad_lexical_cast,
-        "200.1");
-    TEST_CHECK_THROW(
-        lexical_cast<int>("200e1"),
-        bad_lexical_cast,
-        "\"200e1\"");
+    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_THROW(lexical_cast<int>(1.23), boost::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"), 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_THROW(
+        lexical_cast<int>(std::string(" 123")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(std::string("")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<int>(std::string("Test")), boost::bad_lexical_cast);
 }

-void test_to_char()
+void test_conversion_to_double()
 {
-    test::check_equal(
-        lexical_cast<char>("2"), '2',
-        "\"2\" -> '2'");
-    test::check_equal(
-        lexical_cast<char>("    2"), '2',
-        "\"    2\" -> '2'");
-    test::check_equal(
-        lexical_cast<char>("2    "), '2',
-        "\"2    \" -> '2'");
-    test::check_equal(
-        lexical_cast<char>(2), '2',
-        "2 -> '2'");
-    TEST_CHECK_THROW(
-        lexical_cast<char>("2001"),
-        bad_lexical_cast,
-        "\"2001\"");
-    TEST_CHECK_THROW(
-        lexical_cast<char>(2001),
-        bad_lexical_cast,
-        "2001");
+    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("")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<double>(std::string("Test")), boost::bad_lexical_cast);
 }

-void test_to_double()
+void test_conversion_to_bool()
 {
-    test::check_equal(
-        lexical_cast<double>("1e6"), 1e6,
-        "\"1e6\" -> 1e6");
-    test::check_equal(
-        lexical_cast<double>("1e-2"), 1e-2,
-        "\"1e-2\" -> 1e-2");
+    BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
+    BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
+    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), 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>(""), 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("")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<bool>(std::string("Test")), boost::bad_lexical_cast);
 }

-void test_to_bool()
+void test_conversion_to_string()
 {
-    test::check_equal(
-        lexical_cast<bool>(1), true,
-        "1 -> true");
-    test::check_equal(
-        lexical_cast<bool>('0'), false,
-        "'0' -> false");
-    TEST_CHECK_THROW(
-        lexical_cast<bool>(2001),
-        bad_lexical_cast,
-        "2001");
-    TEST_CHECK_THROW(
-        lexical_cast<bool>(2),
-        bad_lexical_cast,
-        "2");
-    TEST_CHECK_THROW(
-        lexical_cast<bool>("true thousand and one"),
-        bad_lexical_cast,
-        "\"true thousand and one\"");
+    BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
+    BOOST_CHECK_EQUAL(" ", lexical_cast<std::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("Test", lexical_cast<std::string>("Test"));
+    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
+    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
+    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
+    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
+    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
 }

-const test_case test_cases[] =
+void test_conversion_from_to_wchar_t_alias()
 {
-    { "lexical_cast<std::string>", test_to_string },
-    { "lexical_cast<int>",         test_to_int    },
-    { "lexical_cast<char>",        test_to_char   },
-    { "lexical_cast<double>",      test_to_double },
-    { "lexical_cast<bool>",        test_to_bool   }
-};
+    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));
+}

-const test_case_iterator begin = test_cases;
-const test_case_iterator end =
-    test_cases + (sizeof test_cases / sizeof *test_cases);
+void test_conversion_to_pointer()
+{
+    BOOST_CHECK_THROW(lexical_cast<char *>("Test"), boost::bad_lexical_cast);
+    #ifndef DISABLE_WIDE_CHAR_SUPPORT
+    BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), boost::bad_lexical_cast);
+    #endif
+}

-// Copyright Kevlin Henney, 2000. All rights reserved.
-//
-// 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.
+void test_conversion_from_wchar_t()
+{
+    #ifndef DISABLE_WIDE_CHAR_SUPPORT
+    BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
+    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""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), boost::bad_lexical_cast);
+
+    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
+    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""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), 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'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""), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), boost::bad_lexical_cast);
+    #endif
+}
+
+void test_conversion_to_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), 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));
+    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
+    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
+    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""), 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"")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<wchar_t>(std::wstring(L"Test")), boost::bad_lexical_cast);
+    #endif
+}
+
+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"")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        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"")), boost::bad_lexical_cast);
+    BOOST_CHECK_THROW(
+        lexical_cast<bool>(std::wstring(L"Test")), boost::bad_lexical_cast);
+    #endif
+}
+
+void test_conversion_to_wstring()
+{
+    #ifndef DISABLE_WIDE_CHAR_SUPPORT
+    BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
+    BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
+    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));
+    BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
+    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
+    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""));
+    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
+    BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
+    BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
+    #endif
+}
@@ -0,0 +1,100 @@
+//  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 ;
+}
@@ -44,7 +44,7 @@ namespace test // failure exception used to indicate checked test failures
        }

        // std::~string has no exception-specification (could throw anything),
-	// but we need to be compatible with std::~exception's empty one
+        // but we need to be compatible with std::~exception's empty one
        // see std::15.4p13 and std::15.4p3
        ~failure() throw()
        {
@@ -303,10 +303,6 @@ namespace test // tester is the driver class for a sequence of tests

 // Copyright Kevlin Henney, 2000. All rights reserved.
 //
-// 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.
+// 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)
@@ -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 ]
+      ;
+}
+      
@@ -0,0 +1,25 @@
+# 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 ../lexical_cast_test.cpp ]
+  ;
+
+      
@@ -0,0 +1,33 @@
+// 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 <cassert>
+#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));
+    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 0;
+}
@@ -0,0 +1,22 @@
+// 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	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
Aleksey Gurtovoy	b8c373ab47	c++boost.gif -> boost.png replacement [SVN r25573]	2004-10-05 15:45:52 +00:00
Aleksey Gurtovoy	f6b0ec3685	fix syntax errors [SVN r25473]	2004-09-29 11:44:04 +00:00
Fernando Cacciola	a096a4b153	numeric_cast<> test factored out from conversion\cast_test.cp and also added (duplicated) in numeric\conversion\test [SVN r25468]	2004-09-28 21:48:39 +00:00
John Maddock	bba9169401	Updated to use the BSL: Permission from Kevlin Henney was granted in blanket-permission.txt, permission from Terje Slettebo was granted for this one file privately. [SVN r25402]	2004-09-25 15:06:48 +00:00
John Maddock	f11967a2c8	BSL update [SVN r25146]	2004-09-16 11:23:30 +00:00
John Maddock	c1c338990c	Added new types boost::long_long_type and boost::ulong_long_type in boost/config.hpp and applied these types in place of "long long" throughout. As a result, almost all of boost now compiles cleanly with -ansi -pedantic with gcc. Changes tested with gcc 3.3, 2.95, VC7.1 and Intel 8. [SVN r24899]	2004-09-04 10:34:49 +00:00
John Maddock	ec35f00bc3	Removed boost.org copyright assignments, and reverted to orginal author (as based on cvs history). [SVN r24402]	2004-08-11 10:59:33 +00:00
Douglas Gregor	abf8ee0eb9	Converted to Boost Software License, Version 1.0 [SVN r24055]	2004-07-26 00:32:12 +00:00
Eric Niebler	463284f46f	remove minmax hack from win32.hpp and fix all places that could be affected by the minmax macros [SVN r22394]	2004-02-26 18:27:02 +00:00
Beman Dawes	9f5ec17603	index.htm renamed index.html [SVN r21230]	2003-12-11 23:13:19 +00:00
Vladimir Prus	575c477f54	Add V2 Jamfile [SVN r20209]	2003-09-29 15:38:40 +00:00
Dave Abrahams	e6c52ae0f4	Improved justification for polymorphic_cast. [SVN r20068]	2003-09-15 16:30:22 +00:00
Dave Abrahams	13796f3f98	Use the import rule [SVN r19968]	2003-09-08 17:38:49 +00:00
Dave Abrahams	80a6db56c1	Warning suppression for GCC from Pierre Barbier de Reuille <pierre.barbier-at-cirad.fr> [SVN r19437]	2003-08-04 15:52:51 +00:00
Jens Maurer	25935cda40	avoid warning about signed/unsigned conversion [SVN r19007]	2003-07-09 22:30:40 +00:00
Dave Abrahams	386d7a67d6	initial commit [SVN r18350]	2003-05-07 22:42:35 +00:00
Beman Dawes	4b3e8171fa	Initial re-commit after CVS disk crash [SVN r18348]	2003-05-07 20:41:11 +00:00
Terje Slettebø	498c84dd4f	no message [SVN r18238]	2003-04-12 08:02:14 +00:00
John Maddock	3ecac311fd	Added no exception handling patch [SVN r18235]	2003-04-11 10:49:52 +00:00
Terje Slettebø	8828af5f5b	no message [SVN r18142]	2003-03-31 23:02:27 +00:00
Terje Slettebø	1937e3a12a	Added test case for unsigned types, in case they are an alias for wchar_t [SVN r18141]	2003-03-31 08:29:45 +00:00
Terje Slettebø	545687e22b	Removed test for MSVC, restored test for BOOST_NO_INTRINSIC_WCHAR_T [SVN r18140]	2003-03-30 23:21:17 +00:00
Terje Slettebø	9c63f9fbd0	Removed test for MSVC, restored test for BOOST_NO_INTRINSIC_WCHAR_T. Changed bad_lexical_cast to provide the types used, using source()/target() members [SVN r18139]	2003-03-30 23:19:28 +00:00
Terje Slettebø	9c1311a712	BOOST_MSVC<=1200 fix from Terje [SVN r18019]	2003-03-19 21:25:45 +00:00
Beman Dawes	51395d7b26	BOOST_MSVC<=1200 fix from Terje [SVN r18002]	2003-03-19 12:14:32 +00:00
Dave Abrahams	02609a4675	Commit Terje's changes [SVN r17980]	2003-03-18 22:46:00 +00:00
Dave Abrahams	52de514faf	Commit Terje's changes [SVN r17979]	2003-03-18 22:34:32 +00:00
Terje Slettebø	ae7d610cb1	Updated Changes section [SVN r17922]	2003-03-14 20:32:51 +00:00
Terje Slettebø	eb9d2c02ea	no message [SVN r17921]	2003-03-14 20:17:47 +00:00
Beman Dawes	e2825ab729	overloading fix + less permissive wide character support [SVN r17893]	2003-03-13 17:27:06 +00:00
Beman Dawes	4978f3a79f	BOOST_NO_STD_WSTRING [SVN r17872]	2003-03-13 00:36:13 +00:00
Beman Dawes	42639f120a	update from Kevlin and Terje [SVN r17861]	2003-03-12 21:33:16 +00:00
Björn Karlsson	0d7e048f06	Untabified [SVN r17190]	2003-02-04 09:10:50 +00:00
Beman Dawes	95e0465334	add or update See www.boost.org comments [SVN r16708]	2002-12-27 16:51:53 +00:00
Beman Dawes	0fba1d9f7d	Add /libs/lib-name to comment [SVN r16685]	2002-12-23 02:43:12 +00:00
Dave Abrahams	3597b25802	patches for HP aCC [SVN r16508]	2002-12-04 15:50:04 +00:00