Release 1.51.0

[SVN r80098]

build/Jamfile.v2

@@ -0,0 +1,14 @@
+# Boost Exception Library build Jamfile
+#
+# Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+#
+# 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)
+
+project boost/exception
+    : source-location ../src
+    : requirements <link>static
+    ;
+
+lib boost_exception : clone_current_exception_non_intrusive.cpp ;
+boost-install boost_exception ;

doc/boost_exception_get_error_info_hpp.html

@@ -28,10 +28,10 @@ namespace
 boost
     {
 <span class="RenoIncludeSPAN">    <span class="RenoIncludeSPAN">template &lt;class ErrorInfo,class E&gt;
-    typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> const * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E const &amp; x );
+    typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> const * <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>( E const &amp; x );
     
     template &lt;class ErrorInfo,class E&gt;
-    typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E &amp; x );</span></span>
+    typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> * <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>( E &amp; x );</span></span>
     }</pre>
 </div></div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
 See also: <span class="RenoPageList"><a href="boost_exception_all_hpp.html">boost/exception/all.hpp</a>&nbsp;| <a href="error_info.html">error_info</a></span>

doc/copy_exception.html

@@ -39,7 +39,7 @@ catch(...)
     return <span class="RenoLink"><a href="current_exception.html">current_exception</a></span>();
     }</pre>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
-See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a>&nbsp;| <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a></span>
+See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a>&nbsp;| <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a>&nbsp;| <a href="current_exception.html">current_exception</a></span>
 </div>
 <!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->
 <!-- Distributed under the Boost Software License, Version 1.0. (See accompanying -->

doc/current_exception.html

@@ -29,6 +29,7 @@ boost
     }</pre>
 </div><h4>Requirements:</h4>
 <p>The <span class="RenoLink">current_exception</span> function must not be called outside of a catch block.</p>
+<p>In addition, to safely copy an exception from one thread to another, if the exception object is copied by <span class="RenoLink">current_exception</span> or <span class="RenoLink"><a href="copy_exception.html">copy_exception</a></span>, the two copies must not have shared state. Exceptions that have value-type semantics (as well as the boost::<span class="RenoLink"><a href="exception.html">exception</a></span> type itself) satisfy this requirement.</p>
 <h4>Returns:</h4>
 <div><ul><li> An <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to the currently handled exception or a copy of the currently handled exception.</li>
 <li> If the function needs to allocate memory and the attempt fails, it returns an <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to an instance of std::bad_alloc.</li>
@@ -43,7 +44,7 @@ boost
 </li>
 </ul></div>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
-See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a>&nbsp;| <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a>&nbsp;| <a href="copy_exception.html">copy_exception</a>&nbsp;| <a href="enable_current_exception.html">enable_current_exception</a>&nbsp;| <a href="exception_ptr.html">exception_ptr</a>&nbsp;| <a href="frequently_asked_questions.html">Frequently Asked Questions</a>&nbsp;| <a href="original_exception_type.html">original_exception_type</a>&nbsp;| <a href="unknown_exception.html">unknown_exception</a></span>
+See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a>&nbsp;| <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a>&nbsp;| <a href="copy_exception.html">copy_exception</a>&nbsp;| <a href="enable_current_exception.html">enable_current_exception</a>&nbsp;| <a href="frequently_asked_questions.html">Frequently Asked Questions</a>&nbsp;| <a href="original_exception_type.html">original_exception_type</a>&nbsp;| <a href="unknown_exception.html">unknown_exception</a></span>
 </div>
 <!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->
 <!-- Distributed under the Boost Software License, Version 1.0. (See accompanying -->

doc/exception_ptr.html

@@ -31,11 +31,12 @@ boost
 <p>The referenced object remains valid at least as long as there is an <span class="RenoLink">exception_ptr</span> object that refers to it.</p>
 <p>Two instances of <span class="RenoLink">exception_ptr</span> are equivalent and compare equal if and only if they refer to the same exception.</p>
 <p>The default constructor of <span class="RenoLink">exception_ptr</span> produces the null value of the type. The null value is equivalent only to itself.</p>
-<h4>Thread safety</h4>
-<div><ul><li> It is legal for multiple threads to hold <span class="RenoLink">exception_ptr</span> references to the same exception object.</li>
-<li> It is illegal for multiple threads to modify the same <span class="RenoLink">exception_ptr</span> object concurrently.</li>
-<li> While calling <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> makes a copy of the current exception object, it is still possible for the two copies to share internal state. Therefore, in general it is not safe to call <span class="RenoLink"><a href="rethrow_exception.html">rethrow_exception</a></span> concurrently to throw the same exception object into multiple threads.</li>
+<h4>Thread safety:</h4>
+<p>The <span class="RenoLink">exception_ptr</span> type is "as thread-safe as built-in types":</p>
+<div><ul><li> An <span class="RenoLink">exception_ptr</span> instance can be "read" simultaneously by multiple threads</li>
+<li> Different <span class="RenoLink">exception_ptr</span> instances can be "written to" simultaneously by multiple threads, even when these instances refer to the same exception object</li>
 </ul></div>
+<p>All other simultaneous accesses result in undefined behavior.</p>
 <h4>Nesting of exceptions:</h4>
 <p>An <span class="RenoLink">exception_ptr</span> can be added as <span class="RenoLink"><a href="error_info.html">error_info</a></span> to any boost::<span class="RenoLink"><a href="exception.html">exception</a></span>. This is a convenient way to nest exceptions. There is no limit on the depth of the nesting, however cyclic references result in undefined behavior.</p>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>

doc/get_error_info.html

@@ -25,10 +25,10 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class ErrorInfo,class E&gt;
-    typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> const * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E const &amp; x );
+    typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> const * get_error_info( E const &amp; x );
     
     template &lt;class ErrorInfo,class E&gt;
-    typename ErrorInfo::<span class="RenoLink"><a href="error_info::value_type">error_info::value_type</a></span> * <span class="RenoLink"><a href="get_error_info">get_error_info</a></span>( E &amp; x );</span>
+    typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">error_info::value_type</a></span> * get_error_info( E &amp; x );</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <div><ul><li> ErrorInfo must be an instance of the <span class="RenoLink"><a href="error_info.html">error_info</a></span> template.</li>

doc/rethrow_exception.html

@@ -32,7 +32,7 @@ boost
 <h4>Throws:</h4>
 <p>The exception to which ep refers.</p>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
-See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a>&nbsp;| <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a>&nbsp;| <a href="diagnostic_information.html">diagnostic_information</a>&nbsp;| <a href="exception_ptr.html">exception_ptr</a></span>
+See also: <span class="RenoPageList"><a href="boost-exception.html">Boost Exception</a>&nbsp;| <a href="boost_exception_ptr_hpp.html">boost/exception_ptr.hpp</a>&nbsp;| <a href="diagnostic_information.html">diagnostic_information</a></span>
 </div>
 <!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->
 <!-- Distributed under the Boost Software License, Version 1.0. (See accompanying -->

include/boost/exception/detail/attribute_noreturn.hpp

@@ -9,7 +9,7 @@
 #if defined(_MSC_VER)
 #define BOOST_ATTRIBUTE_NORETURN __declspec(noreturn)
 #elif defined(__GNUC__)
-#define BOOST_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#define BOOST_ATTRIBUTE_NORETURN __attribute__((__noreturn__))
 #else
 #define BOOST_ATTRIBUTE_NORETURN
 #endif

include/boost/exception/detail/clone_current_exception.hpp

@@ -0,0 +1,47 @@
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_81522C0EB56511DFAB613DB0DFD72085
+#define UUID_81522C0EB56511DFAB613DB0DFD72085
+
+#ifdef BOOST_NO_EXCEPTIONS
+#    error This header requires exception handling to be enabled.
+#endif
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        class clone_base;
+
+#ifdef BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR
+        int clone_current_exception_non_intrusive( clone_base const * & cloned );
+#endif
+
+        namespace
+        clone_current_exception_result
+            {
+            int const success=0;
+            int const bad_alloc=1;
+            int const bad_exception=2;
+            int const not_supported=3;
+            }
+
+        inline
+        int
+        clone_current_exception( clone_base const * & cloned )
+            {
+#ifdef BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR
+            return clone_current_exception_non_intrusive(cloned);
+#else
+            return clone_current_exception_result::not_supported;
+#endif
+            }
+        }
+    }
+
+#endif

