Release 1.37.0

[SVN r49549]

include/boost/detail/atomic_count.hpp

@@ -90,23 +90,18 @@ typedef long atomic_count;
 }
 
 #elif defined(BOOST_AC_USE_PTHREADS)
-
 #  include <boost/detail/atomic_count_pthreads.hpp>
 
 #elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-
 # include <boost/detail/atomic_count_gcc_x86.hpp>
 
 #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-
 #  include <boost/detail/atomic_count_win32.hpp>
 
-#elif defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+#elif defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) && !defined( __arm__ ) && !defined( __hppa ) && ( !defined( __INTEL_COMPILER ) || defined( __ia64__ ) )
-
 #  include <boost/detail/atomic_count_sync.hpp>
 
 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-
 #  include <boost/detail/atomic_count_gcc.hpp>
 
 #elif defined(BOOST_HAS_PTHREADS)

include/boost/detail/atomic_count_sync.hpp

@@ -15,6 +15,10 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#if defined( __ia64__ ) && defined( __INTEL_COMPILER )
+# include <ia64intrin.h>
+#endif
+
 namespace boost
 {
 

include/boost/detail/lwm_win32_cs.hpp

@@ -29,7 +29,7 @@ namespace detail
 
 #ifndef BOOST_USE_WINDOWS_H
 
-struct CRITICAL_SECTION
+struct critical_section
 {
     struct critical_section_debug * DebugInfo;
     long LockCount;
@@ -43,10 +43,14 @@ struct CRITICAL_SECTION
 #endif
 };
 
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
+
+#else
+
+typedef ::CRITICAL_SECTION critical_section;
 
 #endif // #ifndef BOOST_USE_WINDOWS_H
 
@@ -54,7 +58,7 @@ class lightweight_mutex
 {
 private:
 
-    CRITICAL_SECTION cs_;
+    critical_section cs_;
 
     lightweight_mutex(lightweight_mutex const &);
     lightweight_mutex & operator=(lightweight_mutex const &);

include/boost/detail/shared_count.hpp

@@ -28,8 +28,11 @@
 #include <boost/detail/bad_weak_ptr.hpp>
 #include <boost/detail/sp_counted_base.hpp>
 #include <boost/detail/sp_counted_impl.hpp>
-
+// In order to avoid circular dependencies with Boost.TR1
-#include <memory>           // std::auto_ptr
+// we make sure that our include of <memory> doesn't try to
+// pull in the TR1 headers: that's why we use this header 
+// rather than including <memory> directly:
+#include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
 #include <functional>       // std::less
 #include <new>              // std::bad_alloc
 
@@ -46,6 +49,8 @@ int const   weak_count_id = 0x298C38A4;
 
 #endif
 
+struct sp_nothrow_tag {};
+
 class weak_count;
 
 class shared_count
@@ -99,11 +104,18 @@ public:
 #endif
     }
 
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
+    template<class Y, class D> shared_count( Y * p, D d ): pi_(0)
+#else
     template<class P, class D> shared_count( P p, D d ): pi_(0)
+#endif
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
     {
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
+        typedef Y* P;
+#endif
 #ifndef BOOST_NO_EXCEPTIONS
 
         try
@@ -216,6 +228,7 @@ public:
     }
 
     explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
+    shared_count( weak_count const & r, sp_nothrow_tag ); // constructs an empty *this when r.use_count() == 0
 
     shared_count & operator= (shared_count const & r) // nothrow
     {
@@ -248,6 +261,11 @@ public:
         return use_count() == 1;
     }
 
+    bool empty() const // nothrow
+    {
+        return pi_ == 0;
+    }
+
     friend inline bool operator==(shared_count const & a, shared_count const & b)
     {
         return a.pi_ == b.pi_;
@@ -313,9 +331,13 @@ public:
     weak_count & operator= (shared_count const & r) // nothrow
     {
         sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
             if(tmp != 0) tmp->weak_add_ref();
             if(pi_ != 0) pi_->weak_release();
             pi_ = tmp;
+        }
 
         return *this;
     }
@@ -323,9 +345,13 @@ public:
     weak_count & operator= (weak_count const & r) // nothrow
     {
         sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
             if(tmp != 0) tmp->weak_add_ref();
             if(pi_ != 0) pi_->weak_release();
             pi_ = tmp;
+        }
 
         return *this;
     }
@@ -364,6 +390,17 @@ inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
     }
 }
 
+inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+{
+    if( pi_ != 0 && !pi_->add_ref_lock() )
+    {
+        pi_ = 0;
+    }
+}
+
 } // namespace detail
 
 } // namespace boost

include/boost/detail/sp_convertible.hpp

