From ff5d3b49ca6433dbfe50dddcb2389e8595876a14 Mon Sep 17 00:00:00 2001
From: "William E. Kempf" <wekempf@cox.net>
Date: Tue, 4 Feb 2003 23:23:02 +0000
Subject: [PATCH] Updated format (removed tabs) and added missing copyrights

[SVN r17214]
---
 example/Jamfile             |  63 +++++----
 example/condition.cpp       |  21 ++-
 example/monitor.cpp         |  19 ++-
 example/mutex.cpp           |  11 ++
 example/once.cpp            |  23 +++-
 example/recursive_mutex.cpp |  11 ++
 example/starvephil.cpp      |  42 ++++--
 example/tennis.cpp          |  24 +++-
 example/thread.cpp          |  41 +++---
 example/thread_group.cpp    |  23 +++-
 example/tss.cpp             |  37 ++++--
 example/xtime.cpp           |  19 ++-
 src/condition.cpp           |  26 ++--
 src/exceptions.cpp          |   8 +-
 src/mutex.cpp               |  21 +--
 src/once.cpp                | 127 ++++++++++--------
 src/recursive_mutex.cpp     |  27 ++--
 src/thread.cpp              |  97 ++++++++------
 src/threadmon.cpp           | 128 +++++++++---------
 src/timeconv.inl            | 179 ++++++++++++-------------
 src/tss.cpp                 | 151 +++++++++++----------
 src/xtime.cpp               |  36 +++--
 test/Jamfile                |   3 +-
 test/test_condition.cpp     |  33 +++--
 test/test_mutex.cpp         |  28 ++--
 test/test_once.cpp          |  16 ++-
 test/test_thread.cpp        |  21 ++-
 test/test_tss.cpp           |  16 ++-
 test/test_xtime.cpp         |  26 +++-
 test/util.inl               | 258 +++++++++++++++++++-----------------
 tutorial/Jamfile            |  58 +++++---
 tutorial/bounded_buffer.cpp |  21 ++-
 tutorial/counter.cpp        |  13 +-
 tutorial/factorial.cpp      |  13 +-
 tutorial/factorial2.cpp     |  13 +-
 tutorial/factorial3.cpp     |  25 +++-
 tutorial/helloworld.cpp     |  13 +-
 tutorial/helloworld2.cpp    |  13 +-
 tutorial/helloworld3.cpp    |  13 +-
 tutorial/helloworld4.cpp    |  13 +-
 tutorial/once.cpp           |  23 +++-
 tutorial/tss.cpp            |  37 ++++--
 42 files changed, 1118 insertions(+), 672 deletions(-)

diff --git a/example/Jamfile b/example/Jamfile
index c12143ce..20513c3b 100644
--- a/example/Jamfile
+++ b/example/Jamfile
@@ -1,7 +1,19 @@
-#  (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.
 subproject libs/thread/example ;
@@ -12,25 +24,26 @@ 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
-      $(threadmon)
-    ## requirements ##
-    :
-    ## default build ##
-    : release <runtime-link>dynamic
-;
+{
+    template example
+        ## sources ##
+        : <template>thread_base
+          <dll>../build/boost_thread
+        ## requirements ##
+        :
+        ## default build ##
+        :
+    ;
 
-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 ;
+}
diff --git a/example/condition.cpp b/example/condition.cpp
index dc568d4c..0d5c1a26 100644
--- a/example/condition.cpp
+++ b/example/condition.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -43,9 +54,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);
 }
@@ -53,8 +64,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
 }
 
diff --git a/example/monitor.cpp b/example/monitor.cpp
index 93649e11..3d422bb0 100644
--- a/example/monitor.cpp
+++ b/example/monitor.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -6,9 +17,11 @@
 #include <boost/thread/thread.hpp>
 
 namespace {
-    const int ITERS = 100;
-    boost::mutex io_mutex;
-}
+
+const int ITERS = 100;
+boost::mutex io_mutex;
+
+} // namespace
 
 template <typename M>
 class buffer_t