include/boost/exception/detail/error_info_impl.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -25,11 +25,12 @@ boost
             {
             public:
 
-            virtual char const * tag_typeid_name() const = 0;
+            virtual std::string tag_typeid_name() const = 0;
             virtual std::string value_as_string() const = 0;
 
             protected:
 
+            virtual
             ~error_info_base() throw()
                 {
                 }
@@ -62,7 +63,7 @@ boost
 
         private:
 
-        char const * tag_typeid_name() const;
+        std::string tag_typeid_name() const;
         std::string value_as_string() const;
 
         value_type value_;

include/boost/exception/detail/exception_ptr.hpp

@@ -20,14 +20,68 @@
 #include <boost/exception/info.hpp>
 #include <boost/exception/diagnostic_information.hpp>
 #include <boost/exception/detail/type_info.hpp>
+#include <boost/exception/detail/clone_current_exception.hpp>
 #include <boost/shared_ptr.hpp>
 #include <stdexcept>
 #include <new>
 #include <ios>
+#include <stdlib.h>
 
 namespace
 boost
     {
+    class exception_ptr;
+    BOOST_ATTRIBUTE_NORETURN void rethrow_exception( exception_ptr const & );
+    exception_ptr current_exception();
+
+    class
+    exception_ptr
+        {
+        typedef boost::shared_ptr<exception_detail::clone_base const> impl;
+        impl ptr_;
+        friend void rethrow_exception( exception_ptr const & );
+        typedef exception_detail::clone_base const * (impl::*unspecified_bool_type)() const;
+        public:
+        exception_ptr()
+            {
+            }
+        explicit
+        exception_ptr( impl const & ptr ):
+            ptr_(ptr)
+            {
+            }
+        bool
+        operator==( exception_ptr const & other ) const
+            {
+            return ptr_==other.ptr_;
+            }
+        bool
+        operator!=( exception_ptr const & other ) const
+            {
+            return ptr_!=other.ptr_;
+            }
+        operator unspecified_bool_type() const
+            {
+            return ptr_?&impl::get:0;
+            }
+        };
+
+    template <class T>
+    inline
+    exception_ptr
+    copy_exception( T const & e )
+        {
+        try
+            {
+            throw enable_current_exception(e);
+            }
+        catch(
+        ... )
+            {
+            return current_exception();
+            }
+        }
+
 #ifndef BOOST_NO_RTTI
     typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type;
 
@@ -39,91 +93,61 @@ boost
         }
 #endif
 
-    class exception_ptr;
-    exception_ptr current_exception();
-    void rethrow_exception( exception_ptr const & );
-
-    class
-    exception_ptr
+    namespace
+    exception_detail
         {
-        typedef bool exception_ptr::*unspecified_bool_type;
-        friend exception_ptr current_exception();
-        friend void rethrow_exception( exception_ptr const & );
-
-        shared_ptr<exception_detail::clone_base const> c_;
-        bool bad_alloc_;
+        struct
+        bad_alloc_:
+            boost::exception,
+            std::bad_alloc
+                {
+                ~bad_alloc_() throw() { }
+                };
 
         struct
-        bad_alloc_tag
+        bad_exception_:
+            boost::exception,
+            std::bad_exception
+                {
+                ~bad_exception_() throw() { }
+                };
+
+        template <class Exception>
+        exception_ptr
+        get_static_exception_object()
             {
+            Exception ba;
+            exception_detail::clone_impl<Exception> c(ba);
+            c <<
+                throw_function(BOOST_CURRENT_FUNCTION) <<
+                throw_file(__FILE__) <<
+                throw_line(__LINE__);
+            static exception_ptr ep(shared_ptr<exception_detail::clone_base const>(new exception_detail::clone_impl<Exception>(c)));
+            return ep;
+            }
+
+        template <class Exception>
+        struct
+        exception_ptr_static_exception_object
+            {
+            static exception_ptr const e;
             };
 
-        explicit
-        exception_ptr( bad_alloc_tag ):
-            bad_alloc_(true)
-            {
-            }
-
-        explicit
-        exception_ptr( shared_ptr<exception_detail::clone_base const> const & c ):
-            c_(c),
-            bad_alloc_(false)
-            {
-            BOOST_ASSERT(c);
-            }
-
-        void
-        rethrow() const
-            {
-            BOOST_ASSERT(*this);
-            if( bad_alloc_ )
-                throw enable_current_exception(std::bad_alloc());
-            else
-                c_->rethrow();
-            }
-
-        bool
-        empty() const
-            {
-            return !bad_alloc_ && !c_;
-            }
-
-        public:
-
-        exception_ptr():
-            bad_alloc_(false)
-            {
-            }
-
-        ~exception_ptr() throw()
-            {
-            }
-
-        operator unspecified_bool_type() const
-            {
-            return empty() ? 0 : &exception_ptr::bad_alloc_;
-            }
-
-        friend
-        bool
-        operator==( exception_ptr const & a, exception_ptr const & b )
-            {
-            return a.c_==b.c_ && a.bad_alloc_==b.bad_alloc_;
-            }
-
-        friend
-        bool
-        operator!=( exception_ptr const & a, exception_ptr const & b )
-            {
-            return !(a==b);
-            }
-        };
+        template <class Exception>
+        exception_ptr const
+        exception_ptr_static_exception_object<Exception>::
+        e = get_static_exception_object<Exception>();
+        }
 
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
     class
     unknown_exception:
-        public exception,
-        public std::exception,
-        public exception_detail::clone_base
+        public boost::exception,
+        public std::exception
         {
         public:
 
@@ -150,18 +174,6 @@ boost
 
         private:
 
-        exception_detail::clone_base const *
-        clone() const
-            {
-            return new unknown_exception(*this);
-            }
-
-        void
-        rethrow() const
-            {
-            throw*this;
-            }
-
         template <class E>
         void
         add_original_type( E const & e )
@@ -171,6 +183,11 @@ boost
 #endif
             }
         };
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
 
     namespace
     exception_detail
@@ -179,8 +196,7 @@ boost
         class
         current_exception_std_exception_wrapper:
             public T,
-            public boost::exception,
-            public clone_base
+            public boost::exception
             {
             public:
 
@@ -204,18 +220,6 @@ boost
 
             private:
 
-            clone_base const *
-            clone() const
-                {
-                return new current_exception_std_exception_wrapper(*this);
-                }
-
-            void
-            rethrow() const
-                {
-                throw *this;
-                }
-
             template <class E>
             void
             add_original_type( E const & e )
@@ -228,7 +232,7 @@ boost
 
 #ifdef BOOST_NO_RTTI
         template <class T>
-        exception const *
+        boost::exception const *
         get_boost_exception( T const * )
             {
             try
@@ -236,7 +240,7 @@ boost
                 throw;
                 }
             catch(
-            exception & x )
+            boost::exception & x )
                 {
                 return &x;
                 }
@@ -247,147 +251,177 @@ boost
             }
 #else
         template <class T>
-        exception const *
+        boost::exception const *
         get_boost_exception( T const * x )
             {
-            return dynamic_cast<exception const *>(x);
+            return dynamic_cast<boost::exception const *>(x);
             }
 #endif
 
         template <class T>
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_std_exception( T const & e1 )
             {
             if( boost::exception const * e2 = get_boost_exception(&e1) )
-                return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1,*e2));
+                return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1,*e2));
             else
