This commit was manufactured by cvs2svn to create tag 'thread_base'.

[SVN r17054]

build/threads.jam

@@ -22,7 +22,6 @@
         :
         ## requirements ##
         : <sysinclude>$(BOOST_ROOT) <threading>multi $(pthreads-win32)
-		<borland><*><cxxflags>-w-8004
         ## default build ##
         :
     ;

doc/acknowledgments.html

@@ -27,8 +27,8 @@
   Win32 implementation, especially in regards to boost::condition, as well as
   a lot of explanation of POSIX behavior), Greg Colvin (lots of input on the design),
   Paul Mclachlan, Thomas Matelich and Iain Hanson (for help in trying to get the
-  build to work on other platforms), Kevin S. Van Horn (for several updates/corrections
-  to the documentation), and Martin Johnson (shared library implementation).</p>
+  build to work on other platforms), and Kevin S. Van Horn (for several updates/corrections
+  to the documentation).</p>
 <p>The documentation was written by William E. Kempf. Beman Dawes provided additional
   documentation material and editing.</p>
 <p>Discussions on the boost.org mailing list were essential in the development

example/Jamfile

@@ -1,19 +1,7 @@
-#  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell
-#  and distribute this software is granted provided this copyright notice
-#  appears in all copies. This software is provided "as is" without express or
-#  implied warranty, and with no claim as to its suitability for any purpose.
-#
-# Boost.Threads example Jamfile
-#
-# Additional configuration variables used:
-#   1. PTW32 may be used on Win32 platforms to specify that the pthreads-win32
-#      library should be used instead of "native" threads. This feature is
-#      mostly used for testing and it's generally recommended you use the
-#      native threading libraries instead. PTW32 should be set to be a list
-#      of two strings, the first specifying the installation path of the
-#      pthreads-win32 library and the second specifying which library
-#      variant to link against (see the pthreads-win32 documentation).
-#      Example: jam -sPTW32="c:\pthreads-win32 pthreadVCE.lib"
+#  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
 
 # Declare the location of this subproject relative to the root.
 subproject libs/thread/example ;
@@ -24,26 +12,25 @@ subproject libs/thread/example ;
 SEARCH on <module@>threads.jam = $(BOOST_ROOT)/libs/thread/build ;
 include <module@>threads.jam ;
 
-{
-    template example
-        ## sources ##
-        : <template>thread_base
-          <dll>../build/boost_thread
-        ## requirements ##
-        :
-        ## default build ##
-        :
-    ;
+template example
+    ## sources ##
+    : <template>thread_base
+      <dll>../build/boost_thread
+      $(threadmon)
+    ## requirements ##
+    :
+    ## default build ##
+    : release <runtime-link>dynamic
+;
 
-    exe monitor : <template>example monitor.cpp ;
-    exe starvephil : <template>example starvephil.cpp ;
-    exe tennis : <template>example tennis.cpp ;
-    exe condition : <template>example condition.cpp ;
-    exe mutex : <template>example mutex.cpp ;
-    exe once : <template>example once.cpp ;
-    exe recursive_mutex : <template>example recursive_mutex.cpp ;
-    exe thread : <template>example thread.cpp ;
-    exe thread_group : <template>example thread_group.cpp ;
-    exe tss : <template>example tss.cpp ;
-    exe xtime : <template>example xtime.cpp ;
-}
+exe monitor : <template>example monitor.cpp ;
+exe starvephil : <template>example starvephil.cpp ;
+exe tennis : <template>example tennis.cpp ;
+exe condition : <template>example condition.cpp ;
+exe mutex : <template>example mutex.cpp ;
+exe once : <template>example once.cpp ;
+exe recursive_mutex : <template>example recursive_mutex.cpp ;
+exe thread : <template>example thread.cpp ;
+exe thread_group : <template>example thread_group.cpp ;
+exe tss : <template>example tss.cpp ;
+exe xtime : <template>example xtime.cpp ;

example/condition.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <iostream>
 #include <vector>
 #include <boost/utility.hpp>
@@ -54,9 +43,9 @@ bounded_buffer buf(2);
 void sender() {
     int n = 0;
     while (n < 100) {
-        buf.send(n);
-        std::cout << "sent: " << n << std::endl;
-        ++n;
+       buf.send(n);
+       std::cout << "sent: " << n << std::endl;
+       ++n;
     }
     buf.send(-1);
 }
@@ -64,8 +53,8 @@ void sender() {
 void receiver() {
     int n;
     do {
-        n = buf.receive();
-        std::cout << "received: " << n << std::endl;
+       n = buf.receive();
+       std::cout << "received: " << n << std::endl;
     } while (n != -1); // -1 indicates end of buffer
 }
 

example/monitor.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <vector>
 #include <iostream>
 #include <boost/thread/condition.hpp>
@@ -17,11 +6,9 @@
 #include <boost/thread/thread.hpp>
 
 namespace {
-
-const int ITERS = 100;
-boost::mutex io_mutex;
-
-} // namespace
+    const int ITERS = 100;
+    boost::mutex io_mutex;
+}
 
 template <typename M>
 class buffer_t

example/mutex.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <iostream>

example/once.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/thread/once.hpp>
 #include <cassert>
@@ -23,14 +12,14 @@ void init()
 
 void thread_proc()
 {
-    boost::call_once(&init, once);
+   boost::call_once(&init, once);
 }
 
 int main(int argc, char* argv[])
 {
-    boost::thread_group threads;
-    for (int i=0; i<5; ++i)
-        threads.create_thread(&thread_proc);
-    threads.join_all();
-    assert(value == 1);
+   boost::thread_group threads;
+   for (int i=0; i<5; ++i)
+      threads.create_thread(&thread_proc);
+   threads.join_all();
+   assert(value == 1);
 }

example/recursive_mutex.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <iostream>

example/starvephil.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
@@ -16,10 +5,9 @@
 #include <iostream>
 #include <time.h>
 
-namespace {
-
-boost::mutex iomx;
-
+namespace
+{
+    boost::mutex iomx;
 }
 
 class canteen
@@ -51,9 +39,8 @@ public:
         boost::mutex::scoped_lock lock(m_mutex);
         {
             boost::mutex::scoped_lock lock(iomx);
-            std::cout << "(" << clock()
-                      << ") Chef: ouch ... make room ... this dish is "
-                      << "very hot ..." << std::endl;
+            std::cout << "(" << clock() <<
+                ") Chef: ouch ... make room ... this dish is very hot ..." << std::endl;
         }
         boost::xtime xt;
         boost::xtime_get(&xt, boost::TIME_UTC);
@@ -97,7 +84,7 @@ void chef()
         {
             boost::mutex::scoped_lock lock(iomx);
             std::cout << "(" << clock() << ") Chef: " << chickens
-                      << " chickens, ready-to-go ..." << std::endl;
+                << " chickens, ready-to-go ..." << std::endl;
         }
         g_canteen.put(chickens);
     }
@@ -109,8 +96,7 @@ struct phil
     void run() {
         {
             boost::mutex::scoped_lock lock(iomx);
-            std::cout << "(" << clock() << ") Phil" << m_id
-                      << ": starting ..." << std::endl;
+            std::cout << "(" << clock() << ") Phil" << m_id << ": starting ..." << std::endl;
         }
         for (;;)
         {
@@ -124,13 +110,13 @@ struct phil
             {
                 boost::mutex::scoped_lock lock(iomx);
                 std::cout << "(" << clock() << ") Phil" << m_id
-                          << ": gotta eat ..." << std::endl;
+                    << ": gotta eat ..." << std::endl;
             }
             g_canteen.get(m_id);
             {
                 boost::mutex::scoped_lock lock(iomx);
                 std::cout << "(" << clock() << ") Phil" << m_id
-                          << ": mmm ... that's good ..." << std::endl;
+                    << ": mmm ... that's good ..." << std::endl;
             }
         }
     }