diff --git a/example/mutex.cpp b/example/mutex.cpp
index c05ce169..b9b71b14 100644
--- a/example/mutex.cpp
+++ b/example/mutex.cpp
@@ -1,3 +1,14 @@
+// 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>
diff --git a/example/once.cpp b/example/once.cpp
index 6d519a11..13650d3b 100644
--- a/example/once.cpp
+++ b/example/once.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -12,14 +23,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);
 }
diff --git a/example/recursive_mutex.cpp b/example/recursive_mutex.cpp
index 6aba75f3..18fcb583 100644
--- a/example/recursive_mutex.cpp
+++ b/example/recursive_mutex.cpp
@@ -1,3 +1,14 @@
+// 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>
diff --git a/example/starvephil.cpp b/example/starvephil.cpp
index e725fc89..26ca44c5 100644
--- a/example/starvephil.cpp
+++ b/example/starvephil.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -5,9 +16,10 @@
 #include <iostream>
 #include <time.h>
 
-namespace
-{
-    boost::mutex iomx;
+namespace {
+
+boost::mutex iomx;
+
 }
 
 class canteen
@@ -39,8 +51,9 @@ 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);
@@ -84,7 +97,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);
     }
@@ -96,7 +109,8 @@ 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 (;;)
         {
@@ -110,13 +124,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;
             }
         }
     }
@@ -129,7 +143,10 @@ 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);
@@ -143,7 +160,10 @@ 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*);
diff --git a/example/tennis.cpp b/example/tennis.cpp
index 5955d3ee..42ce8aa7 100644
--- a/example/tennis.cpp
+++ b/example/tennis.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -49,7 +60,8 @@ 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);
     }
 
@@ -60,7 +72,10 @@ 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);
@@ -74,7 +89,10 @@ 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*);
diff --git a/example/thread.cpp b/example/thread.cpp
index 4c9ca4f8..3de3f00e 100644
--- a/example/thread.cpp
+++ b/example/thread.cpp
@@ -1,29 +1,40 @@
+// 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();
 }
diff --git a/example/thread_group.cpp b/example/thread_group.cpp
index f9578f4b..bdfcf26e 100644
--- a/example/thread_group.cpp
+++ b/example/thread_group.cpp
@@ -1,3 +1,14 @@
+// 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>
 
@@ -6,14 +17,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();
 }
diff --git a/example/tss.cpp b/example/tss.cpp
index 9072ff1f..68504aa7 100644
--- a/example/tss.cpp
+++ b/example/tss.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -6,25 +17,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();
 }
diff --git a/example/xtime.cpp b/example/xtime.cpp
index 46e90a2b..ad42b1d8 100644
--- a/example/xtime.cpp
+++ b/example/xtime.cpp
@@ -1,10 +1,21 @@
+// 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
 }
diff --git a/src/condition.cpp b/src/condition.cpp
index 89eba294..a301436b 100644
--- a/src/condition.cpp
+++ b/src/condition.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // 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,7 +40,8 @@ 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)
@@ -174,7 +175,8 @@ void condition_impl::notify_all()
 
         if (signals)
         {
-            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals, 0);
+            res = ReleaseSemaphore(reinterpret_cast<HANDLE>(m_queue), signals,
+                0);
             assert(res);
         }
     }
@@ -427,7 +429,8 @@ 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
@@ -479,7 +482,8 @@ 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
@@ -545,7 +549,8 @@ 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;
@@ -605,7 +610,8 @@ 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;
diff --git a/src/exceptions.cpp b/src/exceptions.cpp
index f99d9d81..75beac84 100644
--- a/src/exceptions.cpp
+++ b/src/exceptions.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -14,11 +14,13 @@
 
 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")
 {
 }
 
diff --git a/src/mutex.cpp b/src/mutex.cpp
index f1cb21bb..630771b7 100644
--- a/src/mutex.cpp
+++ b/src/mutex.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -25,10 +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 {
@@ -151,7 +150,8 @@ 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)
@@ -427,7 +427,8 @@ 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);
 }
 