-                return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1));
+                return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1));
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_unknown_exception()
             {
-            return shared_ptr<unknown_exception const>(new unknown_exception());
+            return boost::copy_exception(unknown_exception());
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_unknown_boost_exception( boost::exception const & e )
             {
-            return shared_ptr<unknown_exception const>(new unknown_exception(e));
+            return boost::copy_exception(unknown_exception(e));
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_unknown_std_exception( std::exception const & e )
             {
             if( boost::exception const * be = get_boost_exception(&e) )
                 return current_exception_unknown_boost_exception(*be);
             else
-                return shared_ptr<unknown_exception const>(new unknown_exception(e));
+                return boost::copy_exception(unknown_exception(e));
             }
 
         inline
-        shared_ptr<clone_base const>
+        exception_ptr
         current_exception_impl()
             {
-            try
+            exception_detail::clone_base const * e=0;
+            switch(
+            exception_detail::clone_current_exception(e) )
                 {
-                throw;
-                }
-            catch(
-            exception_detail::clone_base & e )
-                {
-                return shared_ptr<exception_detail::clone_base const>(e.clone());
-                }
-            catch(
-            std::domain_error & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::invalid_argument & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::length_error & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::out_of_range & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::logic_error & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::range_error & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::overflow_error & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::underflow_error & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::ios_base::failure & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::runtime_error & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::bad_alloc & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
+                case exception_detail::clone_current_exception_result::
+                success:
+                    {
+                    BOOST_ASSERT(e!=0);
+                    return exception_ptr(shared_ptr<exception_detail::clone_base const>(e));
+                    }
+                case exception_detail::clone_current_exception_result::
+                bad_alloc:
+                    {
+                    BOOST_ASSERT(!e);
+                    return exception_detail::exception_ptr_static_exception_object<bad_alloc_>::e;
+                    }
+                case exception_detail::clone_current_exception_result::
+                bad_exception:
+                    {
+                    BOOST_ASSERT(!e);
+                    return exception_detail::exception_ptr_static_exception_object<bad_exception_>::e;
+                    }
+                default:
+                    BOOST_ASSERT(0);
+                case exception_detail::clone_current_exception_result::
+                not_supported:
+                    {
+                    BOOST_ASSERT(!e);
+                    try
+                        {
+                        throw;
+                        }
+                    catch(
+                    exception_detail::clone_base & e )
+                        {
+                        return exception_ptr(shared_ptr<exception_detail::clone_base const>(e.clone()));
+                        }
+                    catch(
+                    std::domain_error & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::invalid_argument & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::length_error & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::out_of_range & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::logic_error & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::range_error & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::overflow_error & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::underflow_error & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::ios_base::failure & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::runtime_error & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::bad_alloc & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
 #ifndef BOOST_NO_TYPEID
-            catch(
-            std::bad_cast & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::bad_typeid & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
+                    catch(
+                    std::bad_cast & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::bad_typeid & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
 #endif
-            catch(
-            std::bad_exception & e )
-                {
-                return exception_detail::current_exception_std_exception(e);
-                }
-            catch(
-            std::exception & e )
-                {
-                return exception_detail::current_exception_unknown_std_exception(e);
-                }
-            catch(
-            boost::exception & e )
-                {
-                return exception_detail::current_exception_unknown_boost_exception(e);
-                }
-            catch(
-            ... )
-                {
-                return exception_detail::current_exception_unknown_exception();
+                    catch(
+                    std::bad_exception & e )
+                        {
+                        return exception_detail::current_exception_std_exception(e);
+                        }
+                    catch(
+                    std::exception & e )
+                        {
+                        return exception_detail::current_exception_unknown_std_exception(e);
+                        }
+                    catch(
+                    boost::exception & e )
+                        {
+                        return exception_detail::current_exception_unknown_boost_exception(e);
+                        }
+                    catch(
+                    ... )
+                        {
+                        return exception_detail::current_exception_unknown_exception();
+                        }
+                    }
                 }
             }
         }
@@ -396,55 +430,39 @@ boost
     exception_ptr
     current_exception()
         {
+        exception_ptr ret;
         try
             {
-            return exception_ptr(exception_detail::current_exception_impl());
+            ret=exception_detail::current_exception_impl();
             }
         catch(
         std::bad_alloc & )
             {
+            ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_alloc_>::e;
             }
         catch(
         ... )
             {
-            try
-                {
-                return exception_ptr(exception_detail::current_exception_std_exception(std::bad_exception()));
-                }
-            catch(
-            std::bad_alloc & )
-                {
-                }
-            catch(
-            ... )
-                {
-                BOOST_ASSERT(0);
-                }
-            }
-        return exception_ptr(exception_ptr::bad_alloc_tag());
-        }
-
-    template <class T>
-    inline
-    exception_ptr
-    copy_exception( T const & e )
-        {
-        try
-            {
-            throw enable_current_exception(e);
-            }
-        catch(
-        ... )
-            {
-            return current_exception();
+            ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_exception_>::e;
             }
+        BOOST_ASSERT(ret);
+        return ret;
         }
 
+    BOOST_ATTRIBUTE_NORETURN
     inline
     void
     rethrow_exception( exception_ptr const & p )
         {
-        p.rethrow();
+        BOOST_ASSERT(p);
+        p.ptr_->rethrow();
+        BOOST_ASSERT(0);
+        #if defined(UNDER_CE)
+            // some CE platforms don't define ::abort()
+            exit(-1);
+        #else
+            abort();
+        #endif
         }
 
     inline

include/boost/exception/detail/is_output_streamable.hpp

@@ -20,8 +20,21 @@ boost
     namespace
     to_string_detail
         {
-        template <class T,class CharT,class Traits>
-        char operator<<( std::basic_ostream<CharT,Traits> &, T const & );
+        struct
+        partial_ordering_helper1
+            {
+            template <class CharT,class Traits>
+            partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
+            };
+
+        struct
+        partial_ordering_helper2
+            {
+            template <class T>
+            partial_ordering_helper2( T const & );
+            };
+
+        char operator<<( partial_ordering_helper1, partial_ordering_helper2 );
 
         template <class T,class CharT,class Traits>
         struct

include/boost/exception/detail/type_info.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -15,31 +15,35 @@
 #include <boost/detail/sp_typeinfo.hpp>
 #include <boost/current_function.hpp>
 #include <boost/config.hpp>
+#ifndef BOOST_NO_TYPEID
+#include <boost/units/detail/utility.hpp>
+#endif
+#include <string>
 
 namespace
 boost
     {
     template <class T>
     inline
-    char const *
+    std::string
     tag_type_name()
         {
 #ifdef BOOST_NO_TYPEID
         return BOOST_CURRENT_FUNCTION;
 #else
-        return typeid(T*).name();
+        return units::detail::demangle(typeid(T*).name());
 #endif
         }
 
     template <class T>
     inline
-    char const *
+    std::string
     type_name()
         {
 #ifdef BOOST_NO_TYPEID
         return BOOST_CURRENT_FUNCTION;
 #else
-        return typeid(T).name();
+        return units::detail::demangle(typeid(T).name());
 #endif
         }
 
@@ -49,11 +53,11 @@ boost
         struct
         type_info_
             {
-            detail::sp_typeinfo const & type_;
+            detail::sp_typeinfo const * type_;
 
             explicit
             type_info_( detail::sp_typeinfo const & type ):
-                type_(type)
+                type_(&type)
                 {
                 }
 
@@ -61,7 +65,7 @@ boost
             bool
             operator<( type_info_ const & a, type_info_ const & b )
                 {
-                return 0!=(a.type_.before(b.type_));
+                return 0!=(a.type_->before(*b.type_));
                 }
             };
         }

include/boost/exception/diagnostic_information.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -14,8 +14,11 @@
 
 #include <boost/config.hpp>
 #include <boost/exception/get_error_info.hpp>
+#include <boost/exception/info.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/config.hpp>
+#ifndef BOOST_NO_RTTI
+#include <boost/units/detail/utility.hpp>
+#endif
 #include <exception>
 #include <sstream>
 #include <string>
@@ -83,19 +86,23 @@ boost
         char const *
         get_diagnostic_information( exception const & x, char const * header )
             {
-            if( error_info_container * c=x.data_.get() )
 #ifndef BOOST_NO_EXCEPTIONS
-                try
-                    {
+            try
+                {
 #endif
-                    return c->diagnostic_information(header);
+                error_info_container * c=x.data_.get();
+                if( !c )
+                    x.data_.adopt(c=new exception_detail::error_info_container_impl);
+                char const * di=c->diagnostic_information(header);
+                BOOST_ASSERT(di!=0);
+                return di;
 #ifndef BOOST_NO_EXCEPTIONS
-                    }
-                catch(...)
-                    {
-                    }
+                }
+            catch(...)
+                {
+                return 0;
+                }
 #endif
-            return 0;
             }
 
         inline
@@ -120,22 +127,30 @@ boost
             std::ostringstream tmp;
             if( be )
                 {
-                if( char const * const * f=get_error_info<throw_file>(*be) )
-                    {
-                    tmp << *f;
-                    if( int const * l=get_error_info<throw_line>(*be) )
-                        tmp << '(' << *l << "): ";
-                    }
-                tmp << "Throw in function ";
-                if( char const * const * fn=get_error_info<throw_function>(*be) )
-                    tmp << *fn;
+                char const * const * f=get_error_info<throw_file>(*be);
+                int const * l=get_error_info<throw_line>(*be);
+                char const * const * fn=get_error_info<throw_function>(*be);
+                if( !f && !l && !fn )
+                    tmp << "Throw location unknown (consider using BOOST_THROW_EXCEPTION)\n";
                 else
-                    tmp << "(unknown)";
-                tmp << '\n';
+                    {
+                    if( f )
+                        {
+                        tmp << *f;
+                        if( int const * l=get_error_info<throw_line>(*be) )
+                            tmp << '(' << *l << "): ";
+                        }
+                    tmp << "Throw in function ";
+                    if( char const * const * fn=get_error_info<throw_function>(*be) )
+                        tmp << *fn;
+                    else
+                        tmp << "(unknown)";
+                    tmp << '\n';
+                    }
                 }
 #ifndef BOOST_NO_RTTI
             tmp << std::string("Dynamic exception type: ") <<
-                (be?BOOST_EXCEPTION_DYNAMIC_TYPEID(*be):BOOST_EXCEPTION_DYNAMIC_TYPEID(*se)).type_.name() << '\n';
+                units::detail::demangle((be?(BOOST_EXCEPTION_DYNAMIC_TYPEID(*be)):(BOOST_EXCEPTION_DYNAMIC_TYPEID(*se))).type_->name()) << '\n';
 #endif
             if( with_what && se )
                 tmp << "std::exception::what: " << wh << '\n';
@@ -164,7 +179,10 @@ boost
             {
 #endif
             (void) exception_detail::diagnostic_information_impl(&e,0,false);
-            return exception_detail::get_diagnostic_information(e,0);
+            if( char const * di=exception_detail::get_diagnostic_information(e,0) )
+                return di;
+            else
+                return "Failed to produce boost::diagnostic_information_what()";
 #ifndef BOOST_NO_EXCEPTIONS
             }
         catch(

include/boost/exception/errinfo_nested_exception.hpp

@@ -9,6 +9,7 @@
 namespace
 boost
     {
+    namespace exception_detail { class clone_base; }
     template <class Tag,class T> class error_info;
     class exception_ptr;
     typedef error_info<struct errinfo_nested_exception_,exception_ptr> errinfo_nested_exception;

include/boost/exception/error_info.hpp

@@ -3,4 +3,7 @@
 //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 UUID_EE7ECCA0433B11E1923E37064924019B
+#define UUID_EE7ECCA0433B11E1923E37064924019B
 namespace boost { template <class Tag,class T> class error_info; }
+#endif

include/boost/exception/exception.hpp

@@ -75,8 +75,8 @@ boost
             void
             release()
                 {
-                if( px_ )
-                    px_->release();
+                if( px_ && px_->release() )
+                    px_=0;
                 }
             };
         }
@@ -132,21 +132,19 @@ boost
             }
         };
 
-    template <class E,class Tag,class T>
-    E const & operator<<( E const &, error_info<Tag,T> const & );
-
-    template <class E>
-    E const & operator<<( E const &, throw_function const & );
-
-    template <class E>
-    E const & operator<<( E const &, throw_file const & );
-
-    template <class E>
-    E const & operator<<( E const &, throw_line const & );
-
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
     class exception;
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
 
-    template <class>
+    template <class T>
     class shared_ptr;
 
     namespace
@@ -162,7 +160,8 @@ boost
             virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
             virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
             virtual void add_ref() const = 0;
-            virtual void release() const = 0;
+            virtual bool release() const = 0;
+            virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
 
             protected:
 
@@ -184,8 +183,27 @@ boost
         struct get_info<throw_line>;
 
         char const * get_diagnostic_information( exception const &, char const * );
+
+        void copy_boost_exception( exception *, exception const * );
+
+        template <class E,class Tag,class T>
+        E const & set_info( E const &, error_info<Tag,T> const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_function const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_file const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_line const & );
         }
 
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
     class
     exception
         {
@@ -216,36 +234,42 @@ boost
 #endif
             ;
 
-#if defined(__MWERKS__) && __MWERKS__<=0x3207
+#if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310)
         public:
 #else
         private:
 
         template <class E>
-        friend E const & operator<<( E const &, throw_function const & );
+        friend E const & exception_detail::set_info( E const &, throw_function const & );
 
         template <class E>
-        friend E const & operator<<( E const &, throw_file const & );
+        friend E const & exception_detail::set_info( E const &, throw_file const & );
 
         template <class E>
-        friend E const & operator<<( E const &, throw_line const & );
-
-        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
+        friend E const & exception_detail::set_info( E const &, throw_line const & );
 
         template <class E,class Tag,class T>
-        friend E const & operator<<( E const &, error_info<Tag,T> const & );
+        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
+
+        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
 
         template <class>
         friend struct exception_detail::get_info;
         friend struct exception_detail::get_info<throw_function>;
         friend struct exception_detail::get_info<throw_file>;
         friend struct exception_detail::get_info<throw_line>;
+        friend void exception_detail::copy_boost_exception( exception *, exception const * );
 #endif
         mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
         mutable char const * throw_function_;
         mutable char const * throw_file_;
         mutable int throw_line_;
         };
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
 
     inline
     exception::
@@ -253,28 +277,32 @@ boost
         {
         }
 
-    template <class E>
-    E const &
-    operator<<( E const & x, throw_function const & y )
+    namespace
+    exception_detail
         {
-        x.throw_function_=y.v_;
-        return x;
-        }
+        template <class E>
+        E const &
+        set_info( E const & x, throw_function const & y )
+            {
+            x.throw_function_=y.v_;
+            return x;
+            }
 
-    template <class E>
-    E const &
-    operator<<( E const & x, throw_file const & y )
-        {
-        x.throw_file_=y.v_;
-        return x;
-        }
+        template <class E>
+        E const &
+        set_info( E const & x, throw_file const & y )
+            {
+            x.throw_file_=y.v_;
+            return x;
+            }
 
-    template <class E>
-    E const &
-    operator<<( E const & x, throw_line const & y )
-        {
-        x.throw_line_=y.v_;
-        return x;
+        template <class E>
+        E const &
+        set_info( E const & x, throw_line const & y )
+            {
+            x.throw_line_=y.v_;
+            return x;
+            }
         }
 
     ////////////////////////////////////////////////////////////////////////
@@ -282,6 +310,11 @@ boost
     namespace
     exception_detail
         {
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
         template <class T>
         struct
         error_info_injector:
@@ -298,12 +331,17 @@ boost
                 {
                 }
             };
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
 
         struct large_size { char c[256]; };
-        large_size dispatch( exception * );
+        large_size dispatch_boost_exception( exception const * );
 
         struct small_size { };
-        small_size dispatch( void * );
+        small_size dispatch_boost_exception( void const * );
 
         template <class,int>
         struct enable_error_info_helper;
@@ -326,7 +364,7 @@ boost
         struct
         enable_error_info_return_type
             {
-            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch((T*)0))>::type type;
+            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
             };
         }
 
@@ -345,6 +383,11 @@ boost
     namespace
     exception_detail
         {
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility push (default)
+# endif
+#endif
         class
         clone_base
             {
@@ -358,12 +401,23 @@ boost
                 {
                 }
             };
+#if defined(__GNUC__)
+# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
+#  pragma GCC visibility pop
+# endif
+#endif
 
         inline
         void
         copy_boost_exception( exception * a, exception const * b )
             {
-            *a = *b;
+            refcount_ptr<error_info_container> data;
+            if( error_info_container * d=b->data_.get() )
+                data = d->clone();
+            a->throw_file_ = b->throw_file_;
+            a->throw_line_ = b->throw_line_;
+            a->throw_function_ = b->throw_function_;
+            a->data_ = data;
             }
 
         inline
@@ -376,8 +430,15 @@ boost
         class
         clone_impl:
             public T,
-            public clone_base
+            public virtual clone_base
             {
+            struct clone_tag { };
+            clone_impl( clone_impl const & x, clone_tag ):
+                T(x)
+                {
+                copy_boost_exception(this,&x);
+                }
+
             public:
 
             explicit
@@ -396,7 +457,7 @@ boost
             clone_base const *
             clone() const
                 {
-                return new clone_impl(*this);
+                return new clone_impl(*this,clone_tag());
                 }
 
             void

include/boost/exception/info.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -47,7 +47,7 @@ boost
 
     template <class Tag,class T>
     inline
-    char const *
+    std::string
     error_info<Tag,T>::
     tag_typeid_name() const
         {
@@ -97,7 +97,7 @@ boost
                     {
                     shared_ptr<error_info_base> const & p = i->second;
 #ifndef BOOST_NO_RTTI
-                    BOOST_ASSERT( BOOST_EXCEPTION_DYNAMIC_TYPEID(*p).type_==ti.type_ );
+                    BOOST_ASSERT( *BOOST_EXCEPTION_DYNAMIC_TYPEID(*p).type_==*ti.type_ );
 #endif
                     return p;
                     }
@@ -109,13 +109,12 @@ boost
                 {
                 if( header )
                     {
-                    BOOST_ASSERT(*header!=0);
                     std::ostringstream tmp;
                     tmp << header;
                     for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
                         {
-                        shared_ptr<error_info_base const> const & x = i->second;
-                        tmp << '[' << x->tag_typeid_name() << "] = " << x->value_as_string() << '\n';
+                        error_info_base const & x = *i->second;
+                        tmp << '[' << x.tag_typeid_name() << "] = " << x.value_as_string() << '\n';
                         }
                     tmp.str().swap(diagnostic_info_str_);
                     }
@@ -131,33 +130,66 @@ boost
             mutable std::string diagnostic_info_str_;
             mutable int count_;
 
+            error_info_container_impl( error_info_container_impl const & );
+            error_info_container_impl & operator=( error_info_container const & );
+
             void
             add_ref() const
                 {
                 ++count_;
                 }
 
-            void
+            bool
             release() const
                 {
-                if( !--count_ )
+                if( --count_ )
+                    return false;
+                else
+                    {
                     delete this;
+                    return true;
+                    }
                 }
+
+            refcount_ptr<error_info_container>
+            clone() const
+                {
+                refcount_ptr<error_info_container> p;
+                error_info_container_impl * c=new error_info_container_impl;
+                p.adopt(c);
+                c->info_ = info_;
+                return p;
+                }
+            };
+
+        template <class E,class Tag,class T>
+        inline
+        E const &
+        set_info( E const & x, error_info<Tag,T> const & v )
+            {
+            typedef error_info<Tag,T> error_info_tag_t;
+            shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
+            exception_detail::error_info_container * c=x.data_.get();
+            if( !c )
+                x.data_.adopt(c=new exception_detail::error_info_container_impl);
+            c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
+            return x;
+            }
+
+        template <class T>
+        struct
+        derives_boost_exception
+            {
+            enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
             };
         }
 
     template <class E,class Tag,class T>
     inline
-    E const &
+    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
     operator<<( E const & x, error_info<Tag,T> const & v )
         {
-        typedef error_info<Tag,T> error_info_tag_t;
-        shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
-        exception_detail::error_info_container * c=x.data_.get();
-        if( !c )
-            x.data_.adopt(c=new exception_detail::error_info_container_impl);
-        c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
-        return x;
+        return exception_detail::set_info(x,v);
         }
     }
 

include/boost/exception/info_tuple.hpp

@@ -18,6 +18,30 @@
 namespace
 boost
     {
+    template <
+        class E >
+    inline
+    E const &
+    operator<<(
+        E const & x,
+        tuple< > const & v )
+        {
+        return x;
+        }
+
+    template <
+        class E,
+        class Tag1,class T1 >
+    inline
+    E const &
+    operator<<(
+        E const & x,
+        tuple<
+            error_info<Tag1,T1> > const & v )
+        {
+        return x << v.template get<0>();
+        }
+
     template <
         class E,
         class Tag1,class T1,

include/boost/throw_exception.hpp

@@ -1,5 +1,11 @@
-#ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED
-#define BOOST_THROW_EXCEPTION_HPP_INCLUDED
+#ifndef UUID_AA15E74A856F11E08B8D93F24824019B
+#define UUID_AA15E74A856F11E08B8D93F24824019B
+#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma GCC system_header
+#endif
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(push,1)
+#endif
 
 // MS compatible compilers support #pragma once
 
@@ -36,17 +42,13 @@
 #if !defined( BOOST_EXCEPTION_DISABLE )
 # include <boost/exception/exception.hpp>
 # include <boost/current_function.hpp>
-# define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(::boost::enable_error_info(x) <<\
-    ::boost::throw_function(BOOST_CURRENT_FUNCTION) <<\
-    ::boost::throw_file(__FILE__) <<\
-    ::boost::throw_line(__LINE__))
+# define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_CURRENT_FUNCTION,__FILE__,__LINE__)
 #else
 # define BOOST_THROW_EXCEPTION(x) ::boost::throw_exception(x)
 #endif
 
 namespace boost
 {
-
 #ifdef BOOST_NO_EXCEPTIONS
 
 void throw_exception( std::exception const & e ); // user defined
@@ -70,6 +72,29 @@ template<class E> BOOST_ATTRIBUTE_NORETURN inline void throw_exception( E const
 
 #endif
 
+#if !defined( BOOST_EXCEPTION_DISABLE )
+    namespace
+    exception_detail
+    {
+        template <class E>
+        BOOST_ATTRIBUTE_NORETURN
+        void
+        throw_exception_( E const & x, char const * current_function, char const * file, int line )
+        {
+            boost::throw_exception(
+                set_info(
+                    set_info(
+                        set_info(
+                            enable_error_info(x),
+                            throw_function(current_function)),
+                        throw_file(file)),
+                    throw_line(line)));
+        }
+    }
+#endif
 } // namespace boost
 
-#endif // #ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(pop)
+#endif
+#endif

src/clone_current_exception_non_intrusive.cpp

@@ -0,0 +1,320 @@
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+//This MSVC-specific cpp file implements non-intrusive cloning of exception objects.
+//Based on an exception_ptr implementation by Anthony Williams.
+
+#ifdef BOOST_NO_EXCEPTIONS
+#error This file requires exception handling to be enabled.
+#endif
+
+#include <boost/exception/detail/clone_current_exception.hpp>
+
+#if defined(BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR) && defined(_MSC_VER) && defined(_M_IX86) && !defined(_M_X64)
+
+//Non-intrusive cloning support implemented below, only for MSVC versions mentioned above.
+//Thanks Anthony Williams!
+
+#include <boost/exception/exception.hpp>
+#include <boost/shared_ptr.hpp>
+#ifndef BOOST_NO_RTTI
+#include <typeinfo>
+#endif
+#include <windows.h>
+#include <malloc.h>
+
+namespace
+    {
+    unsigned const exception_maximum_parameters=15;
+    unsigned const exception_noncontinuable=1;
+
+#if _MSC_VER==1310
+    int const exception_info_offset=0x74;
+#elif (_MSC_VER==1400 || _MSC_VER==1500)
+    int const exception_info_offset=0x80;
+#else
+    int const exception_info_offset=-1;
+#endif
+
+    struct
+    exception_record
+        {
+        unsigned long ExceptionCode;
+        unsigned long ExceptionFlags;
+        exception_record * ExceptionRecord;
+        void * ExceptionAddress;
+        unsigned long NumberParameters;
+        ULONG_PTR ExceptionInformation[exception_maximum_parameters];
+        };
+
+    struct
+    exception_pointers
+        {
+        exception_record * ExceptionRecord;
+        void * ContextRecord;
+        };
+
+    unsigned const cpp_exception_code=0xE06D7363;
+    unsigned const cpp_exception_magic_flag=0x19930520;
+    unsigned const cpp_exception_parameter_count=3;
+
+    struct
+    dummy_exception_type
+        {
+        };
+
+    typedef int(dummy_exception_type::*normal_copy_constructor_ptr)(void * src);
+    typedef int(dummy_exception_type::*copy_constructor_with_virtual_base_ptr)(void * src,void * dst);
+    typedef void (dummy_exception_type::*destructor_ptr)();
+
+    union
+    cpp_copy_constructor
+        {
+        normal_copy_constructor_ptr normal_copy_constructor;
+        copy_constructor_with_virtual_base_ptr copy_constructor_with_virtual_base;
+        };
+
+    enum
+    cpp_type_flags
+        {
+        class_is_simple_type=1,
+        class_has_virtual_base=4
+        };
+
+    struct
+    cpp_type_info
+        {
+        unsigned flags;
+#ifndef BOOST_NO_RTTI
+        void const * type_info;
+#else
+        std::type_info * type_info;
+#endif
+        int this_offset;
+        int vbase_descr;
+        int vbase_offset;
+        unsigned long size;
+        cpp_copy_constructor copy_constructor;
+        };
+
+    struct
+    cpp_type_info_table
+        {
+        unsigned count;
+        const cpp_type_info * info[1];
+        };
+
+    struct
+    cpp_exception_type
+        {
+        unsigned flags;
+        destructor_ptr destructor;
+        void(*custom_handler)();
+        cpp_type_info_table const * type_info_table;
+        };
+
+    struct
+    exception_object_deleter
+        {
+        cpp_exception_type const & et_;
+
+        exception_object_deleter( cpp_exception_type const & et ):
+            et_(et)
+            {
+            }
+
+        void
+        operator()( void * obj )
+            {
+            BOOST_ASSERT(obj!=0);
+            dummy_exception_type * dummy_exception_ptr=reinterpret_cast<dummy_exception_type *>(obj);
+            (dummy_exception_ptr->*(et_.destructor))();
+            free(obj);
+            }
+        };
+
+    cpp_type_info const &
+    get_cpp_type_info( cpp_exception_type const & et )
+        {
+        cpp_type_info const * ti = et.type_info_table->info[0];
+        BOOST_ASSERT(ti!=0);
+        return *ti;
+        }
+
+    void
+    copy_msvc_exception( void * dst, void * src, cpp_type_info const & ti )
+        {
+        if( !(ti.flags & class_is_simple_type) && ti.copy_constructor.normal_copy_constructor )
+            {
+            dummy_exception_type * dummy_exception_ptr = reinterpret_cast<dummy_exception_type *>(dst);
+            if( ti.flags & class_has_virtual_base )
+                (dummy_exception_ptr->*(ti.copy_constructor.copy_constructor_with_virtual_base))(src,dst);
+            else
+                (dummy_exception_ptr->*(ti.copy_constructor.normal_copy_constructor))(src);
+            }
+        else
+            memmove(dst,src,ti.size);
+        }
+
+    boost::shared_ptr<void>
+    clone_msvc_exception( void * src, cpp_exception_type const & et )
+        {
+        assert(src!=0);
+        cpp_type_info const & ti=get_cpp_type_info(et);
+        if( void * dst = malloc(ti.size) )
+            {
+            try
+                {
+                copy_msvc_exception(dst,src,ti);
+                }
+            catch(
+            ... )
+                {
+                free(dst);
+                throw;
+                }
+            return boost::shared_ptr<void>(dst,exception_object_deleter(et));
+            }
+        else
+            throw std::bad_alloc();
+        }
+
+    class
+    cloned_exception:
+        public boost::exception_detail::clone_base
+        {
+        cloned_exception( cloned_exception const & );
+        cloned_exception & operator=( cloned_exception const & );
+
+        cpp_exception_type const & et_;
+        boost::shared_ptr<void> exc_;
+
+        public:
+
+        cloned_exception( void * exc, cpp_exception_type const & et ):
+            et_(et),
+            exc_(clone_msvc_exception(exc,et_))
+            {
+            }
+
+        ~cloned_exception() throw()
+            {
+            }
+
+        boost::exception_detail::clone_base const *
+        clone() const
+            {
+            return new cloned_exception(exc_.get(),et_);
+            }
+
+        void
+        rethrow() const
+            {
+            cpp_type_info const & ti=get_cpp_type_info(et_);
+            void * dst = _alloca(ti.size);
+            copy_msvc_exception(dst,exc_.get(),ti);
+            ULONG_PTR args[cpp_exception_parameter_count];
+            args[0]=cpp_exception_magic_flag;
+            args[1]=reinterpret_cast<ULONG_PTR>(dst);
+            args[2]=reinterpret_cast<ULONG_PTR>(&et_);
+            RaiseException(cpp_exception_code,EXCEPTION_NONCONTINUABLE,cpp_exception_parameter_count,args);
+            }
+        };
+
+    bool
+    is_cpp_exception( EXCEPTION_RECORD const * record )
+        {
+        return record && 
+            (record->ExceptionCode==cpp_exception_code) &&
+            (record->NumberParameters==cpp_exception_parameter_count) &&
+            (record->ExceptionInformation[0]==cpp_exception_magic_flag);
+        }
+
+    unsigned long
+    exception_cloning_filter( int & result, boost::exception_detail::clone_base const * & ptr, void * info_ )
+        {
+        BOOST_ASSERT(exception_info_offset>=0);
+        BOOST_ASSERT(info_!=0);
+        EXCEPTION_POINTERS * info=reinterpret_cast<EXCEPTION_POINTERS *>(info_);
+        EXCEPTION_RECORD * record=info->ExceptionRecord;
+        if( is_cpp_exception(record) )
+            {
+            if( !record->ExceptionInformation[2] )
+                record = *reinterpret_cast<EXCEPTION_RECORD * *>(reinterpret_cast<char *>(_errno())+exception_info_offset);
+            if( is_cpp_exception(record) && record->ExceptionInformation[2] )
+                try
+                    {
+                    ptr = new cloned_exception(
+                            reinterpret_cast<void *>(record->ExceptionInformation[1]),
+                            *reinterpret_cast<cpp_exception_type const *>(record->ExceptionInformation[2]));
+                    result = boost::exception_detail::clone_current_exception_result::success;
+                    }
+                catch(
+                std::bad_alloc & )
+                    {
+                    result = boost::exception_detail::clone_current_exception_result::bad_alloc;
+                    }
+                catch(
+                ... )
+                    {
+                    result = boost::exception_detail::clone_current_exception_result::bad_exception;
+                    }
+            }
+        return EXCEPTION_EXECUTE_HANDLER;
+        }
+    }
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        int
+        clone_current_exception_non_intrusive( clone_base const * & cloned )
+            {
+            BOOST_ASSERT(!cloned);
+            int result = clone_current_exception_result::not_supported;
+            if( exception_info_offset>=0 )
+                {
+                 clone_base const * ptr=0;
+                __try
+                    {
+                    throw;
+                    }
+                __except(exception_cloning_filter(result,ptr,GetExceptionInformation()))
+                    {
+                    }
+                if( result==clone_current_exception_result::success )
+                    cloned=ptr;
+                }
+            BOOST_ASSERT(result!=clone_current_exception_result::success || cloned);
+            return result;
+            }
+        }
+    }
+
+#else
+
+//On all other compilers, return clone_current_exception_result::not_supported.
+//On such platforms, only the intrusive enable_current_exception() cloning will work.
+
+#include <boost/config.hpp>
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        int
+        clone_current_exception_non_intrusive( clone_base const * & )
+            {
+            return clone_current_exception_result::not_supported;
+            }
+        }
+    }
+
+#endif