@@ -0,0 +1,76 @@
+#ifndef BOOST_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
+#define BOOST_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/sp_convertible.hpp
+//
+//  Copyright 2008 Peter Dimov
+//
+//  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/config.hpp>
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( BOOST_NO_SFINAE )
+# define BOOST_SP_NO_SP_CONVERTIBLE
+#endif
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ < 303 )
+# define BOOST_SP_NO_SP_CONVERTIBLE
+#endif
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && defined( __BORLANDC__ ) && ( __BORLANDC__ <= 0x610 )
+# define BOOST_SP_NO_SP_CONVERTIBLE
+#endif
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< class Y, class T > struct sp_convertible
+{
+    typedef char (&yes) [1];
+    typedef char (&no)  [2];
+
+    static yes f( T* );
+    static no  f( ... );
+
+    enum _vt { value = sizeof( f( (Y*)0 ) ) == sizeof(yes) };
+};
+
+struct sp_empty
+{
+};
+
+template< bool > struct sp_enable_if_convertible_impl;
+
+template<> struct sp_enable_if_convertible_impl<true>
+{
+    typedef sp_empty type;
+};
+
+template<> struct sp_enable_if_convertible_impl<false>
+{
+};
+
+template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
+{
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif // !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+#endif  // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED

include/boost/detail/sp_counted_base.hpp

@@ -20,61 +20,46 @@
 #include <boost/config.hpp>
 
 #if defined( BOOST_SP_DISABLE_THREADS )
-
 # include <boost/detail/sp_counted_base_nt.hpp>
 
-#elif defined( BOOST_SP_USE_PTHREADS )
+#elif defined( BOOST_SP_USE_SPINLOCK )
+# include <boost/detail/sp_counted_base_spin.hpp>
 
+#elif defined( BOOST_SP_USE_PTHREADS )
 # include <boost/detail/sp_counted_base_pt.hpp>
 
-#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
+#elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
+# include <boost/detail/sp_counted_base_nt.hpp>
 
+#elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
 # include <boost/detail/sp_counted_base_gcc_x86.hpp>
 
-//~ #elif defined( __MWERKS__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
-
-//~ # include <boost/detail/sp_counted_base_cw_x86.hpp>
-
 #elif defined( __GNUC__ ) && defined( __ia64__ ) && !defined( __INTEL_COMPILER )
-
 # include <boost/detail/sp_counted_base_gcc_ia64.hpp>
 
 #elif defined(__HP_aCC) && defined(__ia64)
-
 # include <boost/detail/sp_counted_base_acc_ia64.hpp>
 
 #elif defined( __MWERKS__ ) && defined( __POWERPC__ )
-
 # include <boost/detail/sp_counted_base_cw_ppc.hpp>
 
 #elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc ) )
-
 # include <boost/detail/sp_counted_base_gcc_ppc.hpp>
 
-#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) && !defined( __arm__ ) && !defined( __hppa ) && ( !defined( __INTEL_COMPILER ) || defined( __ia64__ ) )
-
 # include <boost/detail/sp_counted_base_sync.hpp>
 
-#elif defined(__GNUC__) && ( defined( __sparcv8 ) || defined( __sparcv9 ) )
+#elif defined(__GNUC__) && ( defined( __sparcv9 ) || ( defined( __sparcv8 ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 402 ) ) )
-
 # include <boost/detail/sp_counted_base_gcc_sparc.hpp>
 
 #elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
-
 # include <boost/detail/sp_counted_base_w32.hpp>
 
 #elif !defined( BOOST_HAS_THREADS )
-
 # include <boost/detail/sp_counted_base_nt.hpp>
 
-#elif defined( BOOST_HAS_PTHREADS )
-
-# include <boost/detail/sp_counted_base_pt.hpp>
-
 #else
-
+# include <boost/detail/sp_counted_base_spin.hpp>
-// Use #define BOOST_DISABLE_THREADS to avoid the error
-# error Unrecognized threading platform
 
 #endif
 

include/boost/detail/sp_counted_base_acc_ia64.hpp

@@ -15,7 +15,7 @@
 //  Lock-free algorithm by Alexander Terekhov
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 #include <machine/sys/inline.h>
 
 namespace boost

include/boost/detail/sp_counted_base_cw_ppc.hpp

@@ -24,7 +24,7 @@
 //  formulation
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 
 namespace boost
 {

include/boost/detail/sp_counted_base_cw_x86.hpp

@@ -25,7 +25,7 @@
 //  formulation
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 
 namespace boost
 {

include/boost/detail/sp_counted_base_gcc_ia64.hpp

@@ -16,7 +16,7 @@
 //  Lock-free algorithm by Alexander Terekhov
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 
 namespace boost
 {

include/boost/detail/sp_counted_base_gcc_ppc.hpp

@@ -24,7 +24,7 @@
 //  formulation
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 
 namespace boost
 {

include/boost/detail/sp_counted_base_gcc_sparc.hpp

@@ -19,7 +19,7 @@
 //
 //  Thanks to Michael van der Westhuizen
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 #include <inttypes.h> // int32_t
 
 namespace boost

include/boost/detail/sp_counted_base_gcc_x86.hpp

@@ -24,7 +24,7 @@
 //  formulation
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 
 namespace boost
 {

include/boost/detail/sp_counted_base_nt.hpp

@@ -18,7 +18,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 
 namespace boost
 {

include/boost/detail/sp_counted_base_pt.hpp

@@ -18,7 +18,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 #include <pthread.h>
 
 namespace boost

include/boost/detail/sp_counted_base_solaris.hpp

@@ -20,7 +20,7 @@
 //  formulation
 //
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 #include <atomic.h>
 
 namespace boost

include/boost/detail/sp_counted_base_spin.hpp

@@ -0,0 +1,131 @@
+#ifndef BOOST_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED
+#define BOOST_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  detail/sp_counted_base_spin.hpp - spinlock pool atomic emulation
+//
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//  Copyright 2004-2008 Peter Dimov
+//
+//  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/detail/sp_typeinfo.hpp>
+#include <boost/detail/spinlock_pool.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline int atomic_exchange_and_add( int * pw, int dv )
+{
+    spinlock_pool<1>::scoped_lock lock( pw );
+
+    int r = *pw;
+    *pw += dv;
+    return r;
+}
+
+inline void atomic_increment( int * pw )
+{
+    spinlock_pool<1>::scoped_lock lock( pw );
+    ++*pw;
+}
+
+inline int atomic_conditional_increment( int * pw )
+{
+    spinlock_pool<1>::scoped_lock lock( pw );
+
+    int rv = *pw;
+    if( rv != 0 ) ++*pw;
+    return rv;
+}
+
+class sp_counted_base
+{
+private:
+
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+
+    int use_count_;        // #shared
+    int weak_count_;       // #weak + (#shared != 0)
+
+public:
+
+    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    {
+    }
+
+    virtual ~sp_counted_base() // nothrow
+    {
+    }
+
+    // dispose() is called when use_count_ drops to zero, to release
+    // the resources managed by *this.
+
+    virtual void dispose() = 0; // nothrow
+
+    // destroy() is called when weak_count_ drops to zero.
+
+    virtual void destroy() // nothrow
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+
+    void add_ref_copy()
+    {
+        atomic_increment( &use_count_ );
+    }
+
+    bool add_ref_lock() // true on success
+    {
+        return atomic_conditional_increment( &use_count_ ) != 0;
+    }
+
+    void release() // nothrow
+    {
+        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
+        {
+            dispose();
+            weak_release();
+        }
+    }
+
+    void weak_add_ref() // nothrow
+    {
+        atomic_increment( &weak_count_ );
+    }
+
+    void weak_release() // nothrow
+    {
+        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
+        {
+            destroy();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+        spinlock_pool<1>::scoped_lock lock( &use_count_ );
+        return use_count_;
+    }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_SPIN_HPP_INCLUDED

include/boost/detail/sp_counted_base_sync.hpp

@@ -15,9 +15,13 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 #include <limits.h>
 
+#if defined( __ia64__ ) && defined( __INTEL_COMPILER )
+# include <ia64intrin.h>
+#endif
+
 namespace boost
 {
 

include/boost/detail/sp_counted_base_w32.hpp

@@ -26,7 +26,7 @@
 
 #include <boost/detail/interlocked.hpp>
 #include <boost/detail/workaround.hpp>
-#include "sp_typeinfo.hpp"
+#include <boost/detail/sp_typeinfo.hpp>
 
 namespace boost
 {

include/boost/detail/spinlock.hpp

@@ -0,0 +1,47 @@
+#ifndef BOOST_DETAIL_SPINLOCK_HPP_INCLUDED
+#define BOOST_DETAIL_SPINLOCK_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/spinlock.hpp
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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)
+//
+//  struct spinlock
+//  {
+//      void lock();
+//      bool try_lock();
+//      void unlock();
+//
+//      class scoped_lock;
+//  };
+//
+//  #define BOOST_DETAIL_SPINLOCK_INIT <unspecified>
+//
+
+#include <boost/config.hpp>
+
+#if defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
+#  include <boost/detail/spinlock_gcc_arm.hpp>
+#elif defined(__GNUC__) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 ) && !defined( __arm__ ) && !defined( __hppa ) && ( !defined( __INTEL_COMPILER ) || defined( __ia64__ ) )
+#  include <boost/detail/spinlock_sync.hpp>
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#  include <boost/detail/spinlock_w32.hpp>
+#elif defined(BOOST_HAS_PTHREADS)
+#  include <boost/detail/spinlock_pt.hpp>
+#elif !defined(BOOST_HAS_THREADS)
+#  include <boost/detail/spinlock_nt.hpp>
+#else
+#  error Unrecognized threading platform
+#endif
+
+#endif // #ifndef BOOST_DETAIL_SPINLOCK_HPP_INCLUDED

include/boost/detail/spinlock_gcc_arm.hpp

@@ -0,0 +1,85 @@
+#ifndef BOOST_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
+#define BOOST_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED
+
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/detail/yield_k.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+    int v_;
+
+public:
+
+    bool try_lock()
+    {
+        int r;
+
+        __asm__ __volatile__(
+            "swp %0, %1, [%2]":
+            "=&r"( r ): // outputs
+            "r"( 1 ), "r"( &v_ ): // inputs
+            "memory", "cc" );
+
+        return r == 0;
+    }
+
+    void lock()
+    {
+        for( unsigned k = 0; !try_lock(); ++k )
+        {
+            boost::detail::yield( k );
+        }
+    }
+
+    void unlock()
+    {
+        __asm__ __volatile__( "" ::: "memory" );
+        *const_cast< int volatile* >( &v_ ) = 0;
+    }
+
+public:
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        {
+            sp.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+} // namespace detail
+} // namespace boost
+
+#define BOOST_DETAIL_SPINLOCK_INIT {0}
+
+#endif // #ifndef BOOST_DETAIL_SPINLOCK_GCC_ARM_HPP_INCLUDED

include/boost/detail/spinlock_nt.hpp

@@ -0,0 +1,89 @@
+#ifndef BOOST_DETAIL_SPINLOCK_NT_HPP_INCLUDED
+#define BOOST_DETAIL_SPINLOCK_NT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/assert.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+    bool locked_;
+
+public:
+
+    inline bool try_lock()
+    {
+        if( locked_ )
+        {
+            return false;
+        }
+        else
+        {
+            locked_ = true;
+            return true;
+        }
+    }
+
+    inline void lock()
+    {
+        BOOST_ASSERT( !locked_ );
+        locked_ = true;
+    }
+
+    inline void unlock()
+    {
+        BOOST_ASSERT( locked_ );
+        locked_ = false;
+    }
+
+public:
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        {
+            sp.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+} // namespace detail
+} // namespace boost
+
+#define BOOST_DETAIL_SPINLOCK_INIT { false }
+
+#endif // #ifndef BOOST_DETAIL_SPINLOCK_NT_HPP_INCLUDED

include/boost/detail/spinlock_pool.hpp

@@ -0,0 +1,87 @@
+#ifndef BOOST_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
+#define BOOST_DETAIL_SPINLOCK_POOL_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/spinlock_pool.hpp
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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)
+//
+//  spinlock_pool<0> is reserved for atomic<>, when/if it arrives
+//  spinlock_pool<1> is reserved for shared_ptr reference counts
+//  spinlock_pool<2> is reserved for shared_ptr atomic access
+//
+
+#include <boost/config.hpp>
+#include <boost/detail/spinlock.hpp>
+#include <cstddef>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< int I > class spinlock_pool
+{
+private:
+
+    static spinlock pool_[ 41 ];
+
+public:
+
+    static spinlock & spinlock_for( void const * pv )
+    {
+        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
+        return pool_[ i ];
+    }
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
+        {
+            sp_.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
+{
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, BOOST_DETAIL_SPINLOCK_INIT, 
+    BOOST_DETAIL_SPINLOCK_INIT
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_SPINLOCK_POOL_HPP_INCLUDED

include/boost/detail/spinlock_pt.hpp

@@ -0,0 +1,79 @@
+#ifndef BOOST_DETAIL_SPINLOCK_PT_HPP_INCLUDED
+#define BOOST_DETAIL_SPINLOCK_PT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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 <pthread.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+    pthread_mutex_t v_;
+
+public:
+
+    bool try_lock()
+    {
+        return pthread_mutex_trylock( &v_ ) == 0;
+    }
+
+    void lock()
+    {
+        pthread_mutex_lock( &v_ );
+    }
+
+    void unlock()
+    {
+        pthread_mutex_unlock( &v_ );
+    }
+
+public:
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        {
+            sp.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+} // namespace detail
+} // namespace boost
+
+#define BOOST_DETAIL_SPINLOCK_INIT { PTHREAD_MUTEX_INITIALIZER }
+
+#endif // #ifndef BOOST_DETAIL_SPINLOCK_PT_HPP_INCLUDED

include/boost/detail/spinlock_sync.hpp

@@ -0,0 +1,87 @@
+#ifndef BOOST_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
+#define BOOST_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/detail/yield_k.hpp>
+
+#if defined( __ia64__ ) && defined( __INTEL_COMPILER )
+# include <ia64intrin.h>
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+    int v_;
+
+public:
+
+    bool try_lock()
+    {
+        int r = __sync_lock_test_and_set( &v_, 1 );
+        return r == 0;
+    }
+
+    void lock()
+    {
+        for( unsigned k = 0; !try_lock(); ++k )
+        {
+            boost::detail::yield( k );
+        }
+    }
+
+    void unlock()
+    {
+        __sync_lock_release( &v_ );
+    }
+
+public:
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        {
+            sp.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+} // namespace detail
+} // namespace boost
+
+#define BOOST_DETAIL_SPINLOCK_INIT {0}
+
+#endif // #ifndef BOOST_DETAIL_SPINLOCK_SYNC_HPP_INCLUDED

include/boost/detail/spinlock_w32.hpp

@@ -0,0 +1,113 @@
+#ifndef BOOST_DETAIL_SPINLOCK_W32_HPP_INCLUDED
+#define BOOST_DETAIL_SPINLOCK_W32_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/detail/interlocked.hpp>
+#include <boost/detail/yield_k.hpp>
+
+// BOOST_COMPILER_FENCE
+
+#if defined(__INTEL_COMPILER)
+
+#define BOOST_COMPILER_FENCE __memory_barrier();
+
+#elif defined( _MSC_VER ) && _MSC_VER >= 1310
+
+extern "C" void _ReadWriteBarrier();
+#pragma intrinsic( _ReadWriteBarrier )
+
+#define BOOST_COMPILER_FENCE _ReadWriteBarrier();
+
+#elif defined(__GNUC__)
+
+#define BOOST_COMPILER_FENCE __asm__ __volatile__( "" : : : "memory" );
+
+#else
+
+#define BOOST_COMPILER_FENCE
+
+#endif
+
+//
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+    long v_;
+
+public:
+
+    bool try_lock()
+    {
+        long r = BOOST_INTERLOCKED_EXCHANGE( &v_, 1 );
+
+        BOOST_COMPILER_FENCE
+
+        return r == 0;
+    }
+
+    void lock()
+    {
+        for( unsigned k = 0; !try_lock(); ++k )
+        {
+            boost::detail::yield( k );
+        }
+    }
+
+    void unlock()
+    {
+        BOOST_COMPILER_FENCE
+        *const_cast< long volatile* >( &v_ ) = 0;
+    }
+
+public:
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        {
+            sp.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+} // namespace detail
+} // namespace boost
+
+#define BOOST_DETAIL_SPINLOCK_INIT {0}
+
+#endif // #ifndef BOOST_DETAIL_SPINLOCK_W32_HPP_INCLUDED

include/boost/detail/yield_k.hpp

@@ -0,0 +1,149 @@
+#ifndef BOOST_DETAIL_YIELD_K_HPP_INCLUDED
+#define BOOST_DETAIL_YIELD_K_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/detail/yield_k.hpp
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  void yield( unsigned k );
+//
+//  Typical use:
+//
+//  for( unsigned k = 0; !try_lock(); ++k ) yield( k );
+//
+//  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/config.hpp>
+
+// BOOST_SMT_PAUSE
+
+#if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) )
+
+extern "C" void _mm_pause();
+#pragma intrinsic( _mm_pause )
+
+#define BOOST_SMT_PAUSE _mm_pause();
+
+#elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
+
+#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
+
+#endif
+
+//
+
+#if defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+#if !defined( BOOST_USE_WINDOWS_H )
+  extern "C" void __stdcall Sleep( unsigned ms );
+#endif
+
+inline void yield( unsigned k )
+{
+    if( k < 4 )
+    {
+    }
+#if defined( BOOST_SMT_PAUSE )
+    else if( k < 16 )
+    {
+        BOOST_SMT_PAUSE
+    }
+#endif
+    else if( k < 32 )
+    {
+        Sleep( 0 );
+    }
+    else
+    {
+        Sleep( 1 );
+    }
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#elif defined( BOOST_HAS_PTHREADS )
+
+#include <sched.h>
+#include <time.h>
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void yield( unsigned k )
+{
+    if( k < 4 )
+    {
+    }
+#if defined( BOOST_SMT_PAUSE )
+    else if( k < 16 )
+    {
+        BOOST_SMT_PAUSE
+    }
+#endif
+    else if( k < 32 || k & 1 )
+    {
+        sched_yield();
+    }
+    else
+    {
+        // g++ -Wextra warns on {} or {0}
+        struct timespec rqtp = { 0, 0 };
+
+        // POSIX says that timespec has tv_sec and tv_nsec
+        // But it doesn't guarantee order or placement
+
+        rqtp.tv_sec = 0;
+        rqtp.tv_nsec = 1000;
+
+        nanosleep( &rqtp, 0 );
+    }
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#else
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void yield( unsigned )
+{
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#endif
+
+#endif // #ifndef BOOST_DETAIL_YIELD_K_HPP_INCLUDED

include/boost/intrusive_ptr.hpp

@@ -22,9 +22,17 @@
 
 #include <boost/assert.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/detail/sp_convertible.hpp>
 
-#include <functional>           // for std::less
+#include <boost/config/no_tr1/functional.hpp>           // for std::less
+
+#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_NO_IOSFWD)
 #include <iosfwd>               // for std::basic_ostream
+#else
+#include <ostream>
+#endif
+#endif
 
 
 namespace boost
@@ -66,7 +74,17 @@ public:
 
 #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
 
-    template<class U> intrusive_ptr(intrusive_ptr<U> const & rhs): p_(rhs.get())
+    template<class U>
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+    intrusive_ptr( intrusive_ptr<U> const & rhs, typename detail::sp_enable_if_convertible<U,T>::type = detail::sp_empty() )
+
+#else
+
+    intrusive_ptr( intrusive_ptr<U> const & rhs )
+
+#endif
+    : p_( rhs.get() )
     {
         if( p_ != 0 ) intrusive_ptr_add_ref( p_ );
     }
@@ -105,6 +123,11 @@ public:
         return *this;
     }
 
+    void reset()
+    {
+        this_type().swap( *this );
+    }
+
     void reset( T * rhs )
     {
         this_type( rhs ).swap( *this );
@@ -246,7 +269,9 @@ template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U
 
 // operator<<
 
-#if defined(__GNUC__) &&  (__GNUC__ < 3)
+#if !defined(BOOST_NO_IOSTREAM)
+
+#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) &&  (__GNUC__ < 3) )
 
 template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
 {
@@ -275,6 +300,8 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 #endif // __GNUC__ < 3
 
+#endif // !defined(BOOST_NO_IOSTREAM)
+
 } // namespace boost
 
 #ifdef BOOST_MSVC

include/boost/make_shared.hpp

@@ -0,0 +1,433 @@
+#ifndef BOOST_MAKE_SHARED_HPP_INCLUDED
+#define BOOST_MAKE_SHARED_HPP_INCLUDED
+
+//  make_shared.hpp
+//
+//  Copyright (c) 2007, 2008 Peter Dimov
+//
+//  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/libs/smart_ptr/make_shared.html
+//  for documentation.
+
+#include <boost/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <cstddef>
+#include <new>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< std::size_t N, std::size_t A > struct sp_aligned_storage
+{
+    union type
+    {
+        char data_[ N ];
+        typename boost::type_with_alignment< A >::type align_;
+    };
+};
+
+template< class T > class sp_ms_deleter
+{
+private:
+
+    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+    bool initialized_;
+    storage_type storage_;
+
+private:
+
+    void destroy()
+    {
+        if( initialized_ )
+        {
+            reinterpret_cast< T* >( storage_.data_ )->~T();
+            initialized_ = false;
+        }
+    }
+
+public:
+
+    sp_ms_deleter(): initialized_( false )
+    {
+    }
+
+    ~sp_ms_deleter()
+    {
+        destroy();
+    }
+
+    void operator()( T * )
+    {
+        destroy();
+    }
+
+    void * address()
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized()
+    {
+        initialized_ = true;
+    }
+};
+
+template< class T > T forward( T t )
+{
+    return t;
+}
+
+} // namespace detail
+
+// Zero-argument versions
+//
+// Used even when variadic templates are available because of the new T() vs new T issue
+
+template< class T > boost::shared_ptr< T > make_shared()
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T();
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T();
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+#if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
+
+// Variadic templates, rvalue reference
+
+template< class T, class... Args > boost::shared_ptr< T > make_shared( Args && ... args )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( detail::forward<Args>( args )... );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Args && ... args )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( detail::forward<Args>( args )... );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+#else
+
+// C++03 version
+
+template< class T, class A1 >
+boost::shared_ptr< T > make_shared( A1 const & a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2, class A3 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2, class A3 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2, class A3, class A4 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >() );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::sp_ms_deleter< T >(), a );
+
+    detail::sp_ms_deleter< T > * pd = boost::get_deleter< detail::sp_ms_deleter< T > >( pt );
+
+    void * pv = pd->address();
+
+    new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+    pd->set_initialized();
+
+    return boost::shared_ptr< T >( pt, static_cast< T* >( pv ) );
+}
+
+#endif
+
+} // namespace boost
+
+#endif // #ifndef BOOST_MAKE_SHARED_HPP_INCLUDED

include/boost/memory_order.hpp

@@ -0,0 +1,35 @@
+#ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED
+#define BOOST_MEMORY_ORDER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  boost/memory_order.hpp
+//
+//  Defines enum boost::memory_order per the C++0x working draft
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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)
+
+
+namespace boost
+{
+
+enum memory_order
+{
+    memory_order_relaxed = 0,
+    memory_order_acquire = 1,
+    memory_order_release = 2,
+    memory_order_acq_rel = 3, // acquire | release
+    memory_order_seq_cst = 7  // acq_rel | 4
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED

include/boost/pointer_cast.hpp

@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gazta<EFBFBD>aga 2005. 
+// (C) Copyright Ion Gaztanaga 2005. 
 // 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/pointer_to_other.hpp

@@ -4,7 +4,7 @@
 //
 //  pointer_to_other.hpp
 //
-//  (C) Copyright Ion Gazta<EFBFBD>aga 2005.
+//  (C) Copyright Ion Gaztanaga 2005.
 //  Copyright (c) 2005 Peter Dimov.
 //
 //  Distributed under the Boost Software License, Version 1.0.

include/boost/scoped_array.hpp

@@ -46,6 +46,9 @@ private:
 
     typedef scoped_array<T> this_type;
 
+    void operator==( scoped_array const& ) const;
+    void operator!=( scoped_array const& ) const;
+
 public:
 
     typedef T element_type;

include/boost/scoped_ptr.hpp

@@ -47,6 +47,9 @@ private:
 
     typedef scoped_ptr<T> this_type;
 
+    void operator==( scoped_ptr const& ) const;
+    void operator!=( scoped_ptr const& ) const;
+
 public:
 
     typedef T element_type;

include/boost/shared_ptr.hpp

@@ -5,7 +5,7 @@
 //  shared_ptr.hpp
 //
 //  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
-//  Copyright (c) 2001-2007 Peter Dimov
+//  Copyright (c) 2001-2008 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -20,18 +20,35 @@
 #include <boost/detail/shared_ptr_nmt.hpp>
 #else
 
-#include <memory>               // for std::auto_ptr
+// In order to avoid circular dependencies with Boost.TR1
+// we make sure that our include of <memory> doesn't try to
+// pull in the TR1 headers: that's why we use this header 
+// rather than including <memory> directly:
+#include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
 
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/detail/shared_count.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/detail/sp_convertible.hpp>
+
+#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
+#include <boost/detail/spinlock_pool.hpp>
+#include <boost/memory_order.hpp>
+#endif
 
 #include <algorithm>            // for std::swap
 #include <functional>           // for std::less
 #include <typeinfo>             // for std::bad_cast
+
+#if !defined(BOOST_NO_IOSTREAM)
+#if !defined(BOOST_NO_IOSFWD)
 #include <iosfwd>               // for std::basic_ostream
+#else
+#include <ostream>
+#endif
+#endif
 
 #ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
 # pragma warning(push)
@@ -208,7 +225,25 @@ public:
     }
 
     template<class Y>
-    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() ) // never throws
+    {
+        if( !pn.empty() )
+        {
+            px = r.px;
+        }
+    }
+
+    template<class Y>
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+    shared_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
+
+#else
+
+    shared_ptr( shared_ptr<Y> const & r )
+
+#endif
+    : px( r.px ), pn( r.pn ) // never throws
     {
     }
 
@@ -317,7 +352,16 @@ public:
     }
 
     template<class Y>
-    shared_ptr( shared_ptr<Y> && r ): px( r.px ), pn() // never throws
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+    shared_ptr( shared_ptr<Y> && r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
+
+#else
+
+    shared_ptr( shared_ptr<Y> && r )
+
+#endif
+    : px( r.px ), pn() // never throws
     {
         pn.swap( r.pn );
         r.px = 0;
@@ -459,6 +503,11 @@ public:
         return pn.get_deleter( ti );
     }
 
+    bool _internal_equiv( shared_ptr const & r ) const
+    {
+        return px == r.px && pn == r.pn;
+    }
+
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 
@@ -555,7 +604,9 @@ template<class T> inline T * get_pointer(shared_ptr<T> const & p)
 
 // operator<<
 
-#if defined(__GNUC__) &&  (__GNUC__ < 3)
+#if !defined(BOOST_NO_IOSTREAM)
+
+#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) &&  (__GNUC__ < 3) )
 
 template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
 {
@@ -584,6 +635,8 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 #endif // __GNUC__ < 3
 
+#endif // !defined(BOOST_NO_IOSTREAM)
+
 // get_deleter
 
 #if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
@@ -608,6 +661,85 @@ template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
 
 #endif
 
+// atomic access
+
+#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
+
+template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ )
+{
+    return false;
+}
+
+template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    return *p;
+}
+
+template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order /*mo*/ )
+{
+    return atomic_load( p );
+}
+
+template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    p->swap( r );
+}
+
+template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
+{
+    atomic_store( p, r ); // std::move( r )
+}
+
+template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+
+    sp.lock();
+    p->swap( r );
+    sp.unlock();
+
+    return r; // return std::move( r )
+}
+
+template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
+{
+    return atomic_exchange( p, r ); // std::move( r )
+}
+
+template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+
+    sp.lock();
+
+    if( p->_internal_equiv( *v ) )
+    {
+        p->swap( w );
+
+        sp.unlock();
+
+        return true;
+    }
+    else
+    {
+        shared_ptr<T> tmp( *p );
+
+        sp.unlock();
+
+        tmp.swap( *v );
+        return false;
+    }
+}
+
+template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order /*success*/, memory_order /*failure*/ )
+{
+    return atomic_compare_exchange( p, v, w ); // std::move( w )
+}
+
+#endif
+
 } // namespace boost
 
 #ifdef BOOST_MSVC