@@ -143,10 +129,7 @@ struct phil
 
 struct thread_adapt
 {
-    thread_adapt(void (*func)(void*), void* param)
-        : _func(func), _param(param)
-    {
-    }
+    thread_adapt(void (*func)(void*), void* param) : _func(func), _param(param) { }
     int operator()() const
     {
         _func(_param);
@@ -160,10 +143,7 @@ struct thread_adapt
 class thread_adapter
 {
 public:
-    thread_adapter(void (*func)(void*), void* param)
-        : _func(func), _param(param)
-    {
-    }
+    thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
     void operator()() const { _func(_param); }
 private:
     void (*_func)(void*);

example/tennis.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
@@ -60,8 +49,7 @@ void player(void* param)
         {
             cond.wait(lock);
             if (state == other)
-                std::cout << "---" << player_name(active)
-                          << ": Spurious wakeup!" << std::endl;
+                std::cout << "---" << player_name(active) << ": Spurious wakeup!" << std::endl;
         } while (state == other);
     }
 
@@ -72,10 +60,7 @@ void player(void* param)
 
 struct thread_adapt
 {
-    thread_adapt(void (*func)(void*), void* param)
-        : _func(func), _param(param)
-    {
-    }
+    thread_adapt(void (*func)(void*), void* param) : _func(func), _param(param) { }
     int operator()() const
     {
         _func(_param);
@@ -89,10 +74,7 @@ struct thread_adapt
 class thread_adapter
 {
 public:
-    thread_adapter(void (*func)(void*), void* param)
-        : _func(func), _param(param)
-    {
-    }
+    thread_adapter(void (*func)(void*), void* param) : _func(func), _param(param) { }
     void operator()() const { _func(_param); }
 private:
     void (*_func)(void*);

example/thread.cpp

@@ -1,40 +1,29 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 #include <iostream>
 
 struct thread_alarm
 {
-    thread_alarm(int secs) : m_secs(secs) { }
-    void operator()()
-    {
-        boost::xtime xt;
-        boost::xtime_get(&xt, boost::TIME_UTC);
-        xt.sec += m_secs;
+   thread_alarm(int secs) : m_secs(secs) { }
+   void operator()()
+   {
+       boost::xtime xt;
+       boost::xtime_get(&xt, boost::TIME_UTC);
+       xt.sec += m_secs;
 
-        boost::thread::sleep(xt);
+       boost::thread::sleep(xt);
 
-        std::cout << "alarm sounded..." << std::endl;
-    }
+       std::cout << "alarm sounded..." << std::endl;
+   }
 
-    int m_secs;
+   int m_secs;
 };
 
 int main(int argc, char* argv[])
 {
-    int secs = 5;
-    std::cout << "setting alarm for 5 seconds..." << std::endl;
-    thread_alarm alarm(secs);
-    boost::thread thrd(alarm);
-    thrd.join();
+   int secs = 5;
+   std::cout << "setting alarm for 5 seconds..." << std::endl;
+   thread_alarm alarm(secs);
+   boost::thread thrd(alarm);
+   thrd.join();
 }

example/thread_group.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <iostream>
 
@@ -17,14 +6,14 @@ boost::mutex mutex;
 
 void increment_count()
 {
-    boost::mutex::scoped_lock lock(mutex);
-    std::cout << "count = " << ++count << std::endl;
+   boost::mutex::scoped_lock lock(mutex);
+   std::cout << "count = " << ++count << std::endl;
 }
 
 int main(int argc, char* argv[])
 {
-    boost::thread_group threads;
-    for (int i = 0; i < 10; ++i)
-        threads.create_thread(&increment_count);
-    threads.join_all();
+   boost::thread_group threads;
+   for (int i = 0; i < 10; ++i)
+      threads.create_thread(&increment_count);
+   threads.join_all();
 }

example/tss.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/thread/tss.hpp>
 #include <cassert>
@@ -17,25 +6,25 @@ boost::thread_specific_ptr<int> value;
 
 void increment()
 {
-    int* p = value.get();
-    ++*p;
+   int* p = value.get();
+   ++*p;
 }
 
 void thread_proc()
 {
-    value.reset(new int(0)); // initialize the thread's storage
-    for (int i=0; i<10; ++i)
-    {
-        increment();
-        int* p = value.get();
-        assert(*p == i+1);
-    }
+   value.reset(new int(0)); // initialize the thread's storage
+   for (int i=0; i<10; ++i)
+   {
+       increment();
+       int* p = value.get();
+       assert(*p == i+1);
+   }
 }
 
 int main(int argc, char* argv[])
 {
-    boost::thread_group threads;
-    for (int i=0; i<5; ++i)
-        threads.create_thread(&thread_proc);
-    threads.join_all();
+   boost::thread_group threads;
+   for (int i=0; i<5; ++i)
+      threads.create_thread(&thread_proc);
+   threads.join_all();
 }

example/xtime.cpp

@@ -1,21 +1,10 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 
 int main(int argc, char* argv[])
 {
-    boost::xtime xt;
-    boost::xtime_get(&xt, boost::TIME_UTC);
-    xt.sec += 1;
-    boost::thread::sleep(xt); // Sleep for 1 second
+   boost::xtime xt;
+   boost::xtime_get(&xt, boost::TIME_UTC);
+   xt.sec += 1;
+   boost::thread::sleep(xt); // Sleep for 1 second
 }

include/boost/thread.hpp

@@ -1,24 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
-#if !defined(BOOST_THREAD_WEK01082003_HPP)
-#define BOOST_THREAD_WEK01082003_HPP
-
-#include <boost/thread/thread.hpp>
-#include <boost/thread/condition.hpp>
-#include <boost/thread/exceptions.hpp>
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/once.hpp>
-#include <boost/thread/recursive_mutex.hpp>
-#include <boost/thread/tss.hpp>
-#include <boost/thread/xtime.hpp>
-
-#endif

include/boost/thread/condition.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -143,9 +143,9 @@ private:
         typedef detail::thread::lock_ops<M>
 #if defined(__HP_aCC) && __HP_aCC <= 33900 && !defined(BOOST_STRICT_CONFIG)
 # define lock_ops lock_ops_  // HP confuses lock_ops witht the template
-#endif
+#endif 
             lock_ops;
-
+        
         typename lock_ops::lock_state state;
         lock_ops::unlock(mutex, state);
 
@@ -169,9 +169,9 @@ private:
         typedef detail::thread::lock_ops<M>
 #if defined(__HP_aCC) && __HP_aCC <= 33900 && !defined(BOOST_STRICT_CONFIG)
 # define lock_ops lock_ops_  // HP confuses lock_ops witht the template
-#endif
+#endif 
             lock_ops;
-
+        
         typename lock_ops::lock_state state;
         lock_ops::unlock(mutex, state);
 

include/boost/thread/detail/config.hpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #ifndef BOOST_THREAD_CONFIG_WEK01032003_HPP
 #define BOOST_THREAD_CONFIG_WEK01032003_HPP
 

include/boost/thread/detail/force_cast.hpp

@@ -26,12 +26,12 @@ namespace thread {
 // general case
 template<class Return_Type, class Argument_Type>
 inline Return_Type &force_cast(Argument_Type &rSrc)
-{   return(*reinterpret_cast<Return_Type *>(&rSrc));    }
+    {   return(*reinterpret_cast<Return_Type *>(&rSrc));    }
 
 // specialization for const
 template<class Return_Type, class Argument_Type>
 inline const Return_Type &force_cast(const Argument_Type &rSrc)
-{   return(*reinterpret_cast<const Return_Type *>(&rSrc));  }
+    {   return(*reinterpret_cast<const Return_Type *>(&rSrc));  }
 
 
 } // namespace thread

include/boost/thread/detail/lock.hpp

@@ -20,182 +20,182 @@ namespace boost {
 class condition;
 struct xtime;
 
-namespace detail { namespace thread {
+    namespace detail { namespace thread {
 
-template <typename Mutex>
-class lock_ops : private noncopyable
-{
-private:
-    lock_ops() { }
+    template <typename Mutex>
+    class lock_ops : private noncopyable
+    {
+    private:
+        lock_ops() { }
 
-public:
-    typedef typename Mutex::cv_state lock_state;
+    public:
+        typedef typename Mutex::cv_state lock_state;
 
-    static void lock(Mutex& m)
-    {
-        m.do_lock();
-    }
-    static bool trylock(Mutex& m)
-    {
-        return m.do_trylock();
-    }
-    static bool timedlock(Mutex& m, const xtime& xt)
-    {
-        return m.do_timedlock(xt);
-    }
-    static void unlock(Mutex& m)
-    {
-        m.do_unlock();
-    }
-    static void lock(Mutex& m, lock_state& state)
-    {
-        m.do_lock(state);
-    }
-    static void unlock(Mutex& m, lock_state& state)
-    {
-        m.do_unlock(state);
-    }
-};
+        static void lock(Mutex& m)
+        {
+            m.do_lock();
+        }
+        static bool trylock(Mutex& m)
+        {
+            return m.do_trylock();
+        }
+        static bool timedlock(Mutex& m, const xtime& xt)
+        {
+            return m.do_timedlock(xt);
+        }
+        static void unlock(Mutex& m)
+        {
+            m.do_unlock();
+        }
+        static void lock(Mutex& m, lock_state& state)
+        {
+            m.do_lock(state);
+        }
+        static void unlock(Mutex& m, lock_state& state)
+        {
+            m.do_unlock(state);
+        }
+    };
 
-template <typename Mutex>
-class scoped_lock : private noncopyable
-{
-public:
-    typedef Mutex mutex_type;
-
-    explicit scoped_lock(Mutex& mx, bool initially_locked=true)
-        : m_mutex(mx), m_locked(false)
+    template <typename Mutex>
+    class scoped_lock : private noncopyable
     {
-        if (initially_locked) lock();
-    }
-    ~scoped_lock()
+    public:
+        typedef Mutex mutex_type;
+
+        explicit scoped_lock(Mutex& mx, bool initially_locked=true)
+            : m_mutex(mx), m_locked(false)
+        {
+            if (initially_locked) lock();
+        }
+        ~scoped_lock()
+        {
+            if (m_locked) unlock();
+        }
+
+        void lock()
+        {
+            if (m_locked) throw lock_error();
+            lock_ops<Mutex>::lock(m_mutex);
+            m_locked = true;
+        }
+        void unlock()
+        {
+            if (!m_locked) throw lock_error();
+            lock_ops<Mutex>::unlock(m_mutex);
+            m_locked = false;
+        }
+
+        bool locked() const { return m_locked; }
+        operator const void*() const { return m_locked ? this : 0; }
+
+    private:
+        friend class boost::condition;
+
+        Mutex& m_mutex;
+        bool m_locked;
+    };
+
+    template <typename TryMutex>
+    class scoped_try_lock : private noncopyable
     {
-        if (m_locked) unlock();
-    }
+    public:
+        typedef TryMutex mutex_type;
 
-    void lock()
+        explicit scoped_try_lock(TryMutex& mx)
+            : m_mutex(mx), m_locked(false)
+        {
+            try_lock();
+        }
+        scoped_try_lock(TryMutex& mx, bool initially_locked)
+            : m_mutex(mx), m_locked(false)
+        {
+            if (initially_locked) lock();
+        }
+        ~scoped_try_lock()
+        {
+            if (m_locked) unlock();
+        }
+
+        void lock()
+        {
+            if (m_locked) throw lock_error();
+            lock_ops<TryMutex>::lock(m_mutex);
+            m_locked = true;
+        }
+        bool try_lock()
+        {
+            if (m_locked) throw lock_error();
+            return (m_locked = lock_ops<TryMutex>::trylock(m_mutex));
+        }
+        void unlock()
+        {
+            if (!m_locked) throw lock_error();
+            lock_ops<TryMutex>::unlock(m_mutex);
+            m_locked = false;
+        }
+
+        bool locked() const { return m_locked; }
+        operator const void*() const { return m_locked ? this : 0; }
+
+    private:
+        friend class boost::condition;
+
+        TryMutex& m_mutex;
+        bool m_locked;
+    };
+
+    template <typename TimedMutex>
+    class scoped_timed_lock : private noncopyable
     {
-        if (m_locked) throw lock_error();
-        lock_ops<Mutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<Mutex>::unlock(m_mutex);
-        m_locked = false;
-    }
+    public:
+        typedef TimedMutex mutex_type;
 
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
+        scoped_timed_lock(TimedMutex& mx, const xtime& xt)
+            : m_mutex(mx), m_locked(false)
+        {
+            timed_lock(xt);
+        }
+        scoped_timed_lock(TimedMutex& mx, bool initially_locked)
+            : m_mutex(mx), m_locked(false)
+        {
+            if (initially_locked) lock();
+        }
+        ~scoped_timed_lock()
+        {
+            if (m_locked) unlock();
+        }
 
-private:
-    friend class boost::condition;
+        void lock()
+        {
+            if (m_locked) throw lock_error();
+            lock_ops<TimedMutex>::lock(m_mutex);
+            m_locked = true;
+        }
+        bool timed_lock(const xtime& xt)
+        {
+            if (m_locked) throw lock_error();
+            return (m_locked = lock_ops<TimedMutex>::timedlock(m_mutex, xt));
+        }
+        void unlock()
+        {
+            if (!m_locked) throw lock_error();
+            lock_ops<TimedMutex>::unlock(m_mutex);
+            m_locked = false;
+        }
 
-    Mutex& m_mutex;
-    bool m_locked;
-};
+        bool locked() const { return m_locked; }
+        operator const void*() const { return m_locked ? this : 0; }
 
-template <typename TryMutex>
-class scoped_try_lock : private noncopyable
-{
-public:
-    typedef TryMutex mutex_type;
+    private:
+        friend class boost::condition;
 
-    explicit scoped_try_lock(TryMutex& mx)
-        : m_mutex(mx), m_locked(false)
-    {
-        try_lock();
-    }
-    scoped_try_lock(TryMutex& mx, bool initially_locked)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_try_lock()
-    {
-        if (m_locked) unlock();
-    }
+        TimedMutex& m_mutex;
+        bool m_locked;
+    };
 
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<TryMutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    bool try_lock()
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TryMutex>::trylock(m_mutex));
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<TryMutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    TryMutex& m_mutex;
-    bool m_locked;
-};
-
-template <typename TimedMutex>
-class scoped_timed_lock : private noncopyable
-{
-public:
-    typedef TimedMutex mutex_type;
-
-    scoped_timed_lock(TimedMutex& mx, const xtime& xt)
-        : m_mutex(mx), m_locked(false)
-    {
-        timed_lock(xt);
-    }
-    scoped_timed_lock(TimedMutex& mx, bool initially_locked)
-        : m_mutex(mx), m_locked(false)
-    {
-        if (initially_locked) lock();
-    }
-    ~scoped_timed_lock()
-    {
-        if (m_locked) unlock();
-    }
-
-    void lock()
-    {
-        if (m_locked) throw lock_error();
-        lock_ops<TimedMutex>::lock(m_mutex);
-        m_locked = true;
-    }
-    bool timed_lock(const xtime& xt)
-    {
-        if (m_locked) throw lock_error();
-        return (m_locked = lock_ops<TimedMutex>::timedlock(m_mutex, xt));
-    }
-    void unlock()
-    {
-        if (!m_locked) throw lock_error();
-        lock_ops<TimedMutex>::unlock(m_mutex);
-        m_locked = false;
-    }
-
-    bool locked() const { return m_locked; }
-    operator const void*() const { return m_locked ? this : 0; }
-
-private:
-    friend class boost::condition;
-
-    TimedMutex& m_mutex;
-    bool m_locked;
-};
-
-} // namespace thread
-} // namespace detail
+    } // namespace thread
+    } // namespace detail
 } // namespace boost
 
 // Change Log:

include/boost/thread/detail/singleton.hpp

@@ -26,29 +26,29 @@ namespace thread {
 template<class T>
 class singleton: private T
 {
-private:
+  private:
     singleton();
     ~singleton();
 
-public:
+  public:
     static T &instance();
 };
 
 
 template<class T>
 inline singleton<T>::singleton()
-{   /* no-op */ }
+    {   /* no-op */ }
 
 template<class T>
 inline singleton<T>::~singleton()
-{   /* no-op */ }
+    {   /* no-op */ }
 
 
 template<class T>
 /*static*/ T &singleton<T>::instance()
 {
-    // function-local static to force this to work correctly at static
-    // initialization time.
+// function-local static to force this to work correctly at static initialization
+//  time.
     static singleton<T> s_oT;
     return(s_oT);
 }

include/boost/thread/detail/threadmon.hpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/config.hpp>
 #ifndef BOOST_HAS_THREADS
 #   error   Thread support is unavailable!

include/boost/thread/exceptions.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software

include/boost/thread/mutex.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software

include/boost/thread/once.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software

include/boost/thread/recursive_mutex.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -80,8 +80,7 @@ public:
     friend class detail::thread::lock_ops<recursive_try_mutex>;
 
     typedef detail::thread::scoped_lock<recursive_try_mutex> scoped_lock;
-    typedef detail::thread::scoped_try_lock<
-        recursive_try_mutex> scoped_try_lock;
+    typedef detail::thread::scoped_try_lock<recursive_try_mutex> scoped_try_lock;
 
     recursive_try_mutex();
     ~recursive_try_mutex();
@@ -126,10 +125,8 @@ public:
     friend class detail::thread::lock_ops<recursive_timed_mutex>;
 
     typedef detail::thread::scoped_lock<recursive_timed_mutex> scoped_lock;
-    typedef detail::thread::scoped_try_lock<
-        recursive_timed_mutex> scoped_try_lock;
-    typedef detail::thread::scoped_timed_lock<
-        recursive_timed_mutex> scoped_timed_lock;
+    typedef detail::thread::scoped_try_lock<recursive_timed_mutex> scoped_try_lock;
+    typedef detail::thread::scoped_timed_lock<recursive_timed_mutex> scoped_timed_lock;
 
     recursive_timed_mutex();
     ~recursive_timed_mutex();

include/boost/thread/thread.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software

include/boost/thread/tss.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -28,32 +28,32 @@
 
 namespace boost {
 
-namespace detail {
-class BOOST_THREAD_DECL tss : private noncopyable
-{
-public:
-    tss(void (*cleanup)(void*)=0);
-    ~tss();
+    namespace detail {
+        class BOOST_THREAD_DECL tss : private noncopyable
+        {
+        public:
+            tss(void (*cleanup)(void*)=0);
+            ~tss();
 
-    void* get() const;
-    bool set(void* value);
+            void* get() const;
+            bool set(void* value);
 
-private:
-#if defined(BOOST_HAS_WINTHREADS)
-    unsigned long m_key;
-    void (*m_cleanup)(void*);
-#elif defined(BOOST_HAS_PTHREADS)
-    pthread_key_t m_key;
-#elif defined(BOOST_HAS_MPTASKS)
-    TaskStorageIndex m_key;
-    void (*m_cleanup)(void*);
-#endif
-};
+        private:
+        #if defined(BOOST_HAS_WINTHREADS)
+            unsigned long m_key;
+            void (*m_cleanup)(void*);
+        #elif defined(BOOST_HAS_PTHREADS)
+            pthread_key_t m_key;
+        #elif defined(BOOST_HAS_MPTASKS)
+            TaskStorageIndex m_key;
+            void (*m_cleanup)(void*);
+        #endif
+        };
 
-#if defined(BOOST_HAS_MPTASKS)
-void thread_cleanup();
-#endif
-}
+    #if defined(BOOST_HAS_MPTASKS)
+        void thread_cleanup();
+    #endif
+    }
 
 template <typename T>
 class thread_specific_ptr : private noncopyable
@@ -65,13 +65,7 @@ public:
     T* operator->() const { return get(); }
     T& operator*() const { return *get(); }
     T* release() { T* temp = get(); m_tss.set(0); return temp; }
-    void reset(T* p=0)
-    {
-        T* cur = get();
-        if (cur == p) return;
-        delete cur;
-        m_tss.set(p);
-    }
+    void reset(T* p=0) { T* cur = get(); if (cur == p) return; delete cur; m_tss.set(p); }
 
 private:
     static void cleanup(void* p) { delete static_cast<T*>(p); }

include/boost/thread/xtime.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software

src/condition.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -25,9 +25,9 @@
 #elif defined(BOOST_HAS_PTHREADS)
 #   include <errno.h>
 #elif defined(BOOST_HAS_MPTASKS)
-#   include <MacErrors.h>
-#   include "mac/init.hpp"
-#   include "mac/safe.hpp"
+#    include <MacErrors.h>
+#    include "mac/init.hpp"
+#    include "mac/safe.hpp"
 #endif
 
 namespace boost {
@@ -40,31 +40,30 @@ condition_impl::condition_impl()
 {
     m_gate = reinterpret_cast<void*>(CreateSemaphore(0, 1, 1, 0));
     m_queue = reinterpret_cast<void*>(CreateSemaphore(0, 0,
-                                                      std::numeric_limits<long>::max(),
-                                                      0));
+        std::numeric_limits<long>::max(), 0));
     m_mutex = reinterpret_cast<void*>(CreateMutex(0, 0, 0));
 
     if (!m_gate || !m_queue || !m_mutex)
+    {
+        int res = 0;
+        if (m_gate)
         {
-            int res = 0;
-            if (m_gate)
-                {
-                    res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
-                    assert(res);
-                }
-            if (m_queue)
-                {
-                    res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
-                    assert(res);
-                }
-            if (m_mutex)
-                {
-                    res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
-                    assert(res);
-                }
-
-            throw thread_resource_error();
+            res = CloseHandle(reinterpret_cast<HANDLE>(m_gate));
+            assert(res);
         }
+        if (m_queue)
+        {
+            res = CloseHandle(reinterpret_cast<HANDLE>(m_queue));
+            assert(res);
+        }
+        if (m_mutex)
+        {
+            res = CloseHandle(reinterpret_cast<HANDLE>(m_mutex));
+            assert(res);
+        }
+
+        throw thread_resource_error();
+    }
 }
 
 condition_impl::~condition_impl()
@@ -87,47 +86,47 @@ void condition_impl::notify_one()
     assert(res == WAIT_OBJECT_0);
 
     if (m_waiting != 0) // the m_gate is already closed
+    {
+        if (m_blocked == 0)
         {
-            if (m_blocked == 0)
-                {
-                    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-                    assert(res);
-                    return;
-                }
+            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
+            assert(res);
+            return;
+        }
 
-            ++m_waiting;
-            --m_blocked;
-            signals = 1;
-        }
+        ++m_waiting;
+        --m_blocked;
+        signals = 1;
+    }
     else
+    {
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
+        assert(res == WAIT_OBJECT_0);
+        if (m_blocked > m_gone)
         {
-            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-            assert(res == WAIT_OBJECT_0);
-            if (m_blocked > m_gone)
-                {
-                    if (m_gone != 0)
-                        {
-                            m_blocked -= m_gone;
-                            m_gone = 0;
-                        }
-                    signals = m_waiting = 1;
-                    --m_blocked;
-                }
-            else
-                {
-                    res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-                    assert(res);
-                }
+            if (m_gone != 0)
+            {
+                m_blocked -= m_gone;
+                m_gone = 0;
+            }
+            signals = m_waiting = 1;
+            --m_blocked;
         }
+        else
+        {
+            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
+            assert(res);
+        }
+    }
 
     res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
     assert(res);
 
     if (signals)
-        {
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
-            assert(res);
-        }
+    {
+        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
+        assert(res);
+    }
 }
 
 void condition_impl::notify_all()