@@ -459,7 +460,8 @@ 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);
 }
 
@@ -499,7 +501,8 @@ 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);
 }
 
diff --git a/src/once.cpp b/src/once.cpp
index 2485073b..851adf63 100644
--- a/src/once.cpp
+++ b/src/once.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -17,14 +17,16 @@
 #   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
@@ -33,7 +35,7 @@
 #endif
 
 #ifdef BOOST_NO_STDC_NAMESPACE
-    namespace std { using ::sprintf; }
+namespace std { using ::sprintf; }
 #endif
 
 #if defined(BOOST_HAS_PTHREADS)
@@ -46,64 +48,70 @@ 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)
+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)
     {
-        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);
+        rData.first();
+        *rData.second = true;
     }
+
+    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
 
@@ -116,12 +124,14 @@ 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);
@@ -148,7 +158,8 @@ 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);
diff --git a/src/recursive_mutex.cpp b/src/recursive_mutex.cpp
index 6ab84eeb..86e15894 100644
--- a/src/recursive_mutex.cpp
+++ b/src/recursive_mutex.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -23,8 +23,8 @@
 #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 {
@@ -201,7 +201,8 @@ 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)
@@ -798,7 +799,8 @@ 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)
@@ -821,7 +823,8 @@ 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;
@@ -849,7 +852,8 @@ 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)
@@ -890,7 +894,8 @@ 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;
@@ -918,7 +923,8 @@ 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)
@@ -981,7 +987,8 @@ 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;
diff --git a/src/thread.cpp b/src/thread.cpp
index a1f7e8ea..423fa754 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // 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,7 +32,10 @@ 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);
@@ -56,28 +59,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
     {
-        thread_param* p = static_cast<thread_param*>(param);
-        boost::function0<void> threadfunc = p->m_threadfunc;
-        p->started();
-        threadfunc();
-    }
-    catch (...)
-    {
-    }
+        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();
+        ::boost::detail::thread_cleanup();
 #endif
-    return 0;
-}
+        return 0;
+    }
 
 }
 
@@ -104,7 +107,8 @@ 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)
@@ -121,11 +125,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);
@@ -181,7 +185,8 @@ 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
@@ -260,17 +265,20 @@ 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();
@@ -280,9 +288,11 @@ 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);
@@ -292,9 +302,11 @@ 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);
@@ -303,8 +315,11 @@ 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
diff --git a/src/threadmon.cpp b/src/threadmon.cpp
index 8628c524..2cb6d6e0 100644
--- a/src/threadmon.cpp
+++ b/src/threadmon.cpp
@@ -1,5 +1,13 @@
-// threadmon.cpp : Defines the entry point for the DLL application.
+// 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>
 
@@ -26,9 +34,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__)
@@ -40,66 +48,66 @@ 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:
+    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)
             {
-                // 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;
-                }
+                (*it)();
             }
-            break;
-        case DLL_PROCESS_DETACH:
+
+            // 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)
             {
-                // 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);
+                (*it)();
             }
-            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;
 }
diff --git a/src/timeconv.inl b/src/timeconv.inl
index 7820e53b..001dcccf 100644
--- a/src/timeconv.inl
+++ b/src/timeconv.inl
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -10,118 +10,119 @@
 // 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)
+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))
     {
-        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;
-        }
+        ++xt.sec;
+        xt.nsec -= NANOSECONDS_PER_SECOND;
     }
+}
 
 #if defined(BOOST_HAS_PTHREADS)
-    inline void to_timespec(const boost::xtime& xt, timespec& ts)
+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))
     {
-        ts.tv_sec = static_cast<int>(xt.sec);
-        ts.tv_nsec = static_cast<int>(xt.nsec);
+        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;
         }
     }
-
-    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);
+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
+    if (boost::xtime_cmp(xt, cur) <= 0)
+        milliseconds = 0;
+    else
+    {
+        if (cur.nsec > xt.nsec)
         {
-            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)) /
+            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)
+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
     {
-        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)) /
+        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.
diff --git a/src/tss.cpp b/src/tss.cpp
index 0f32cb05..d0255578 100644
--- a/src/tss.cpp
+++ b/src/tss.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -23,94 +23,100 @@
 #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()