include/boost/weak_ptr.hpp

@@ -61,13 +61,31 @@ public:
 //
 
     template<class Y>
-    weak_ptr(weak_ptr<Y> const & r): pn(r.pn) // never throws
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+    weak_ptr( weak_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
+
+#else
+
+    weak_ptr( weak_ptr<Y> const & r )
+
+#endif
+    : pn(r.pn) // never throws
     {
         px = r.lock().get();
     }
 
     template<class Y>
-    weak_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
+
+    weak_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
+
+#else
+
+    weak_ptr( shared_ptr<Y> const & r )
+
+#endif
+    : px( r.px ), pn( r.pn ) // never throws
     {
     }
 
@@ -93,31 +111,7 @@ public:
 
     shared_ptr<T> lock() const // never throws
     {
-#if defined(BOOST_HAS_THREADS)
+        return shared_ptr<element_type>( *this, boost::detail::sp_nothrow_tag() );
-
-        // optimization: avoid throw overhead
-        if(expired())
-        {
-            return shared_ptr<element_type>();
-        }
-
-        try
-        {
-            return shared_ptr<element_type>(*this);
-        }
-        catch(bad_weak_ptr const &)
-        {
-            // Q: how can we get here?
-            // A: another thread may have invalidated r after the use_count test above.
-            return shared_ptr<element_type>();
-        }
-
-#else
-
-        // optimization: avoid try/catch overhead when single threaded
-        return expired()? shared_ptr<element_type>(): shared_ptr<element_type>(*this);
-
-#endif
     }
 
     long use_count() const // never throws

intrusive_ptr.html

@@ -62,6 +62,8 @@
       intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr const &amp; r);
       template&lt;class Y&gt; intrusive_ptr &amp; <A href="#assignment" >operator=</A>(intrusive_ptr&lt;Y&gt; const &amp; r);
       intrusive_ptr &amp; <A href="#assignment" >operator=</A>(T * r);