@@ -139,47 +138,46 @@ void condition_impl::notify_all()
     assert(res == WAIT_OBJECT_0);
 
     if (m_waiting != 0) // the m_gate is already closed
+    {
+        if (m_blocked == 0)
         {
-            if (m_blocked == 0)
-                {
-                    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-                    assert(res);
-                    return;
-                }
+            res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
+            assert(res);
+            return;
+        }
 
-            m_waiting += (signals = m_blocked);
+        m_waiting += (signals = m_blocked);
+        m_blocked = 0;
+    }
+    else
+    {
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
+        assert(res == WAIT_OBJECT_0);
+        if (m_blocked > m_gone)
+        {
+            if (m_gone != 0)
+            {
+                m_blocked -= m_gone;
+                m_gone = 0;
+            }
+            signals = m_waiting = m_blocked;
             m_blocked = 0;
         }
-    else
+        else
         {
-            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-            assert(res == WAIT_OBJECT_0);
-            if (m_blocked > m_gone)
-                {
-                    if (m_gone != 0)
-                        {
-                            m_blocked -= m_gone;
-                            m_gone = 0;
-                        }
-                    signals = m_waiting = m_blocked;
-                    m_blocked = 0;
-                }
-            else
-                {
-                    res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-                    assert(res);
-                }
-        }
-
-    res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
-    assert(res);
-
-    if (signals)
-        {
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals,
-                                   0);
+            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
             assert(res);
         }
+
+        res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
+        assert(res);
+
+        if (signals)
+        {
+            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
+            assert(res);
+        }
+    }
 }
 
 void condition_impl::enter_wait()
@@ -206,47 +204,47 @@ void condition_impl::do_wait()
     was_waiting = m_waiting;
     was_gone = m_gone;
     if (was_waiting != 0)
+    {
+        if (--m_waiting == 0)
         {
-            if (--m_waiting == 0)
-                {
-                    if (m_blocked != 0)
-                        {
-                            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1,
-                                                   0); // open m_gate
-                            assert(res);
-                            was_waiting = 0;
-                        }
-                    else if (m_gone != 0)
-                        m_gone = 0;
-                }
+            if (m_blocked != 0)
+            {
+                res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1,
+                    0); // open m_gate
+                assert(res);
+                was_waiting = 0;
+            }
+            else if (m_gone != 0)
+                m_gone = 0;
         }
+    }
     else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
-        {
-            // timeout occured, normalize the m_gone count
-            // this may occur if many calls to wait with a timeout are made and
-            // no call to notify_* is made
-            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-            assert(res == WAIT_OBJECT_0);
-            m_blocked -= m_gone;
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-            assert(res);
-            m_gone = 0;
-        }
+    {
+        // timeout occured, normalize the m_gone count
+        // this may occur if many calls to wait with a timeout are made and
+        // no call to notify_* is made
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
+        assert(res == WAIT_OBJECT_0);
+        m_blocked -= m_gone;
+        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
+        assert(res);
+        m_gone = 0;
+    }
     res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
     assert(res);
 
     if (was_waiting == 1)
+    {
+        for (/**/ ; was_gone; --was_gone)
         {
-            for (/**/ ; was_gone; --was_gone)
-                {
-                    // better now than spurious later
-                    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
-                                              INFINITE);
-                    assert(res == WAIT_OBJECT_0);
-                }
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-            assert(res);
+            // better now than spurious later
+            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
+                INFINITE);
+            assert(res == WAIT_OBJECT_0);
         }
+        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
+        assert(res);
+    }
 }
 
 bool condition_impl::do_timed_wait(const xtime& xt)
@@ -255,26 +253,26 @@ bool condition_impl::do_timed_wait(const xtime& xt)
     unsigned int res = 0;
 
     for (;;)
+    {
+        int milliseconds;
+        to_duration(xt, milliseconds);
+
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
+            milliseconds);
+        assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
+        ret = (res == WAIT_OBJECT_0);
+
+        if (res == WAIT_TIMEOUT)
         {
-            int milliseconds;
-            to_duration(xt, milliseconds);
-
-            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
-                                      milliseconds);
-            assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
-            ret = (res == WAIT_OBJECT_0);
-
-            if (res == WAIT_TIMEOUT)
-                {
-                    xtime cur;
-                    xtime_get(&cur, TIME_UTC);
-                    if (xtime_cmp(xt, cur) > 0)
-                        continue;
-                }
-
-            break;
+            xtime cur;
+            xtime_get(&cur, TIME_UTC);
+            if (xtime_cmp(xt, cur) > 0)
+                continue;
         }
 
+        break;
+    }
+
     unsigned was_waiting=0;
     unsigned was_gone=0;
 
@@ -283,54 +281,54 @@ bool condition_impl::do_timed_wait(const xtime& xt)
     was_waiting = m_waiting;
     was_gone = m_gone;
     if (was_waiting != 0)
+    {
+        if (!ret) // timeout
         {
-            if (!ret) // timeout
-                {
-                    if (m_blocked != 0)
-                        --m_blocked;
-                    else
-                        ++m_gone; // count spurious wakeups
-                }
-            if (--m_waiting == 0)
-                {
-                    if (m_blocked != 0)
-                        {
-                            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1,
-                                                   0); // open m_gate
-                            assert(res);
-                            was_waiting = 0;
-                        }
-                    else if (m_gone != 0)
-                        m_gone = 0;
-                }
+            if (m_blocked != 0)
+                --m_blocked;
+            else
+                ++m_gone; // count spurious wakeups
         }
+        if (--m_waiting == 0)
+        {
+            if (m_blocked != 0)
+            {
+                res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1,
+                    0); // open m_gate
+                assert(res);
+                was_waiting = 0;
+            }
+            else if (m_gone != 0)
+                m_gone = 0;
+        }
+    }
     else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
-        {
-            // timeout occured, normalize the m_gone count
-            // this may occur if many calls to wait with a timeout are made and
-            // no call to notify_* is made
-            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
-            assert(res == WAIT_OBJECT_0);
-            m_blocked -= m_gone;
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-            assert(res);
-            m_gone = 0;
-        }
+    {
+        // timeout occured, normalize the m_gone count
+        // this may occur if many calls to wait with a timeout are made and
+        // no call to notify_* is made
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_gate), INFINITE);
+        assert(res == WAIT_OBJECT_0);
+        m_blocked -= m_gone;
+        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
+        assert(res);
+        m_gone = 0;
+    }
     res = ReleaseMutex(reinterpret_cast<HANDLE>(m_mutex));
     assert(res);
 
     if (was_waiting == 1)
+    {
+        for (/**/ ; was_gone; --was_gone)
         {
-            for (/**/ ; was_gone; --was_gone)
-                {
-                    // better now than spurious later
-                    res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
-                                              INFINITE);
-                    assert(res ==  WAIT_OBJECT_0);
-                }
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
-            assert(res);
+            // better now than spurious later
+            res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_queue),
+                INFINITE);
+            assert(res ==  WAIT_OBJECT_0);
         }
+        res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_gate), 1, 0);
+        assert(res);
+    }
 
     return ret;
 }
@@ -399,20 +397,20 @@ condition_impl::condition_impl()
         lStatus = MPCreateSemaphore(ULONG_MAX, 0, &m_queue);
 
     if(lStatus != noErr || !m_gate || !m_queue)
+    {
+        if (m_gate)
         {
-            if (m_gate)
-                {
-                    lStatus = MPDeleteSemaphore(m_gate);
-                    assert(lStatus == noErr);
-                }
-            if (m_queue)
-                {
-                    lStatus = MPDeleteSemaphore(m_queue);
-                    assert(lStatus == noErr);
-                }
-
-            throw thread_resource_error();
+            lStatus = MPDeleteSemaphore(m_gate);
+            assert(lStatus == noErr);
         }
+        if (m_queue)
+        {
+            lStatus = MPDeleteSemaphore(m_queue);
+            assert(lStatus == noErr);
+        }
+
+        throw thread_resource_error();
+    }
 }
 
 condition_impl::~condition_impl()
@@ -429,52 +427,51 @@ void condition_impl::notify_one()
     unsigned signals = 0;
 
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-                                         m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     if (m_waiting != 0) // the m_gate is already closed
+    {
+        if (m_blocked == 0)
         {
-            if (m_blocked == 0)
-                {
-                    lStatus = MPExitCriticalRegion(m_mutex);
-                    assert(lStatus == noErr);
-                    return;
-                }
-
-            ++m_waiting;
-            --m_blocked;
-        }
-    else
-        {
-            lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-            assert(lStatus == noErr);
-            if (m_blocked > m_gone)
-                {
-                    if (m_gone != 0)
-                        {
-                            m_blocked -= m_gone;
-                            m_gone = 0;
-                        }
-                    signals = m_waiting = 1;
-                    --m_blocked;
-                }
-            else
-                {
-                    lStatus = MPSignalSemaphore(m_gate);
-                    assert(lStatus == noErr);
-                }
-
             lStatus = MPExitCriticalRegion(m_mutex);
             assert(lStatus == noErr);
-
-            while (signals)
-                {
-                    lStatus = MPSignalSemaphore(m_queue);
-                    assert(lStatus == noErr);
-                    --signals;
-                }
+            return;
         }
+
+        ++m_waiting;
+        --m_blocked;
+    }
+    else
+    {
+        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
+        assert(lStatus == noErr);
+        if (m_blocked > m_gone)
+        {
+            if (m_gone != 0)
+            {
+                m_blocked -= m_gone;
+                m_gone = 0;
+            }
+            signals = m_waiting = 1;
+            --m_blocked;
+        }
+        else
+        {
+            lStatus = MPSignalSemaphore(m_gate);
+            assert(lStatus == noErr);
+        }
+
+        lStatus = MPExitCriticalRegion(m_mutex);
+        assert(lStatus == noErr);
+
+        while (signals)
+        {
+            lStatus = MPSignalSemaphore(m_queue);
+            assert(lStatus == noErr);
+            --signals;
+        }
+    }
 }
 
 void condition_impl::notify_all()