test/Jamfile.v2

@@ -7,7 +7,11 @@
 
 import testing ;
 
-project : requirements <exception-handling>on ;
+project
+    : requirements
+        <link>static
+        <exception-handling>on
+    ;
 
 #to_string
 
@@ -24,7 +28,7 @@ run 2-throw_exception_no_exceptions_test.cpp ;
 run 3-throw_exception_no_integration_test.cpp ;
 run 4-throw_exception_no_both_test.cpp ;
 run cloning_test.cpp ;
-run copy_exception_test.cpp ;
+run copy_exception_test.cpp /boost//thread : : : <threading>multi ;
 run unknown_exception_test.cpp ;
 run exception_test.cpp ;
 run enable_error_info_test.cpp helper1.cpp ;
@@ -36,6 +40,9 @@ run refcount_ptr_test.cpp ;
 run current_exception_cast_test.cpp ;
 run no_exceptions_test.cpp : : : <exception-handling>off ;
 run errinfos_test.cpp ;
+run exception_ptr_test.cpp/<define>BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR /boost/exception /boost//thread : : : <threading>multi : non_intrusive_exception_ptr_test ;
+run exception_ptr_test.cpp /boost//thread : : : <threading>multi ;
+
 compile-fail exception_fail.cpp ;
 compile-fail throw_exception_fail.cpp ;
 compile-fail error_info_const_fail.cpp ;