+
+      void <a href="#reset" >reset</a>();
       void <a href="#reset" >reset</a>(T * r);
 
       T &amp; <A href="#indirection" >operator*</A>() const; // never throws
@@ -148,6 +150,10 @@ intrusive_ptr &amp; operator=(T * r);</pre>
 			<P><B>Returns:</B> <code>*this</code>.</P>
 		</BLOCKQUOTE>
 		<H3><a name="reset">reset</a></H3>
+		<pre>void reset();</pre>
+		<BLOCKQUOTE>
+			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr().swap(*this)</code>.</P>
+		</BLOCKQUOTE>
 		<pre>void reset(T * r);</pre>
 		<BLOCKQUOTE>
 			<P><B>Effects:</B> Equivalent to <code>intrusive_ptr(r).swap(*this)</code>.</P>

shared_array.htm

@@ -47,7 +47,7 @@
       void <a href="#reset">reset</a>(T * p = 0);
       template&lt;class D&gt; void <a href="#reset">reset</a>(T * p, D d);
 
-      T &amp; <a href="#indexing">operator[]</a>(std::ptrdiff_t i) const() const; // never throws
+      T &amp; <a href="#indexing">operator[]</a>(std::ptrdiff_t i) const; // never throws
       T * <a href="#get">get</a>() const; // never throws
 
       bool <a href="#unique">unique</a>() const; // never throws

shared_ptr.htm

@@ -373,8 +373,8 @@ q = p;
 		<pre>long use_count() const; // never throws</pre>
 		<blockquote>
 			<p><b>Returns:</b> the number of <b>shared_ptr</b> objects, <STRONG>*this</STRONG> included, 
-				that <i>share ownership</i> with <b>*this</b>, or an unspecified nonnegative 
+				that <i>share ownership</i> with <b>*this</b>, or 0 when <STRONG>*this</STRONG>
-				value when <STRONG>*this</STRONG> is <EM>empty</EM>.</p>
+				is <EM>empty</EM>.</p>
 			<p><b>Throws:</b> nothing.</p>
 			<P><B>Notes:</B> <code>use_count()</code> is not necessarily efficient. Use only 
 				for debugging and testing purposes, not for production code.</P>
@@ -522,6 +522,7 @@ q = p;
 			<P><B>Returns:</B> If <STRONG>*this</STRONG> <EM>owns</EM> a deleter <STRONG>d</STRONG>
 				of type (cv-unqualified) <STRONG>D</STRONG>, returns <code>&amp;d</code>; 
 				otherwise returns 0.</P>
+			<P><B>Throws:</B> nothing.</P>
 		</BLOCKQUOTE>
 		<h2><a name="example">Example</a></h2>
 		<p>See <A href="example/shared_ptr_example.cpp">shared_ptr_example.cpp</A> for a 
@@ -709,8 +710,8 @@ int * p = a.release();
 		<p>
 			$Date$</p>
 		<p><small>Copyright 1999 Greg Colvin and Beman Dawes. Copyright 2002 Darin Adler. 
-			Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, Version 
+				Copyright 2002-2005 Peter Dimov. Distributed under the Boost Software License, 
-			1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
+				Version 1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A>
-			copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
+				or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
 	</body>
 </html>

src/sp_collector.cpp

@@ -104,6 +104,8 @@ static void find_unreachable_objects_impl(map_type const & m, map2_type & m2)
 
             BOOST_ASSERT(p->use_count() != 0); // there should be no inactive counts in the map
 
+            m2[ i->first ];
+
             scan_and_count(i->second.first, i->second.second, m, m2);
         }
 
@@ -121,7 +123,7 @@ static void find_unreachable_objects_impl(map_type const & m, map2_type & m2)
             if(p->use_count() != i->second) open.push_back(p);
         }
 
-        std::cout << "... " << m2.size() << " objects in open.\n";
+        std::cout << "... " << open.size() << " objects in open.\n";
 
         for(open_type::iterator j = open.begin(); j != open.end(); ++j)
         {

test/Jamfile.v2

@@ -33,5 +33,20 @@ import testing ;
           [ run shared_ptr_move_test.cpp ]
           [ compile-fail shared_ptr_pv_fail.cpp ]
           [ run sp_unary_addr_test.cpp ]
+          [ compile-fail scoped_ptr_eq_fail.cpp ]
+          [ compile-fail scoped_array_eq_fail.cpp ]
+          [ run esft_regtest.cpp ]
+          [ run yield_k_test.cpp ]
+          [ run yield_k_test.cpp : : : <threading>multi : yield_k_test.mt ]
+          [ run spinlock_test.cpp ]
+          [ run spinlock_try_test.cpp ]
+          [ run spinlock_try_test.cpp : : : <threading>multi : spinlock_try_test.mt ]
+          [ run spinlock_pool_test.cpp ]
+          [ run make_shared_test.cpp ]
+          [ run sp_convertible_test.cpp ]
+          [ run wp_convertible_test.cpp ]
+          [ run ip_convertible_test.cpp ]
+          [ run allocate_shared_test.cpp ]
+          [ run sp_atomic_test.cpp ]
         ;
 }

test/allocate_shared_test.cpp