@@ -482,52 +479,51 @@ void condition_impl::notify_all()
     unsigned signals = 0;
 
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-                                         m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     if (m_waiting != 0) // the m_gate is already closed
+    {
+        if (m_blocked == 0)
         {
-            if (m_blocked == 0)
-                {
-                    lStatus = MPExitCriticalRegion(m_mutex);
-                    assert(lStatus == noErr);
-                    return;
-                }
-
-            m_waiting += (signals = m_blocked);
-            m_blocked = 0;
-        }
-    else
-        {
-            lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-            assert(lStatus == noErr);
-            if (m_blocked > m_gone)
-                {
-                    if (m_gone != 0)
-                        {
-                            m_blocked -= m_gone;
-                            m_gone = 0;
-                        }
-                    signals = m_waiting = m_blocked;
-                    m_blocked = 0;
-                }
-            else
-                {
-                    lStatus = MPSignalSemaphore(m_gate);
-                    assert(lStatus == noErr);
-                }
-
             lStatus = MPExitCriticalRegion(m_mutex);
             assert(lStatus == noErr);
-
-            while (signals)
-                {
-                    lStatus = MPSignalSemaphore(m_queue);
-                    assert(lStatus == noErr);
-                    --signals;
-                }
+            return;
         }
+
+        m_waiting += (signals = m_blocked);
+        m_blocked = 0;
+    }
+    else
+    {
+        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
+        assert(lStatus == noErr);
+        if (m_blocked > m_gone)
+        {
+            if (m_gone != 0)
+            {
+                m_blocked -= m_gone;
+                m_gone = 0;
+            }
+            signals = m_waiting = m_blocked;
+            m_blocked = 0;
+        }
+        else
+        {
+            lStatus = MPSignalSemaphore(m_gate);
+            assert(lStatus == noErr);
+        }
+
+        lStatus = MPExitCriticalRegion(m_mutex);
+        assert(lStatus == noErr);
+
+        while (signals)
+        {
+            lStatus = MPSignalSemaphore(m_queue);
+            assert(lStatus == noErr);
+            --signals;
+        }
+    }
 }
 
 void condition_impl::enter_wait()
@@ -549,51 +545,50 @@ void condition_impl::do_wait()
     unsigned was_waiting=0;
     unsigned was_gone=0;
 
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-                                         m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
     was_waiting = m_waiting;
     was_gone = m_gone;
     if (was_waiting != 0)
+    {
+        if (--m_waiting == 0)
         {
-            if (--m_waiting == 0)
-                {
-                    if (m_blocked != 0)
-                        {
-                            lStatus = MPSignalSemaphore(m_gate); // open m_gate
-                            assert(lStatus == noErr);
-                            was_waiting = 0;
-                        }
-                    else if (m_gone != 0)
-                        m_gone = 0;
-                }
+            if (m_blocked != 0)
+            {
+                lStatus = MPSignalSemaphore(m_gate); // open m_gate
+                assert(lStatus == noErr);
+                was_waiting = 0;
+            }
+            else if (m_gone != 0)
+                m_gone = 0;
         }
+    }
     else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
-        {
-            // timeout occured, normalize the m_gone count
-            // this may occur if many calls to wait with a timeout are made and
-            // no call to notify_* is made
-            lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-            assert(lStatus == noErr);
-            m_blocked -= m_gone;
-            lStatus = MPSignalSemaphore(m_gate);
-            assert(lStatus == noErr);
-            m_gone = 0;
-        }
+    {
+        // timeout occured, normalize the m_gone count
+        // this may occur if many calls to wait with a timeout are made and
+        // no call to notify_* is made
+        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
+        assert(lStatus == noErr);
+        m_blocked -= m_gone;
+        lStatus = MPSignalSemaphore(m_gate);
+        assert(lStatus == noErr);
+        m_gone = 0;
+    }
     lStatus = MPExitCriticalRegion(m_mutex);
     assert(lStatus == noErr);
 
     if (was_waiting == 1)
+    {
+        for (/**/ ; was_gone; --was_gone)
         {
-            for (/**/ ; was_gone; --was_gone)
-                {
-                    // better now than spurious later
-                    lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
-                    assert(lStatus == noErr);
-                }
-            lStatus = MPSignalSemaphore(m_gate);
+            // better now than spurious later
+            lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
             assert(lStatus == noErr);
         }
+        lStatus = MPSignalSemaphore(m_gate);
+        assert(lStatus == noErr);
+    }
 }
 
 bool condition_impl::do_timed_wait(const xtime& xt)
@@ -610,58 +605,57 @@ bool condition_impl::do_timed_wait(const xtime& xt)
     unsigned was_waiting=0;
     unsigned was_gone=0;
 
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-                                         m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
     was_waiting = m_waiting;
     was_gone = m_gone;
     if (was_waiting != 0)
+    {
+        if (!ret) // timeout
         {
-            if (!ret) // timeout
-                {
-                    if (m_blocked != 0)
-                        --m_blocked;
-                    else
-                        ++m_gone; // count spurious wakeups
-                }
-            if (--m_waiting == 0)
-                {
-                    if (m_blocked != 0)
-                        {
-                            lStatus = MPSignalSemaphore(m_gate); // open m_gate
-                            assert(lStatus == noErr);
-                            was_waiting = 0;
-                        }
-                    else if (m_gone != 0)
-                        m_gone = 0;
-                }
+            if (m_blocked != 0)
+                --m_blocked;
+            else
+                ++m_gone; // count spurious wakeups
         }
+        if (--m_waiting == 0)
+        {
+            if (m_blocked != 0)
+            {
+                lStatus = MPSignalSemaphore(m_gate); // open m_gate
+                assert(lStatus == noErr);
+                was_waiting = 0;
+            }
+            else if (m_gone != 0)
+                m_gone = 0;
+        }
+    }
     else if (++m_gone == (std::numeric_limits<unsigned>::max() / 2))
-        {
-            // timeout occured, normalize the m_gone count
-            // this may occur if many calls to wait with a timeout are made and
-            // no call to notify_* is made
-            lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
-            assert(lStatus == noErr);
-            m_blocked -= m_gone;
-            lStatus = MPSignalSemaphore(m_gate);
-            assert(lStatus == noErr);
-            m_gone = 0;
-        }
+    {
+        // timeout occured, normalize the m_gone count
+        // this may occur if many calls to wait with a timeout are made and
+        // no call to notify_* is made
+        lStatus = safe_wait_on_semaphore(m_gate, kDurationForever);
+        assert(lStatus == noErr);
+        m_blocked -= m_gone;
+        lStatus = MPSignalSemaphore(m_gate);
+        assert(lStatus == noErr);
+        m_gone = 0;
+    }
     lStatus = MPExitCriticalRegion(m_mutex);
     assert(lStatus == noErr);
 
     if (was_waiting == 1)
+    {
+        for (/**/ ; was_gone; --was_gone)
         {
-            for (/**/ ; was_gone; --was_gone)
-                {
-                    // better now than spurious later
-                    lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
-                    assert(lStatus == noErr);
-                }
-            lStatus = MPSignalSemaphore(m_gate);
+            // better now than spurious later
+            lStatus = safe_wait_on_semaphore(m_queue, kDurationForever);
             assert(lStatus == noErr);
         }
+        lStatus = MPSignalSemaphore(m_gate);
+        assert(lStatus == noErr);
+    }
 
     return ret;
 }

src/exceptions.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -14,13 +14,11 @@
 
 namespace boost {
 
-lock_error::lock_error()
-    : std::logic_error("thread lock error")
+lock_error::lock_error() : std::logic_error("thread lock error")
 {
 }
 
-thread_resource_error::thread_resource_error()
-    : std::runtime_error("thread resource error")
+thread_resource_error::thread_resource_error() : std::runtime_error("thread resource error")
 {
 }
 

src/mutex.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -16,6 +16,7 @@
 #include <boost/limits.hpp>
 #include <stdexcept>
 #include <cassert>
+#include <new>
 #include "timeconv.inl"
 
 #if defined(BOOST_HAS_WINTHREADS)
@@ -24,23 +25,18 @@
 #elif defined(BOOST_HAS_PTHREADS)
 #   include <errno.h>
 #elif defined(BOOST_HAS_MPTASKS)
-#   include <MacErrors.h>
-#   include "mac/init.hpp"
-#   include "mac/safe.hpp"
+#    include <MacErrors.h>
+
+#    include "mac/init.hpp"
+#    include "mac/safe.hpp"
 #endif
 
 namespace boost {
 
 #if defined(BOOST_HAS_WINTHREADS)
-mutex::mutex() : m_mutex(0)
+mutex::mutex()
 {
-    try
-    {
-        m_mutex = reinterpret_cast<void*>(new CRITICAL_SECTION);
-    }
-    catch (...)
-    {
-    }
+    m_mutex = reinterpret_cast<void*>(new(std::nothrow) CRITICAL_SECTION);
     if (!m_mutex)
         throw thread_resource_error();
     InitializeCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
@@ -155,8 +151,7 @@ bool timed_mutex::do_timedlock(const xtime& xt)
         int milliseconds;
         to_duration(xt, milliseconds);
 
-        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex),
-            milliseconds);
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
         assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
 
         if (res == WAIT_TIMEOUT)
@@ -432,8 +427,7 @@ mutex::~mutex()
 void mutex::do_lock()
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 }
 
@@ -465,8 +459,7 @@ try_mutex::~try_mutex()
 void try_mutex::do_lock()
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 }
 
@@ -506,8 +499,7 @@ timed_mutex::~timed_mutex()
 void timed_mutex::do_lock()
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 }
 

src/once.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -17,16 +17,14 @@
 #   include <windows.h>
 #   if defined(BOOST_NO_STRINGSTREAM)
 #       include <strstream>
-
-class unfreezer
-{
-public:
-    unfreezer(std::ostrstream& s) : m_stream(s) {}
-    ~unfreezer() { m_stream.freeze(false); }
-private:
-    std::ostrstream& m_stream;
-};
-
+        class unfreezer
+        {
+        public:
+            unfreezer(std::ostrstream& s) : m_stream(s) {}
+            ~unfreezer() { m_stream.freeze(false); }
+        private:
+            std::ostrstream& m_stream;
+        };
 #   else
 #       include <sstream>
 #   endif
@@ -35,7 +33,7 @@ private:
 #endif
 
 #ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::sprintf; }
+    namespace std { using ::sprintf; }
 #endif
 
 #if defined(BOOST_HAS_PTHREADS)
@@ -48,70 +46,64 @@ typedef void (*once_callback)();
 
 extern "C" {
 
-    static void key_init()
-    {
-        pthread_key_create(&key, 0);
-    }
+static void key_init()
+{
+    pthread_key_create(&key, 0);
+}
 
-    static void do_once()
-    {
-        once_callback* cb = reinterpret_cast<once_callback*>(
-            pthread_getspecific(key));
-        (**cb)();
-    }
+static void do_once()
+{
+    once_callback* cb = reinterpret_cast<once_callback*>(pthread_getspecific(key));
+    (**cb)();
+}
 
 }
 #elif defined(BOOST_HAS_MPTASKS)
 namespace {
-void *remote_call_proxy(void *pData)
-{
-    std::pair<void (*)(), boost::once_flag *> &rData(
-        *reinterpret_cast<std::pair<void (*)(), boost::once_flag *> *>(pData));
-
-    if(*rData.second == false)
+    void *remote_call_proxy(void *pData)
     {
-        rData.first();
-        *rData.second = true;
+        std::pair<void (*)(), boost::once_flag *> &rData(*reinterpret_cast<std::pair<void (*)(), boost::once_flag *> *>(pData));
+
+        if(*rData.second == false)
+        {
+            rData.first();
+            *rData.second = true;
+        }
+
+        return(NULL);
     }
-
-    return(NULL);
 }
-}
-
 #elif defined(BOOST_HAS_WINTHREADS)
 namespace {
-// The signature for InterlockedCompareExchange has changed with the
-// addition of Win64 support. I can't determine any (consistent and
-// portable) way of using conditional compilation to detect this, so
-// we use these type wrappers.  Unfortunately, the various vendors
-// use different calling conventions and other signature anamolies,
-// and thus have unique types as well.  This is known to work on VC6,
-// VC7, Borland 5.5.2 and gcc 3.2.  Are there other signatures for
-// other platforms?
-inline LONG ice_wrapper(LONG (__stdcall *ice)(LONG*, LONG, LONG),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (*ice)(const_cast<LONG*>(dest), exch, cmp);
-}
+    // The signature for InterlockedCompareExchange has changed with the
+    // addition of Win64 support. I can't determine any (consistent and
+    // portable) way of using conditional compilation to detect this, so
+    // we use these type wrappers.  Unfortunately, the various vendors
+    // use different calling conventions and other signature anamolies,
+    // and thus have unique types as well.  This is known to work on VC6,
+    // VC7, Borland 5.5.2 and gcc 3.2.  Are there other signatures for
+    // other platforms?
+    inline LONG ice_wrapper(LONG (__stdcall *ice)(LONG*, LONG, LONG), volatile LONG* dest, LONG exch, LONG cmp)
+    {
+        return (*ice)(const_cast<LONG*>(dest), exch, cmp);
+    }
 
-inline LONG ice_wrapper(LONG (__stdcall *ice)(volatile LONG*, LONG, LONG),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (*ice)(dest, exch, cmp);
-}
+    inline LONG ice_wrapper(LONG (__stdcall *ice)(volatile LONG*, LONG, LONG), volatile LONG* dest, LONG exch, LONG cmp)
+    {
+        return (*ice)(dest, exch, cmp);
+    }
 
-inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID),
-    volatile LONG* dest, LONG exch, LONG cmp)
-{
-    return (LONG)(*ice)((LPVOID*)dest, (LPVOID)exch, (LPVOID)cmp);
-}
+    inline LONG ice_wrapper(LPVOID (__stdcall *ice)(LPVOID*, LPVOID, LPVOID), volatile LONG* dest, LONG exch, LONG cmp)
+    {
+        return (LONG)(*ice)((LPVOID*)dest, (LPVOID)exch, (LPVOID)cmp);
+    }
 
-// The friendly form of InterlockedCompareExchange that defers
-// according to the above function type wrappers.
-inline LONG compare_exchange(volatile LPLONG dest, LONG exch, LONG cmp)
-{
-    return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
-}
+    // The friendly form of InterlockedCompareExchange that defers
+    // according to the above function type wrappers.
+    inline LONG compare_exchange(volatile LPLONG dest, LONG exch, LONG cmp)
+    {
+        return ice_wrapper(&InterlockedCompareExchange, dest, exch, cmp);
+    }
 }
 #endif
 