test/cloning_test.cpp

@@ -146,6 +146,10 @@ test_std_exception()
 #endif
             }
         catch(
+        T & )
+            {
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -176,7 +180,7 @@ test_std_exception_what()
         catch(
         T & x )
             {
-            BOOST_TEST(std::string("what")==x.what());
+            BOOST_TEST(std::string(x.what()).find("what")!=std::string::npos);
             boost::exception_ptr p = boost::current_exception();
             BOOST_TEST(!(p==boost::exception_ptr()));
             BOOST_TEST(p!=boost::exception_ptr());
@@ -189,7 +193,7 @@ test_std_exception_what()
             catch(
             T & x )
                 {
-                BOOST_TEST(std::string("what")==x.what());
+                BOOST_TEST(std::string(x.what()).find("what")!=std::string::npos);
                 }
             catch(
             ... )
@@ -216,6 +220,10 @@ test_std_exception_what()
 #endif
             }
         catch(
+        T & )
+            {
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -385,6 +393,11 @@ main()
             BOOST_TEST(false);
             }
         catch(
+        derives_std_exception & )
+            {
+            //Yay! Non-intrusive cloning supported!
+            }
+        catch(
         boost::unknown_exception & e )
             {
 #ifndef BOOST_NO_RTTI
@@ -434,6 +447,14 @@ main()
             BOOST_TEST(false);
             }
         catch(
+        derives_std_boost_exception & x )
+            {
+            //Yay! Non-intrusive cloning supported!
+            BOOST_TEST(boost::get_error_info<my_info>(x));
+            if( int const * p=boost::get_error_info<my_info>(x) )
+                BOOST_TEST(*p==42);
+            }
+        catch(
         boost::unknown_exception & x )
             {
             BOOST_TEST(boost::get_error_info<my_info>(x));
@@ -495,6 +516,14 @@ main()
             BOOST_TEST(false);
             }
         catch(
+        derives_boost_exception & x )
+            {
+            //Yay! Non-intrusive cloning supported!
+            BOOST_TEST(boost::get_error_info<my_info>(x));
+            if( int const * p=boost::get_error_info<my_info>(x) )
+                BOOST_TEST(*p==42);
+            }
+        catch(
         boost::unknown_exception & x )
             {
             BOOST_TEST(boost::get_error_info<my_info>(x));

test/copy_exception_test.cpp

@@ -4,25 +4,128 @@
 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/exception_ptr.hpp>
+#include <boost/exception/get_error_info.hpp>
+#include <boost/thread.hpp>
+#include <boost/detail/atomic_count.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
+typedef boost::error_info<struct tag_answer,int> answer;
+
+boost::detail::atomic_count exc_count(0);
+
 struct
-test_exception:
-    std::exception
+err:
+    virtual boost::exception,
+    virtual std::exception
     {
+    err()
+        {
+        ++exc_count;
+        }
+
+    err( err const & )
+        {
+        ++exc_count;
+        }
+
+    virtual
+    ~err() throw()
+        {
+        --exc_count;
+        }
+
+    private:
+
+    err & operator=( err const & );
     };
 
-int
-main()
+class
+future
     {
-    boost::exception_ptr p = boost::copy_exception(test_exception());
+    public:
+
+    future ():
+        ready_ (false)
+        {
+        }
+
+    void
+    set_exception( boost::exception_ptr const & e )
+        {
+        boost::unique_lock<boost::mutex> lck (mux_);
+        exc_ = e;
+        ready_ = true;
+        cond_.notify_all();
+        }
+
+    void
+    get_exception() const
+        {
+        boost::unique_lock<boost::mutex> lck (mux_);
+        while (! ready_)
+            cond_.wait (lck);
+        rethrow_exception (exc_);
+        }
+
+    private:
+
+    bool ready_;
+    boost::exception_ptr exc_;
+    mutable boost::mutex mux_;
+    mutable boost::condition_variable cond_;
+    };
+
+void
+producer( future & f )
+    {
+    f.set_exception (boost::copy_exception (err () << answer(42)));
+    }
+
+void
+consumer()
+    {
+    future f;
+    boost::thread thr (boost::bind (&producer, boost::ref (f)));
+    try
+        {
+        f.get_exception ();
+        }
+    catch(
+    err & e )
+        {
+        int const * ans=boost::get_error_info<answer>(e);
+        BOOST_TEST(ans && *ans==42);
+        }
+    thr.join();
+    }
+
+void
+consume()
+    {
+    for( int i=0; i!=100; ++i )
+        consumer();
+    }
+
+void
+thread_test()
+    {
+    boost::thread_group grp;
+    for( int i=0; i!=50; ++i )
+        grp.create_thread(&consume);
+    grp.join_all ();
+    }
+
+void
+simple_test()
+    {
+    boost::exception_ptr p = boost::copy_exception(err());
     try
         {
         rethrow_exception(p);
         BOOST_TEST(false);
         }
     catch(
-    test_exception & )
+    err & )
         {
         }
     catch(
@@ -30,5 +133,14 @@ main()
         {
         BOOST_TEST(false);
         }
+    }
+
+int
+main()
+    {
+    BOOST_TEST(++exc_count==1);
+    simple_test();
+    thread_test();
+    BOOST_TEST(!--exc_count);
     return boost::report_errors();
     }

test/diagnostic_information_test.cpp

@@ -200,6 +200,17 @@ main()
         std::string di=current_exception_diagnostic_information();
         test3(di);
         }
+    try
+        {
+        throw error4();
+        }
+    catch(
+    error4 & x )
+        {
+        std::string di1=boost::diagnostic_information(x);
+        std::string wh1=x.what();
+        BOOST_TEST(wh1==di1);
+        }
     try
         {
         error4 x; x << tagged_int1(42) << tagged_int2(42);

test/errinfos_test.cpp

@@ -34,7 +34,7 @@ main()
         e <<
             errinfo_api_function("failed_api_function") <<
             errinfo_at_line(42) <<
-            errinfo_errno(errno) <<
+            errinfo_errno(0) <<
             errinfo_file_handle(weak_ptr<FILE>()) <<
             errinfo_file_name("filename.txt") <<
             errinfo_file_open_mode("rb");

test/error_info_test.cpp

@@ -5,6 +5,7 @@
 
 #include <boost/exception/get_error_info.hpp>
 #include <boost/exception/info_tuple.hpp>
+#include <boost/exception_ptr.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/detail/workaround.hpp>
 
@@ -302,7 +303,7 @@ test_add_tuple()
     }
 
 void
-test_lifetime()
+test_lifetime1()
     {
     int count=0;
     try
@@ -323,6 +324,19 @@ test_lifetime()
     BOOST_TEST(!count);
     }
 
+void
+test_lifetime2()
+    {
+    int count=0;
+        {
+        boost::exception_ptr ep;
+        test_exception e; e<<test_7(user_data(count));
+        ep=boost::copy_exception(e);
+        BOOST_TEST(count>0);
+        }
+    BOOST_TEST(!count);
+    }
+
 bool
 is_const( int const * )
     {
@@ -354,7 +368,8 @@ main()
     test_basic_throw_catch();
     test_catch_add_info();
     test_add_tuple();
-    test_lifetime();
+    test_lifetime1();
+    test_lifetime2();
     test_const();
     return boost::report_errors();
     }

test/exception_ptr_test.cpp

@@ -0,0 +1,142 @@
+//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+
+//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/exception_ptr.hpp>
+#include <boost/exception/info.hpp>
+#include <boost/exception/get_error_info.hpp>
+#include <boost/exception/diagnostic_information.hpp>
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+#include <boost/thread.hpp>
+#include <boost/detail/atomic_count.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <iostream>
+
+class thread_handle;
+boost::shared_ptr<thread_handle> create_thread( boost::function<void()> const & f );
+void join( thread_handle & t );
+
+class
+thread_handle
+    {
+    thread_handle( thread_handle const & );
+    thread_handle & operator=( thread_handle const & );
+
+    boost::exception_ptr err_;
+    boost::thread t_;
+
+    static
+    void
+    thread_wrapper( boost::function<void()> const & f, boost::exception_ptr & ep )
+        {
+        BOOST_ASSERT(!ep);
+        try
+            {
+            f();
+            }
+        catch(...)
+            {
+            ep = boost::current_exception();
+            }
+        }
+
+    explicit
+    thread_handle( boost::function<void()> const & f ):
+        t_(boost::bind(thread_wrapper,f,err_))
+        {
+        }
+
+    friend boost::shared_ptr<thread_handle> create_thread( boost::function<void()> const & f );
+    friend void join( thread_handle & t );
+    };
+
+boost::shared_ptr<thread_handle>
+create_thread( boost::function<void()> const & f )
+    {
+    boost::shared_ptr<thread_handle> t( new thread_handle(f) );
+    return t;
+    }
+
+void
+join( thread_handle & t )
+    {
+    t.t_.join();
+    if( t.err_ )
+        rethrow_exception(t.err_);
+    }
+
+boost::detail::atomic_count exc_count(0);
+
+struct
+exc:
+    virtual boost::exception,
+    virtual std::exception
+    {
+    exc()
+        {
+        ++exc_count;
+        }
+
+    exc( exc const & )
+        {
+        ++exc_count;
+        }
+
+    virtual
+    ~exc() throw()
+        {
+        --exc_count;
+        }
+
+    private:
+
+    exc & operator=( exc const & );
+    };
+
+typedef boost::error_info<struct answer_,int> answer;
+
+void
+thread_func()
+    {
+    BOOST_THROW_EXCEPTION(exc() << answer(42));
+    }
+
+void
+check( boost::shared_ptr<thread_handle> const & t )
+    {
+    try
+        {
+        join(*t);
+        }
+    catch(
+    exc & e )
+        {
+        int const * a = boost::get_error_info<answer>(e);
+        BOOST_TEST(a && *a==42);
+        }
+    }
+
+int
+main()
+    {
+    BOOST_TEST(++exc_count==1);
+    try
+        {
+        std::vector< boost::shared_ptr<thread_handle> > threads;
+        std::generate_n(std::inserter(threads,threads.end()),256,boost::bind(create_thread,thread_func));
+        std::for_each(threads.begin(),threads.end(),check);
+        return boost::report_errors();
+        }
+    catch(
+    ... )
+        {
+        std::cerr <<
+            "Caught unexpected exception.\n"
+            "Output from current_exception_diagnostic_information:\n" <<
+            boost::current_exception_diagnostic_information() << std::endl;
+        return 42;
+        }
+    BOOST_TEST(!--exc_count);
+    }

test/is_output_streamable_test.cpp

@@ -4,7 +4,6 @@
 //file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/exception/detail/is_output_streamable.hpp>
-#include <boost/detail/lightweight_test.hpp>
 
 namespace
 n1
@@ -31,11 +30,20 @@ n2
         }           
     }
 