@@ -0,0 +1,189 @@
+//  allocate_shared_test.cpp
+//
+//  Copyright (c) 2007, 2008 Peter Dimov
+//
+// 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/detail/lightweight_test.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+class X
+{
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+
+public:
+
+    static int instances;
+
+    int v;
+
+    explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        boost::shared_ptr< int > pi = boost::allocate_shared< int >( std::allocator<int>() );
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 0 );
+    }
+
+    {
+        boost::shared_ptr< int > pi = boost::allocate_shared< int >( std::allocator<int>(), 5 );
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 5 );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>() );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2, 3 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2, 3, 4 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::allocate_shared< X >( std::allocator<void>(), 1, 2, 3, 4, 5, 6, 7, 8, 9 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8+9 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    return boost::report_errors();
+}

test/esft_regtest.cpp

@@ -0,0 +1,221 @@
+//
+//  esft_regtest.cpp
+//
+//  A regression test for enable_shared_from_this
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/enable_shared_from_this.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <memory>
+#include <string>
+
+class X: public boost::enable_shared_from_this< X >
+{
+private:
+
+    int destroyed_;
+    int deleted_;
+    int expected_;
+
+private:
+
+    X( X const& );
+    X& operator=( X const& );
+
+public:
+
+    static int instances;
+
+public:
+
+    explicit X( int expected ): destroyed_( 0 ), deleted_( 0 ), expected_( expected )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        BOOST_TEST( deleted_ == expected_ );
+        BOOST_TEST( destroyed_ == 0 );
+        ++destroyed_;
+        --instances;
+    }
+
+    typedef void (*deleter_type)( X* );
+
+    static void deleter( X * px )
+    {
+        ++px->deleted_;
+    }
+
+    static void deleter2( X * px )
+    {
+        ++px->deleted_;
+        delete px;
+    }
+};
+
+int X::instances = 0;
+
+void test()
+{
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        X x( 0 );
+        BOOST_TEST( X::instances == 1 );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        std::auto_ptr<X> px( new X( 0 ) );
+        BOOST_TEST( X::instances == 1 );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr<X> px( new X( 0 ) );
+        BOOST_TEST( X::instances == 1 );
+
+        boost::weak_ptr<X> wp( px );
+        BOOST_TEST( !wp.expired() );
+
+        px.reset();
+
+        BOOST_TEST( wp.expired() );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        X x( 1 );
+        boost::shared_ptr<X> px( &x, X::deleter );
+        BOOST_TEST( X::instances == 1 );
+
+        X::deleter_type * pd = boost::get_deleter<X::deleter_type>( px );
+        BOOST_TEST( pd != 0 && *pd == X::deleter );
+
+        boost::weak_ptr<X> wp( px );
+        BOOST_TEST( !wp.expired() );
+
+        px.reset();
+
+        BOOST_TEST( wp.expired() );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr<X> px( new X( 1 ), X::deleter2 );
+        BOOST_TEST( X::instances == 1 );
+
+        X::deleter_type * pd = boost::get_deleter<X::deleter_type>( px );
+        BOOST_TEST( pd != 0 && *pd == X::deleter2 );
+
+        boost::weak_ptr<X> wp( px );
+        BOOST_TEST( !wp.expired() );
+
+        px.reset();
+
+        BOOST_TEST( wp.expired() );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+}
+
+struct V: public boost::enable_shared_from_this<V>
+{
+    virtual ~V() {}
+    std::string m_;
+};
+
+struct V2
+{
+    virtual ~V2() {}
+    std::string m2_;
+};
+
+struct W: V2, V
+{
+};
+
+void test2()
+{
+    boost::shared_ptr<W> p( new W );
+}
+
+void test3()
+{
+    V * p = new W;
+    boost::shared_ptr<void> pv( p );
+    BOOST_TEST( pv.get() == p );
+    BOOST_TEST( pv.use_count() == 1 );
+}
+
+struct null_deleter
+{
+    void operator()( void const* ) const {}
+};
+
+void test4()
+{
+    boost::shared_ptr<V> pv( new V );
+    boost::shared_ptr<V> pv2( pv.get(), null_deleter() );
+    BOOST_TEST( pv2.get() == pv.get() );
+    BOOST_TEST( pv2.use_count() == 1 );
+}
+
+void test5()
+{
+    V v;
+
+    boost::shared_ptr<V> p1( &v, null_deleter() );
+    BOOST_TEST( p1.get() == &v );
+    BOOST_TEST( p1.use_count() == 1 );
+
+    try
+    {
+        p1->shared_from_this();
+    }
+    catch( ... )
+    {
+        BOOST_ERROR( "p1->shared_from_this() failed" );
+    }
+
+    p1.reset();
+
+    boost::shared_ptr<V> p2( &v, null_deleter() );
+    BOOST_TEST( p2.get() == &v );
+    BOOST_TEST( p2.use_count() == 1 );
+
+    try
+    {
+        p2->shared_from_this();
+    }
+    catch( ... )
+    {
+        BOOST_ERROR( "p2->shared_from_this() failed" );
+    }
+}
+
+int main()
+{
+    test();
+    test2();
+    test3();
+    test4();
+    test5();
+
+    return boost::report_errors();
+}

test/ip_convertible_test.cpp

@@ -0,0 +1,54 @@
+#include <boost/config.hpp>
+
+//  wp_convertible_test.cpp
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/detail/lightweight_test.hpp>
+#include <boost/intrusive_ptr.hpp>
+
+//
+
+struct W
+{
+};
+
+void intrusive_ptr_add_ref( W* )
+{
+}
+
+void intrusive_ptr_release( W* )
+{
+}
+
+struct X: public virtual W
+{
+};
+
+struct Y: public virtual W
+{
+};
+
+struct Z: public X
+{
+};
+
+int f( boost::intrusive_ptr<X> )
+{
+    return 1;
+}
+
+int f( boost::intrusive_ptr<Y> )
+{
+    return 2;
+}
+
+int main()
+{
+    BOOST_TEST( 1 == f( boost::intrusive_ptr<Z>() ) );
+    return boost::report_errors();
+}

test/make_shared_test.cpp

@@ -0,0 +1,189 @@
+//  make_shared_test.cpp
+//
+//  Copyright (c) 2007, 2008 Peter Dimov
+//
+// 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/detail/lightweight_test.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+
+class X
+{
+private:
+
+    X( X const & );
+    X & operator=( X const & );
+
+public:
+
+    static int instances;
+
+    int v;
+
+    explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
+    {
+        ++instances;
+    }
+
+    ~X()
+    {
+        --instances;
+    }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        boost::shared_ptr< int > pi = boost::make_shared< int >();
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 0 );
+    }
+
+    {
+        boost::shared_ptr< int > pi = boost::make_shared< int >( 5 );
+
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( *pi == 5 );
+    }
+
+    BOOST_TEST( X::instances == 0 );
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >();
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 0 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2, 3 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2, 3, 4 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2, 3, 4, 5 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2, 3, 4, 5, 6 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2, 3, 4, 5, 6, 7 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    {
+        boost::shared_ptr< X > pi = boost::make_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8, 9 );
+        boost::weak_ptr<X> wp( pi );
+
+        BOOST_TEST( X::instances == 1 );
+        BOOST_TEST( pi.get() != 0 );
+        BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8+9 );
+
+        pi.reset();
+
+        BOOST_TEST( X::instances == 0 );
+    }
+
+    return boost::report_errors();
+}

test/pointer_cast_test.cpp

@@ -1,7 +1,7 @@
 //
 //  pointer_cast_test.cpp - a test for boost/pointer_cast.hpp
 //
-//  Copyright (c) 2005 Ion Gazta<EFBFBD>aga
+//  Copyright (c) 2005 Ion Gaztanaga
 //  Copyright (c) 2005 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0. (See

test/scoped_array_eq_fail.cpp

@@ -0,0 +1,27 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+// scoped_array_eq_fail.cpp - a negative test for "p == q"
+//
+// Copyright (c) 2008 Peter Dimov
+//
+// 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/scoped_array.hpp>
+
+int main()
+{
+    boost::scoped_array<int> p, q;
+    p == q; // must fail
+    return 0;
+}

test/scoped_ptr_eq_fail.cpp

@@ -0,0 +1,27 @@
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(disable: 4786)  // identifier truncated in debug info
+#pragma warning(disable: 4710)  // function not inlined
+#pragma warning(disable: 4711)  // function selected for automatic inline expansion
+#pragma warning(disable: 4514)  // unreferenced inline removed
+#endif
+
+//
+// scoped_ptr_eq_fail.cpp - a negative test for "p == q"
+//
+// Copyright (c) 2008 Peter Dimov
+//
+// 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/scoped_ptr.hpp>
+
+int main()
+{
+    boost::scoped_ptr<int> p, q;
+    p == q; // must fail
+    return 0;
+}

test/shared_from_this_test.cpp

