Create a branch for inspect fixes.

[SVN r61439]

doc/thread_ref.qbk

@@ -219,7 +219,6 @@ __thread_id__ yield a total order for every non-equal thread ID.
     };
 
     void swap(thread& lhs,thread& rhs);
-    detail::thread_move_t<thread> move(detail::thread_move_t<thread> t);
 
 [section:default_constructor Default Constructor]
 
@@ -235,40 +234,6 @@ __thread_id__ yield a total order for every non-equal thread ID.
 
 [endsect]
 
-[section:move_constructor Move Constructor]
-
-    thread(detail::thread_move_t<thread> other);
-
-[variablelist
-
-[[Effects:] [Transfers ownership of the thread managed by `other` (if any) to the newly constructed __thread__ instance.]]
-
-[[Postconditions:] [`other->get_id()==thread::id()`]]
-
-[[Throws:] [Nothing]]
-
-]
-
-[endsect]
-
-[section:move_assignment Move assignment operator]
-
-    thread& operator=(detail::thread_move_t<thread> other);
-
-[variablelist
-
-[[Effects:] [Transfers ownership of the thread managed by `other` (if
-any) to `*this`. If there was a thread previously associated with
-`*this` then that thread is detached.]]
-
-[[Postconditions:] [`other->get_id()==thread::id()`]]
-
-[[Throws:] [Nothing]]
-
-]
-
-[endsect]
-
 [section:callable_constructor Thread Constructor]
 
     template<typename Callable>
@@ -556,26 +521,6 @@ value as `this->get_id()` prior to the call.]]
 
 [endsect]
 
-[section:non_member_move Non-member function `move()`]
-
-    #include <boost/thread/thread.hpp>
-
-    detail::thread_move_t<thread> move(detail::thread_move_t<thread> t)
-
-[variablelist
-
-[[Returns:] [`t`.]]
-
-]
-
-Enables moving thread objects. e.g.
-
-    extern void some_func();
-    boost::thread t(some_func);
-    boost::thread t2(boost::move(t)); // transfer thread from t to t2
-
-[endsect]
-
 
 [section:id Class `boost::thread::id`]
 