+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)
     {
-        key = TlsAlloc();
-        assert(key != 0xFFFFFFFF);
+        cleanup_info info = it->second;
+        if (info.second)
+            info.first(info.second);
     }
+    delete handlers;
+}
 
-    void __cdecl cleanup()
+cleanup_handlers* get_handlers()
+{
+    boost::call_once(&init_cleanup_key, once);
+
+    cleanup_handlers* handlers = static_cast<cleanup_handlers*>(
+        TlsGetValue(key));
+    if (!handlers)
     {
-        cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
-        for (cleanup_handlers::iterator it = handlers->begin(); it != handlers->end(); ++it)
+        try
         {
-            cleanup_info info = it->second;
-            if (info.second)
-                info.first(info.second);
+            handlers = new cleanup_handlers;
         }
-        delete handlers;
-    }
-
-    cleanup_handlers* get_handlers()
-    {
-        boost::call_once(&init_cleanup_key, once);
-
-        cleanup_handlers* handlers = static_cast<cleanup_handlers*>(TlsGetValue(key));
-        if (!handlers)
+        catch (...)
         {
-            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 0;
         }
-
-        return handlers;
+        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()
+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)
     {
-        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)
+        try
         {
-            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.
+            handlers = new cleanup_handlers;
         }
-
-        return 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 {
@@ -120,10 +126,12 @@ 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)
@@ -235,7 +243,8 @@ 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
diff --git a/src/xtime.cpp b/src/xtime.cpp
index e7e5164d..9f234a90 100644
--- a/src/xtime.cpp
+++ b/src/xtime.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2001
+// Copyright (C) 2001-2003
 // William E. Kempf
 //
 // Permission to use, copy, modify, distribute and sell this software
@@ -33,29 +33,30 @@ 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;
     }
 
@@ -77,10 +78,13 @@ 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;
@@ -96,12 +100,16 @@ 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;
diff --git a/test/Jamfile b/test/Jamfile
index 5498c063..3de4bdf8 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -34,11 +34,10 @@ 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"
diff --git a/test/test_condition.cpp b/test/test_condition.cpp
index 0e7ac037..d103c59a 100644
--- a/test/test_condition.cpp
+++ b/test/test_condition.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -66,7 +77,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);
@@ -95,7 +106,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()
@@ -120,10 +131,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()
@@ -175,16 +186,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));
diff --git a/test/test_mutex.cpp b/test/test_mutex.cpp
index ff5dc3d7..22877d69 100644
--- a/test/test_mutex.cpp
+++ b/test/test_mutex.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -132,7 +143,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);
     }
@@ -159,7 +170,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()
@@ -170,7 +181,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()
@@ -182,7 +193,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()
@@ -193,7 +204,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()
@@ -205,7 +216,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()
@@ -218,12 +229,13 @@ 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));
diff --git a/test/test_once.cpp b/test/test_once.cpp
index 4a82381b..9ea1cace 100644
--- a/test/test_once.cpp
+++ b/test/test_once.cpp
@@ -1,3 +1,14 @@
+// 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>
 
@@ -30,12 +41,13 @@ 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));
 
diff --git a/test/test_thread.cpp b/test/test_thread.cpp
index 97f637fe..38b21869 100644
--- a/test/test_thread.cpp
+++ b/test/test_thread.cpp
@@ -1,3 +1,14 @@
+// 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>
 
@@ -25,7 +36,8 @@ void test_sleep()
     boost::xtime xt = delay(3);
     boost::thread::sleep(xt);
 
-    // Insure it's in a range instead of checking actual equality due to time lapse
+    // Ensure it's in a range instead of checking actual equality due to time
+    // lapse
     BOOST_CHECK(in_range(xt));
 }
 
@@ -39,7 +51,7 @@ void do_test_creation()
 
 void test_creation()
 {
-	timed_test(&do_test_creation, 1);
+    timed_test(&do_test_creation, 1);
 }
 
 void do_test_comparison()