@@ -133,7 +133,8 @@ void test3()
     try
     {
         boost::shared_ptr<V> r = v2.shared_from_this();
-        BOOST_ERROR("v2.shared_from_this() failed to throw");
+        BOOST_TEST( p < r || r < p );
+        BOOST_TEST( r.get() == &v2 );
     }
     catch(boost::bad_weak_ptr const &)
     {

test/shared_ptr_mt_test.cpp

@@ -7,125 +7,24 @@
 #pragma warning(disable: 4514)  // unreferenced inline removed
 #endif
 
-//
 //  shared_ptr_mt_test.cpp - tests shared_ptr with multiple threads
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2008 Peter Dimov
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+//  Distributed under the Boost Software License, Version 1.0.
-// accompanying file LICENSE_1_0.txt or copy at
+//  See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  http://www.boost.org/LICENSE_1_0.txt
-//
 
 #include <boost/shared_ptr.hpp>
 #include <boost/bind.hpp>
 
 #include <vector>
-#include <memory>
-#include <stdexcept>
 
 #include <cstdio>
 #include <ctime>
 
-// 'portable' thread framework
+#include <boost/detail/lightweight_thread.hpp>
-
-class abstract_thread
-{
-public:
-
-    virtual ~abstract_thread() {}
-    virtual void run() = 0;
-};
-
-#if !defined(BOOST_HAS_PTHREADS) && defined(BOOST_HAS_WINTHREADS)
-
-char const * title = "Using Windows threads";
-
-#include <windows.h>
-#include <process.h>
-
-typedef HANDLE pthread_t;
-
-unsigned __stdcall common_thread_routine(void * pv)
-{
-    abstract_thread * pt = static_cast<abstract_thread *>(pv);
-    pt->run();
-    delete pt;
-    return 0;
-}
-
-int pthread_create(pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg)
-{
-    HANDLE h = (HANDLE)_beginthreadex(0, 0, start_routine, arg, 0, 0);
-
-    if(h != 0)
-    {
-        *thread = h;
-        return 0;
-    }
-    else
-    {
-        return 1; // return errno;
-    }
-}
-
-int pthread_join(pthread_t thread, void ** /*value_ptr*/)
-{
-    ::WaitForSingleObject(thread, INFINITE);
-    ::CloseHandle(thread);
-    return 0;
-}
-
-#else
-
-char const * title = "Using POSIX threads";
-
-#include <pthread.h>
-
-extern "C" void * common_thread_routine(void * pv)
-{
-    abstract_thread * pt = static_cast<abstract_thread *>(pv);
-    pt->run();
-    delete pt;
-    return 0;
-}
-
-#endif
-
-//
-
-template<class F> class thread: public abstract_thread
-{
-public:
-
-    explicit thread(F f): f_(f)
-    {
-    }
-
-    void run()
-    {
-        f_();
-    }
-
-private:
-
-    F f_;
-};
-
-template<class F> pthread_t createThread(F f)
-{
-    std::auto_ptr<abstract_thread> p(new thread<F>(f));
-
-    pthread_t r;
-
-    if(pthread_create(&r, 0, common_thread_routine, p.get()) == 0)
-    {
-        p.release();
-        return r;
-    }
-
-    throw std::runtime_error("createThread failed.");
-}
 
 //
 
@@ -143,11 +42,21 @@ void test(boost::shared_ptr<int> const & pi)
 
 int const m = 16; // threads
 
+#if defined( BOOST_HAS_PTHREADS )
+
+char const * thmodel = "POSIX";
+
+#else
+
+char const * thmodel = "Windows";
+
+#endif
+
 int main()
 {
     using namespace std; // printf, clock_t, clock
 
-    printf("%s: %d threads, %d iterations: ", title, m, n);
+    printf( "Using %s threads: %d threads, %d iterations: ", thmodel, m, n );
 
     boost::shared_ptr<int> pi( new int(42) );
 
@@ -157,7 +66,7 @@ int main()
 
     for( int i = 0; i < m; ++i )
     {
-        a[i] = createThread( boost::bind(test, pi) );
+        boost::detail::lw_thread_create( a[ i ], boost::bind( test, pi ) );
     }
 
     for( int j = 0; j < m; ++j )

test/shared_ptr_test.cpp

@@ -62,6 +62,7 @@ void default_constructor()
         BOOST_TEST(pi? false: true);
         BOOST_TEST(!pi);
         BOOST_TEST(pi.get() == 0);
+        BOOST_TEST(pi.use_count() == 0);
     }
 
     {
@@ -69,6 +70,7 @@ void default_constructor()
         BOOST_TEST(pv? false: true);
         BOOST_TEST(!pv);
         BOOST_TEST(pv.get() == 0);
+        BOOST_TEST(pv.use_count() == 0);
     }
 
     {
@@ -76,6 +78,7 @@ void default_constructor()
         BOOST_TEST(px? false: true);
         BOOST_TEST(!px);
         BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px.use_count() == 0);
     }
 }
 
@@ -1565,6 +1568,7 @@ void plain_reset()
         BOOST_TEST(pi? false: true);
         BOOST_TEST(!pi);
         BOOST_TEST(pi.get() == 0);
+        BOOST_TEST(pi.use_count() == 0);
     }
 
     {
@@ -1573,6 +1577,7 @@ void plain_reset()
         BOOST_TEST(pi? false: true);
         BOOST_TEST(!pi);
         BOOST_TEST(pi.get() == 0);
+        BOOST_TEST(pi.use_count() == 0);
     }
 
     {
@@ -1581,6 +1586,7 @@ void plain_reset()
         BOOST_TEST(pi? false: true);
         BOOST_TEST(!pi);
         BOOST_TEST(pi.get() == 0);
+        BOOST_TEST(pi.use_count() == 0);
     }
 
     {
@@ -1589,6 +1595,7 @@ void plain_reset()
         BOOST_TEST(px? false: true);
         BOOST_TEST(!px);
         BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px.use_count() == 0);
     }
 
     {
@@ -1597,6 +1604,7 @@ void plain_reset()
         BOOST_TEST(px? false: true);
         BOOST_TEST(!px);
         BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px.use_count() == 0);
     }
 
     {
@@ -1605,6 +1613,7 @@ void plain_reset()
         BOOST_TEST(px? false: true);
         BOOST_TEST(!px);
         BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px.use_count() == 0);
     }
 
     {
@@ -1615,6 +1624,7 @@ void plain_reset()
         BOOST_TEST(px? false: true);
         BOOST_TEST(!px);
         BOOST_TEST(px.get() == 0);
+        BOOST_TEST(px.use_count() == 0);
         BOOST_TEST(X::instances == 0);
     }
 
@@ -1624,6 +1634,7 @@ void plain_reset()
         BOOST_TEST(pv? false: true);
         BOOST_TEST(!pv);
         BOOST_TEST(pv.get() == 0);
+        BOOST_TEST(pv.use_count() == 0);
     }
 
     {
@@ -1634,6 +1645,7 @@ void plain_reset()
         BOOST_TEST(pv? false: true);
         BOOST_TEST(!pv);
         BOOST_TEST(pv.get() == 0);
+        BOOST_TEST(pv.use_count() == 0);
         BOOST_TEST(X::instances == 0);
     }
 }

test/smart_ptr_test.cpp

@@ -196,6 +196,10 @@ void test()
     BOOST_TEST( cp.use_count() == 3 );
     BOOST_TEST( *cp == 87654 );
 
+#if defined( BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP )
+    using boost::swap;
+#endif
+
     boost::shared_ptr<int> cp4;
     swap( cp2, cp4 );
     BOOST_TEST( cp4.use_count() == 3 );

test/sp_atomic_mt2_test.cpp

@@ -0,0 +1,247 @@
+
+// Copyright (c) 2008 Peter Dimov
+//
+// 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/config.hpp>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/locks.hpp>
+
+#include <boost/detail/lightweight_mutex.hpp>
+#include <boost/detail/lightweight_thread.hpp>
+
+#include <vector>
+#include <numeric>
+#include <cstdio>
+#include <cstdlib>
+#include <cstddef>
+#include <ctime>
+
+//
+
+static void next_value( unsigned & v )
+{
+    v = v % 2? 3 * v + 1: v / 2;
+}
+
+struct X
+{
+    std::vector<unsigned> v_;
+
+    explicit X( std::size_t n ): v_( n )
+    {
+        for( std::size_t i = 0; i < n; ++i )
+        {
+            v_[ i ] = i;
+        }
+    }
+
+    unsigned get() const
+    {
+        return std::accumulate( v_.begin(), v_.end(), 0 );
+    }
+
+    void set()
+    {
+        std::for_each( v_.begin(), v_.end(), next_value );
+    }
+};
+
+static boost::shared_ptr<X> ps;
+
+static boost::detail::lightweight_mutex lm;
+static boost::shared_mutex rw;
+
+enum prim_type
+{
+    pt_mutex,
+    pt_rwlock,
+    pt_atomics
+};
+
+int read_access( prim_type pt )
+{
+    switch( pt )
+    {
+    case pt_mutex:
+        {
+            boost::detail::lightweight_mutex::scoped_lock lock( lm );
+            return ps->get();
+        }
+
+    case pt_rwlock:
+        {
+            boost::shared_lock<boost::shared_mutex> lock( rw );
+            return ps->get();
+        }
+
+    case pt_atomics:
+        {
+            boost::shared_ptr<X> p2 = boost::atomic_load( &ps );
+            return p2->get();
+        }
+    }
+}
+
+void write_access( prim_type pt )
+{
+    switch( pt )
+    {
+    case pt_mutex:
+        {
+            boost::detail::lightweight_mutex::scoped_lock lock( lm );
+            ps->set();
+        }
+        break;
+
+    case pt_rwlock:
+        {
+            boost::unique_lock<boost::shared_mutex> lock( rw );
+            ps->set();
+        }
+        break;
+
+    case pt_atomics:
+        {
+            boost::shared_ptr<X> p1 = boost::atomic_load( &ps );
+
+            for( ;; )
+            {
+                boost::shared_ptr<X> p2( new X( *p1 ) );
+                p2->set();
+
+                if( boost::atomic_compare_exchange( &ps, &p1, p2 ) ) break;
+            }
+        }
+        break;
+    }
+}
+
+void worker( int k, prim_type pt, int n, int r )
+{
+    ++r;
+
+    unsigned s = 0, nr = 0, nw = 0;
+
+    for( int i = 0; i < n; ++i )
+    {
+        if( i % r )
+        {
+            s += read_access( pt );
+            ++nr;
+        }
+        else
+        {
+            write_access( pt );
+            ++s;
+            ++nw;
+        }
+    }
+
+    printf( "Worker %2d: %u:%u, %10u\n", k, nr, nw, s );
+}
+
+#if defined( BOOST_HAS_PTHREADS )
+  char const * thmodel = "POSIX";
+#else
+  char const * thmodel = "Windows";
+#endif
+
+char const * pt_to_string( prim_type pt )
+{
+    switch( pt )
+    {
+    case pt_mutex:
+
+        return "mutex";
+
+    case pt_rwlock:
+
+        return "rwlock";
+
+    case pt_atomics:
+
+        return "atomics";
+    }
+}
+
+static void handle_pt_option( std::string const & opt, prim_type & pt, prim_type pt2 )
+{
+    if( opt == pt_to_string( pt2 ) )
+    {
+        pt = pt2;
+    }
+}
+
+static void handle_int_option( std::string const & opt, std::string const & prefix, int & k, int kmin, int kmax )
+{
+    if( opt.substr( 0, prefix.size() ) == prefix )
+    {
+        int v = atoi( opt.substr( prefix.size() ).c_str() );
+
+        if( v >= kmin && v <= kmax )
+        {
+            k = v;
+        }
+    }
+}
+
+int main( int ac, char const * av[] )
+{
+    using namespace std; // printf, clock_t, clock
+
+    int m = 4;          // threads
+    int n = 10000;      // vector size
+    int k = 1000000;    // iterations
+    int r = 100;        // read/write ratio, r:1
+
+    prim_type pt = pt_atomics;
+
+    for( int i = 1; i < ac; ++i )
+    {
+        handle_pt_option( av[i], pt, pt_mutex );
+        handle_pt_option( av[i], pt, pt_rwlock );
+        handle_pt_option( av[i], pt, pt_atomics );
+
+        handle_int_option( av[i], "n=", n, 1, INT_MAX );
+        handle_int_option( av[i], "size=", n, 1, INT_MAX );
+
+        handle_int_option( av[i], "k=", k, 1, INT_MAX );
+        handle_int_option( av[i], "iterations=", k, 1, INT_MAX );
+
+        handle_int_option( av[i], "m=", m, 1, INT_MAX );
+        handle_int_option( av[i], "threads=", m, 1, INT_MAX );
+
+        handle_int_option( av[i], "r=", r, 1, INT_MAX );
+        handle_int_option( av[i], "ratio=", r, 1, INT_MAX );
+    }
+
+    printf( "%s: threads=%d size=%d iterations=%d ratio=%d %s\n\n", thmodel, m, n, k, r, pt_to_string( pt ) );
+
+    ps.reset( new X( n ) );
+
+    clock_t t = clock();
+
+    std::vector<pthread_t> a( m );
+
+    for( int i = 0; i < m; ++i )
+    {
+        boost::detail::lw_thread_create( a[ i ], boost::bind( worker, i, pt, k, r ) );
+    }
+
+    for( int j = 0; j < m; ++j )
+    {
+        pthread_join( a[ j ], 0 );
+    }
+
+    t = clock() - t;
+
+    double ts = static_cast<double>( t ) / CLOCKS_PER_SEC;
+    printf( "%.3f seconds, %.3f accesses per microsecond.\n", ts, m * k / ts / 1e+6 );
+}