@@ -124,14 +116,12 @@ void call_once(void (*func)(), once_flag& flag)
     {
 #if defined(BOOST_NO_STRINGSTREAM)
         std::ostrstream strm;
-        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" << std::hex
-             << GetCurrentProcessId() << &flag << std::ends;
+        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" << std::hex << GetCurrentProcessId() << &flag << std::ends;
         unfreezer unfreeze(strm);
         HANDLE mutex = CreateMutex(NULL, FALSE, strm.str());
 #else
         std::ostringstream strm;
-        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" << std::hex
-             << GetCurrentProcessId() << &flag;
+        strm << "2AC1A572DB6944B0A65C38C4140AF2F4" << std::hex << GetCurrentProcessId() << &flag;
         HANDLE mutex = CreateMutexA(NULL, FALSE, strm.str().c_str());
 #endif
         assert(mutex != NULL);
@@ -158,8 +148,7 @@ void call_once(void (*func)(), once_flag& flag)
 #elif defined(BOOST_HAS_MPTASKS)
     if(flag == false)
     {
-        // all we do here is make a remote call to blue, as blue is not
-        // reentrant.
+    // all we do here is make a remote call to blue, as blue is not reentrant.
         std::pair<void (*)(), once_flag *> sData(func, &flag);
         MPRemoteCall(remote_call_proxy, &sData, kMPOwningProcessRemoteContext);
         assert(flag == true);

src/recursive_mutex.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -23,23 +23,17 @@
 #elif defined(BOOST_HAS_PTHREADS)
 #   include <errno.h>
 #elif defined(BOOST_HAS_MPTASKS)
-#   include <MacErrors.h>
-#   include "safe.hpp"
+#    include <MacErrors.h>
+#    include "safe.hpp"
 #endif
 
 namespace boost {
 
 #if defined(BOOST_HAS_WINTHREADS)
 recursive_mutex::recursive_mutex()
-    : m_mutex(0), m_count(0)
+    : m_count(0)
 {
-    try
-	{
-       m_mutex = reinterpret_cast<void*>(new CRITICAL_SECTION);
-	}
-	catch (...)
-	{
-	}
+    m_mutex = reinterpret_cast<void*>(new(std::nothrow) CRITICAL_SECTION);
     if (!m_mutex)
         throw thread_resource_error();
     InitializeCriticalSection(reinterpret_cast<LPCRITICAL_SECTION>(m_mutex));
@@ -207,8 +201,7 @@ bool recursive_timed_mutex::do_timedlock(const xtime& xt)
         to_duration(xt, milliseconds);
 
         unsigned int res = 0;
-        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex),
-            milliseconds);
+        res = WaitForSingleObject(reinterpret_cast<HANDLE>(m_mutex), milliseconds);
         assert(res != WAIT_FAILED && res != WAIT_ABANDONED);
 
         if (res == WAIT_TIMEOUT)
@@ -805,8 +798,7 @@ recursive_mutex::~recursive_mutex()
 void recursive_mutex::do_lock()
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     if (++m_count > 1)
@@ -829,8 +821,7 @@ void recursive_mutex::do_unlock()
 void recursive_mutex::do_lock(cv_state& state)
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     m_count = state;
@@ -858,8 +849,7 @@ recursive_try_mutex::~recursive_try_mutex()
 void recursive_try_mutex::do_lock()
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     if (++m_count > 1)
@@ -900,8 +890,7 @@ void recursive_try_mutex::do_unlock()
 void recursive_try_mutex::do_lock(cv_state& state)
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     m_count = state;
@@ -929,8 +918,7 @@ recursive_timed_mutex::~recursive_timed_mutex()
 void recursive_timed_mutex::do_lock()
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     if (++m_count > 1)
@@ -993,8 +981,7 @@ void recursive_timed_mutex::do_unlock()
 void recursive_timed_mutex::do_lock(cv_state& state)
 {
     OSStatus lStatus = noErr;
-    lStatus = safe_enter_critical_region(m_mutex, kDurationForever,
-        m_mutex_mutex);
+    lStatus = safe_enter_critical_region(m_mutex, kDurationForever, m_mutex_mutex);
     assert(lStatus == noErr);
 
     m_count = state;

src/thread.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -18,11 +18,11 @@
 #   include <windows.h>
 #   include <process.h>
 #elif defined(BOOST_HAS_MPTASKS)
-#   include <DriverServices.h>
+#    include <DriverServices.h>
 
-#   include "init.hpp"
-#   include "safe.hpp"
-#   include <boost/thread/tss.hpp>
+#    include "init.hpp"
+#    include "safe.hpp"
+#    include <boost/thread/tss.hpp>
 #endif
 
 #include "timeconv.inl"
@@ -32,10 +32,7 @@ namespace {
 class thread_param
 {
 public:
-    thread_param(const boost::function0<void>& threadfunc)
-        : m_threadfunc(threadfunc), m_started(false)
-    {
-    }
+    thread_param(const boost::function0<void>& threadfunc) : m_threadfunc(threadfunc), m_started(false) { }
     void wait()
     {
         boost::mutex::scoped_lock scoped_lock(m_mutex);
@@ -59,28 +56,28 @@ public:
 
 extern "C" {
 #if defined(BOOST_HAS_WINTHREADS)
-    unsigned __stdcall thread_proxy(void* param)
+unsigned __stdcall thread_proxy(void* param)
 #elif defined(BOOST_HAS_PTHREADS)
-        static void* thread_proxy(void* param)
+static void* thread_proxy(void* param)
 #elif defined(BOOST_HAS_MPTASKS)
-        static OSStatus thread_proxy(void* param)
+static OSStatus thread_proxy(void* param)
 #endif
+{
+    try
     {
-        try
-        {
-            thread_param* p = static_cast<thread_param*>(param);
-            boost::function0<void> threadfunc = p->m_threadfunc;
-            p->started();
-            threadfunc();
-        }
-        catch (...)
-        {
-        }
-#if defined(BOOST_HAS_MPTASKS)
-        ::boost::detail::thread_cleanup();
-#endif
-        return 0;
+        thread_param* p = static_cast<thread_param*>(param);
+        boost::function0<void> threadfunc = p->m_threadfunc;
+        p->started();
+        threadfunc();
     }
+    catch (...)
+    {
+    }
+#if defined(BOOST_HAS_MPTASKS)
+    ::boost::detail::thread_cleanup();
+#endif
+    return 0;
+}
 
 }
 
@@ -107,8 +104,7 @@ thread::thread(const function0<void>& threadfunc)
 {
     thread_param param(threadfunc);
 #if defined(BOOST_HAS_WINTHREADS)
-    m_thread = reinterpret_cast<void*>(_beginthreadex(0, 0, &thread_proxy,
-                                           &param, 0, &m_id));
+    m_thread = reinterpret_cast<void*>(_beginthreadex(0, 0, &thread_proxy, &param, 0, &m_id));
     if (!m_thread)
         throw thread_resource_error();
 #elif defined(BOOST_HAS_PTHREADS)
@@ -125,11 +121,11 @@ thread::thread(const function0<void>& threadfunc)
     m_pTaskID = kInvalidID;
 
     lStatus = MPCreateQueue(&m_pJoinQueueID);
-    if (lStatus != noErr) throw thread_resource_error();
+    if(lStatus != noErr) throw thread_resource_error();
 
-    lStatus = MPCreateTask(&thread_proxy, &param, 0UL, m_pJoinQueueID, NULL,
-        NULL, 0UL, &m_pTaskID);
-    if (lStatus != noErr)
+    lStatus = MPCreateTask(&thread_proxy, &param, 0UL, m_pJoinQueueID, NULL, NULL,
+                            0UL, &m_pTaskID);
+    if(lStatus != noErr)
     {
         lStatus = MPDeleteQueue(m_pJoinQueueID);
         assert(lStatus == noErr);
@@ -185,8 +181,7 @@ void thread::join()
     res = pthread_join(m_thread, 0);
     assert(res == 0);
 #elif defined(BOOST_HAS_MPTASKS)
-    OSStatus lStatus = threads::mac::detail::safe_wait_on_queue(
-        m_pJoinQueueID, NULL, NULL, NULL, kDurationForever);
+    OSStatus lStatus = threads::mac::detail::safe_wait_on_queue(m_pJoinQueueID, NULL, NULL, NULL, kDurationForever);
     assert(lStatus == noErr);
 #endif
     // This isn't a race condition since any race that could occur would
@@ -265,20 +260,17 @@ thread_group::thread_group()
 
 thread_group::~thread_group()
 {
-    // We shouldn't have to scoped_lock here, since referencing this object
-    // from another thread while we're deleting it in the current thread is
-    // going to lead to undefined behavior any way.
-    for (std::list<thread*>::iterator it = m_threads.begin();
-         it != m_threads.end(); ++it)
-    {
+    // We shouldn't have to scoped_lock here, since referencing this object from another thread
+    // while we're deleting it in the current thread is going to lead to undefined behavior
+    // any way.
+    for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
         delete (*it);
-    }
 }
 
 thread* thread_group::create_thread(const function0<void>& threadfunc)
 {
-    // No scoped_lock required here since the only "shared data" that's
-    // modified here occurs inside add_thread which does scoped_lock.
+    // No scoped_lock required here since the only "shared data" that's modified here occurs
+    // inside add_thread which does scoped_lock.
     std::auto_ptr<thread> thrd(new thread(threadfunc));
     add_thread(thrd.get());
     return thrd.release();
@@ -288,11 +280,9 @@ void thread_group::add_thread(thread* thrd)
 {
     mutex::scoped_lock scoped_lock(m_mutex);
 
-    // For now we'll simply ignore requests to add a thread object multiple
-    // times. Should we consider this an error and either throw or return an
-    // error value?
-    std::list<thread*>::iterator it = std::find(m_threads.begin(),
-        m_threads.end(), thrd);
+    // For now we'll simply ignore requests to add a thread object multiple times.
+    // Should we consider this an error and either throw or return an error value?
+    std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
     assert(it == m_threads.end());
     if (it == m_threads.end())
         m_threads.push_back(thrd);
@@ -302,11 +292,9 @@ void thread_group::remove_thread(thread* thrd)
 {
     mutex::scoped_lock scoped_lock(m_mutex);
 
-    // For now we'll simply ignore requests to remove a thread object that's
-    // not in the group. Should we consider this an error and either throw or
-    // return an error value?
-    std::list<thread*>::iterator it = std::find(m_threads.begin(),
-        m_threads.end(), thrd);
+    // For now we'll simply ignore requests to remove a thread object that's not in the group.
+    // Should we consider this an error and either throw or return an error value?
+    std::list<thread*>::iterator it = std::find(m_threads.begin(), m_threads.end(), thrd);
     assert(it != m_threads.end());
     if (it != m_threads.end())
         m_threads.erase(it);
@@ -315,11 +303,8 @@ void thread_group::remove_thread(thread* thrd)
 void thread_group::join_all()
 {
     mutex::scoped_lock scoped_lock(m_mutex);
-    for (std::list<thread*>::iterator it = m_threads.begin();
-         it != m_threads.end(); ++it)
-    {
+    for (std::list<thread*>::iterator it = m_threads.begin(); it != m_threads.end(); ++it)
         (*it)->join();
-    }
 }
 
 } // namespace boost

src/threadmon.cpp

@@ -1,13 +1,5 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+// threadmon.cpp : Defines the entry point for the DLL application.
 //
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
 
 #include <boost/config.hpp>
 
@@ -34,9 +26,9 @@ typedef std::set<exit_handlers*> registered_handlers;
 
 namespace
 {
-CRITICAL_SECTION cs;
-DWORD key;
-registered_handlers registry;
+    CRITICAL_SECTION cs;
+    DWORD key;
+    registered_handlers registry;
 }
 
 #if defined(__BORLANDC__)
@@ -44,70 +36,70 @@ registered_handlers registry;
 #endif
 
 extern "C"
-BOOL WINAPI DllMain(HANDLE /*module*/, DWORD reason, LPVOID)
+BOOL WINAPI DllMain(HANDLE module, DWORD reason, LPVOID)
 {
     switch (reason)
     {
-    case DLL_PROCESS_ATTACH:
-        InitializeCriticalSection(&cs);
-        key = TlsAlloc();
-        break;
-    case DLL_THREAD_ATTACH:
-        break;
-    case DLL_THREAD_DETACH:
-    {
-        // Call the thread's exit handlers.
-        exit_handlers* handlers =
-            static_cast<exit_handlers*>(TlsGetValue(key));
-        if (handlers)
-        {
-            for (exit_handlers::iterator it = handlers->begin();
-                 it != handlers->end(); ++it)
+        case DLL_PROCESS_ATTACH:
+            InitializeCriticalSection(&cs);
+            key = TlsAlloc();
+            break;
+        case DLL_THREAD_ATTACH:
+            break;
+        case DLL_THREAD_DETACH:
             {
-                (*it)();
-            }
+                // Call the thread's exit handlers.
+                exit_handlers* handlers =
+                    static_cast<exit_handlers*>(TlsGetValue(key));
+                if (handlers)
+                {
+                    for (exit_handlers::iterator it = handlers->begin();
+                        it != handlers->end(); ++it)
+		    {
+                        (*it)();
+		    }
 
-            // Remove the exit handler list from the registered lists
-            // and then destroy it.
-            EnterCriticalSection(&cs);
-            registry.erase(handlers);
-            LeaveCriticalSection(&cs);
-            delete handlers;
-        }
-    }
-    break;
-    case DLL_PROCESS_DETACH:
-    {
-        // Assume the main thread is ending (call its handlers) and
-        // all other threads have already ended.  If this DLL is
-        // loaded and unloaded dynamically at run time
-        // this is a bad assumption, but this is the best we can do.
-        exit_handlers* handlers =
-            static_cast<exit_handlers*>(TlsGetValue(key));
-        if (handlers)
-        {
-            for (exit_handlers::iterator it = handlers->begin();
-                 it != handlers->end(); ++it)
+                    // Remove the exit handler list from the registered lists
+                    // and then destroy it.
+                    EnterCriticalSection(&cs);
+                    registry.erase(handlers);
+                    LeaveCriticalSection(&cs);
+                    delete handlers;
+                }
+            }
+            break;
+        case DLL_PROCESS_DETACH:
             {
-                (*it)();
-            }
-        }
+                // Assume the main thread is ending (call its handlers) and
+                // all other threads have already ended.  If this DLL is
+                // loaded and unloaded dynamically at run time
+                // this is a bad assumption, but this is the best we can do.
+                exit_handlers* handlers =
+                    static_cast<exit_handlers*>(TlsGetValue(key));
+                if (handlers)
+                {
+                    for (exit_handlers::iterator it = handlers->begin();
+                        it != handlers->end(); ++it)
+		    {
+                        (*it)();
+		    }
+                }
 
-        // Destroy any remaining exit handlers.  Above we assumed
-        // there'd only be the main thread left, but to insure we
-        // don't get memory leaks we won't make that assumption
-        // here.
-        EnterCriticalSection(&cs);
-        for (registered_handlers::iterator it = registry.begin();
-             it != registry.end(); ++it)
-        {
-            delete (*it);
-        }
-        LeaveCriticalSection(&cs);
-        DeleteCriticalSection(&cs);
-        TlsFree(key);
-    }
-    break;
+                // Destroy any remaining exit handlers.  Above we assumed
+                // there'd only be the main thread left, but to insure we
+                // don't get memory leaks we won't make that assumption
+                // here.
+                EnterCriticalSection(&cs);
+                for (registered_handlers::iterator it = registry.begin();
+                    it != registry.end(); ++it)
+		{
+                    delete (*it);
+		}
+                LeaveCriticalSection(&cs);
+                DeleteCriticalSection(&cs);
+                TlsFree(key);
+            }
+            break;
     }
     return TRUE;
 }

src/timeconv.inl

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -10,119 +10,118 @@
 // It is provided "as is" without express or implied warranty.
 
 namespace {
-const int MILLISECONDS_PER_SECOND = 1000;
-const int NANOSECONDS_PER_SECOND = 1000000000;
-const int NANOSECONDS_PER_MILLISECOND = 1000000;
+    const int MILLISECONDS_PER_SECOND = 1000;
+    const int NANOSECONDS_PER_SECOND = 1000000000;
+    const int NANOSECONDS_PER_MILLISECOND = 1000000;
 
-const int MICROSECONDS_PER_SECOND = 1000000;
-const int NANOSECONDS_PER_MICROSECOND = 1000;
+    const int MICROSECONDS_PER_SECOND = 1000000;
+    const int NANOSECONDS_PER_MICROSECOND = 1000;
 
-inline void to_time(int milliseconds, boost::xtime& xt)
-{
-    int res = 0;
-    res = boost::xtime_get(&xt, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
-
-    xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
-    xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) *
-        NANOSECONDS_PER_MILLISECOND);
-
-    if (xt.nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
+    inline void to_time(int milliseconds, boost::xtime& xt)
     {
-        ++xt.sec;
-        xt.nsec -= NANOSECONDS_PER_SECOND;
+        int res = 0;
+        res = boost::xtime_get(&xt, boost::TIME_UTC);
+        assert(res == boost::TIME_UTC);
+
+        xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);
+        xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND);
+
+        if (xt.nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
+        {
+            ++xt.sec;
+            xt.nsec -= NANOSECONDS_PER_SECOND;
+        }
     }
-}
 
 #if defined(BOOST_HAS_PTHREADS)
-inline void to_timespec(const boost::xtime& xt, timespec& ts)
-{
-    ts.tv_sec = static_cast<int>(xt.sec);
-    ts.tv_nsec = static_cast<int>(xt.nsec);
-    if(ts.tv_nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
+    inline void to_timespec(const boost::xtime& xt, timespec& ts)
     {
-        ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
-        ts.tv_nsec %= NANOSECONDS_PER_SECOND;
-    }
-}
-
-inline void to_time(int milliseconds, timespec& ts)
-{
-    boost::xtime xt;
-    to_time(milliseconds, xt);
-    to_timespec(xt, ts);
-}
-
-inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
-{
-    boost::xtime cur;
-    int res = 0;
-    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
-
-    if (boost::xtime_cmp(xt, cur) <= 0)
-    {
-        ts.tv_sec = 0;
-        ts.tv_nsec = 0;
-    }
-    else
-    {
-        ts.tv_sec = xt.sec - cur.sec;
-        ts.tv_nsec = xt.nsec - cur.nsec;
-
-        if( ts.tv_nsec < 0 )
-        {
-            ts.tv_sec -= 1;
-            ts.tv_nsec += NANOSECONDS_PER_SECOND;
-        }
+        ts.tv_sec = static_cast<int>(xt.sec);
+        ts.tv_nsec = static_cast<int>(xt.nsec);
         if(ts.tv_nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
         {
             ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
             ts.tv_nsec %= NANOSECONDS_PER_SECOND;
         }
     }
-}
+
+    inline void to_time(int milliseconds, timespec& ts)
+    {
+        boost::xtime xt;
+        to_time(milliseconds, xt);
+        to_timespec(xt, ts);
+    }
+
+    inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)
+    {
+        boost::xtime cur;
+        int res = 0;
+        res = boost::xtime_get(&cur, boost::TIME_UTC);
+        assert(res == boost::TIME_UTC);
+
+        if (boost::xtime_cmp(xt, cur) <= 0)
+        {
+            ts.tv_sec = 0;
+            ts.tv_nsec = 0;
+        }
+        else
+        {
+            ts.tv_sec = xt.sec - cur.sec;
+            ts.tv_nsec = xt.nsec - cur.nsec;
+
+            if( ts.tv_nsec < 0 )
+            {
+                ts.tv_sec -= 1;
+                ts.tv_nsec += NANOSECONDS_PER_SECOND;
+            }
+           if(ts.tv_nsec > static_cast<const int>(NANOSECONDS_PER_SECOND))
+           {
+               ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;
+               ts.tv_nsec %= NANOSECONDS_PER_SECOND;
+           }
+        }
+    }
 #endif
 
-inline void to_duration(boost::xtime xt, int& milliseconds)
-{
-    boost::xtime cur;
-    int res = 0;
-    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
-
-    if (boost::xtime_cmp(xt, cur) <= 0)
-        milliseconds = 0;
-    else
+    inline void to_duration(boost::xtime xt, int& milliseconds)
     {
-        if (cur.nsec > xt.nsec)
+        boost::xtime cur;
+        int res = 0;
+        res = boost::xtime_get(&cur, boost::TIME_UTC);
+        assert(res == boost::TIME_UTC);
+
+        if (boost::xtime_cmp(xt, cur) <= 0)
+            milliseconds = 0;
+        else
         {
-            xt.nsec += NANOSECONDS_PER_SECOND;
-            --xt.sec;
-        }
-        milliseconds = (int)((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
-            (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /
+            if (cur.nsec > xt.nsec)
+            {
+                xt.nsec += NANOSECONDS_PER_SECOND;
+                --xt.sec;
+            }
+            milliseconds = ((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +
+                (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /
                 NANOSECONDS_PER_MILLISECOND);
+        }
     }
-}
 
-inline void to_microduration(const boost::xtime& xt, int& microseconds)
-{
-    boost::xtime cur;
-    int res = 0;
-    res = boost::xtime_get(&cur, boost::TIME_UTC);
-    assert(res == boost::TIME_UTC);
-
-    if (boost::xtime_get(&cur, boost::TIME_UTC) <= 0)
-        microseconds = 0;
-    else
+    inline void to_microduration(const boost::xtime& xt, int& microseconds)
     {
-        microseconds = (int)((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) +
-            (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) /
+        boost::xtime cur;
+        int res = 0;
+        res = boost::xtime_get(&cur, boost::TIME_UTC);
+        assert(res == boost::TIME_UTC);
+
+        if (boost::xtime_get(&cur, boost::TIME_UTC) <= 0)
+            microseconds = 0;
+        else
+        {
+            microseconds = ((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) +
+                (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) /
                 NANOSECONDS_PER_MICROSECOND);
+        }
     }
 }
-}
 
 // Change Log:
 //    1 Jun 01  Initial creation.

src/tss.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -23,100 +23,94 @@
 #include <boost/thread/detail/threadmon.hpp>
 #include <map>
 namespace {
-typedef std::pair<void(*)(void*), void*> cleanup_info;
-typedef std::map<int, cleanup_info> cleanup_handlers;
+    typedef std::pair<void(*)(void*), void*> cleanup_info;
+    typedef std::map<int, cleanup_info> cleanup_handlers;
 
-DWORD key;
-boost::once_flag once = BOOST_ONCE_INIT;
+    DWORD key;
+    boost::once_flag once = BOOST_ONCE_INIT;
 
-void init_cleanup_key()
-{
-    key = TlsAlloc();
-    assert(key != 0xFFFFFFFF);
-}
-
-void __cdecl cleanup()
-{
-    cleanup_handlers* handlers = static_cast<cleanup_handlers*>(
-        TlsGetValue(key));
-    for (cleanup_handlers::iterator it = handlers->begin();
-         it != handlers->end(); ++it)
+    void init_cleanup_key()
     {
-        cleanup_info info = it->second;
-        if (info.second)
-            info.first(info.second);
-    }
-    delete handlers;
-}
-
-cleanup_handlers* get_handlers()
-{
-    boost::call_once(&init_cleanup_key, once);
-
-    cleanup_handlers* handlers = static_cast<cleanup_handlers*>(
-        TlsGetValue(key));
-    if (!handlers)
-    {
-        try
-        {
-            handlers = new cleanup_handlers;
-        }
-        catch (...)
-        {
-            return 0;
-        }
-        int res = 0;
-        res = TlsSetValue(key, handlers);
-        assert(res);
-        res = on_thread_exit(&cleanup);
-        assert(res == 0);
+        key = TlsAlloc();
+        assert(key != 0xFFFFFFFF);
     }
 
-    return handlers;
-}
+    void __cdecl cleanup()
+    {
+        cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
+        for (cleanup_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
+        {
+            cleanup_info info = it->second;
+            if (info.second)
+                info.first(info.second);
+        }
+        delete handlers;
+    }
+
+    cleanup_handlers* get_handlers()
+    {
+        boost::call_once(&init_cleanup_key, once);
+
+        cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
+        if (!handlers)
+        {
+            try
+            {
+                handlers = new cleanup_handlers;
+            }
+            catch (...)
+            {
+                return 0;
+            }
+            int res = 0;
+            res = TlsSetValue(key, handlers);
+            assert(res);
+            res = on_thread_exit(&cleanup);
+            assert(res == 0);
+        }
+
+        return handlers;
+    }
 }
 #elif defined(BOOST_HAS_MPTASKS)
 #include <map>
 namespace {
-typedef std::pair<void(*)(void*), void*> cleanup_info;
-typedef std::map<int, cleanup_info> cleanup_handlers;
+    typedef std::pair<void(*)(void*), void*> cleanup_info;
+    typedef std::map<int, cleanup_info> cleanup_handlers;
 
-TaskStorageIndex key;
-boost::once_flag once = BOOST_ONCE_INIT;
+    TaskStorageIndex key;
+    boost::once_flag once = BOOST_ONCE_INIT;
 
-void init_cleanup_key()
-{
-    OSStatus lStatus = MPAllocateTaskStorageIndex(&key);
-    assert(lStatus == noErr);
-}
-
-cleanup_handlers* get_handlers()
-{
-    boost::call_once(&init_cleanup_key, once);
-
-    cleanup_handlers* handlers = reinterpret_cast<cleanup_handlers*>(
-        MPGetTaskStorageValue(key));
-    if (!handlers)
+    void init_cleanup_key()
     {
-        try
-        {
-            handlers = new cleanup_handlers;
-        }
-        catch (...)
-        {
-            return 0;
-        }
-        OSStatus lStatus = noErr;
-        lStatus = MPSetTaskStorageValue(key,
-            reinterpret_cast<TaskStorageValue>(handlers));
+        OSStatus lStatus = MPAllocateTaskStorageIndex(&key);
         assert(lStatus == noErr);
-        // TODO - create a generalized mechanism for registering thread exit
-        // functions and use it here.
     }
 
-    return handlers;
-}
+    cleanup_handlers* get_handlers()
+    {
+        boost::call_once(&init_cleanup_key, once);
 
+        cleanup_handlers* handlers = reinterpret_cast<cleanup_handlers*>(MPGetTaskStorageValue(key));
+        if (!handlers)
+        {
+            try
+            {
+                handlers = new cleanup_handlers;
+            }
+            catch (...)
+            {
+                return 0;
+            }
+            OSStatus lStatus = noErr;
+            lStatus = MPSetTaskStorageValue(key, reinterpret_cast<TaskStorageValue>(handlers));
+            assert(lStatus == noErr);
+        // TODO - create a generalized mechanism for registering thread exit functions
+        //            and use it here.
+        }
+
+        return handlers;
+    }
 }
 
 namespace boost {
@@ -126,12 +120,10 @@ namespace detail {
 
 void thread_cleanup()
 {
-    cleanup_handlers* handlers = reinterpret_cast<cleanup_handlers*>(
-        MPGetTaskStorageValue(key));
+    cleanup_handlers* handlers = reinterpret_cast<cleanup_handlers*>(MPGetTaskStorageValue(key));
     if(handlers != NULL)
     {
-        for (cleanup_handlers::iterator it = handlers->begin();
-             it != handlers->end(); ++it)
+        for (cleanup_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
         {
             cleanup_info info = it->second;
             if (info.second)
@@ -243,8 +235,7 @@ bool tss::set(void* value)
         cleanup_info info(m_cleanup, value);
         (*handlers)[m_key] = info;
     }
-    OSStatus lStatus = MPSetTaskStorageValue(m_key,
-        reinterpret_cast<TaskStorageValue>(value));
+    OSStatus lStatus = MPSetTaskStorageValue(m_key, reinterpret_cast<TaskStorageValue>(value));
     return(lStatus == noErr);
 }
 #endif

src/xtime.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2001-2003
+// Copyright (C) 2001
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -33,30 +33,29 @@ struct startup_time_info
 {
     startup_time_info()
     {
-        // 1970 Jan 1 at 00:00:00
+    // 1970 Jan 1 at 00:00:00
         static const DateTimeRec k_sUNIXBase = {1970, 1, 1, 0, 0, 0, 0};
         static unsigned long s_ulUNIXBaseSeconds = 0UL;
 
         if(s_ulUNIXBaseSeconds == 0UL)
         {
-            // calculate the number of seconds between the Mac OS base and the
-            // UNIX base the first time we enter this constructor.
+        // calculate the number of seconds between the Mac OS base and the UNIX base
+        //    the first time we enter this constructor.
             DateToSeconds(&k_sUNIXBase, &s_ulUNIXBaseSeconds);
         }
 
         unsigned long ulSeconds;
 
-        // get the time in UpTime units twice, with the time in seconds in the
-        // middle.
+    // get the time in UpTime units twice, with the time in seconds in the middle.
         uint64_t ullFirstUpTime = force_cast<uint64_t>(UpTime());
         GetDateTime(&ulSeconds);
         uint64_t ullSecondUpTime = force_cast<uint64_t>(UpTime());
 
-        // calculate the midpoint of the two UpTimes, and save that.
+    // calculate the midpoint of the two UpTimes, and save that.
         uint64_t ullAverageUpTime = (ullFirstUpTime + ullSecondUpTime) / 2ULL;
         m_sStartupAbsoluteTime = force_cast<AbsoluteTime>(ullAverageUpTime);
 
-        // save the number of seconds, recentered at the UNIX base.
+    // save the number of seconds, recentered at the UNIX base.
         m_ulStartupSeconds = ulSeconds - s_ulUNIXBaseSeconds;
     }
 
@@ -78,13 +77,10 @@ int xtime_get(struct xtime* xtp, int clock_type)
 #if defined(BOOST_HAS_FTIME)
         FILETIME ft;
         GetSystemTimeAsFileTime(&ft);
-        const boost::uint64_t TIMESPEC_TO_FILETIME_OFFSET =
-            ((boost::uint64_t)27111902UL << 32) +
-            (boost::uint64_t)3577643008UL;
-        xtp->sec = (int)((*(__int64*)&ft - TIMESPEC_TO_FILETIME_OFFSET) /
-            10000000);
+        const boost::uint64_t TIMESPEC_TO_FILETIME_OFFSET = ((boost::uint64_t)27111902UL << 32) + (boost::uint64_t)3577643008UL;
+        xtp->sec = (int)((*(__int64*)&ft - TIMESPEC_TO_FILETIME_OFFSET) / 10000000);
         xtp->nsec = (int)((*(__int64*)&ft - TIMESPEC_TO_FILETIME_OFFSET -
-                              ((__int64)xtp->sec * (__int64)10000000)) * 100);
+            ((__int64)xtp->sec * (__int64)10000000)) * 100);
         return clock_type;
 #elif defined(BOOST_HAS_GETTIMEOFDAY)
         struct timeval tv;
@@ -100,16 +96,12 @@ int xtime_get(struct xtime* xtp, int clock_type)
         return clock_type;
 #elif defined(BOOST_HAS_MPTASKS)
         using detail::thread::force_cast;
-        // the Mac OS does not have an MP-safe way of getting the date/time,
-        // so we use a delta from the startup time.  We _could_ defer this
-        // and use something that is interrupt-safe, but this would be _SLOW_,
-        // and we need speed here.
+    // the Mac OS does not have an MP-safe way of getting the date/time, so we use a
+    //  delta from the startup time.  We _could_ defer this and use something that is
+    //  interrupt-safe, but this would be _SLOW_, and we need speed here.
         const uint64_t k_ullNanosecondsPerSecond(1000ULL * 1000ULL * 1000ULL);
         AbsoluteTime sUpTime(UpTime());
-        uint64_t ullNanoseconds(
-            force_cast<uint64_t>(
-                AbsoluteDeltaToNanoseconds(sUpTime,
-                    detail::g_sStartupTimeInfo.m_sStartupAbsoluteTime)));
+        uint64_t ullNanoseconds(force_cast<uint64_t>(AbsoluteDeltaToNanoseconds(sUpTime, detail::g_sStartupTimeInfo.m_sStartupAbsoluteTime)));
         uint64_t ullSeconds = (ullNanoseconds / k_ullNanosecondsPerSecond);
         ullNanoseconds -= (ullSeconds * k_ullNanosecondsPerSecond);
         xtp->sec = detail::g_sStartupTimeInfo.m_ulStartupSeconds + ullSeconds;

test/Jamfile

@@ -34,10 +34,11 @@ include testing.jam ;
         : <template>thread_base
           <dll>../build/boost_thread
           <lib>../../test/build/boost_unit_test_framework
+#          $(threadmon)
         ## requirements ##
         :
         ## default build ##
-        :
+        : # debug release <runtime-link>static/dynamic
     ;
 
     test-suite "threads"

test/test_condition.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
@@ -77,7 +66,7 @@ void condition_test_waits(condition_test_data* data)
     data->condition.notify_one();
 
     // Test predicate timed_wait.
-    xt = delay(10);
+	xt = delay(10);
     cond_predicate pred(data->notified, 4);
     BOOST_CHECK(data->condition.timed_wait(lock, xt, pred));
     BOOST_CHECK(lock ? true : false);
@@ -106,7 +95,7 @@ void do_test_condition_notify_one()
 
 void test_condition_notify_one()
 {
-    timed_test(&do_test_condition_notify_one, 2, execution_monitor::use_mutex);
+	timed_test(&do_test_condition_notify_one, 2, execution_monitor::use_mutex);
 }
 
 void do_test_condition_notify_all()
@@ -131,10 +120,10 @@ void do_test_condition_notify_all()
 
 void test_condition_notify_all()
 {
-    // We should have already tested notify_one here, so
-    // a timed test with the default execution_monitor::use_condition
-    // should be OK, and gives the fastest performance
-    timed_test(&do_test_condition_notify_all, 3);
+	// We should have already tested notify_one here, so
+	// a timed test with the default execution_monitor::use_condition
+	// should be OK, and gives the fastest performance
+	timed_test(&do_test_condition_notify_all, 3);
 }
 
 void do_test_condition_waits()
@@ -186,16 +175,16 @@ void do_test_condition_waits()
 
 void test_condition_waits()
 {
-    // We should have already tested notify_one here, so
-    // a timed test with the default execution_monitor::use_condition
-    // should be OK, and gives the fastest performance
-    timed_test(&do_test_condition_waits, 12);
+	// We should have already tested notify_one here, so
+	// a timed test with the default execution_monitor::use_condition
+	// should be OK, and gives the fastest performance
+	timed_test(&do_test_condition_waits, 12);
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
     boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: condition test suite");
+       BOOST_TEST_SUITE("Boost.Threads: condition test suite");
 
     test->add(BOOST_TEST_CASE(&test_condition_notify_one));
     test->add(BOOST_TEST_CASE(&test_condition_notify_all));

test/test_mutex.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/xtime.hpp>
@@ -143,7 +132,7 @@ struct test_timedlock
         BOOST_CHECK(lock ? true : false);
         lock.unlock();
         BOOST_CHECK(!lock);
-        xt = delay(0, 100);
+		xt = delay(0, 100);
         BOOST_CHECK(lock.timed_lock(xt));
         BOOST_CHECK(lock ? true : false);
     }
@@ -170,7 +159,7 @@ void do_test_mutex()
 
 void test_mutex()
 {
-    timed_test(&do_test_mutex, 3);
+	timed_test(&do_test_mutex, 3);
 }
 
 void do_test_try_mutex()
@@ -181,7 +170,7 @@ void do_test_try_mutex()
 
 void test_try_mutex()
 {
-    timed_test(&do_test_try_mutex, 3);
+	timed_test(&do_test_try_mutex, 3);
 }
 
 void do_test_timed_mutex()
@@ -193,7 +182,7 @@ void do_test_timed_mutex()
 
 void test_timed_mutex()
 {
-    timed_test(&do_test_timed_mutex, 3);
+	timed_test(&do_test_timed_mutex, 3);
 }
 
 void do_test_recursive_mutex()
@@ -204,7 +193,7 @@ void do_test_recursive_mutex()
 
 void test_recursive_mutex()
 {
-    timed_test(&do_test_recursive_mutex, 3);
+	timed_test(&do_test_recursive_mutex, 3);
 }
 
 void do_test_recursive_try_mutex()
@@ -216,7 +205,7 @@ void do_test_recursive_try_mutex()
 
 void test_recursive_try_mutex()
 {
-    timed_test(&do_test_recursive_try_mutex, 3);
+	timed_test(&do_test_recursive_try_mutex, 3);
 }
 
 void do_test_recursive_timed_mutex()
@@ -229,13 +218,12 @@ void do_test_recursive_timed_mutex()
 
 void test_recursive_timed_mutex()
 {
-    timed_test(&do_test_recursive_timed_mutex, 3);
+	timed_test(&do_test_recursive_timed_mutex, 3);
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-    boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: mutex test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: mutex test suite");
 
     test->add(BOOST_TEST_CASE(&test_mutex));
     test->add(BOOST_TEST_CASE(&test_try_mutex));

test/test_once.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/once.hpp>
 #include <boost/thread/thread.hpp>
 
@@ -41,13 +30,12 @@ void do_test_once()
 
 void test_once()
 {
-    timed_test(&do_test_once, 2);
+	timed_test(&do_test_once, 2);
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-    boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: once test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: once test suite");
 
     test->add(BOOST_TEST_CASE(test_once));
 

test/test_thread.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/thread/xtime.hpp>
 
@@ -36,8 +25,7 @@ void test_sleep()
     boost::xtime xt = delay(3);
     boost::thread::sleep(xt);
 
-    // Ensure it's in a range instead of checking actual equality due to time
-    // lapse
+    // Insure it's in a range instead of checking actual equality due to time lapse
     BOOST_CHECK(in_range(xt));
 }
 
@@ -51,7 +39,7 @@ void do_test_creation()
 
 void test_creation()
 {
-    timed_test(&do_test_creation, 1);
+	timed_test(&do_test_creation, 1);
 }
 
 void do_test_comparison()
@@ -63,13 +51,12 @@ void do_test_comparison()
 
 void test_comparison()
 {
-    timed_test(&do_test_comparison, 1);
+	timed_test(&do_test_comparison, 1);
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-    boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: thread test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: thread test suite");
 
     test->add(BOOST_TEST_CASE(test_sleep));
     test->add(BOOST_TEST_CASE(test_creation));

test/test_tss.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/tss.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
@@ -61,13 +50,12 @@ void do_test_tss()
 
 void test_tss()
 {
-    timed_test(&do_test_tss, 2);
+	timed_test(&do_test_tss, 2);
 }
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-    boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: tss test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: tss test suite");
 
     test->add(BOOST_TEST_CASE(test_tss));
 

test/test_xtime.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/xtime.hpp>
 
 #include <boost/test/unit_test.hpp>
@@ -16,9 +5,7 @@
 void test_xtime_cmp()
 {
     boost::xtime xt1, xt2, cur;
-    BOOST_CHECK_EQUAL(
-        boost::xtime_get(&cur, boost::TIME_UTC),
-        static_cast<int>(boost::TIME_UTC));
+    BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), static_cast<int>(boost::TIME_UTC));
 
     xt1 = xt2 = cur;
     xt1.nsec -= 1;
@@ -40,16 +27,12 @@ void test_xtime_cmp()
 void test_xtime_get()
 {
     boost::xtime orig, cur, old;
-    BOOST_CHECK_EQUAL(
-        boost::xtime_get(&orig,
-            boost::TIME_UTC), static_cast<int>(boost::TIME_UTC));
+    BOOST_CHECK_EQUAL(boost::xtime_get(&orig, boost::TIME_UTC), static_cast<int>(boost::TIME_UTC));
     old = orig;
 
     for (int x=0; x < 100; ++x)
     {
-        BOOST_CHECK_EQUAL(
-            boost::xtime_get(&cur, boost::TIME_UTC),
-            static_cast<int>(boost::TIME_UTC));
+        BOOST_CHECK_EQUAL(boost::xtime_get(&cur, boost::TIME_UTC), static_cast<int>(boost::TIME_UTC));
         BOOST_CHECK(boost::xtime_cmp(cur, orig) >= 0);
         BOOST_CHECK(boost::xtime_cmp(cur, old) >= 0);
         old = cur;
@@ -58,8 +41,7 @@ void test_xtime_get()
 
 boost::unit_test_framework::test_suite* init_unit_test_suite(int, char*[])
 {
-    boost::unit_test_framework::test_suite* test =
-        BOOST_TEST_SUITE("Boost.Threads: xtime test suite");
+    boost::unit_test_framework::test_suite* test = BOOST_TEST_SUITE("Boost.Threads: xtime test suite");
 
     test->add(BOOST_TEST_CASE(&test_xtime_cmp));
     test->add(BOOST_TEST_CASE(&test_xtime_get));

test/util.inl

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #if !defined(UTIL_INL_WEK01242003)
 #define UTIL_INL_WEK01242003
 
@@ -23,140 +12,139 @@
 
 namespace
 {
-inline boost::xtime delay(int secs, int msecs=0, int nsecs=0)
-{
-    const int MILLISECONDS_PER_SECOND = 1000;
-    const int NANOSECONDS_PER_SECOND = 1000000000;
-    const int NANOSECONDS_PER_MILLISECOND = 1000000;
+	inline boost::xtime delay(int secs, int msecs=0, int nsecs=0)
+	{
+		const int MILLISECONDS_PER_SECOND = 1000;
+		const int NANOSECONDS_PER_SECOND = 1000000000;
+		const int NANOSECONDS_PER_MILLISECOND = 1000000;
 
-    boost::xtime xt;
-    BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC),
-        static_cast<int>(boost::TIME_UTC));
+		boost::xtime xt;
+        BOOST_CHECK_EQUAL(boost::xtime_get(&xt, boost::TIME_UTC),
+            static_cast<int>(boost::TIME_UTC));
 
-    nsecs += xt.nsec;
-    msecs += nsecs / NANOSECONDS_PER_MILLISECOND;
-    secs += msecs / MILLISECONDS_PER_SECOND;
-    nsecs += (msecs % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
-    xt.nsec = nsecs % NANOSECONDS_PER_SECOND;
-    xt.sec += secs + (nsecs / NANOSECONDS_PER_SECOND);
+		nsecs += xt.nsec;
+		msecs += nsecs / NANOSECONDS_PER_MILLISECOND;
+		secs += msecs / MILLISECONDS_PER_SECOND;
+		nsecs += (msecs % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
+		xt.nsec = nsecs % NANOSECONDS_PER_SECOND;
+		xt.sec += secs + (nsecs / NANOSECONDS_PER_SECOND);
 
-    return xt;
-}
+		return xt;
+	}
 
-inline bool in_range(const boost::xtime& xt, int secs=1)
-{
-    boost::xtime min = delay(-secs);
-    boost::xtime max = delay(0);
-    return (boost::xtime_cmp(xt, min) >= 0) &&
-        (boost::xtime_cmp(xt, max) <= 0);
-}
+	inline bool in_range(const boost::xtime& xt, int secs=1)
+	{
+		boost::xtime min = delay(-secs);
+		boost::xtime max = delay(0);
+		return (boost::xtime_cmp(xt, min) >= 0) && (boost::xtime_cmp(xt, max) <= 0);
+	}
 
-class execution_monitor
-{
-public:
-    enum wait_type { use_sleep_only, use_mutex, use_condition };
-
-    execution_monitor(wait_type type, int secs)
-        : done(false), type(type), secs(secs) { }
-    void start()
+    class execution_monitor
     {
-        if (type != use_sleep_only) {
-            boost::mutex::scoped_lock lock(mutex); done = false;
-        } else {
-            done = false;
-        }
-    }
-    void finish()
-    {
-        if (type != use_sleep_only) {
-            boost::mutex::scoped_lock lock(mutex);
-            done = true;
-            if (type == use_condition)
-                cond.notify_one();
-        } else {
-            done = true;
-        }
-    }
-    bool wait()
-    {
-        boost::xtime xt = delay(secs);
-        if (type != use_condition)
-            boost::thread::sleep(xt);
-        if (type != use_sleep_only) {
-            boost::mutex::scoped_lock lock(mutex);
-            while (type == use_condition && !done) {
-                if (!cond.timed_wait(lock, xt))
-                    break;
-            }
-            return done;
-        }
-        return done;
-    }
+    public:
+		enum wait_type { use_sleep_only, use_mutex, use_condition };
 
-private:
-    boost::mutex mutex;
-    boost::condition cond;
-    bool done;
-    wait_type type;
-    int secs;
-};
+        execution_monitor(wait_type type, int secs)
+			: done(false), type(type), secs(secs) { }
+		void start()
+		{
+			if (type != use_sleep_only) {
+				boost::mutex::scoped_lock lock(mutex); done = false;
+			} else {
+				done = false;
+			}
+		}
+        void finish()
+		{
+			if (type != use_sleep_only) {
+				boost::mutex::scoped_lock lock(mutex);
+				done = true;
+				if (type == use_condition)
+					cond.notify_one();
+			} else {
+				done = true;
+			}
+		}
+		bool wait()
+		{
+			boost::xtime xt = delay(secs);
+			if (type != use_condition)
+				boost::thread::sleep(xt);
+			if (type != use_sleep_only) {
+				boost::mutex::scoped_lock lock(mutex);
+				while (type == use_condition && !done) {
+					if (!cond.timed_wait(lock, xt))
+						break;
+				}
+				return done;
+			}
+			return done;
+		}
 
-template <typename F>
-class indirect_adapter
-{
-public:
-    indirect_adapter(F func, execution_monitor& monitor)
-        : func(func), monitor(monitor) { }
-    void operator()() const
+    private:
+        boost::mutex mutex;
+		boost::condition cond;
+        bool done;
+		wait_type type;
+		int secs;
+    };
+
+	template <typename F>
+    class indirect_adapter
     {
-        try
+    public:
+        indirect_adapter(F func, execution_monitor& monitor)
+            : func(func), monitor(monitor) { }
+        void operator()() const
         {
-            boost::thread thrd(func);
-            thrd.join();
+			try
+			{
+				boost::thread thrd(func);
+				thrd.join();
+			}
+			catch (...)
+			{
+				monitor.finish();
+				throw;
+			}
+			monitor.finish();
         }
-        catch (...)
-        {
-            monitor.finish();
-            throw;
-        }
-        monitor.finish();
-    }
 
-private:
-    F func;
-    execution_monitor& monitor;
-};
+    private:
+		F func;
+        execution_monitor& monitor;
+    };
 
-template <typename F>
-void timed_test(F func, int secs,
-    execution_monitor::wait_type type=DEFAULT_EXECUTION_MONITOR_TYPE)
-{
-    execution_monitor monitor(type, secs);
-    indirect_adapter<F> ifunc(func, monitor);
-    monitor.start();
-    boost::thread thrd(ifunc);
-    BOOST_REQUIRE_MESSAGE(monitor.wait(),
-        "Timed test didn't complete in time, possible deadlock.");
-}
+	template <typename F>
+	void timed_test(F func, int secs,
+		execution_monitor::wait_type type=DEFAULT_EXECUTION_MONITOR_TYPE)
+	{
+		execution_monitor monitor(type, secs);
+		indirect_adapter<F> ifunc(func, monitor);
+		monitor.start();
+		boost::thread thrd(ifunc);
+		BOOST_REQUIRE_MESSAGE(monitor.wait(),
+			"Timed test didn't complete in time, possible deadlock.");
+	}
 
-template <typename F, typename T>
-class binder
-{
-public:
-    binder(const F& func, const T& param)
-        : func(func), param(param) { }
-    void operator()() const { func(param); }
+	template <typename F, typename T>
+    class binder
+    {
+    public:
+        binder(const F& func, const T& param)
+            : func(func), param(param) { }
+        void operator()() const { func(param); }
 
-private:
-    F func;
-    T param;
-};
+    private:
+		F func;
+        T param;
+    };
 
-template <typename F, typename T>
-binder<F, T> bind(const F& func, const T& param)
-{
-    return binder<F, T>(func, param);
-}
+	template <typename F, typename T>
+	binder<F, T> bind(const F& func, const T& param)
+	{
+		return binder<F, T>(func, param);
+	}
 } // namespace
 
 #endif

tutorial/Jamfile

@@ -1,19 +1,8 @@
-#  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell
-#  and distribute this software is granted provided this copyright notice
-#  appears in all copies. This software is provided "as is" without express or
-#  implied warranty, and with no claim as to its suitability for any purpose.
+#  (C) Copyright William E. Kempf 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
 #
-# Boost.Threads example Jamfile
-#
-# Additional configuration variables used:
-#   1. PTW32 may be used on Win32 platforms to specify that the pthreads-win32
-#      library should be used instead of "native" threads. This feature is
-#      mostly used for testing and it's generally recommended you use the
-#      native threading libraries instead. PTW32 should be set to be a list
-#      of two strings, the first specifying the installation path of the
-#      pthreads-win32 library and the second specifying which library
-#      variant to link against (see the pthreads-win32 documentation).
-#      Example: jam -sPTW32="c:\pthreads-win32 pthreadVCE.lib"
 
 # Declare the location of this subproject relative to the root.
 
@@ -25,25 +14,22 @@ subproject libs/thread/tutorial ;
 SEARCH on <module@>threads.jam = $(BOOST_ROOT)/libs/thread/build ;
 include <module@>threads.jam ;
 
-{
-    template tutorial
-        ## sources ##
-        : <template>thread_base
-          <dll>../build/boost_thread
-        ## requirements ##
-        :
-        ## default build ##
-        :
-    ;
+template tutorial
+    ## sources ##
+    : <template>thread_base <lib>../build/boost_thread <lib>../../test/build/unit_test_framework $(threadmon)
+    ## requirements ##
+    :
+    ## default build ##
+    : release <runtime-link>static
+;
 
-    exe helloworld : <template>tutorial helloworld.cpp ;
-    exe helloworld2 : <template>tutorial helloworld2.cpp ;
-    exe helloworld3 : <template>tutorial helloworld3.cpp ;
-    exe helloworld4 : <template>tutorial helloworld4.cpp ;
-    exe factorial : <template>tutorial factorial.cpp ;
-    exe factorial2 : <template>tutorial factorial2.cpp ;
-    exe factorial3 : <template>tutorial factorial3.cpp ;
-    exe counter : <template>tutorial counter.cpp ;
-    exe bounded_buffer : <template>tutorial bounded_buffer.cpp ;
-    exe once : <template>tutorial once.cpp ;
-}
+exe helloworld : <template>tutorial helloworld.cpp ;
+exe helloworld2 : <template>tutorial helloworld2.cpp ;
+exe helloworld3 : <template>tutorial helloworld3.cpp ;
+exe helloworld4 : <template>tutorial helloworld4.cpp ;
+exe factorial : <template>tutorial factorial.cpp ;
+exe factorial2 : <template>tutorial factorial2.cpp ;
+exe factorial3 : <template>tutorial factorial3.cpp ;
+exe counter : <template>tutorial counter.cpp ;
+exe bounded_buffer : <template>tutorial bounded_buffer.cpp ;
+exe once : <template>tutorial once.cpp ;

tutorial/bounded_buffer.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/condition.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
@@ -50,9 +39,9 @@ bounded_buffer buf(2);
 void sender() {
     int n = 0;
     while (n < 100) {
-        buf.send(n);
-        std::cout << "sent: " << n << std::endl;
-        ++n;
+       buf.send(n);
+       std::cout << "sent: " << n << std::endl;
+       ++n;
     }
     buf.send(-1);
 }
@@ -60,8 +49,8 @@ void sender() {
 void receiver() {
     int n;
     do {
-        n = buf.receive();
-        std::cout << "received: " << n << std::endl;
+       n = buf.receive();
+       std::cout << "received: " << n << std::endl;
     } while (n != -1); // -1 indicates end of buffer
 }
 

tutorial/counter.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 #include <iostream>
@@ -18,7 +7,7 @@ int counter=0;
 
 void change_count()
 {
-    boost::mutex::scoped_lock lock(mutex);
+	boost::mutex::scoped_lock lock(mutex);
     int i = ++counter;
     std::cout << "count == " << i << std::endl;
 }

tutorial/factorial.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <iostream>
 
@@ -34,4 +23,4 @@ int main()
     boost::thread thrd(f);
     thrd.join();
     std::cout << "10! = " << result << std::endl;
-}
+}

tutorial/factorial2.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/ref.hpp>
 #include <iostream>
@@ -34,4 +23,4 @@ int main()
     boost::thread thrd(boost::ref(f));
     thrd.join();
     std::cout << "10! = " << f.result() << std::endl;
-}
+}

tutorial/factorial3.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <iostream>
 
@@ -32,10 +21,10 @@ private:
 int main()
 {
     int results[NUM_CALCS];
-    boost::thread_group thrds;
-    for (int i=0; i < NUM_CALCS; ++i)
-        thrds.create_thread(factorial(i*10, results[i]));
-    thrds.join_all();
-    for (int j=0; j < NUM_CALCS; ++j)
-        std::cout << j*10 << "! = " << results[j] << std::endl;
-}
+	boost::thread_group thrds;
+	for (int i=0; i < NUM_CALCS; ++i)
+		thrds.create_thread(factorial(i*10, results[i]));
+	thrds.join_all();
+	for (int i=0; i < NUM_CALCS; ++i)
+		std::cout << i*10 << "! = " << results[i] << std::endl;
+}

tutorial/helloworld.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <iostream>
 
@@ -21,4 +10,4 @@ int main()
 {
     boost::thread thrd(&helloworld);
     thrd.join();
-}
+}

tutorial/helloworld2.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <iostream>
 
@@ -22,4 +11,4 @@ int main()
 {
     boost::thread thrd(helloworld());
     thrd.join();
-}
+}

tutorial/helloworld3.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <iostream>
 
@@ -23,4 +12,4 @@ int main()
 {
     boost::thread thrd(helloworld("Bob"));
     thrd.join();
-}
+}

tutorial/helloworld4.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/bind.hpp>
 #include <iostream>
@@ -22,4 +11,4 @@ int main()
 {
     boost::thread thrd(boost::bind(&helloworld, "Bob"));
     thrd.join();
-}
+}

tutorial/once.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/thread/once.hpp>
 #include <cassert>
@@ -23,14 +12,14 @@ void init()
 
 void thread_proc()
 {
-    boost::call_once(&init, once);
+   boost::call_once(&init, once);
 }
 
 int main(int argc, char* argv[])
 {
-    boost::thread_group threads;
-    for (int i=0; i<5; ++i)
-        threads.create_thread(&thread_proc);
-    threads.join_all();
-    assert(value == 1);
+   boost::thread_group threads;
+   for (int i=0; i<5; ++i)
+      threads.create_thread(&thread_proc);
+   threads.join_all();
+   assert(value == 1);
 }

tutorial/tss.cpp

@@ -1,14 +1,3 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-
 #include <boost/thread/thread.hpp>
 #include <boost/thread/tss.hpp>
 #include <cassert>
@@ -17,25 +6,25 @@ boost::thread_specific_ptr<int> value;
 
 void increment()
 {
-    int* p = value.get();
-    ++*p;
+   int* p = value.get();
+   ++*p;
 }
 
 void thread_proc()
 {
-    value.reset(new int(0)); // initialize the thread's storage
-    for (int i=0; i<10; ++i)
-    {
-        increment();
-        int* p = value.get();
-        assert(*p == i+1);
-    }
+   value.reset(new int(0)); // initialize the thread's storage
+   for (int i=0; i<10; ++i)
+   {
+       increment();
+       int* p = value.get();
+       assert(*p == i+1);
+   }
 }
 
 int main(int argc, char* argv[])
 {
-    boost::thread_group threads;
-    for (int i=0; i<5; ++i)
-        threads.create_thread(&thread_proc);
-    threads.join_all();
+   boost::thread_group threads;
+   for (int i=0; i<5; ++i)
+      threads.create_thread(&thread_proc);
+   threads.join_all();
 }