@@ -51,12 +63,13 @@ 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));
diff --git a/test/test_tss.cpp b/test/test_tss.cpp
index d8c325c0..85f7ff3a 100644
--- a/test/test_tss.cpp
+++ b/test/test_tss.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -50,12 +61,13 @@ 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));
 
diff --git a/test/test_xtime.cpp b/test/test_xtime.cpp
index ea43bdf3..43e9fd85 100644
--- a/test/test_xtime.cpp
+++ b/test/test_xtime.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -5,7 +16,9 @@
 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;
@@ -27,12 +40,16 @@ 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;
@@ -41,7 +58,8 @@ 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));
diff --git a/test/util.inl b/test/util.inl
index 446c039f..9c8f31b6 100644
--- a/test/util.inl
+++ b/test/util.inl
@@ -1,3 +1,14 @@
+// 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
 
@@ -12,139 +23,140 @@
 
 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
+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()
     {
-    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()
-		{
-			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;
-		}
-
-    private:
-        boost::mutex mutex;
-		boost::condition cond;
-        bool done;
-		wait_type type;
-		int secs;
-    };
-
-	template <typename F>
-    class indirect_adapter
-    {
-    public:
-        indirect_adapter(F func, execution_monitor& monitor)
-            : func(func), monitor(monitor) { }
-        void operator()() const
-        {
-			try
-			{
-				boost::thread thrd(func);
-				thrd.join();
-			}
-			catch (...)
-			{
-				monitor.finish();
-				throw;
-			}
-			monitor.finish();
+        if (type != use_sleep_only) {
+            boost::mutex::scoped_lock lock(mutex); done = false;
+        } else {
+            done = false;
         }
-
-    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, typename T>
-    class binder
+    }
+    void finish()
     {
-    public:
-        binder(const F& func, const T& param)
-            : func(func), param(param) { }
-        void operator()() const { func(param); }
+        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;
+    }
 
-    private:
-		F func;
-        T param;
-    };
+private:
+    boost::mutex mutex;
+    boost::condition cond;
+    bool done;
+    wait_type type;
+    int secs;
+};
 
-	template <typename F, typename T>
-	binder<F, T> bind(const F& func, const T& param)
-	{
-		return binder<F, T>(func, param);
-	}
+template <typename F>
+class indirect_adapter
+{
+public:
+    indirect_adapter(F func, execution_monitor& monitor)
+        : func(func), monitor(monitor) { }
+    void operator()() const
+    {
+        try
+        {
+            boost::thread thrd(func);
+            thrd.join();
+        }
+        catch (...)
+        {
+            monitor.finish();
+            throw;
+        }
+        monitor.finish();
+    }
+
+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, 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;
+};
+
+template <typename F, typename T>
+binder<F, T> bind(const F& func, const T& param)
+{
+    return binder<F, T>(func, param);
+}
 } // namespace
 
 #endif
diff --git a/tutorial/Jamfile b/tutorial/Jamfile
index 166ada2e..1531ab57 100644
--- a/tutorial/Jamfile
+++ b/tutorial/Jamfile
@@ -1,8 +1,19 @@
-#  (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.
 
@@ -14,22 +25,25 @@ subproject libs/thread/tutorial ;
 SEARCH on <module@>threads.jam = $(BOOST_ROOT)/libs/thread/build ;
 include <module@>threads.jam ;
 
-template tutorial
-    ## sources ##
-    : <template>thread_base <lib>../build/boost_thread <lib>../../test/build/unit_test_framework $(threadmon)
-    ## requirements ##
-    :
-    ## default build ##
-    : release <runtime-link>static
-;
+{
+    template tutorial
+        ## sources ##
+        : <template>thread_base
+          <dll>../build/boost_thread
+        ## requirements ##
+        :
+        ## default build ##
+        :
+    ;
 
-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 ;
+}
diff --git a/tutorial/bounded_buffer.cpp b/tutorial/bounded_buffer.cpp
index 330536d4..ec7b61ac 100644
--- a/tutorial/bounded_buffer.cpp
+++ b/tutorial/bounded_buffer.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -39,9 +50,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);
 }