test/sp_atomic_mt_test.cpp

@@ -0,0 +1,191 @@
+
+// Copyright (c) 2008 Peter Dimov
+//
+// 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
+
+//#define USE_MUTEX
+//#define USE_RWLOCK
+
+#include <boost/config.hpp>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+
+#if defined( USE_RWLOCK )
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/locks.hpp>
+#endif
+
+#include <boost/detail/lightweight_mutex.hpp>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/detail/lightweight_thread.hpp>
+
+#include <cstdio>
+#include <ctime>
+
+//
+
+int const n = 1024 * 1024;
+
+struct X
+{
+    int v_; // version
+
+    unsigned a_;
+    unsigned b_;
+
+    X(): v_( 0 ), a_( 1 ), b_( 1 )
+    {
+    }
+
+    int get() const
+    {
+        return a_ * 7 + b_ * 11;
+    }
+
+    void set()
+    {
+        int tmp = get();
+
+        b_ = a_;
+        a_ = tmp;
+
+        ++v_;
+    }
+};
+
+static boost::shared_ptr<X> ps( new X );
+
+static boost::detail::lightweight_mutex lm;
+
+#if defined( USE_RWLOCK )
+static boost::shared_mutex rw;
+#endif
+
+static int tr = 0;
+
+void reader( int r )
+{
+    int k = 0;
+    unsigned s = 0;
+
+    for( int i = 0; i < n; ++k )
+    {
+#if defined( USE_MUTEX )
+
+        boost::detail::lightweight_mutex::scoped_lock lock( lm );
+
+        s += ps->get();
+
+        BOOST_TEST( ps->v_ >= i );
+        i = ps->v_;
+
+#elif defined( USE_RWLOCK )
+
+        boost::shared_lock<boost::shared_mutex> lock( rw );
+
+        s += ps->get();
+
+        BOOST_TEST( ps->v_ >= i );
+        i = ps->v_;
+
+#else
+
+        boost::shared_ptr<X> p2 = boost::atomic_load( &ps );
+
+        s += p2->get();
+
+        BOOST_TEST( p2->v_ >= i );
+        i = p2->v_;
+
+#endif
+    }
+
+    printf( "Reader %d: %9d iterations (%6.3fx), %u\n", r, k, (double)k / n, s );
+
+    boost::detail::lightweight_mutex::scoped_lock lock( lm );
+    tr += k;
+}
+
+void writer()
+{
+    for( int i = 0; i < n; ++i )
+    {
+#if defined( USE_MUTEX )
+
+        boost::detail::lightweight_mutex::scoped_lock lock( lm );
+
+        BOOST_TEST( ps->v_ == i );
+        ps->set();
+
+#elif defined( USE_RWLOCK )
+
+        boost::unique_lock<boost::shared_mutex> lock( rw );
+
+        BOOST_TEST( ps->v_ == i );
+        ps->set();
+
+#else
+
+        boost::shared_ptr<X> p2( new X( *ps ) );
+
+        BOOST_TEST( p2->v_ == i );
+        p2->set();
+
+        boost::atomic_store( &ps, p2 );
+
+#endif
+    }
+}
+
+#if defined( BOOST_HAS_PTHREADS )
+  char const * thmodel = "POSIX";
+#else
+  char const * thmodel = "Windows";
+#endif
+
+int const mr = 8; // reader threads
+int const mw = 1; // writer thread
+
+#if defined( USE_MUTEX )
+  char const * prim = "mutex";
+#elif defined( USE_RWLOCK )
+  char const * prim = "rwlock";
+#else
+  char const * prim = "atomics";
+#endif
+
+int main()
+{
+    using namespace std; // printf, clock_t, clock
+
+    printf( "Using %s threads: %dR + %dW threads, %d iterations, %s\n\n", thmodel, mr, mw, n, prim );
+
+    clock_t t = clock();
+
+    pthread_t a[ mr+mw ];
+
+    for( int i = 0; i < mr; ++i )
+    {
+        boost::detail::lw_thread_create( a[ i ], boost::bind( reader, i ) );
+    }
+
+    for( int i = mr; i < mr+mw; ++i )
+    {
+        boost::detail::lw_thread_create( a[ i ], writer );
+    }
+
+    for( int j = 0; j < mr+mw; ++j )
+    {
+        pthread_join( a[ j ], 0 );
+    }
+
+    t = clock() - t;
+
+    double ts = static_cast<double>( t ) / CLOCKS_PER_SEC;
+    printf( "%.3f seconds, %.3f reads per microsecond.\n", ts, tr / ts / 1e+6 );
+
+    return boost::report_errors();
+}

test/sp_atomic_test.cpp

@@ -0,0 +1,87 @@
+#include <boost/config.hpp>
+
+//  sp_atomic_test.cpp
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/detail/lightweight_test.hpp>
+#include <boost/shared_ptr.hpp>
+
+//
+
+struct X
+{
+};
+
+#define BOOST_TEST_SP_EQ( p, q ) BOOST_TEST( p == q && !( p < q ) && !( q < p ) )
+
+int main()
+{
+    boost::shared_ptr<X> px( new X );
+
+    {
+        boost::shared_ptr<X> p2 = boost::atomic_load( &px );
+        BOOST_TEST_SP_EQ( p2, px );
+
+        boost::shared_ptr<X> px2( new X );
+        boost::atomic_store( &px, px2 );
+        BOOST_TEST_SP_EQ( px, px2 );
+
+        p2 = boost::atomic_load( &px );
+        BOOST_TEST_SP_EQ( p2, px );
+        BOOST_TEST_SP_EQ( p2, px2 );
+
+        boost::shared_ptr<X> px3( new X );
+        boost::shared_ptr<X> p3 = boost::atomic_exchange( &px, px3 );
+        BOOST_TEST_SP_EQ( p3, px2 );
+        BOOST_TEST_SP_EQ( px, px3 );
+
+        boost::shared_ptr<X> px4( new X );
+        boost::shared_ptr<X> cmp;
+
+        bool r = boost::atomic_compare_exchange( &px, &cmp, px4 );
+        BOOST_TEST( !r );
+        BOOST_TEST_SP_EQ( px, px3 );
+        BOOST_TEST_SP_EQ( cmp, px3 );
+
+        r = boost::atomic_compare_exchange( &px, &cmp, px4 );
+        BOOST_TEST( r );
+        BOOST_TEST_SP_EQ( px, px4 );
+    }
+
+    //
+
+    px.reset();
+
+    {
+        boost::shared_ptr<X> p2 = boost::atomic_load_explicit( &px, boost::memory_order_acquire );
+        BOOST_TEST_SP_EQ( p2, px );
+
+        boost::shared_ptr<X> px2( new X );
+        boost::atomic_store_explicit( &px, px2, boost::memory_order_release );
+        BOOST_TEST_SP_EQ( px, px2 );
+
+        boost::shared_ptr<X> p3 = boost::atomic_exchange_explicit( &px, boost::shared_ptr<X>(), boost::memory_order_acq_rel );
+        BOOST_TEST_SP_EQ( p3, px2 );
+        BOOST_TEST_SP_EQ( px, p2 );
+
+        boost::shared_ptr<X> px4( new X );
+        boost::shared_ptr<X> cmp( px2 );
+
+        bool r = boost::atomic_compare_exchange_explicit( &px, &cmp, px4, boost::memory_order_acquire, boost::memory_order_relaxed );
+        BOOST_TEST( !r );
+        BOOST_TEST_SP_EQ( px, p2 );
+        BOOST_TEST_SP_EQ( cmp, p2 );
+
+        r = boost::atomic_compare_exchange_explicit( &px, &cmp, px4, boost::memory_order_release, boost::memory_order_acquire );
+        BOOST_TEST( r );
+        BOOST_TEST_SP_EQ( px, px4 );
+    }
+
+    return boost::report_errors();
+}