+template <bool Test>
+struct test;
+
+template <>
+struct
+test<true>
+    {
+    };
+
 int
 main()
     {
-    BOOST_TEST( !boost::is_output_streamable<n1::c1>::value );
-    BOOST_TEST( boost::is_output_streamable<n2::c2>::value );
-    BOOST_TEST( boost::is_output_streamable<int>::value );
-    return boost::report_errors();
+    test<!boost::is_output_streamable<n1::c1>::value>();
+    test<boost::is_output_streamable<n2::c2>::value>();
+    test<boost::is_output_streamable<int>::value>();
+    return 0;
     }

test/no_exceptions_test.cpp

@@ -9,6 +9,7 @@
 #include <boost/exception/info.hpp>
 #include <boost/exception/diagnostic_information.hpp>
 #include <boost/detail/lightweight_test.hpp>
+#include <stdlib.h>
 
 struct
 my_exception:
@@ -38,6 +39,7 @@ boost
 #ifndef BOOST_NO_RTTI
         BOOST_TEST(s.find("my_tag")!=std::string::npos);
 #endif
+        exit(0);
         }
     }
 

test/refcount_ptr_test.cpp

@@ -28,11 +28,16 @@ test_type
         ++count_;
         }
 
-    void
+    bool
     release()
         {
-        if( !--count_ )
+        if( --count_ )
+            return false;
+        else
+            {
             delete this;
+            return true;
+            }
         }
 
     private:

test/unknown_exception_test.cpp

@@ -62,6 +62,15 @@ main()
                 BOOST_TEST(false);
             }
         catch(
+        boost::exception & x )
+            {
+            //Yay! Non-intrusive cloning supported!
+            if( int const * d=boost::get_error_info<test>(x) )
+                BOOST_TEST( 42==*d );
+            else
+                BOOST_TEST(false);
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -101,6 +110,11 @@ main()
             {
             }
         catch(
+        std::exception & )
+            {
+            //Yay! Non-intrusive cloning supported!
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -114,6 +128,11 @@ main()
             {
             }
         catch(
+        std::exception & )
+            {
+            //Yay! Non-intrusive cloning supported!
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);