@@ -49,8 +60,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
 }
 
diff --git a/tutorial/counter.cpp b/tutorial/counter.cpp
index f93be50f..48b243b0 100644
--- a/tutorial/counter.cpp
+++ b/tutorial/counter.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -7,7 +18,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;
 }
diff --git a/tutorial/factorial.cpp b/tutorial/factorial.cpp
index 08ca06dc..0ccafb69 100644
--- a/tutorial/factorial.cpp
+++ b/tutorial/factorial.cpp
@@ -1,3 +1,14 @@
+// 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 +34,4 @@ int main()
     boost::thread thrd(f);
     thrd.join();
     std::cout << "10! = " << result << std::endl;
-}
\ No newline at end of file
+}
diff --git a/tutorial/factorial2.cpp b/tutorial/factorial2.cpp
index 47376c6f..e711de18 100644
--- a/tutorial/factorial2.cpp
+++ b/tutorial/factorial2.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -23,4 +34,4 @@ int main()
     boost::thread thrd(boost::ref(f));
     thrd.join();
     std::cout << "10! = " << f.result() << std::endl;
-}
\ No newline at end of file
+}
diff --git a/tutorial/factorial3.cpp b/tutorial/factorial3.cpp
index db895252..f30dedf3 100644
--- a/tutorial/factorial3.cpp
+++ b/tutorial/factorial3.cpp
@@ -1,3 +1,14 @@
+// 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,10 +32,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 i=0; i < NUM_CALCS; ++i)
-		std::cout << i*10 << "! = " << results[i] << std::endl;
-}
\ No newline at end of file
+    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;
+}
diff --git a/tutorial/helloworld.cpp b/tutorial/helloworld.cpp
index fdf29675..f7538d97 100644
--- a/tutorial/helloworld.cpp
+++ b/tutorial/helloworld.cpp
@@ -1,3 +1,14 @@
+// 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>
 
@@ -10,4 +21,4 @@ int main()
 {
     boost::thread thrd(&helloworld);
     thrd.join();
-}
\ No newline at end of file
+}
diff --git a/tutorial/helloworld2.cpp b/tutorial/helloworld2.cpp
index 378897cd..e8df9aee 100644
--- a/tutorial/helloworld2.cpp
+++ b/tutorial/helloworld2.cpp
@@ -1,3 +1,14 @@
+// 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>
 
@@ -11,4 +22,4 @@ int main()
 {
     boost::thread thrd(helloworld());
     thrd.join();
-}
\ No newline at end of file
+}
diff --git a/tutorial/helloworld3.cpp b/tutorial/helloworld3.cpp
index 85874da1..8b532c66 100644
--- a/tutorial/helloworld3.cpp
+++ b/tutorial/helloworld3.cpp
@@ -1,3 +1,14 @@
+// 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>
 
@@ -12,4 +23,4 @@ int main()
 {
     boost::thread thrd(helloworld("Bob"));
     thrd.join();
-}
\ No newline at end of file
+}
diff --git a/tutorial/helloworld4.cpp b/tutorial/helloworld4.cpp
index 20628323..35e9b509 100644
--- a/tutorial/helloworld4.cpp
+++ b/tutorial/helloworld4.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -11,4 +22,4 @@ int main()
 {
     boost::thread thrd(boost::bind(&helloworld, "Bob"));
     thrd.join();
-}
\ No newline at end of file
+}
diff --git a/tutorial/once.cpp b/tutorial/once.cpp
index 6d519a11..13650d3b 100644
--- a/tutorial/once.cpp
+++ b/tutorial/once.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -12,14 +23,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);
 }
diff --git a/tutorial/tss.cpp b/tutorial/tss.cpp
index 9072ff1f..68504aa7 100644
--- a/tutorial/tss.cpp
+++ b/tutorial/tss.cpp
@@ -1,3 +1,14 @@
+// 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>
@@ -6,25 +17,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();
 }