@@ -811,14 +756,11 @@ instances of __thread_id__ `a` and `b` is the same if `a==b`, and different if `
     {
         template<typename TimeDuration>
         void sleep(TimeDuration const& rel_time);
-        void sleep(system_time const& abs_time)
     }
 
 [variablelist
 
-[[Effects:] [Suspends the current thread until the time period
-specified by `rel_time` has elapsed or the time point specified by
-`abs_time` has been reached.]]
+[[Effects:] [Suspends the current thread until the specified time has elapsed.]]
 
 [[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]
 

include/boost/thread/detail/config.hpp

@@ -20,7 +20,7 @@
 #include "platform.hpp"
 
 // compatibility with the rest of Boost's auto-linking code:
-#if defined(BOOST_THREAD_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
+#if defined(BOOST_THREAD_DYN_DLL) || defined(BOOST_ALL_DYN_LINK)
 # undef  BOOST_THREAD_USE_LIB
 # define BOOST_THREAD_USE_DLL
 #endif

include/boost/thread/detail/thread.hpp

@@ -3,12 +3,10 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
-// (C) Copyright 2007-10 Anthony Williams
+// (C) Copyright 2007-8 Anthony Williams
  
 #include <boost/thread/exceptions.hpp>
-#ifndef BOOST_NO_IOSTREAM
 #include <ostream>
-#endif
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/xtime.hpp>
@@ -149,7 +147,7 @@ namespace boost
 #endif
         struct dummy;
     public:
-#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
+#ifdef __SUNPRO_CC 
         thread(const volatile thread&); 
 #endif 
         thread();
@@ -219,7 +217,7 @@ namespace boost
             x->thread_info.reset();
         }
        
-#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
+#ifdef __SUNPRO_CC 
         thread& operator=(thread x) 
         { 
             swap(x); 
@@ -396,7 +394,7 @@ namespace boost
             thread_data(thread_data_)
         {}
         friend class thread;
-        friend id BOOST_THREAD_DECL this_thread::get_id();
+        friend id this_thread::get_id();
     public:
         id():
             thread_data()
@@ -432,7 +430,6 @@ namespace boost
             return !(thread_data<y.thread_data);
         }
 
-#ifndef BOOST_NO_IOSTREAM
         template<class charT, class traits>
         friend std::basic_ostream<charT, traits>& 
         operator<<(std::basic_ostream<charT, traits>& os, const id& x)
@@ -446,7 +443,6 @@ namespace boost
                 return os<<"{Not-any-thread}";
             }
         }
-#endif
     };
 
     inline bool thread::operator==(const thread& other) const

include/boost/thread/detail/thread_group.hpp

@@ -18,13 +18,10 @@
 
 namespace boost
 {
-    class thread_group
+    class thread_group:
+        private noncopyable
     {
-    private:
-        thread_group(thread_group const&);
-        thread_group& operator=(thread_group const&);        
     public:
-        thread_group() {}
         ~thread_group()
         {
             for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();

include/boost/thread/detail/tss_hooks.hpp

@@ -12,9 +12,27 @@
 
 #if defined(BOOST_HAS_WINTHREADS)
 
-namespace boost
-{
-    BOOST_THREAD_DECL void __cdecl on_process_enter(void);
+    typedef void (__cdecl *thread_exit_handler)(void);
+
+    extern "C" BOOST_THREAD_DECL int at_thread_exit(
+        thread_exit_handler exit_handler
+        );
+        //Add a function to the list of functions that will
+            //be called when a thread is about to exit.
+        //Currently only implemented for Win32, but should
+            //later be implemented for all platforms.
+        //Used by Win32 implementation of Boost.Threads
+            //tss to perform cleanup.
+        //Like the C runtime library atexit() function,
+            //which it mimics, at_thread_exit() returns
+            //zero if successful and a nonzero
+            //value if an error occurs.
+
+#endif //defined(BOOST_HAS_WINTHREADS)
+
+#if defined(BOOST_HAS_WINTHREADS)
+
+    extern "C" BOOST_THREAD_DECL void on_process_enter(void);
         //Function to be called when the exe or dll
             //that uses Boost.Threads first starts
             //or is first loaded.
@@ -24,7 +42,7 @@ namespace boost
             //a method for doing so has been discovered.
         //May be omitted; may be called multiple times.
 
-    BOOST_THREAD_DECL void __cdecl on_process_exit(void);
+    extern "C" BOOST_THREAD_DECL void on_process_exit(void);
         //Function to be called when the exe or dll
             //that uses Boost.Threads first starts
             //or is first loaded.
@@ -34,7 +52,7 @@ namespace boost
             //a method for doing so has been discovered.
         //Must not be omitted; may be called multiple times.
 
-    BOOST_THREAD_DECL void __cdecl on_thread_enter(void);
+    extern "C" BOOST_THREAD_DECL void on_thread_enter(void);
         //Function to be called just after a thread starts
             //in an exe or dll that uses Boost.Threads.
         //Must be called in the context of the thread
@@ -43,7 +61,7 @@ namespace boost
             //a method for doing so has been discovered.
         //May be omitted; may be called multiple times.
 
-    BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
+    extern "C" BOOST_THREAD_DECL void __cdecl on_thread_exit(void);
         //Function to be called just be fore a thread ends
             //in an exe or dll that uses Boost.Threads.
         //Must be called in the context of the thread
@@ -52,11 +70,10 @@ namespace boost
             //a method for doing so has been discovered.
         //Must not be omitted; may be called multiple times.
     
-    void tss_cleanup_implemented();
+    extern "C" void tss_cleanup_implemented(void);
         //Dummy function used both to detect whether tss cleanup
             //cleanup has been implemented and to force
             //it to be linked into the Boost.Threads library.
-}
 
 #endif //defined(BOOST_HAS_WINTHREADS)
 

include/boost/thread/future.hpp

@@ -9,8 +9,6 @@
 #include <stdexcept>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/thread_time.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/condition_variable.hpp>
 #include <boost/exception_ptr.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/scoped_ptr.hpp>
@@ -390,18 +388,15 @@ namespace boost
 
         class future_waiter
         {
-            struct registered_waiter;
-            typedef std::vector<registered_waiter>::size_type count_type;
-            
             struct registered_waiter
             {
                 boost::shared_ptr<detail::future_object_base> future;
                 detail::future_object_base::waiter_list::iterator wait_iterator;
-                count_type index;
+                unsigned index;
 
                 registered_waiter(boost::shared_ptr<detail::future_object_base> const& future_,
                                   detail::future_object_base::waiter_list::iterator wait_iterator_,
-                                  count_type index_):
+                                  unsigned index_):
                     future(future_),wait_iterator(wait_iterator_),index(index_)
                 {}
 
@@ -409,6 +404,7 @@ namespace boost
             
             struct all_futures_lock
             {
+                typedef std::vector<registered_waiter>::size_type count_type;
                 count_type count;
                 boost::scoped_array<boost::unique_lock<boost::mutex> > locks;
                 
@@ -428,7 +424,7 @@ namespace boost
                 
                 void unlock()
                 {
-                    for(count_type i=0;i<count;++i)
+                    for(unsigned i=0;i<count;++i)
                     {
                         locks[i].unlock();
                     }
@@ -437,7 +433,7 @@ namespace boost
             
             boost::condition_variable_any cv;
             std::vector<registered_waiter> futures;
-            count_type future_count;
+            unsigned future_count;
             
         public:
             future_waiter():
@@ -454,12 +450,12 @@ namespace boost
                 ++future_count;
             }
 
-            count_type wait()
+            unsigned wait()
             {
                 all_futures_lock lk(futures);
                 for(;;)
                 {
-                    for(count_type i=0;i<futures.size();++i)
+                    for(unsigned i=0;i<futures.size();++i)
                     {
                         if(futures[i].future->done)
                         {
@@ -472,7 +468,7 @@ namespace boost
             
             ~future_waiter()
             {
-                for(count_type i=0;i<futures.size();++i)
+                for(unsigned i=0;i<futures.size();++i)
                 {
                     futures[i].future->remove_external_waiter(futures[i].wait_iterator);
                 }

include/boost/thread/locks.hpp

@@ -11,7 +11,6 @@
 #include <iterator>
 #include <boost/thread/thread_time.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/type_traits/is_class.hpp>
 
 #include <boost/config/abi_prefix.hpp>
 
@@ -28,52 +27,8 @@ namespace boost
 #ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES
     namespace detail
     {
-#define BOOST_DEFINE_HAS_MEMBER_CALLED(member_name)                     \
-        template<typename T, bool=boost::is_class<T>::value>            \
-        struct has_member_called_##member_name                          \
-        {                                                               \
-            BOOST_STATIC_CONSTANT(bool, value=false);                   \
-        };                                                              \
-                                                                        \
-        template<typename T>                                            \
-        struct has_member_called_##member_name<T,true>                  \
-        {                                                               \
-            typedef char true_type;                                     \
-            struct false_type                                           \
-            {                                                           \
-                true_type dummy[2];                                     \
-            };                                                          \
-                                                                        \
-            struct fallback { int member_name; };                       \
-            struct derived:                                             \
-                T, fallback                                             \
-            {                                                           \
-                derived();                                              \
-            };                                                          \
-                                                                        \
-            template<int fallback::*> struct tester;                    \
-                                                                        \
-            template<typename U>                                        \
-                static false_type has_member(tester<&U::member_name>*); \
-            template<typename U>                                        \
-                static true_type has_member(...);                       \
-                                                                        \
-            BOOST_STATIC_CONSTANT(                                      \
-                bool, value=sizeof(has_member<derived>(0))==sizeof(true_type)); \
-        }
-
-        BOOST_DEFINE_HAS_MEMBER_CALLED(lock);
-        BOOST_DEFINE_HAS_MEMBER_CALLED(unlock);
-        BOOST_DEFINE_HAS_MEMBER_CALLED(try_lock);
-
-        template<typename T,bool=has_member_called_lock<T>::value >
+        template<typename T>
         struct has_member_lock
-        {
-            BOOST_STATIC_CONSTANT(bool, value=false);
-        };
-        
-        template<typename T>
-        struct has_member_lock<T,true>
         {
             typedef char true_type;
             struct false_type
@@ -81,23 +36,15 @@ namespace boost
                 true_type dummy[2];
             };
             
-            template<typename U,typename V>
-            static true_type has_member(V (U::*)());
             template<typename U>
-            static false_type has_member(U);
+            static true_type has_member(U*,void (U::*dummy)()=&U::lock);
+            static false_type has_member(void*);
             
-            BOOST_STATIC_CONSTANT(
-                bool,value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type));
+            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_lock<T>::has_member((T*)NULL))==sizeof(true_type));
         };
-        
-        template<typename T,bool=has_member_called_unlock<T>::value >
+
+        template<typename T>
         struct has_member_unlock
-        {
-            BOOST_STATIC_CONSTANT(bool, value=false);
-        };
-        
-        template<typename T>
-        struct has_member_unlock<T,true>
         {
             typedef char true_type;
             struct false_type
@@ -105,23 +52,15 @@ namespace boost
                 true_type dummy[2];
             };
             
-            template<typename U,typename V>
-            static true_type has_member(V (U::*)());
             template<typename U>
-            static false_type has_member(U);
+            static true_type has_member(U*,void (U::*dummy)()=&U::unlock);
+            static false_type has_member(void*);
             
-            BOOST_STATIC_CONSTANT(
-                bool,value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type));
+            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_unlock<T>::has_member((T*)NULL))==sizeof(true_type));
         };
         
-        template<typename T,bool=has_member_called_try_lock<T>::value >
+        template<typename T>
         struct has_member_try_lock
-        {
-            BOOST_STATIC_CONSTANT(bool, value=false);
-        };
-        
-        template<typename T>
-        struct has_member_try_lock<T,true>
         {
             typedef char true_type;
             struct false_type
@@ -130,12 +69,10 @@ namespace boost
             };
             
             template<typename U>
-            static true_type has_member(bool (U::*)());
-            template<typename U>
-            static false_type has_member(U);
+            static true_type has_member(U*,bool (U::*dummy)()=&U::try_lock);
+            static false_type has_member(void*);
             
-            BOOST_STATIC_CONSTANT(
-                bool,value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type));
+            BOOST_STATIC_CONSTANT(bool, value=sizeof(has_member_try_lock<T>::has_member((T*)NULL))==sizeof(true_type));
         };
 
     }

include/boost/thread/pthread/condition_variable.hpp

@@ -3,7 +3,7 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
-// (C) Copyright 2007-10 Anthony Williams
+// (C) Copyright 2007-8 Anthony Williams
 
 #include "timespec.hpp"
 #include "pthread_mutex_scoped_lock.hpp"
@@ -48,8 +48,8 @@ namespace boost
         pthread_mutex_t internal_mutex;
         pthread_cond_t cond;
 
-        condition_variable_any(condition_variable_any&);
-        condition_variable_any& operator=(condition_variable_any&);
+        condition_variable_any(condition_variable&);
+        condition_variable_any& operator=(condition_variable&);
 
     public:
         condition_variable_any()

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -47,8 +47,7 @@ namespace boost
             while(!pred()) wait(m);
         }
 
-        inline bool timed_wait(unique_lock<mutex>& m,
-                               boost::system_time const& wait_until);
+        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until);
         bool timed_wait(unique_lock<mutex>& m,xtime const& wait_until)
         {
             return timed_wait(m,system_time(wait_until));

include/boost/thread/pthread/mutex.hpp

@@ -27,11 +27,10 @@
 
 namespace boost
 {
-    class mutex
+    class mutex:
+        boost::noncopyable
     {
     private:
-        mutex(mutex const&);
-        mutex& operator=(mutex const&);        
         pthread_mutex_t m;
     public:
         mutex()
@@ -49,11 +48,7 @@ namespace boost
         
         void lock()
         {
-            int const res=pthread_mutex_lock(&m);
-            if(res)
-            {
-                boost::throw_exception(lock_error(res));
-            }
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
         }
 
         void unlock()
@@ -64,11 +59,7 @@ namespace boost
         bool try_lock()
         {
             int const res=pthread_mutex_trylock(&m);
-            if(res && (res!=EBUSY))
-            {
-                boost::throw_exception(lock_error(res));
-            }
-            
+            BOOST_ASSERT(!res || res==EBUSY);
             return !res;
         }
 
@@ -84,11 +75,9 @@ namespace boost
 
     typedef mutex try_mutex;
 
-    class timed_mutex
+    class timed_mutex:
+        boost::noncopyable
     {
-    private:
-        timed_mutex(timed_mutex const&);
-        timed_mutex& operator=(timed_mutex const&);        
     private:
         pthread_mutex_t m;
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK

include/boost/thread/pthread/recursive_mutex.hpp

@@ -30,11 +30,10 @@
 
 namespace boost
 {
-    class recursive_mutex
+    class recursive_mutex:
+        boost::noncopyable
     {
     private:
-        recursive_mutex(recursive_mutex const&);
-        recursive_mutex& operator=(recursive_mutex const&);        
         pthread_mutex_t m;
     public:
         recursive_mutex()
@@ -93,11 +92,9 @@ namespace boost
 
     typedef recursive_mutex recursive_try_mutex;
 
-    class recursive_timed_mutex
+    class recursive_timed_mutex:
+        boost::noncopyable
     {
-    private:
-        recursive_timed_mutex(recursive_timed_mutex const&);
-        recursive_timed_mutex& operator=(recursive_timed_mutex const&);        
     private:
         pthread_mutex_t m;
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK

include/boost/thread/pthread/shared_mutex.hpp

@@ -225,7 +225,7 @@ namespace boost
         template<typename TimeDuration>
         bool timed_lock_upgrade(TimeDuration const & relative_time)
         {
-            return timed_lock_upgrade(get_system_time()+relative_time);
+            return timed_lock(get_system_time()+relative_time);
         }
 
         bool try_lock_upgrade()

include/boost/thread/tss.hpp

@@ -62,8 +62,6 @@ namespace boost
         boost::shared_ptr<detail::tss_cleanup_function> cleanup;
         
     public:
-        typedef T element_type;
-        
         thread_specific_ptr():
             cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
         {}

include/boost/thread/win32/mutex.hpp

@@ -20,11 +20,9 @@ namespace boost
     }
 
     class mutex:
+        boost::noncopyable,
         public ::boost::detail::underlying_mutex
     {
-    private:
-        mutex(mutex const&);
-        mutex& operator=(mutex const&);
     public:
         mutex()
         {
@@ -42,11 +40,9 @@ namespace boost
     typedef mutex try_mutex;
 
     class timed_mutex:
+        boost::noncopyable,
         public ::boost::detail::basic_timed_mutex
     {
-    private:
-        timed_mutex(timed_mutex const&);
-        timed_mutex& operator=(timed_mutex const&);
     public:
         timed_mutex()
         {

include/boost/thread/win32/recursive_mutex.hpp

@@ -20,11 +20,9 @@
 namespace boost
 {
     class recursive_mutex:
+        boost::noncopyable,
         public ::boost::detail::basic_recursive_mutex
     {
-    private:
-        recursive_mutex(recursive_mutex const&);
-        recursive_mutex& operator=(recursive_mutex const&);        
     public:
         recursive_mutex()
         {
@@ -42,11 +40,9 @@ namespace boost
     typedef recursive_mutex recursive_try_mutex;
 
     class recursive_timed_mutex:
+        boost::noncopyable,
         public ::boost::detail::basic_recursive_timed_mutex
     {
-    private:
-        recursive_timed_mutex(recursive_timed_mutex const&);
-        recursive_timed_mutex& operator=(recursive_timed_mutex const&);        
     public:
         recursive_timed_mutex()
         {

include/boost/thread/win32/shared_mutex.hpp

@@ -19,11 +19,9 @@
 
 namespace boost
 {
-    class shared_mutex
+    class shared_mutex:
+        private boost::noncopyable
     {
-    private:
-        shared_mutex(shared_mutex const&);
-        shared_mutex& operator=(shared_mutex const&);        
     private:
         struct state_data
         {
@@ -51,35 +49,33 @@ namespace boost
             return *reinterpret_cast<T const*>(&res);
         }
 
-        enum
-        {
-            unlock_sem = 0,
-            exclusive_sem = 1
-        };
-
         state_data state;
         detail::win32::handle semaphores[2];
+        detail::win32::handle &unlock_sem;
+        detail::win32::handle &exclusive_sem;
         detail::win32::handle upgrade_sem;
 
         void release_waiters(state_data old_state)
         {
             if(old_state.exclusive_waiting)
             {
-                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[exclusive_sem],1,0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(exclusive_sem,1,0)!=0);
             }
                         
             if(old_state.shared_waiting || old_state.exclusive_waiting)
             {
-                BOOST_VERIFY(detail::win32::ReleaseSemaphore(semaphores[unlock_sem],old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
             }
         }
         
 
     public:
-        shared_mutex()
+        shared_mutex():
+            unlock_sem(semaphores[0]),
+            exclusive_sem(semaphores[1]) 
         {
-            semaphores[unlock_sem]=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
-            semaphores[exclusive_sem]=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            unlock_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+            exclusive_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
             upgrade_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
             state_data state_={0};
             state=state_;
@@ -88,8 +84,8 @@ namespace boost
         ~shared_mutex()
         {
             detail::win32::CloseHandle(upgrade_sem);
-            detail::win32::CloseHandle(semaphores[unlock_sem]);
-            detail::win32::CloseHandle(semaphores[exclusive_sem]);
+            detail::win32::CloseHandle(unlock_sem);
+            detail::win32::CloseHandle(exclusive_sem);
         }
 
         bool try_lock_shared()
@@ -101,10 +97,6 @@ namespace boost
                 if(!new_state.exclusive && !new_state.exclusive_waiting_blocked)
                 {
                     ++new_state.shared_count;
-                    if(!new_state.shared_count)
-                    {
-                        return false;
-                    }
                 }
                 
                 state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
@@ -139,18 +131,10 @@ namespace boost
                     if(new_state.exclusive || new_state.exclusive_waiting_blocked)
                     {
                         ++new_state.shared_waiting;
-                        if(!new_state.shared_waiting)
-                        {
-                            boost::throw_exception(boost::lock_error());
-                        }
                     }
                     else
                     {
                         ++new_state.shared_count;
-                        if(!new_state.shared_count)
-                        {
-                            boost::throw_exception(boost::lock_error());
-                        }
                     }
 
                     state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
@@ -166,7 +150,7 @@ namespace boost
                     return true;
                 }
                     
-                unsigned long const res=detail::win32::WaitForSingleObject(semaphores[unlock_sem],::boost::detail::get_milliseconds_until(wait_until));
+                unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,::boost::detail::get_milliseconds_until(wait_until));
                 if(res==detail::win32::timeout)
                 {
                     for(;;)
@@ -182,10 +166,6 @@ namespace boost
                         else
                         {
                             ++new_state.shared_count;
-                            if(!new_state.shared_count)
-                            {
-                                return false;
-                            }
                         }
 
                         state_data const current_state=interlocked_compare_exchange(&state,new_state,old_state);
@@ -302,11 +282,6 @@ namespace boost
                     if(new_state.shared_count || new_state.exclusive)
                     {
                         ++new_state.exclusive_waiting;
-                        if(!new_state.exclusive_waiting)
-                        {
-                            boost::throw_exception(boost::lock_error());
-                        }
-                        
                         new_state.exclusive_waiting_blocked=true;
                     }
                     else
@@ -399,18 +374,10 @@ namespace boost
                     if(new_state.exclusive || new_state.exclusive_waiting_blocked || new_state.upgrade)
                     {
                         ++new_state.shared_waiting;
-                        if(!new_state.shared_waiting)
-                        {
-                            boost::throw_exception(boost::lock_error());
-                        }
                     }
                     else
                     {
                         ++new_state.shared_count;
-                        if(!new_state.shared_count)
-                        {
-                            boost::throw_exception(boost::lock_error());
-                        }
                         new_state.upgrade=true;
                     }
 
@@ -427,7 +394,7 @@ namespace boost
                     return;
                 }
                     
-                BOOST_VERIFY(!detail::win32::WaitForSingleObject(semaphores[unlock_sem],detail::win32::infinite));
+                BOOST_VERIFY(!detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite));
             }
         }
 
@@ -444,10 +411,6 @@ namespace boost
                 else
                 {
                     ++new_state.shared_count;
-                    if(!new_state.shared_count)
-                    {
-                        return false;
-                    }
                     new_state.upgrade=true;
                 }
                 

include/boost/thread/win32/thread_data.hpp

@@ -144,11 +144,6 @@ namespace boost
                 start(0),milliseconds(~uintmax_t(0)),relative(true)
             {}
         };
-
-        inline unsigned long pin_to_zero(long value)
-        {
-            return (value<0)?0u:(unsigned long)value;
-        }
     }
 
     namespace this_thread
@@ -168,7 +163,7 @@ namespace boost
         template<typename TimeDuration>
         inline void sleep(TimeDuration const& rel_time)
         {
-            interruptible_wait(detail::pin_to_zero(rel_time.total_milliseconds()));
+            interruptible_wait(static_cast<unsigned long>(rel_time.total_milliseconds()));
         }
         inline void sleep(system_time const& abs_time)
         {

src/pthread/thread.cpp

@@ -75,7 +75,7 @@ namespace boost
                             {
                                 current=next;
                                 ++next;
-                                if(current->second.func && (current->second.value!=0))
+                                if(current->second.func && current->second.value)
                                 {
                                     (*current->second.func)(current->second.value);
                                 }
@@ -381,12 +381,12 @@ namespace boost
     {
 #if defined(PTW32_VERSION) || defined(__hpux)
         return pthread_num_processors_np();
+#elif defined(_GNU_SOURCE)
+        return get_nprocs();
 #elif defined(__APPLE__) || defined(__FreeBSD__)
         int count;
         size_t size=sizeof(count);
         return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
-#elif defined(_GNU_SOURCE)
-        return get_nprocs();
 #elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
         int const count=sysconf(_SC_NPROCESSORS_ONLN);
         return (count>0)?count:0;
@@ -582,11 +582,11 @@ namespace boost
         {
             if(tss_data_node* const current_node=find_tss_data(key))
             {
-                if(cleanup_existing && current_node->func && (current_node->value!=0))
+                if(cleanup_existing && current_node->func && current_node->value)
                 {
                     (*current_node->func)(current_node->value);
                 }
-                if(func || (tss_data!=0))
+                if(func || tss_data)
                 {
                     current_node->func=func;
                     current_node->value=tss_data;

src/win32/thread.cpp

@@ -304,7 +304,7 @@ namespace boost
     
     unsigned thread::hardware_concurrency()
     {
-        SYSTEM_INFO info={{0}};
+        SYSTEM_INFO info={0};
         GetSystemInfo(&info);
         return info.dwNumberOfProcessors;
     }
@@ -327,7 +327,7 @@ namespace boost
         {
             LARGE_INTEGER get_due_time(detail::timeout const&  target_time)
             {
-                LARGE_INTEGER due_time={{0}};
+                LARGE_INTEGER due_time={0};
                 if(target_time.relative)
                 {
                     unsigned long const elapsed_milliseconds=GetTickCount()-target_time.start;
@@ -356,23 +356,7 @@ namespace boost
                     else
                     {
                         long const hundred_nanoseconds_in_one_second=10000000;
-                        posix_time::time_duration::tick_type const ticks_per_second=
-                            target_time.abs_time.time_of_day().ticks_per_second();
-                        if(ticks_per_second>hundred_nanoseconds_in_one_second)
-                        {
-                            posix_time::time_duration::tick_type const 
-                                ticks_per_hundred_nanoseconds=
-                                ticks_per_second/hundred_nanoseconds_in_one_second;
-                            due_time.QuadPart+=
-                                target_time.abs_time.time_of_day().fractional_seconds()/
-                                ticks_per_hundred_nanoseconds;
-                        }
-                        else
-                        {
-                            due_time.QuadPart+=
-                                target_time.abs_time.time_of_day().fractional_seconds()*
-                                (hundred_nanoseconds_in_one_second/ticks_per_second);
-                        }
+                        due_time.QuadPart+=target_time.abs_time.time_of_day().fractional_seconds()*(hundred_nanoseconds_in_one_second/target_time.abs_time.time_of_day().ticks_per_second());
                     }
                 }
                 return due_time;
@@ -593,22 +577,22 @@ namespace boost
             }
         }
     }
-    BOOST_THREAD_DECL void __cdecl on_process_enter()
-    {}
-
-    BOOST_THREAD_DECL void __cdecl on_thread_enter()
-    {}
-
-    BOOST_THREAD_DECL void __cdecl on_process_exit()
-    {
-        boost::cleanup_tls_key();
-    }
-
-    BOOST_THREAD_DECL void __cdecl on_thread_exit()
-    {
-        boost::run_thread_exit_callbacks();
-    }
-
 }
 
 
+extern "C" BOOST_THREAD_DECL void on_process_enter()
+{}
+
+extern "C" BOOST_THREAD_DECL void on_thread_enter()
+{}
+
+extern "C" BOOST_THREAD_DECL void on_process_exit()
+{
+    boost::cleanup_tls_key();
+}
+
+extern "C" BOOST_THREAD_DECL void on_thread_exit()
+{
+    boost::run_thread_exit_callbacks();
+}
+

src/win32/tss_dll.cpp

@@ -24,27 +24,27 @@
         {
             case DLL_PROCESS_ATTACH:
             {
-                boost::on_process_enter();
-                boost::on_thread_enter();
+                on_process_enter();
+                on_thread_enter();
                 break;
             }
 
             case DLL_THREAD_ATTACH:
             {
-                boost::on_thread_enter();
+                on_thread_enter();
                 break;
             }
 
             case DLL_THREAD_DETACH:
             {
-                boost::on_thread_exit();
+                on_thread_exit();
                 break;
             }
 
             case DLL_PROCESS_DETACH:
             {
-                boost::on_thread_exit();
-                boost::on_process_exit();
+                on_thread_exit();
+                on_process_exit();
                 break;
             }
         }
@@ -52,9 +52,7 @@
         return TRUE;
     }
 
-namespace boost
-{
-    void tss_cleanup_implemented()
+    extern "C" void tss_cleanup_implemented(void)
     {
         /*
         This function's sole purpose is to cause a link error in cases where
@@ -70,7 +68,5 @@ namespace boost
         longer needed and can be removed.
         */
     }
-}
-
 
 #endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)

src/win32/tss_pe.cpp

@@ -19,10 +19,7 @@
 
 #include <cstdlib>
 
-namespace boost
-{
-    void tss_cleanup_implemented() {}
-}
+extern "C" void tss_cleanup_implemented(void) {}
 
 namespace {
     void NTAPI on_tls_callback(void* h, DWORD dwReason, PVOID pv)
@@ -31,18 +28,33 @@ namespace {
         {
         case DLL_THREAD_DETACH:
         {
-            boost::on_thread_exit();
+            on_thread_exit();
             break;
         }
         }
     }
+
+    void on_after_ctors(void)
+    {
+        on_process_enter();
+    }
+    
+    void on_before_dtors(void)
+    {
+        on_thread_exit();
+    }
+    
+    void on_after_dtors(void)
+    {
+        on_process_exit();        
+    }
 }
 
 extern "C" {
 
-    void (* after_ctors )(void) __attribute__((section(".ctors")))     = boost::on_process_enter;
-    void (* before_dtors)(void) __attribute__((section(".dtors")))     = boost::on_thread_exit;
-    void (* after_dtors )(void) __attribute__((section(".dtors.zzz"))) = boost::on_process_exit;
+    void (* after_ctors )(void) __attribute__((section(".ctors")))     = on_after_ctors;
+    void (* before_dtors)(void) __attribute__((section(".dtors")))     = on_before_dtors;
+    void (* after_dtors )(void) __attribute__((section(".dtors.zzz"))) = on_after_dtors;
 
     ULONG __tls_index__ = 0;
     char __tls_end__ __attribute__((section(".tls$zzz"))) = 0;
@@ -209,18 +221,18 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
             //for destructors of global objects, so that
             //shouldn't be a problem.
 
-            atexit(boost::on_thread_exit);
+            atexit(on_thread_exit);
 
             //Call Boost process entry callback here
 
-            boost::on_process_enter();
+            on_process_enter();
 
             return INIRETSUCCESS;
         }
 
         PVAPI on_process_term(void)
         {
-            boost::on_process_exit();
+            on_process_exit();
             return INIRETSUCCESS;
         }
 
@@ -229,7 +241,7 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
             switch (dwReason)
             {
             case DLL_THREAD_DETACH:
-                boost::on_thread_exit();
+                on_thread_exit();
                 break;
             }
         }
@@ -239,10 +251,10 @@ extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata
             switch (dwReason)
             {
             case DLL_THREAD_DETACH:
-                boost::on_thread_exit();
+                on_thread_exit();
                 break;
             case DLL_PROCESS_DETACH:
-                boost::on_process_exit();
+                on_process_exit();
                 break;
             }
             return true;
@@ -253,9 +265,8 @@ extern "C"
 {
     extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID)=&dll_callback;
 }
-namespace boost
-{
-    void tss_cleanup_implemented()
+
+    extern "C" void tss_cleanup_implemented(void)
     {
         /*
         This function's sole purpose is to cause a link error in cases where
@@ -271,8 +282,6 @@ namespace boost
         longer needed and can be removed.
         */
     }
-}
-
 #endif //defined(_MSC_VER) && !defined(UNDER_CE)
 
 #endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)

test/test_generic_locks.cpp

@@ -296,80 +296,10 @@ void test_lock_five_in_range()
     }
 }
 
-class dummy_iterator:
-    public std::iterator<std::forward_iterator_tag,
-                         dummy_mutex>
-{
-private:
-    dummy_mutex* p;
-public:
-    explicit dummy_iterator(dummy_mutex* p_):
-        p(p_)
-    {}
-    
-    bool operator==(dummy_iterator const& other) const
-    {
-        return p==other.p;
-    }
-
-    bool operator!=(dummy_iterator const& other) const
-    {
-        return p!=other.p;
-    }
-
-    bool operator<(dummy_iterator const& other) const
-    {
-        return p<other.p;
-    }
-    
-    dummy_mutex& operator*() const
-    {
-        return *p;
-    }
-
-    dummy_mutex* operator->() const
-    {
-        return p;
-    }
-    
-    dummy_iterator operator++(int)
-    {
-        dummy_iterator temp(*this);
-        ++p;
-        return temp;
-    }
-    
-    dummy_iterator& operator++()
-    {
-        ++p;
-        return *this;
-    }
-    
-};
-    
-
-void test_lock_five_in_range_custom_iterator()
-{
-    unsigned const num_mutexes=5;
-    dummy_mutex mutexes[num_mutexes];
-
-    boost::lock(dummy_iterator(mutexes),dummy_iterator(mutexes+num_mutexes));
-    
-    for(unsigned i=0;i<num_mutexes;++i)
-    {
-        BOOST_CHECK(mutexes[i].is_locked);
-    }
-}
-
-class dummy_mutex2:
-    public dummy_mutex
-{};
-
-
-void test_lock_ten_in_range_inherited_mutex()
+void test_lock_ten_in_range()
 {
     unsigned const num_mutexes=10;
-    dummy_mutex2 mutexes[num_mutexes];
+    dummy_mutex mutexes[num_mutexes];
 
     boost::lock(mutexes,mutexes+num_mutexes);
     
@@ -580,8 +510,7 @@ boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
     test->add(BOOST_TEST_CASE(&test_lock_five_other_thread_locks_in_order));
     test->add(BOOST_TEST_CASE(&test_lock_five_other_thread_locks_in_different_order));
     test->add(BOOST_TEST_CASE(&test_lock_five_in_range));
-    test->add(BOOST_TEST_CASE(&test_lock_five_in_range_custom_iterator));
-    test->add(BOOST_TEST_CASE(&test_lock_ten_in_range_inherited_mutex));
+    test->add(BOOST_TEST_CASE(&test_lock_ten_in_range));
     test->add(BOOST_TEST_CASE(&test_lock_ten_other_thread_locks_in_different_order));
     test->add(BOOST_TEST_CASE(&test_try_lock_two_uncontended));
     test->add(BOOST_TEST_CASE(&test_try_lock_two_first_locked));