test/sp_convertible_test.cpp

@@ -0,0 +1,71 @@
+#include <boost/config.hpp>
+
+//  sp_convertible_test.cpp
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/detail/lightweight_test.hpp>
+#include <boost/shared_ptr.hpp>
+
+//
+
+class incomplete;
+
+struct X
+{
+};
+
+struct Y
+{
+};
+
+struct Z: public X
+{
+};
+
+int f( boost::shared_ptr<void const> )
+{
+    return 1;
+}
+
+int f( boost::shared_ptr<int> )
+{
+    return 2;
+}
+
+int f( boost::shared_ptr<incomplete> )
+{
+    return 3;
+}
+
+int g( boost::shared_ptr<X> )
+{
+    return 4;
+}
+
+int g( boost::shared_ptr<Y> )
+{
+    return 5;
+}
+
+int g( boost::shared_ptr<incomplete> )
+{
+    return 6;
+}
+
+int main()
+{
+    boost::shared_ptr<double> p1;
+    BOOST_TEST( 1 == f( p1 ) );
+    BOOST_TEST( 1 == f( boost::shared_ptr<double>() ) );
+
+    boost::shared_ptr<Z> p2;
+    BOOST_TEST( 4 == g( p2 ) );
+    BOOST_TEST( 4 == g( boost::shared_ptr<Z>() ) );
+
+    return boost::report_errors();
+}

test/sp_unary_addr_test.cpp

@@ -49,6 +49,9 @@ int main()
         BOOST_TEST( q != 0 && q->data == 17041 );
     }
 
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 )
+#else
+
     {
         boost::shared_ptr<X> p( &x, deleter(), std::allocator<X>() );
 
@@ -58,5 +61,7 @@ int main()
         BOOST_TEST( q != 0 && q->data == 17041 );
     }
 
+#endif
+
     return boost::report_errors();
 }

test/spinlock_pool_test.cpp

@@ -0,0 +1,30 @@
+//
+// spinlock_pool_test.cpp
+//
+// Copyright 2008 Peter Dimov
+//
+// 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/detail/spinlock_pool.hpp>
+
+// Sanity check only
+
+int main()
+{
+    int x = 0;
+
+    {
+        boost::detail::spinlock_pool<0>::scoped_lock lock( &x );
+        ++x;
+    }
+
+    {
+        boost::detail::spinlock_pool<1>::scoped_lock lock( &x );
+        boost::detail::spinlock_pool<2>::scoped_lock lock2( &x );
+    }
+
+    return 0;
+}

test/spinlock_test.cpp

@@ -0,0 +1,31 @@
+//
+// spinlock_test.cpp
+//
+// Copyright 2008 Peter Dimov
+//
+// 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/detail/spinlock.hpp>
+
+// Sanity check only
+
+static boost::detail::spinlock sp = BOOST_DETAIL_SPINLOCK_INIT;
+static boost::detail::spinlock sp2 = BOOST_DETAIL_SPINLOCK_INIT;
+
+int main()
+{
+    sp.lock();
+    sp2.lock();
+    sp.unlock();
+    sp2.unlock();
+
+    {
+        boost::detail::spinlock::scoped_lock lock( sp );
+        boost::detail::spinlock::scoped_lock lock2( sp2 );
+    }
+
+    return 0;
+}

test/spinlock_try_test.cpp

@@ -0,0 +1,46 @@
+//
+// spinlock_try_test.cpp
+//
+// Copyright 2008 Peter Dimov
+//
+// 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/detail/spinlock.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+// Sanity check only
+
+static boost::detail::spinlock sp = BOOST_DETAIL_SPINLOCK_INIT;
+static boost::detail::spinlock sp2 = BOOST_DETAIL_SPINLOCK_INIT;
+
+int main()
+{
+    BOOST_TEST( sp.try_lock() );
+    BOOST_TEST( !sp.try_lock() );
+    BOOST_TEST( sp2.try_lock() );
+    BOOST_TEST( !sp.try_lock() );
+    BOOST_TEST( !sp2.try_lock() );
+    sp.unlock();
+    sp2.unlock();
+
+    sp.lock();
+    BOOST_TEST( !sp.try_lock() );
+    sp2.lock();
+    BOOST_TEST( !sp.try_lock() );
+    BOOST_TEST( !sp2.try_lock() );
+    sp.unlock();
+    sp2.unlock();
+
+    {
+        boost::detail::spinlock::scoped_lock lock( sp );
+        BOOST_TEST( !sp.try_lock() );
+        boost::detail::spinlock::scoped_lock lock2( sp2 );
+        BOOST_TEST( !sp.try_lock() );
+        BOOST_TEST( !sp2.try_lock() );
+    }
+
+    return boost::report_errors();
+}

test/weak_ptr_mt_test.cpp

@@ -7,128 +7,26 @@
 #pragma warning(disable: 4514)  // unreferenced inline removed
 #endif
 
-//
 //  weak_ptr_mt_test.cpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright 2005 Peter Dimov
+//  Copyright 2005, 2008 Peter Dimov
-//
-// 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)
 //
+//  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/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 #include <boost/bind.hpp>
 
 #include <vector>
-#include <memory>
-#include <stdexcept>
 
 #include <cstdio>
 #include <ctime>
 #include <cstdlib>
 
-// 'portable' thread framework
+#include <boost/detail/lightweight_thread.hpp>
-
-class abstract_thread
-{
-public:
-
-    virtual ~abstract_thread() {}
-    virtual void run() = 0;
-};
-
-#if !defined(BOOST_HAS_PTHREADS) && defined(BOOST_HAS_WINTHREADS)
-
-char const * title = "Using Windows threads";
-
-#include <windows.h>
-#include <process.h>
-
-typedef HANDLE pthread_t;
-
-unsigned __stdcall common_thread_routine(void * pv)
-{
-    abstract_thread * pt = static_cast<abstract_thread *>(pv);
-    pt->run();
-    delete pt;
-    return 0;
-}
-
-int pthread_create(pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg)
-{
-    HANDLE h = (HANDLE)_beginthreadex(0, 0, start_routine, arg, 0, 0);
-
-    if(h != 0)
-    {
-        *thread = h;
-        return 0;
-    }
-    else
-    {
-        return 1; // return errno;
-    }
-}
-
-int pthread_join(pthread_t thread, void ** /*value_ptr*/)
-{
-    ::WaitForSingleObject(thread, INFINITE);
-    ::CloseHandle(thread);
-    return 0;
-}
-
-#else
-
-char const * title = "Using POSIX threads";
-
-#include <pthread.h>
-
-extern "C" void * common_thread_routine(void * pv)
-{
-    abstract_thread * pt = static_cast<abstract_thread *>(pv);
-    pt->run();
-    delete pt;
-    return 0;
-}
-
-#endif
-
-//
-
-template<class F> class thread: public abstract_thread
-{
-public:
-
-    explicit thread(F f): f_(f)
-    {
-    }
-
-    void run()
-    {
-        f_();
-    }
-
-private:
-
-    F f_;
-};
-
-template<class F> pthread_t createThread(F f)
-{
-    std::auto_ptr<abstract_thread> p(new thread<F>(f));
-
-    pthread_t r;
-
-    if(pthread_create(&r, 0, common_thread_routine, p.get()) == 0)
-    {
-        p.release();
-        return r;
-    }
-
-    throw std::runtime_error("createThread failed.");
-}
 
 //
 
@@ -177,11 +75,21 @@ void test( std::vector< boost::shared_ptr<int> > & v )
     printf( "\n%d locks, %d forced rebinds, %d normal rebinds.", s, f, r );
 }
 
+#if defined( BOOST_HAS_PTHREADS )
+
+char const * thmodel = "POSIX";
+
+#else
+
+char const * thmodel = "Windows";
+
+#endif
+
 int main()
 {
     using namespace std; // printf, clock_t, clock
 
-    printf("%s: %d threads, %d * %d iterations: ", title, m, n, k );
+    printf("Using %s threads: %d threads, %d * %d iterations: ", thmodel, m, n, k );
 
     std::vector< boost::shared_ptr<int> > v( k );
 
@@ -196,7 +104,7 @@ int main()
 
     for( int i = 0; i < m; ++i )
     {
-        a[i] = createThread( boost::bind( test, v ) );
+        boost::detail::lw_thread_create( a[ i ], boost::bind( test, v ) );
     }
 
     v.resize( 0 ); // kill original copies

test/wp_convertible_test.cpp

@@ -0,0 +1,68 @@
+#include <boost/config.hpp>
+
+//  wp_convertible_test.cpp
+//
+//  Copyright (c) 2008 Peter Dimov
+//
+//  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/detail/lightweight_test.hpp>
+#include <boost/weak_ptr.hpp>
+
+//
+
+class incomplete;
+
+struct X
+{
+};
+
+struct Y
+{
+};
+
+struct Z: public X
+{
+};
+
+int f( boost::weak_ptr<void const> )
+{
+    return 1;
+}
+
+int f( boost::weak_ptr<int> )
+{
+    return 2;
+}
+
+int f( boost::weak_ptr<incomplete> )
+{
+    return 3;
+}
+
+int g( boost::weak_ptr<X> )
+{
+    return 4;
+}
+
+int g( boost::weak_ptr<Y> )
+{
+    return 5;
+}
+
+int g( boost::weak_ptr<incomplete> )
+{
+    return 6;
+}
+
+int main()
+{
+    BOOST_TEST( 1 == f( boost::weak_ptr<double>() ) );
+    BOOST_TEST( 1 == f( boost::shared_ptr<double>() ) );
+    BOOST_TEST( 4 == g( boost::weak_ptr<Z>() ) );
+    BOOST_TEST( 4 == g( boost::shared_ptr<Z>() ) );
+
+    return boost::report_errors();
+}

test/yield_k_test.cpp

@@ -0,0 +1,23 @@
+//
+// yield_k_test.cpp
+//
+// Copyright 2008 Peter Dimov
+//
+// 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/detail/yield_k.hpp>
+
+// Sanity check only
+
+int main()
+{
+    for( unsigned k = 0; k < 256; ++k )
+    {
+        boost::detail::yield( k );
+    }
+
+    return 0;
+}