Fix links to the license text file.

[SVN r43289]

build/.cvsignore

@@ -1,2 +0,0 @@
-bin*
-*.pdb

build/Jamfile.v2

@@ -1,39 +1,208 @@
-# (C) Copyright Vladimir Prus, David Abrahams, Michael Stevens, Hartmut Kaiser, 
-# William E Kempf 2002-2006
-# Use, modification and distribution are subject to the
-# Boost Software License, Version 1.0. (See accompanying file
-# LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+# $Id$
+# Copyright 2006-2007 Roland Schwarz.
+# Copyright 2007 Anthony Williams
+# Distributed under the Boost Software License, Version 1.0. (See
+# accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+#########################################################################
+# The boost threading library can be built on top of different API's
+# Currently this is the win32 API and the pthreads API.
+# Pthread is native on unix variants.
+# To get pthread on windows you need the pthread win32 library
+# http://sourceware.org/pthreads-win32 which is available under LGPL.
+#
+# You need to provide the include path and lib path in the variables
+# PTW32_INCLUDE and PTW32_LIB respectively. You can specify these
+# paths in site-config.jam, user-config.jam or in the environment.
+# A new feature is provided to request a specific API:
+# <threadapi>win32 and <threadapi)pthread.
+#
+# The naming of the resulting libraries is mostly the same for the
+# variant native to the build platform, i.e.
+# boost_thread and the boost specific tagging.
+# For the library variant that is not native on the build platform
+# an additional tag is applied:
+# boost_thread_pthread for the pthread variant on windows, and
+# boost_thread_win32 for the win32 variant (likely when built on cygwin).
+#
+# To request the pthread variant on windows, from boost root you would
+# say e.g:
+# bjam msvc-8.0 --with-thread install threadapi=pthread
+#########################################################################
 
 import os ;
-
+import feature ;
+import indirect ;
+import path ;
 
 project boost/thread
-    : source-location ../src 
-    : requirements <link>shared:<define>BOOST_THREAD_BUILD_DLL=1  <threading>multi 
+    : source-location ../src
+    : requirements <threading>multi
+      <link>static:<define>BOOST_THREAD_BUILD_LIB=1
+      <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
+      -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+      <tag>@$(__name__).tag
     : default-build <threading>multi
     ;
 
-CPP_SOURCES =  
-#        barrier
-#        condition
-        exceptions
-#        mutex
-#        once
-#        recursive_mutex
-#        read_write_mutex
-        thread
-        tss_hooks
-        tss_dll
-        tss_pe
-        tss
-        xtime
+local rule default_threadapi ( )
+{
+    local api = pthread ;
+    if [ os.name ] = "NT" { api = win32 ; }
+    return $(api) ;
+}
+
+feature.feature threadapi : pthread win32 : propagated ;
+feature.set-default threadapi : [ default_threadapi ] ;
+
+rule tag ( name : type ? : property-set )
+{
+    local result = $(name) ;
+    
+    if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB
+    {
+        local api = [ $(property-set).get <threadapi> ] ;
+        
+        # non native api gets additional tag
+        if $(api) != [ default_threadapi ] {
+            result = $(result)_$(api) ;
+        }
+    }
+    
+    # forward to the boost tagging rule
+    return  [ indirect.call $(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag 
+                $(result) : $(type) : $(property-set) ] ;
+}
+
+rule win32_pthread_paths ( properties * )
+{
+    local result ;
+    local PTW32_INCLUDE ;
+    local PTW32_LIB ;
+    PTW32_INCLUDE  = [ modules.peek             : PTW32_INCLUDE ] ;
+    PTW32_LIB      = [ modules.peek             : PTW32_LIB     ] ;
+    PTW32_INCLUDE ?= [ modules.peek user-config : PTW32_INCLUDE ] ;
+    PTW32_LIB     ?= [ modules.peek user-config : PTW32_LIB     ] ;
+    PTW32_INCLUDE ?= [ modules.peek site-config : PTW32_INCLUDE ] ;
+    PTW32_LIB     ?= [ modules.peek site-config : PTW32_LIB     ] ;
+
+    if ! ( $(PTW32_INCLUDE) && $(PTW32_LIB) )
+    {
+        if  ! $(.notified)
+        {
+            echo "************************************************************" ;
+            echo "Trying to build Boost.Thread with pthread support."           ;
+            echo "If you need pthread you should specify the paths."            ;
+            echo "You can specify them in site-config.jam, user-config.jam"     ;
+            echo "or in the environment."                                       ;
+            echo "For example:"                                                 ;
+            echo "PTW32_INCLUDE=C:\\Program Files\\ptw32\\Pre-built2\\include"  ;
+            echo "PTW32_LIB=C:\\Program Files\\ptw32\\Pre-built2\\lib"          ;
+            echo "************************************************************" ;
+            .notified = true ;
+        }
+    }
+    else
+    {
+        local include_path = [ path.make $(PTW32_INCLUDE) ] ;
+        local lib_path = [ path.make $(PTW32_LIB) ] ;
+        local libname = pthread ;
+        if <toolset>msvc in $(properties)
+        {
+            libname = $(libname)VC2.lib ;
+        }
+        if <toolset>gcc in $(properties)
+        {
+            libname = lib$(libname)GC2.a ;
+        }
+        lib_path = [ path.glob $(lib_path) : $(libname) ] ;
+        if ! $(lib_path)
+        {
+            if  ! $(.notified)
+            {
+                echo "************************************************************" ;
+                echo "Trying to build Boost.Thread with pthread support."           ;
+                echo "But the library" $(libname) "could not be found in path"      ;
+                echo $(PTW32_LIB)                                                   ;
+                echo "************************************************************" ;
+                .notified = true ;
+            }
+        }
+        else 
+        {
+            result += <include>$(include_path) ;
+            result += <library>$(lib_path) ;
+        }
+    }
+    return $(result) ;
+}
+
+rule usage-requirements ( properties * )
+{
+    local result ;
+    if <threadapi>pthread in $(properties)
+    {
+        result += <define>BOOST_THREAD_POSIX ;
+        if <target-os>windows in $(properties)
+        {
+            result += [ win32_pthread_paths $(properties) ] ;
+            # TODO: What is for static linking? Is the <library> also needed
+            # in that case?
+        }
+    }
+    return $(result) ;
+}
+
+rule requirements ( properties * )
+{
+    local result ;
+
+    if <threadapi>pthread in $(properties)
+    {
+        result += <define>BOOST_THREAD_POSIX ;
+        if <target-os>windows in $(properties) 
+        {
+            local paths = [ win32_pthread_paths $(properties) ] ;
+            if $(paths)
+            {
+                result += $(paths) ;
+            }
+            else
+            {
+                result = <build>no ;
+            }
+        }
+    }
+    return $(result) ;
+}
+
+alias thread_sources
+    : ## win32 sources ##
+      win32/thread.cpp
+      win32/exceptions.cpp
+      win32/tss_dll.cpp
+      win32/tss_pe.cpp
+    : ## requirements ##
+      <threadapi>win32
     ;
 
+alias thread_sources
+    : ## pthread sources ##
+      pthread/thread.cpp
+      pthread/exceptions.cpp
+      pthread/once.cpp
+    : ## requirements ##
+      <threadapi>pthread
+    ;
+
+explicit thread_sources ;
+
 lib boost_thread
-   : $(CPP_SOURCES).cpp
-   : <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
-     <link>static:<define>BOOST_THREAD_BUILD_LIB=1
-   : # default build
-   : <link>shared:<define>BOOST_THREAD_BUILD_DLL=1
-     <link>static:<define>BOOST_THREAD_BUILD_LIB=1
-   ;
+    : thread_sources
+    : <conditional>@requirements
+    :
+    : <link>shared:<define>BOOST_THREAD_USE_DLL=1
+      <link>static:<define>BOOST_THREAD_USE_LIB=1
+      <conditional>@usage-requirements
+    ;

doc/acknowledgements.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.acknowledgements"
 last-revision="$Date$">

doc/barrier-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/barrier.hpp"
   last-revision="$Date$">

doc/bibliography.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <bibliography id="thread.bibliography"
 last-revision="$Date$">
@@ -45,7 +45,7 @@ last-revision="$Date$">
   <biblioentry id="thread.bib.Boost">
     <abbrev id="thread.bib.Boost.abbrev">Boost</abbrev>
     <bibliomisc>The <emphasis>Boost</emphasis> world wide web site.
-	<ulink url="http:/www.boost.org">http://www.boost.org</ulink></bibliomisc>
+	<ulink url="http://www.boost.org">http://www.boost.org</ulink></bibliomisc>
 	<para>&Boost.Thread; is one of many Boost libraries. The Boost web
     site includes a great deal of documentation and general information which
     applies to all Boost libraries. Current copies of the libraries including

doc/build.xml

@@ -7,7 +7,7 @@
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Copyright (c) 2007 Roland Schwarz
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.build" last-revision="$Date$">
 	<title>Build</title>

doc/concepts.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.concepts" last-revision="$Date$">
 	<title>Concepts</title>

doc/condition-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/condition.hpp"
   last-revision="$Date$">

doc/configuration.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.configuration" last-revision="$Date$">
 	<title>Configuration</title>

doc/design.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.design" last-revision="$Date$">
   <title>Design</title>

doc/entities.xml

@@ -1,6 +1,6 @@
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <!ENTITY Boost "<emphasis role='bold'>Boost</emphasis>">
 <!ENTITY Boost.Thread "<emphasis role='bold'>Boost.Thread</emphasis>">

doc/exceptions-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/exceptions.hpp"
   last-revision="$Date$">

doc/faq.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.faq" last-revision="$Date$">
   <title>Frequently Asked Questions</title>

doc/glossary.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <glossary id="thread.glossary" last-revision="$Date$">
   <title>Glossary</title>

doc/implementation_notes.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.implementation_notes" last-revision="$Date$">
 	<title>Implementation Notes</title>

doc/index.html

@@ -1,6 +1,6 @@
 <!-- Copyright (c) 2002-2003 Beman Dawes, William E. Kempf.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <html>
 <head>

doc/mutex-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/mutex.hpp"
   last-revision="$Date$">

doc/once-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/once.hpp"
 	last-revision="$Date$">

doc/overview.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.overview" last-revision="$Date$">
   <title>Overview</title>

doc/rationale.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.rationale" last-revision="$Date$">
   <title>Rationale</title>

doc/read_write_mutex-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/read_write_mutex.hpp"
   last-revision="$Date$">

doc/recursive_mutex-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/recursive_mutex.hpp"
   last-revision="$Date$">

doc/reference.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <library-reference id="thread.reference"
   last-revision="$Date$"

doc/release_notes.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <section id="thread.release_notes" last-revision="$Date$">
 	<title>Release Notes</title>

doc/thread-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/thread.hpp"
   last-revision="$Date$">

doc/thread.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <library name="Thread" dirname="thread" id="thread"
 last-revision="$Date$"
@@ -25,7 +25,7 @@ xmlns:xi="http://www.w3.org/2001/XInclude">
     </copyright>
     <legalnotice>
       <para>Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)</para>
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)</para>
     </legalnotice>
     <librarypurpose>Portable C++ multi-threading</librarypurpose>
     <librarycategory name="category:concurrent" />

doc/tss-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/tss.hpp"
 	last-revision="$Date$">

doc/xtime-ref.xml

@@ -6,7 +6,7 @@
 ]>
 <!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 <header name="boost/thread/xtime.hpp"
   last-revision="$Date$">

example/.cvsignore

@@ -1,2 +0,0 @@
-bin
-*.pdb

include/boost/thread.hpp

@@ -4,6 +4,8 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying 
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+//  See www.boost.org/libs/thread for documentation.
+
 #if !defined(BOOST_THREAD_WEK01082003_HPP)
 #define BOOST_THREAD_WEK01082003_HPP
 

include/boost/thread/barrier.hpp

@@ -11,7 +11,7 @@
 #include <boost/thread/detail/config.hpp>
 
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>
+#include <boost/thread/condition_variable.hpp>
 #include <string>
 #include <stdexcept>
 
@@ -48,7 +48,7 @@ namespace boost
 
     private:
         mutex m_mutex;
-        condition m_cond;
+        condition_variable m_cond;
         unsigned int m_threshold;
         unsigned int m_count;
         unsigned int m_generation;

include/boost/thread/condition.hpp

@@ -1,5 +1,11 @@
 #ifndef BOOST_THREAD_CONDITION_HPP
 #define BOOST_THREAD_CONDITION_HPP
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 #include <boost/thread/condition_variable.hpp>
 
 namespace boost

include/boost/thread/condition_variable.hpp

@@ -10,6 +10,12 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/platform.hpp>
-#include BOOST_THREAD_PLATFORM(condition_variable.hpp)
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/condition_variable.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/condition_variable.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
 
 #endif

include/boost/thread/detail/config.hpp

@@ -17,8 +17,7 @@
 #  pragma warn -8066 // Unreachable code
 #endif
 
-// insist on threading support being available:
-#include <boost/config/requires_threads.hpp>
+#include "platform.hpp"
 
 // compatibility with the rest of Boost's auto-linking code:
 #if defined(BOOST_THREAD_DYN_DLL) || defined(BOOST_ALL_DYN_LINK)
@@ -31,7 +30,7 @@
 #elif defined(BOOST_THREAD_USE_DLL)   //Use dll
 #elif defined(BOOST_THREAD_USE_LIB)   //Use lib
 #else //Use default
-#   if defined(BOOST_HAS_WINTHREADS)
+#   if defined(BOOST_THREAD_PLATFORM_WIN32)
 #       if defined(BOOST_MSVC) || defined(BOOST_INTEL_WIN)
             //For compilers supporting auto-tss cleanup
             //with Boost.Threads lib, use Boost.Threads lib

include/boost/thread/detail/move.hpp

@@ -8,25 +8,23 @@
 
 namespace boost
 {
-    template<typename T>
-    struct move_t
+    namespace detail
     {
-        T& t;
-        move_t(T& t_):
-            t(t_)
-        {}
-
-        T* operator->() const
+        template<typename T>
+        struct thread_move_t
         {
-            return &t;
-        }
-    };
+            T& t;
+            thread_move_t(T& t_):
+                t(t_)
+            {}
 
-    template<typename T>
-    move_t<T> move(T& t)
-    {
-        return move_t<T>(t);
+            T* operator->() const
+            {
+                return &t;
+            }
+        };
     }
+    
 }
 
 

include/boost/thread/detail/platform.hpp

@@ -1,4 +1,5 @@
 // Copyright 2006 Roland Schwarz.
+// (C) Copyright 2007 Anthony Williams
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
@@ -56,17 +57,15 @@
 // available the preprocessor will fail with a diagnostic message.
  
 #if defined(BOOST_THREAD_POSIX)
-#  define BOOST_THREAD_PPFX pthread
+#  define BOOST_THREAD_PLATFORM_PTHREAD
 #else
 #  if defined(BOOST_THREAD_WIN32)
-#       define BOOST_THREAD_PPFX win32
+#       define BOOST_THREAD_PLATFORM_WIN32
 #  elif defined(BOOST_HAS_PTHREADS)
-#       define BOOST_THREAD_PPFX pthread
+#       define BOOST_THREAD_PLATFORM_PTHREAD
 #  else
 #       error "Sorry, no boost threads are available for this platform."
 #  endif
 #endif
 
-#define BOOST_THREAD_PLATFORM(header) <boost/thread/BOOST_THREAD_PPFX/header>
-
 #endif // BOOST_THREAD_RS06040501_HPP

include/boost/thread/detail/tss_hooks.hpp

@@ -67,7 +67,7 @@
         //Called automatically by Boost.Threads when
             //a method for doing so has been discovered.
         //Must not be omitted; may be called multiple times.
-
+    
     extern "C" void tss_cleanup_implemented(void);
         //Dummy function used both to detect whether tss cleanup
             //cleanup has been implemented and to force

include/boost/thread/locks.hpp

@@ -86,21 +86,32 @@ namespace boost
         {
             timed_lock(target_time);
         }
-        unique_lock(boost::move_t<unique_lock<Mutex> > other):
+        unique_lock(detail::thread_move_t<unique_lock<Mutex> > other):
             m(other->m),is_locked(other->is_locked)
         {
             other->is_locked=false;
+            other->m=0;
         }
-        unique_lock(boost::move_t<upgrade_lock<Mutex> > other);
+        unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other);
 
-        unique_lock& operator=(boost::move_t<unique_lock<Mutex> > other)
+        operator detail::thread_move_t<unique_lock<Mutex> >()
+        {
+            return move();
+        }
+
+        detail::thread_move_t<unique_lock<Mutex> > move()
+        {
+            return detail::thread_move_t<unique_lock<Mutex> >(*this);
+        }
+
+        unique_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
         {
             unique_lock temp(other);
             swap(temp);
             return *this;
         }
 
-        unique_lock& operator=(boost::move_t<upgrade_lock<Mutex> > other)
+        unique_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
         {
             unique_lock temp(other);
             swap(temp);
@@ -112,7 +123,7 @@ namespace boost
             std::swap(m,other.m);
             std::swap(is_locked,other.is_locked);
         }
-        void swap(boost::move_t<unique_lock<Mutex> > other)
+        void swap(detail::thread_move_t<unique_lock<Mutex> > other)
         {
             std::swap(m,other->m);
             std::swap(is_locked,other->is_locked);
@@ -196,6 +207,18 @@ namespace boost
         friend class upgrade_lock<Mutex>;
     };
 
+    template<typename Mutex>
+    inline detail::thread_move_t<unique_lock<Mutex> > move(unique_lock<Mutex> & x)
+    {
+        return x.move();
+    }
+    
+    template<typename Mutex>
+    inline detail::thread_move_t<unique_lock<Mutex> > move(detail::thread_move_t<unique_lock<Mutex> > x)
+    {
+        return x;
+    }
+
     template<typename Mutex>
     class shared_lock
     {
@@ -228,13 +251,13 @@ namespace boost
             timed_lock(target_time);
         }
 
-        shared_lock(boost::move_t<shared_lock<Mutex> > other):
+        shared_lock(detail::thread_move_t<shared_lock<Mutex> > other):
             m(other->m),is_locked(other->is_locked)
         {
             other->is_locked=false;
         }
 
-        shared_lock(boost::move_t<unique_lock<Mutex> > other):
+        shared_lock(detail::thread_move_t<unique_lock<Mutex> > other):
             m(other->m),is_locked(other->is_locked)
         {
             other->is_locked=false;
@@ -244,7 +267,7 @@ namespace boost
             }
         }
 
-        shared_lock(boost::move_t<upgrade_lock<Mutex> > other):
+        shared_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
             m(other->m),is_locked(other->is_locked)
         {
             other->is_locked=false;
@@ -254,21 +277,32 @@ namespace boost
             }
         }
 
-        shared_lock& operator=(boost::move_t<shared_lock<Mutex> > other)
+        operator detail::thread_move_t<shared_lock<Mutex> >()
+        {
+            return move();
+        }
+
+        detail::thread_move_t<shared_lock<Mutex> > move()
+        {
+            return detail::thread_move_t<shared_lock<Mutex> >(*this);
+        }
+
+
+        shared_lock& operator=(detail::thread_move_t<shared_lock<Mutex> > other)
         {
             shared_lock temp(other);
             swap(temp);
             return *this;
         }
 
-        shared_lock& operator=(boost::move_t<unique_lock<Mutex> > other)
+        shared_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
         {
             shared_lock temp(other);
             swap(temp);
             return *this;
         }
 
-        shared_lock& operator=(boost::move_t<upgrade_lock<Mutex> > other)
+        shared_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
         {
             shared_lock temp(other);
             swap(temp);
@@ -341,6 +375,19 @@ namespace boost
 
     };
 
+    template<typename Mutex>
+    inline detail::thread_move_t<shared_lock<Mutex> > move(shared_lock<Mutex> & x)
+    {
+        return x.move();
+    }
+    
+    template<typename Mutex>
+    inline detail::thread_move_t<shared_lock<Mutex> > move(detail::thread_move_t<shared_lock<Mutex> > x)
+    {
+        return x;
+    }
+
+
     template<typename Mutex>
     class upgrade_lock
     {
@@ -364,13 +411,13 @@ namespace boost
                 lock();
             }
         }
-        upgrade_lock(boost::move_t<upgrade_lock<Mutex> > other):
+        upgrade_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
             m(other->m),is_locked(other->is_locked)
         {
             other->is_locked=false;
         }
 
-        upgrade_lock(boost::move_t<unique_lock<Mutex> > other):
+        upgrade_lock(detail::thread_move_t<unique_lock<Mutex> > other):
             m(other->m),is_locked(other->is_locked)
         {
             other->is_locked=false;
@@ -380,14 +427,25 @@ namespace boost
             }
         }
 
-        upgrade_lock& operator=(boost::move_t<upgrade_lock<Mutex> > other)
+        operator detail::thread_move_t<upgrade_lock<Mutex> >()
+        {
+            return move();
+        }
+
+        detail::thread_move_t<upgrade_lock<Mutex> > move()
+        {
+            return detail::thread_move_t<upgrade_lock<Mutex> >(*this);
+        }
+
+
+        upgrade_lock& operator=(detail::thread_move_t<upgrade_lock<Mutex> > other)
         {
             upgrade_lock temp(other);
             swap(temp);
             return *this;
         }
 
-        upgrade_lock& operator=(boost::move_t<unique_lock<Mutex> > other)
+        upgrade_lock& operator=(detail::thread_move_t<unique_lock<Mutex> > other)
         {
             upgrade_lock temp(other);
             swap(temp);
@@ -452,8 +510,21 @@ namespace boost
         friend class unique_lock<Mutex>;
     };
 
+
     template<typename Mutex>
-    unique_lock<Mutex>::unique_lock(boost::move_t<upgrade_lock<Mutex> > other):
+    inline detail::thread_move_t<upgrade_lock<Mutex> > move(upgrade_lock<Mutex> & x)
+    {
+        return x.move();
+    }
+    
+    template<typename Mutex>
+    inline detail::thread_move_t<upgrade_lock<Mutex> > move(detail::thread_move_t<upgrade_lock<Mutex> > x)
+    {
+        return x;
+    }
+
+    template<typename Mutex>
+    unique_lock<Mutex>::unique_lock(detail::thread_move_t<upgrade_lock<Mutex> > other):
         m(other->m),is_locked(other->is_locked)
     {
         other->is_locked=false;
@@ -474,23 +545,23 @@ namespace boost
         upgrade_to_unique_lock& operator=(upgrade_to_unique_lock&);
     public:
         explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_):
-            source(&m_),exclusive(boost::move(*source))
+            source(&m_),exclusive(move(*source))
         {}
         ~upgrade_to_unique_lock()
         {
             if(source)
             {
-                *source=boost::move(exclusive);
+                *source=move(exclusive);
             }
         }
 
-        upgrade_to_unique_lock(boost::move_t<upgrade_to_unique_lock<Mutex> > other):
-            source(other->source),exclusive(boost::move(other->exclusive))
+        upgrade_to_unique_lock(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other):
+            source(other->source),exclusive(move(other->exclusive))
         {
             other->source=0;
         }
         
-        upgrade_to_unique_lock& operator=(boost::move_t<upgrade_to_unique_lock<Mutex> > other)
+        upgrade_to_unique_lock& operator=(detail::thread_move_t<upgrade_to_unique_lock<Mutex> > other)
         {
             upgrade_to_unique_lock temp(other);
             swap(temp);
@@ -515,6 +586,7 @@ namespace boost
             return exclusive.owns_lock();
         }
     };
+
 }
 
 #endif

include/boost/thread/mutex.hpp

@@ -10,6 +10,12 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/platform.hpp>
-#include BOOST_THREAD_PLATFORM(mutex.hpp)
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/mutex.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/mutex.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
 
 #endif

include/boost/thread/once.hpp

@@ -10,7 +10,13 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/platform.hpp>
-#include BOOST_THREAD_PLATFORM(once.hpp)
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/once.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/once.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
 
 namespace boost
 {

include/boost/thread/pthread/condition_variable.hpp

@@ -1,91 +1,62 @@
-#ifndef BOOST_THREAD_CONDITION_VARIABLE_WIN32_HPP
-#define BOOST_THREAD_CONDITION_VARIABLE_WIN32_HPP
+#ifndef BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP
+#define BOOST_THREAD_CONDITION_VARIABLE_PTHREAD_HPP
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 // (C) Copyright 2007 Anthony Williams
 
-#include <boost/thread/mutex.hpp>
 #include <limits.h>
 #include <boost/assert.hpp>
 #include <algorithm>
-#include <boost/thread/thread.hpp>
-#include <boost/thread/thread_time.hpp>
 #include <pthread.h>
 #include "timespec.hpp"
 #include "pthread_mutex_scoped_lock.hpp"
+#include "thread_data.hpp"
+#include "condition_variable_fwd.hpp"
 
 namespace boost
 {
-    class condition_variable
+    inline condition_variable::condition_variable()
     {
-    private:
-        pthread_cond_t cond;
+        int const res=pthread_cond_init(&cond,NULL);
+        if(res)
+        {
+            throw thread_resource_error();
+        }
+    }
+    inline condition_variable::~condition_variable()
+    {
+        BOOST_VERIFY(!pthread_cond_destroy(&cond));
+    }
+
+    inline void condition_variable::wait(unique_lock<mutex>& m)
+    {
+        detail::interruption_checker check_for_interruption(&cond);
+        BOOST_VERIFY(!pthread_cond_wait(&cond,m.mutex()->native_handle()));
+    }
+
+    inline bool condition_variable::timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
+    {
+        detail::interruption_checker check_for_interruption(&cond);
+        struct timespec const timeout=detail::get_timespec(wait_until);
+        int const cond_res=pthread_cond_timedwait(&cond,m.mutex()->native_handle(),&timeout);
+        if(cond_res==ETIMEDOUT)
+        {
+            return false;
+        }
+        BOOST_ASSERT(!cond_res);
+        return true;
+    }
+
+    inline void condition_variable::notify_one()
+    {
+        BOOST_VERIFY(!pthread_cond_signal(&cond));
+    }
         
-        condition_variable(condition_variable&);
-        condition_variable& operator=(condition_variable&);
-    public:
-        condition_variable()
-        {
-            int const res=pthread_cond_init(&cond,NULL);
-            if(res)
-            {
-                throw thread_resource_error();
-            }
-        }
-        ~condition_variable()
-        {
-            int const res=pthread_cond_destroy(&cond);
-            BOOST_ASSERT(!res);
-        }
-
-        void wait(unique_lock<mutex>& m)
-        {
-            int const cond_res=pthread_cond_wait(&cond,m.mutex()->native_handle());
-            BOOST_ASSERT(!cond_res);
-        }
-
-        template<typename predicate_type>
-        void wait(unique_lock<mutex>& m,predicate_type pred)
-        {
-            while(!pred()) wait(m);
-        }
-
-        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until)
-        {
-            struct timespec const timeout=detail::get_timespec(wait_until);
-            int const cond_res=pthread_cond_timedwait(&cond,m.mutex()->native_handle(),&timeout);
-            if(cond_res==ETIMEDOUT)
-            {
-                return false;
-            }
-            BOOST_ASSERT(!cond_res);
-            return true;
-        }
-
-        template<typename predicate_type>
-        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until,predicate_type pred)
-        {
-            while (!pred())
-            {
-                if(!timed_wait(m, wait_until))
-                    return false;
-            }
-            return true;
-        }
-
-        void notify_one()
-        {
-            int const res=pthread_cond_signal(&cond);
-            BOOST_ASSERT(!res);
-        }
-        
-        void notify_all()
-        {
-            int const res=pthread_cond_broadcast(&cond);
-            BOOST_ASSERT(!res);
-        }
-    };
+    inline void condition_variable::notify_all()
+    {
+        BOOST_VERIFY(!pthread_cond_broadcast(&cond));
+    }
     
     class condition_variable_any
     {
@@ -106,17 +77,14 @@ namespace boost
             int const res2=pthread_cond_init(&cond,NULL);
             if(res2)
             {
-                int const destroy_res=pthread_mutex_destroy(&internal_mutex);
-                BOOST_ASSERT(!destroy_res);
+                BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
                 throw thread_resource_error();
             }
         }
         ~condition_variable_any()
         {
-            int const res=pthread_mutex_destroy(&internal_mutex);
-            BOOST_ASSERT(!res);
-            int const res2=pthread_cond_destroy(&cond);
-            BOOST_ASSERT(!res2);
+            BOOST_VERIFY(!pthread_mutex_destroy(&internal_mutex));
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
         }
         
         template<typename lock_type>
@@ -124,11 +92,14 @@ namespace boost
         {
             int res=0;
             {
-                boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-                m.unlock();
-                res=pthread_cond_wait(&cond,&internal_mutex);
+                detail::interruption_checker check_for_interruption(&cond);
+                {
+                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+                    m.unlock();
+                    res=pthread_cond_wait(&cond,&internal_mutex);
+                }
+                m.lock();
             }
-            m.lock();
             if(res)
             {
                 throw condition_error();
@@ -147,11 +118,14 @@ namespace boost
             struct timespec const timeout=detail::get_timespec(wait_until);
             int res=0;
             {
-                boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-                m.unlock();
-                res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+                detail::interruption_checker check_for_interruption(&cond);
+                {
+                    boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
+                    m.unlock();
+                    res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
+                }
+                m.lock();
             }
-            m.lock();
             if(res==ETIMEDOUT)
             {
                 return false;
@@ -169,23 +143,33 @@ namespace boost
             while (!pred())
             {
                 if(!timed_wait(m, wait_until))
-                    return false;
+                    return pred();
             }
             return true;
         }
 
+        template<typename lock_type,typename predicate_type>
+        bool timed_wait(lock_type& m,xtime const& wait_until,predicate_type pred)
+        {
+            return timed_wait(m,system_time(wait_until),pred);
+        }
+
+        template<typename lock_type,typename duration_type,typename predicate_type>
+        bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return timed_wait(m,get_system_time()+wait_duration,pred);
+        }
+
         void notify_one()
         {
             boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-            int const res=pthread_cond_signal(&cond);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
         }
         
         void notify_all()
         {
             boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
-            int const res=pthread_cond_broadcast(&cond);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_cond_broadcast(&cond));
         }
     };
 

include/boost/thread/pthread/condition_variable_fwd.hpp

@@ -0,0 +1,66 @@
+#ifndef BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_HPP
+#define BOOST_THREAD_PTHREAD_CONDITION_VARIABLE_FWD_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007 Anthony Williams
+
+#include <pthread.h>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/thread_time.hpp>
+#include <boost/thread/xtime.hpp>
+
+namespace boost
+{
+    class condition_variable
+    {
+    private:
+        pthread_cond_t cond;
+        
+        condition_variable(condition_variable&);
+        condition_variable& operator=(condition_variable&);
+
+    public:
+        condition_variable();
+        ~condition_variable();
+
+        void wait(unique_lock<mutex>& m);
+
+        template<typename predicate_type>
+        void wait(unique_lock<mutex>& m,predicate_type pred)
+        {
+            while(!pred()) wait(m);
+        }
+
+        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until);
+
+        template<typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until,predicate_type pred)
+        {
+            while (!pred())
+            {
+                if(!timed_wait(m, wait_until))
+                    return pred();
+            }
+            return true;
+        }
+
+        template<typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,xtime const& wait_until,predicate_type pred)
+        {
+            return timed_wait(m,system_time(wait_until),pred);
+        }
+
+        template<typename duration_type,typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return timed_wait(m,get_system_time()+wait_duration,pred);
+        }
+
+        void notify_one();
+        void notify_all();
+    };
+}
+
+#endif

include/boost/thread/pthread/mutex.hpp

@@ -11,7 +11,9 @@
 #include <boost/thread/locks.hpp>
 #include <boost/thread/thread_time.hpp>
 #include <boost/assert.hpp>
+#ifndef WIN32
 #include <unistd.h>
+#endif
 #include <errno.h>
 #include "timespec.hpp"
 #include "pthread_mutex_scoped_lock.hpp"
@@ -40,20 +42,17 @@ namespace boost
         }
         ~mutex()
         {
-            int const res=pthread_mutex_destroy(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
         }
         
         void lock()
         {
-            int const res=pthread_mutex_lock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            int const res=pthread_mutex_unlock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
         }
         
         bool try_lock()
@@ -64,7 +63,7 @@ namespace boost
         }
 
         typedef pthread_mutex_t* native_handle_type;
-        native_handle_type native_handle() const
+        native_handle_type native_handle()
         {
             return &m;
         }
@@ -96,8 +95,7 @@ namespace boost
             int const res2=pthread_cond_init(&cond,NULL);
             if(res2)
             {
-                int const destroy_res=pthread_mutex_destroy(&m);
-                BOOST_ASSERT(!destroy_res);
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
                 throw thread_resource_error();
             }
             is_locked=false;
@@ -105,11 +103,9 @@ namespace boost
         }
         ~timed_mutex()
         {
-            int const res=pthread_mutex_destroy(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
-            int const res2=pthread_cond_destroy(&cond);
-            BOOST_ASSERT(!res2);
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
 #endif
         }
 
@@ -122,14 +118,12 @@ namespace boost
 #ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
         void lock()
         {
-            int const res=pthread_mutex_lock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            int const res=pthread_mutex_unlock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
         }
         
         bool try_lock()
@@ -151,8 +145,7 @@ namespace boost
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             while(is_locked)
             {
-                int const cond_res=pthread_cond_wait(&cond,&m);
-                BOOST_ASSERT(!cond_res);
+                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
             }
             is_locked=true;
         }
@@ -161,8 +154,7 @@ namespace boost
         {
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
             is_locked=false;
-            int const res=pthread_cond_signal(&cond);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
         }
         
         bool try_lock()

include/boost/thread/pthread/once.hpp

@@ -13,62 +13,73 @@
 
 #include <pthread.h>
 #include <boost/assert.hpp>
+#include "pthread_mutex_scoped_lock.hpp"
+#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
+#include <boost/cstdint.hpp>
 
 namespace boost {
 
     struct once_flag
     {
-        pthread_mutex_t mutex;
-        unsigned flag;
+        boost::uintmax_t epoch;
     };
 
-#define BOOST_ONCE_INIT {PTHREAD_MUTEX_INITIALIZER,0}
-
     namespace detail
     {
-        struct pthread_mutex_scoped_lock
-        {
-            pthread_mutex_t * mutex;
-            
-            explicit pthread_mutex_scoped_lock(pthread_mutex_t* mutex_):
-                mutex(mutex_)
-            {
-                int const res=pthread_mutex_lock(mutex);
-                BOOST_ASSERT(!res);
-            }
-            ~pthread_mutex_scoped_lock()
-            {
-                int const res=pthread_mutex_unlock(mutex);
-                BOOST_ASSERT(!res);
-            }
-        };
+        BOOST_THREAD_DECL boost::uintmax_t& get_once_per_thread_epoch();
+        BOOST_THREAD_DECL extern boost::uintmax_t once_global_epoch;
+        BOOST_THREAD_DECL extern pthread_mutex_t once_epoch_mutex;
+        BOOST_THREAD_DECL extern pthread_cond_t once_epoch_cv;
     }
+    
+#define BOOST_ONCE_INITIAL_FLAG_VALUE 0
+#define BOOST_ONCE_INIT {BOOST_ONCE_INITIAL_FLAG_VALUE}
 
+
+    // Based on Mike Burrows fast_pthread_once algorithm as described in
+    // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2444.html
     template<typename Function>
     void call_once(once_flag& flag,Function f)
     {
-        long const function_complete_flag_value=0xc15730e2;
-
-#ifdef BOOST_PTHREAD_HAS_ATOMICS
-        if(::boost::detail::interlocked_read_acquire(&flag.flag)!=function_complete_flag_value)
+        static boost::uintmax_t const uninitialized_flag=BOOST_ONCE_INITIAL_FLAG_VALUE;
+        static boost::uintmax_t const being_initialized=uninitialized_flag+1;
+        boost::uintmax_t const epoch=flag.epoch;
+        boost::uintmax_t& this_thread_epoch=detail::get_once_per_thread_epoch();
+        
+        if(epoch<this_thread_epoch)
         {
-#endif
-            detail::pthread_mutex_scoped_lock const lock(&flag.mutex);
-            if(flag.flag!=function_complete_flag_value)
-            {
-                f();
-#ifdef BOOST_PTHREAD_HAS_ATOMICS
-                ::boost::detail::interlocked_write_release(&flag.flag,function_complete_flag_value);
-#else
-                flag.flag=function_complete_flag_value;
-#endif
-            }
-#ifdef BOOST_PTHREAD_HAS_ATOMICS
-        }
-#endif
-    }
-    
+            pthread::pthread_mutex_scoped_lock lk(&detail::once_epoch_mutex);
 
+            while(flag.epoch<=being_initialized)
+            {
+                if(flag.epoch==uninitialized_flag)
+                {
+                    flag.epoch=being_initialized;
+                    try
+                    {
+                        pthread::pthread_mutex_scoped_unlock relocker(&detail::once_epoch_mutex);
+                        f();
+                    }
+                    catch(...)
+                    {
+                        flag.epoch=uninitialized_flag;
+                        BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
+                        throw;
+                    }
+                    flag.epoch=--detail::once_global_epoch;
+                    BOOST_VERIFY(!pthread_cond_broadcast(&detail::once_epoch_cv));
+                }
+                else
+                {
+                    while(flag.epoch==being_initialized)
+                    {
+                        BOOST_VERIFY(!pthread_cond_wait(&detail::once_epoch_cv,&detail::once_epoch_mutex));
+                    }
+                }
+            }
+            this_thread_epoch=detail::once_global_epoch;
+        }
+    }
 }
 
 #endif

include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp

@@ -1,5 +1,11 @@
 #ifndef BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
 #define BOOST_PTHREAD_MUTEX_SCOPED_LOCK_HPP
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 #include <pthread.h>
 #include <boost/assert.hpp>
 
@@ -14,13 +20,27 @@ namespace boost
             explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
                 m(m_)
             {
-                int const res=pthread_mutex_lock(m);
-                BOOST_ASSERT(!res);
+                BOOST_VERIFY(!pthread_mutex_lock(m));
             }
             ~pthread_mutex_scoped_lock()
             {
-                int const res=pthread_mutex_unlock(m);
-                BOOST_ASSERT(!res);
+                BOOST_VERIFY(!pthread_mutex_unlock(m));
+            }
+            
+        };
+
+        class pthread_mutex_scoped_unlock
+        {
+            pthread_mutex_t* m;
+        public:
+            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
+                m(m_)
+            {
+                BOOST_VERIFY(!pthread_mutex_unlock(m));
+            }
+            ~pthread_mutex_scoped_unlock()
+            {
+                BOOST_VERIFY(!pthread_mutex_lock(m));
             }
             
         };

include/boost/thread/pthread/recursive_mutex.hpp

@@ -11,7 +11,9 @@
 #include <boost/thread/locks.hpp>
 #include <boost/thread/thread_time.hpp>
 #include <boost/assert.hpp>
+#ifndef WIN32
 #include <unistd.h>
+#endif
 #include <boost/date_time/posix_time/conversion.hpp>
 #include <errno.h>
 #include "timespec.hpp"
@@ -51,25 +53,21 @@ namespace boost
             {
                 throw thread_resource_error();
             }
-            int const destroy_attr_res=pthread_mutexattr_destroy(&attr);
-            BOOST_ASSERT(!destroy_attr_res);
+            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
         }
         ~recursive_mutex()
         {
-            int const res=pthread_mutex_destroy(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
         }
         
         void lock()
         {
-            int const res=pthread_mutex_lock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            int const res=pthread_mutex_unlock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
         }
         
         bool try_lock()
@@ -115,12 +113,10 @@ namespace boost
             int const res=pthread_mutex_init(&m,&attr);
             if(res)
             {
-                int const destroy_attr_res=pthread_mutexattr_destroy(&attr);
-                BOOST_ASSERT(!destroy_attr_res);
+                BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
                 throw thread_resource_error();
             }
-            int const destroy_attr_res=pthread_mutexattr_destroy(&attr);
-            BOOST_ASSERT(!destroy_attr_res);
+            BOOST_VERIFY(!pthread_mutexattr_destroy(&attr));
 #else
             int const res=pthread_mutex_init(&m,NULL);
             if(res)
@@ -130,8 +126,7 @@ namespace boost
             int const res2=pthread_cond_init(&cond,NULL);
             if(res2)
             {
-                int const destroy_res=pthread_mutex_destroy(&m);
-                BOOST_ASSERT(!destroy_res);
+                BOOST_VERIFY(!pthread_mutex_destroy(&m));
                 throw thread_resource_error();
             }
             is_locked=false;
@@ -140,11 +135,9 @@ namespace boost
         }
         ~recursive_timed_mutex()
         {
-            int const res=pthread_mutex_destroy(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_destroy(&m));
 #ifndef BOOST_PTHREAD_HAS_TIMEDLOCK
-            int const res2=pthread_cond_destroy(&cond);
-            BOOST_ASSERT(!res2);
+            BOOST_VERIFY(!pthread_cond_destroy(&cond));
 #endif
         }
 
@@ -157,14 +150,12 @@ namespace boost
 #ifdef BOOST_PTHREAD_HAS_TIMEDLOCK
         void lock()
         {
-            int const res=pthread_mutex_lock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_lock(&m));
         }
 
         void unlock()
         {
-            int const res=pthread_mutex_unlock(&m);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_mutex_unlock(&m));
         }
         
         bool try_lock()
@@ -184,7 +175,7 @@ namespace boost
         void lock()
         {
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
-            if(is_locked && owner==pthread_self())
+            if(is_locked && pthread_equal(owner,pthread_self()))
             {
                 ++count;
                 return;
@@ -192,8 +183,7 @@ namespace boost
             
             while(is_locked)
             {
-                int const cond_res=pthread_cond_wait(&cond,&m);
-                BOOST_ASSERT(!cond_res);
+                BOOST_VERIFY(!pthread_cond_wait(&cond,&m));
             }
             is_locked=true;
             ++count;
@@ -207,14 +197,13 @@ namespace boost
             {
                 is_locked=false;
             }
-            int const res=pthread_cond_signal(&cond);
-            BOOST_ASSERT(!res);
+            BOOST_VERIFY(!pthread_cond_signal(&cond));
         }
         
         bool try_lock()
         {
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
-            if(is_locked && owner!=pthread_self())
+            if(is_locked && !pthread_equal(owner,pthread_self()))
             {
                 return false;
             }
@@ -228,7 +217,7 @@ namespace boost
         {
             struct timespec const timeout=detail::get_timespec(abs_time);
             boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
-            if(is_locked && owner==pthread_self())
+            if(is_locked && pthread_equal(owner,pthread_self()))
             {
                 ++count;
                 return true;

include/boost/thread/pthread/shared_mutex.hpp

@@ -10,7 +10,8 @@
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/thread/mutex.hpp>
-#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/condition_variable.hpp>
 
 namespace boost
 {
@@ -29,9 +30,9 @@ namespace boost
 
         state_data state;
         boost::mutex state_change;
-        boost::condition shared_cond;
-        boost::condition exclusive_cond;
-        boost::condition upgrade_cond;
+        boost::condition_variable shared_cond;
+        boost::condition_variable exclusive_cond;
+        boost::condition_variable upgrade_cond;
 
         void release_waiters()
         {
@@ -53,6 +54,7 @@ namespace boost
 
         void lock_shared()
         {
+            boost::this_thread::disable_interruption do_not_disturb;
             boost::mutex::scoped_lock lock(state_change);
                 
             while(true)
@@ -84,6 +86,7 @@ namespace boost
 
         bool timed_lock_shared(system_time const& timeout)
         {
+            boost::this_thread::disable_interruption do_not_disturb;
             boost::mutex::scoped_lock lock(state_change);
                 
             while(true)
@@ -124,6 +127,7 @@ namespace boost
 
         void lock()
         {
+            boost::this_thread::disable_interruption do_not_disturb;
             boost::mutex::scoped_lock lock(state_change);
                 
             while(true)
@@ -143,6 +147,7 @@ namespace boost
 
         bool timed_lock(system_time const& timeout)
         {
+            boost::this_thread::disable_interruption do_not_disturb;
             boost::mutex::scoped_lock lock(state_change);
                 
             while(true)
@@ -189,6 +194,7 @@ namespace boost
 
         void lock_upgrade()
         {
+            boost::this_thread::disable_interruption do_not_disturb;
             boost::mutex::scoped_lock lock(state_change);
             while(true)
             {
@@ -205,6 +211,7 @@ namespace boost
 
         bool timed_lock_upgrade(system_time const& timeout)
         {
+            boost::this_thread::disable_interruption do_not_disturb;
             boost::mutex::scoped_lock lock(state_change);
             while(true)
             {
@@ -252,6 +259,7 @@ namespace boost
 
         void unlock_upgrade_and_lock()
         {
+            boost::this_thread::disable_interruption do_not_disturb;
             boost::mutex::scoped_lock lock(state_change);
             --state.shared_count;
             while(true)

include/boost/thread/pthread/thread.hpp

@@ -0,0 +1,316 @@
+#ifndef BOOST_THREAD_THREAD_PTHREAD_HPP
+#define BOOST_THREAD_THREAD_PTHREAD_HPP
+// Copyright (C) 2001-2003
+// William E. Kempf
+// Copyright (C) 2007 Anthony Williams
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/thread/detail/config.hpp>
+
+#include <boost/utility.hpp>
+#include <boost/function.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition_variable.hpp>
+#include <list>
+#include <memory>
+
+#include <pthread.h>
+#include <boost/optional.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/shared_ptr.hpp>
+#include "thread_data.hpp"
+
+namespace boost
+{
+    class thread;
+
+    namespace detail
+    {
+        class thread_id;
+    }
+    
+    namespace this_thread
+    {
+        BOOST_THREAD_DECL detail::thread_id get_id();
+    }
+    
+    namespace detail
+    {
+        class thread_id
+        {
+        private:
+            detail::thread_data_ptr thread_data;
+            
+            thread_id(detail::thread_data_ptr thread_data_):
+                thread_data(thread_data_)
+            {}
+            friend class boost::thread;
+            friend thread_id this_thread::get_id();
+        public:
+            thread_id():
+                thread_data()
+            {}
+            
+            bool operator==(const thread_id& y) const
+            {
+                return thread_data==y.thread_data;
+            }
+        
+            bool operator!=(const thread_id& y) const
+            {
+                return thread_data!=y.thread_data;
+            }
+        
+            bool operator<(const thread_id& y) const
+            {
+                return thread_data<y.thread_data;
+            }
+        
+            bool operator>(const thread_id& y) const
+            {
+                return y.thread_data<thread_data;
+            }
+        
+            bool operator<=(const thread_id& y) const
+            {
+                return !(y.thread_data<thread_data);
+            }
+        
+            bool operator>=(const thread_id& y) const
+            {
+                return !(thread_data<y.thread_data);
+            }
+
+            template<class charT, class traits>
+            friend std::basic_ostream<charT, traits>& 
+            operator<<(std::basic_ostream<charT, traits>& os, const thread_id& x)
+            {
+                if(x.thread_data)
+                {
+                    return os<<x.thread_data;
+                }
+                else
+                {
+                    return os<<"{Not-any-thread}";
+                }
+            }
+        };
+    }
+
+    struct xtime;
+    class BOOST_THREAD_DECL thread
+    {
+    private:
+        thread(thread&);
+        thread& operator=(thread&);
+
+        template<typename F>
+        struct thread_data:
+            detail::thread_data_base
+        {
+            F f;
+
+            thread_data(F f_):
+                f(f_)
+            {}
+            thread_data(detail::thread_move_t<F> f_):
+                f(f_)
+            {}
+            
+            void run()
+            {
+                f();
+            }
+        };
+        
+        mutable boost::mutex thread_info_mutex;
+        detail::thread_data_ptr thread_info;
+
+        void start_thread();
+        
+        explicit thread(detail::thread_data_ptr data);
+
+        detail::thread_data_ptr get_thread_info() const;
+        
+    public:
+        thread();
+        ~thread();
+
+        template <class F>
+        explicit thread(F f):
+            thread_info(new thread_data<F>(f))
+        {
+            start_thread();
+        }
+        template <class F>
+        thread(detail::thread_move_t<F> f):
+            thread_info(new thread_data<F>(f))
+        {
+            start_thread();
+        }
+
+        thread(detail::thread_move_t<thread> x);
+        thread& operator=(detail::thread_move_t<thread> x);
+        operator detail::thread_move_t<thread>();
+        detail::thread_move_t<thread> move();
+
+        void swap(thread& x);
+
+        typedef detail::thread_id id;
+        
+        id get_id() const;
+
+        bool joinable() const;
+        void join();
+        bool timed_join(const system_time& wait_until);
+
+        template<typename TimeDuration>
+        inline bool timed_join(TimeDuration const& rel_time)
+        {
+            return timed_join(get_system_time()+rel_time);
+        }
+        void detach();
+
+        static unsigned hardware_concurrency();
+
+        // backwards compatibility
+        bool operator==(const thread& other) const;
+        bool operator!=(const thread& other) const;
+
+        static void sleep(const system_time& xt);
+        static void yield();
+
+        // extensions
+        void interrupt();
+        bool interruption_requested() const;
+    };
+
+    inline detail::thread_move_t<thread> move(thread& x)
+    {
+        return x.move();
+    }
+    
+    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> x)
+    {
+        return x;
+    }
+
+
+    template<typename F>
+    struct thread::thread_data<boost::reference_wrapper<F> >:
+        detail::thread_data_base
+    {
+        F& f;
+        
+        thread_data(boost::reference_wrapper<F> f_):
+            f(f_)
+        {}
+        
+        void run()
+        {
+            f();
+        }
+    };
+
+    namespace this_thread
+    {
+        class BOOST_THREAD_DECL disable_interruption
+        {
+            disable_interruption(const disable_interruption&);
+            disable_interruption& operator=(const disable_interruption&);
+            
+            bool interruption_was_enabled;
+            friend class restore_interruption;
+        public:
+            disable_interruption();
+            ~disable_interruption();
+        };
+
+        class BOOST_THREAD_DECL restore_interruption
+        {
+            restore_interruption(const restore_interruption&);
+            restore_interruption& operator=(const restore_interruption&);
+        public:
+            explicit restore_interruption(disable_interruption& d);
+            ~restore_interruption();
+        };
+
+        BOOST_THREAD_DECL thread::id get_id();
+
+        BOOST_THREAD_DECL void interruption_point();
+        BOOST_THREAD_DECL bool interruption_enabled();
+        BOOST_THREAD_DECL bool interruption_requested();
+
+        inline void yield()
+        {
+            thread::yield();
+        }
+        
+        template<typename TimeDuration>
+        inline void sleep(TimeDuration const& rel_time)
+        {
+            thread::sleep(get_system_time()+rel_time);
+        }
+    }
+
+    namespace detail
+    {
+        struct thread_exit_function_base
+        {
+            virtual ~thread_exit_function_base()
+            {}
+            virtual void operator()() const=0;
+        };
+        
+        template<typename F>
+        struct thread_exit_function:
+            thread_exit_function_base
+        {
+            F f;
+            
+            thread_exit_function(F f_):
+                f(f_)
+            {}
+            
+            void operator()() const
+            {
+                f();
+            }
+        };
+        
+        BOOST_THREAD_DECL void add_thread_exit_function(thread_exit_function_base*);
+    }
+    
+    namespace this_thread
+    {
+        template<typename F>
+        inline void at_thread_exit(F f)
+        {
+            detail::thread_exit_function_base* const thread_exit_func=new detail::thread_exit_function<F>(f);
+            detail::add_thread_exit_function(thread_exit_func);
+        }
+    }
+
+    class BOOST_THREAD_DECL thread_group : private noncopyable
+    {
+    public:
+        thread_group();
+        ~thread_group();
+
+        thread* create_thread(const function0<void>& threadfunc);
+        void add_thread(thread* thrd);
+        void remove_thread(thread* thrd);
+        void join_all();
+        void interrupt_all();
+        int size() const;
+
+    private:
+        std::list<thread*> m_threads;
+        mutex m_mutex;
+    };
+} // namespace boost
+
+
+#endif

include/boost/thread/pthread/thread_data.hpp

@@ -0,0 +1,100 @@
+#ifndef BOOST_THREAD_PTHREAD_THREAD_DATA_HPP
+#define BOOST_THREAD_PTHREAD_THREAD_DATA_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007 Anthony Williams
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/optional.hpp>
+#include <pthread.h>
+#include "condition_variable_fwd.hpp"
+
+namespace boost
+{
+    class thread_interrupted
+    {};
+
+    namespace detail
+    {
+        struct thread_exit_callback_node;
+        struct tss_data_node;
+
+        struct thread_data_base;
+        typedef boost::shared_ptr<thread_data_base> thread_data_ptr;
+        
+        struct thread_data_base:
+            enable_shared_from_this<thread_data_base>
+        {
+            thread_data_ptr self;
+            pthread_t thread_handle;
+            boost::mutex data_mutex;
+            boost::condition_variable done_condition;
+            boost::mutex sleep_mutex;
+            boost::condition_variable sleep_condition;
+            bool done;
+            bool join_started;
+            bool joined;
+            boost::detail::thread_exit_callback_node* thread_exit_callbacks;
+            boost::detail::tss_data_node* tss_data;
+            bool interrupt_enabled;
+            bool interrupt_requested;
+            pthread_cond_t* current_cond;
+
+            thread_data_base():
+                done(false),join_started(false),joined(false),
+                thread_exit_callbacks(0),tss_data(0),
+                interrupt_enabled(true),
+                interrupt_requested(false),
+                current_cond(0)
+            {}
+            virtual ~thread_data_base()
+            {}
+
+            virtual void run()=0;
+        };
+
+        BOOST_THREAD_DECL thread_data_base* get_current_thread_data();
+
+        class interruption_checker
+        {
+            thread_data_base* const thread_info;
+
+            void check_for_interruption()
+            {
+                if(thread_info->interrupt_requested)
+                {
+                    thread_info->interrupt_requested=false;
+                    throw thread_interrupted();
+                }
+            }
+            
+        public:
+            explicit interruption_checker(pthread_cond_t* cond):
+                thread_info(detail::get_current_thread_data())
+            {
+                if(thread_info && thread_info->interrupt_enabled)
+                {
+                    lock_guard<mutex> guard(thread_info->data_mutex);
+                    check_for_interruption();
+                    thread_info->current_cond=cond;
+                }
+            }
+            ~interruption_checker()
+            {
+                if(thread_info && thread_info->interrupt_enabled)
+                {
+                    lock_guard<mutex> guard(thread_info->data_mutex);
+                    thread_info->current_cond=NULL;
+                    check_for_interruption();
+                }
+            }
+        };
+    }
+}
+
+
+#endif

include/boost/thread/pthread/timespec.hpp

@@ -1,5 +1,10 @@
 #ifndef BOOST_THREAD_PTHREAD_TIMESPEC_HPP
 #define BOOST_THREAD_PTHREAD_TIMESPEC_HPP
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/thread_time.hpp>
 #include <boost/date_time/posix_time/conversion.hpp>

include/boost/thread/pthread/tss.hpp

@@ -0,0 +1,103 @@
+#ifndef BOOST_THREAD_PTHREAD_TSS_HPP
+#define BOOST_THREAD_PTHREAD_TSS_HPP
+
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007 Anthony Williams
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace boost
+{
+    namespace detail
+    {
+        struct tss_cleanup_function
+        {
+            virtual ~tss_cleanup_function()
+            {}
+            
+            virtual void operator()(void* data)=0;
+        };
+        
+        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
+        BOOST_THREAD_DECL void* get_tss_data(void const* key);
+    }
+
+    template <typename T>
+    class thread_specific_ptr
+    {
+    private:
+        thread_specific_ptr(thread_specific_ptr&);
+        thread_specific_ptr& operator=(thread_specific_ptr&);
+
+        struct delete_data:
+            detail::tss_cleanup_function
+        {
+            void operator()(void* data)
+            {
+                delete static_cast<T*>(data);
+            }
+        };
+        
+        struct run_custom_cleanup_function:
+            detail::tss_cleanup_function
+        {
+            void (*cleanup_function)(T*);
+            
+            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
+                cleanup_function(cleanup_function_)
+            {}
+            
+            void operator()(void* data)
+            {
+                cleanup_function(data);
+            }
+        };
+
+
+        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
+        
+    public:
+        thread_specific_ptr():
+            cleanup(new delete_data)
+        {}
+        explicit thread_specific_ptr(void (*func_)(T*)):
+            cleanup(new run_custom_cleanup_function(func_))
+        {}
+        ~thread_specific_ptr()
+        {
+            reset();
+        }
+
+        T* get() const
+        {
+            return static_cast<T*>(detail::get_tss_data(this));
+        }
+        T* operator->() const
+        {
+            return get();
+        }
+        T& operator*() const
+        {
+            return *get();
+        }
+        T* release()
+        {
+            T* const temp=get();
+            detail::set_tss_data(this,0,0,false);
+            return temp;
+        }
+        void reset(T* new_value=0)
+        {
+            T* const current_value=get();
+            if(current_value!=new_value)
+            {
+                detail::set_tss_data(this,cleanup,new_value,true);
+            }
+        }
+    };
+}
+
+#endif

include/boost/thread/recursive_mutex.hpp

@@ -10,6 +10,12 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/platform.hpp>
-#include BOOST_THREAD_PLATFORM(recursive_mutex.hpp)
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/recursive_mutex.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/recursive_mutex.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
 
 #endif

include/boost/thread/shared_mutex.hpp

@@ -10,6 +10,12 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/thread/detail/platform.hpp>
-#include BOOST_THREAD_PLATFORM(shared_mutex.hpp)
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/shared_mutex.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/shared_mutex.hpp>
+#else
+#error "Boost threads unavailable on this platform"
+#endif
 
 #endif

include/boost/thread/thread.hpp

@@ -1,88 +1,22 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
+#ifndef BOOST_THREAD_THREAD_HPP
+#define BOOST_THREAD_THREAD_HPP
+
+//  thread.hpp
 //
-//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
-//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_THREAD_WEK070601_HPP
-#define BOOST_THREAD_WEK070601_HPP
+#include <boost/thread/detail/platform.hpp>
 
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/function.hpp>
-#include <boost/thread/mutex.hpp>
-#include <list>
-#include <memory>
-
-#if defined(BOOST_HAS_PTHREADS)
-#   include <pthread.h>
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <Multiprocessing.h>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/thread.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/thread.hpp>
+#else
+#error "Boost threads unavailable on this platform"
 #endif
 
-namespace boost {
-
-struct xtime;
-// disable warnings about non dll import
-// see: http://www.boost.org/more/separate_compilation.html#dlls
-#ifdef BOOST_MSVC
-#   pragma warning(push)
-#   pragma warning(disable: 4251 4231 4660 4275)
 #endif
-class BOOST_THREAD_DECL thread : private noncopyable
-{
-public:
-    thread();
-    explicit thread(const function0<void>& threadfunc);
-    ~thread();
-
-    bool operator==(const thread& other) const;
-    bool operator!=(const thread& other) const;
-
-    void join();
-
-    static void sleep(const xtime& xt);
-    static void yield();
-
-private:
-#if defined(BOOST_HAS_WINTHREADS)
-    void* m_thread;
-    unsigned int m_id;
-#elif defined(BOOST_HAS_PTHREADS)
-private:
-    pthread_t m_thread;
-#elif defined(BOOST_HAS_MPTASKS)
-    MPQueueID m_pJoinQueueID;
-    MPTaskID m_pTaskID;
-#endif
-    bool m_joinable;
-};
-
-class BOOST_THREAD_DECL thread_group : private noncopyable
-{
-public:
-    thread_group();
-    ~thread_group();
-
-    thread* create_thread(const function0<void>& threadfunc);
-    void add_thread(thread* thrd);
-    void remove_thread(thread* thrd);
-    void join_all();
-        int size() const;
-
-private:
-    std::list<thread*> m_threads;
-    mutex m_mutex;
-};
-#ifdef BOOST_MSVC
-#   pragma warning(pop)
-#endif
-} // namespace boost
-
-// Change Log:
-//    8 Feb 01  WEKEMPF Initial version.
-//    1 Jun 01  WEKEMPF Added boost::thread initial implementation.
-//    3 Jul 01  WEKEMPF Redesigned boost::thread to be noncopyable.
-
-#endif // BOOST_THREAD_WEK070601_HPP

include/boost/thread/thread_time.hpp

@@ -1,5 +1,11 @@
 #ifndef BOOST_THREAD_TIME_HPP
 #define BOOST_THREAD_TIME_HPP
+//  (C) Copyright 2007 Anthony Williams 
+//
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
 #include <boost/date_time/microsec_time_clock.hpp>
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 

include/boost/thread/tss.hpp

@@ -1,128 +1,18 @@
-// Copyright (C) 2001-2003 William E. Kempf
-// Copyright (C) 2006 Roland Schwarz
+// Copyright (C) 2007 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying 
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_TSS_WEK070601_HPP
-#define BOOST_TSS_WEK070601_HPP
+#ifndef BOOST_THREAD_TSS_HPP
+#define BOOST_THREAD_TSS_HPP
 
-#include <boost/thread/detail/config.hpp>
-
-#include <boost/utility.hpp>
-#include <boost/function.hpp>
-#include <boost/thread/exceptions.hpp>
-
-#if defined(BOOST_HAS_PTHREADS)
-#   include <pthread.h>
-#elif defined(BOOST_HAS_MPTASKS)
-#   include <Multiprocessing.h>
+#include <boost/thread/detail/platform.hpp>
+#if defined(BOOST_THREAD_PLATFORM_WIN32)
+#include <boost/thread/win32/tss.hpp>
+#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
+#include <boost/thread/pthread/tss.hpp>
+#else
+#error "Boost threads unavailable on this platform"
 #endif
 
-namespace boost {
-
-// disable warnings about non dll import
-// see: http://www.boost.org/more/separate_compilation.html#dlls
-#ifdef BOOST_MSVC
-#   pragma warning(push)
-#   pragma warning(disable: 4251 4231 4660 4275)
 #endif
-
-namespace detail {
-
-class BOOST_THREAD_DECL tss : private noncopyable
-{
-public:
-    tss(boost::function1<void, void*>* pcleanup) {
-        if (pcleanup == 0) throw boost::thread_resource_error();
-        try
-        {
-            init(pcleanup);
-        }
-        catch (...)
-        {
-            delete pcleanup;
-            throw boost::thread_resource_error();
-        }
-    }
-
-    ~tss();
-    void* get() const;
-    void set(void* value);
-    void cleanup(void* p);
-
-private:
-    unsigned int m_slot; //This is a "pseudo-slot", not a native slot
-
-    void init(boost::function1<void, void*>* pcleanup);
-};
-
-#if defined(BOOST_HAS_MPTASKS)
-void thread_cleanup();
-#endif
-
-template <typename T>
-struct tss_adapter
-{
-    template <typename F>
-    tss_adapter(const F& cleanup) : m_cleanup(cleanup) { }
-    void operator()(void* p) { m_cleanup(static_cast<T*>(p)); }
-    boost::function1<void, T*> m_cleanup;
-};
-
-} // namespace detail
-
-template <typename T>
-class thread_specific_ptr : private noncopyable
-{
-public:
-    thread_specific_ptr()
-        : m_tss(new boost::function1<void, void*>(
-                    boost::detail::tss_adapter<T>(
-                        &thread_specific_ptr<T>::cleanup)))
-    {
-    }
-    thread_specific_ptr(void (*clean)(T*))
-        : m_tss(new boost::function1<void, void*>(
-                    boost::detail::tss_adapter<T>(clean)))
-    {
-    }
-    ~thread_specific_ptr() { reset(); }
-
-    T* get() const { return static_cast<T*>(m_tss.get()); }
-    T* operator->() const { return get(); }
-    T& operator*() const { return *get(); }
-    T* release() { T* temp = get(); if (temp) m_tss.set(0); return temp; }
-    void reset(T* p=0)
-    {
-        T* cur = get();
-        if (cur == p) return;
-        m_tss.set(p);
-        if (cur) m_tss.cleanup(cur);
-    }
-
-private:
-    static void cleanup(T* p) { delete p; }
-    detail::tss m_tss;
-};
-
-#ifdef BOOST_MSVC
-#   pragma warning(pop)
-#endif
-
-} // namespace boost
-
-#endif //BOOST_TSS_WEK070601_HPP
-
-// Change Log:
-//   6 Jun 01  
-//      WEKEMPF Initial version.
-//  30 May 02  WEKEMPF 
-//      Added interface to set specific cleanup handlers.
-//      Removed TLS slot limits from most implementations.
-//  22 Mar 04 GlassfordM for WEKEMPF
-//      Fixed: thread_specific_ptr::reset() doesn't check error returned
-//          by tss::set(); tss::set() now throws if it fails.
-//      Fixed: calling thread_specific_ptr::reset() or 
-//          thread_specific_ptr::release() causes double-delete: once on
-//          reset()/release() and once on ~thread_specific_ptr().

include/boost/thread/win32/basic_recursive_mutex.hpp

@@ -56,6 +56,12 @@ namespace boost
                 long const current_thread_id=win32::GetCurrentThreadId();
                 return try_recursive_lock(current_thread_id) || try_timed_lock(current_thread_id,target);
             }
+            template<typename Duration>
+            bool timed_lock(Duration const& timeout)
+            {
+                return timed_lock(get_system_time()+timeout);
+            }
+
             long get_active_count()
             {
                 return mutex.get_active_count();

include/boost/thread/win32/basic_timed_mutex.hpp

@@ -59,8 +59,7 @@ namespace boost
             
             void lock()
             {
-                bool const success=timed_lock(::boost::detail::get_system_time_sentinel());
-                BOOST_ASSERT(success);
+                BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
             }
             bool timed_lock(::boost::system_time const& wait_until)
             {
@@ -105,6 +104,12 @@ namespace boost
                 return true;
             }
 
+            template<typename Duration>
+            bool timed_lock(Duration const& timeout)
+            {
+                return timed_lock(get_system_time()+timeout);
+            }
+
             long get_active_count()
             {
                 return ::boost::detail::interlocked_read_acquire(&active_count);

include/boost/thread/win32/condition_variable.hpp

@@ -13,6 +13,7 @@
 #include <boost/thread/thread.hpp>
 #include <boost/thread/thread_time.hpp>
 #include "interlocked_read.hpp"
+#include <boost/thread/xtime.hpp>
 
 namespace boost
 {
@@ -29,6 +30,10 @@ namespace boost
                 detail::win32::handle semaphore;
                 long count;
                 bool notified;
+
+                list_entry():
+                    semaphore(0),count(0),notified(0)
+                {}
             };
 
             BOOST_STATIC_CONSTANT(unsigned,generation_count=3);
@@ -75,8 +80,7 @@ namespace boost
             {
                 if(entry.semaphore)
                 {
-                    unsigned long const close_result=detail::win32::CloseHandle(entry.semaphore);
-                    BOOST_ASSERT(close_result);
+                    BOOST_VERIFY(detail::win32::CloseHandle(entry.semaphore));
                     entry.semaphore=0;
                 }
                 entry.notified=false;
@@ -107,58 +111,66 @@ namespace boost
             };
             
 
+            template<typename lock_type>
+            void start_wait_loop_first_time(relocker<lock_type>& locker,
+                                            detail::win32::handle_manager& local_wake_sem)
+            {
+                locker.unlock();
+                if(!wake_sem)
+                {
+                    wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+                    BOOST_ASSERT(wake_sem);
+                }
+                local_wake_sem=detail::win32::duplicate_handle(wake_sem);
+                        
+                if(generations[0].notified)
+                {
+                    shift_generations_down();
+                }
+                else if(!active_generation_count)
+                {
+                    active_generation_count=1;
+                }
+            }
+            
+            template<typename lock_type>
+            void start_wait_loop(relocker<lock_type>& locker,
+                                 detail::win32::handle_manager& local_wake_sem,
+                                 detail::win32::handle_manager& sem)
+            {
+                boost::mutex::scoped_lock internal_lock(internal_mutex);
+                detail::interlocked_write_release(&total_count,total_count+1);
+                if(!local_wake_sem)
+                {
+                    start_wait_loop_first_time(locker,local_wake_sem);
+                }
+                if(!generations[0].semaphore)
+                {
+                    generations[0].semaphore=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
+                    BOOST_ASSERT(generations[0].semaphore);
+                }
+                ++generations[0].count;
+                sem=detail::win32::duplicate_handle(generations[0].semaphore);
+            }
+
         protected:
             template<typename lock_type>
-            bool do_wait(lock_type& lock,::boost::system_time const& wait_until)
+            bool do_wait(lock_type& lock,timeout wait_until)
             {
                 detail::win32::handle_manager local_wake_sem;
                 detail::win32::handle_manager sem;
-                bool first_loop=true;
                 bool woken=false;
 
                 relocker<lock_type> locker(lock);
             
                 while(!woken)
                 {
+                    start_wait_loop(locker,local_wake_sem,sem);
+                    
+                    if(!this_thread::interruptible_wait(sem,wait_until))
                     {
-                        boost::mutex::scoped_lock internal_lock(internal_mutex);
-                        detail::interlocked_write_release(&total_count,total_count+1);
-                        if(first_loop)
-                        {
-                            locker.unlock();
-                            if(!wake_sem)
-                            {
-                                wake_sem=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
-                                BOOST_ASSERT(wake_sem);
-                            }
-                            local_wake_sem=detail::win32::duplicate_handle(wake_sem);
-                        
-                            if(generations[0].notified)
-                            {
-                                shift_generations_down();
-                            }
-                            else if(!active_generation_count)
-                            {
-                                active_generation_count=1;
-                            }
-                        
-                            first_loop=false;
-                        }
-                        if(!generations[0].semaphore)
-                        {
-                            generations[0].semaphore=detail::win32::create_anonymous_semaphore(0,LONG_MAX);
-                            BOOST_ASSERT(generations[0].semaphore);
-                        }
-                        ++generations[0].count;
-                        sem=detail::win32::duplicate_handle(generations[0].semaphore);
+                        return false;
                     }
-                    unsigned long const wait_result=detail::win32::WaitForSingleObject(sem,::boost::detail::get_milliseconds_until(wait_until));
-
-                    if(wait_result==detail::win32::timeout)
-                    {
-                        break;
-                    }
-                    BOOST_ASSERT(!wait_result);
                 
                     unsigned long const woken_result=detail::win32::WaitForSingleObject(local_wake_sem,0);
                     BOOST_ASSERT(woken_result==detail::win32::timeout || woken_result==0);
@@ -167,18 +179,24 @@ namespace boost
                 }
                 return woken;
             }
+
+            template<typename lock_type,typename predicate_type>
+            bool do_wait(lock_type& m,timeout const& wait_until,predicate_type pred)
+            {
+                while (!pred())
+                {
+                    if(!do_wait(m, wait_until))
+                        return pred();
+                }
+                return true;
+            }
         
             basic_condition_variable(const basic_condition_variable& other);
             basic_condition_variable& operator=(const basic_condition_variable& other);
         public:
             basic_condition_variable():
                 total_count(0),active_generation_count(0),wake_sem(0)
-            {
-                for(unsigned i=0;i<generation_count;++i)
-                {
-                    generations[i]=list_entry();
-                }
-            }
+            {}
             
             ~basic_condition_variable()
             {
@@ -243,7 +261,7 @@ namespace boost
     public:
         void wait(unique_lock<mutex>& m)
         {
-            do_wait(m,::boost::detail::get_system_time_sentinel());
+            do_wait(m,detail::timeout::sentinel());
         }
 
         template<typename predicate_type>
@@ -258,15 +276,30 @@ namespace boost
             return do_wait(m,wait_until);
         }
 
+        bool timed_wait(unique_lock<mutex>& m,boost::xtime const& wait_until)
+        {
+            return do_wait(m,system_time(wait_until));
+        }
+        template<typename duration_type>
+        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration)
+        {
+            return do_wait(m,wait_duration.total_milliseconds());
+        }
+
         template<typename predicate_type>
         bool timed_wait(unique_lock<mutex>& m,boost::system_time const& wait_until,predicate_type pred)
         {
-            while (!pred())
-            {
-                if(!timed_wait(m, wait_until))
-                    return false;
-            }
-            return true;
+            return do_wait(m,wait_until,pred);
+        }
+        template<typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,boost::xtime const& wait_until,predicate_type pred)
+        {
+            return do_wait(m,system_time(wait_until),pred);
+        }
+        template<typename duration_type,typename predicate_type>
+        bool timed_wait(unique_lock<mutex>& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return do_wait(m,wait_duration.total_milliseconds(),pred);
         }
     };
     
@@ -277,7 +310,7 @@ namespace boost
         template<typename lock_type>
         void wait(lock_type& m)
         {
-            do_wait(m,::boost::detail::get_system_time_sentinel());
+            do_wait(m,detail::timeout::sentinel());
         }
 
         template<typename lock_type,typename predicate_type>
@@ -292,15 +325,34 @@ namespace boost
             return do_wait(m,wait_until);
         }
 
+        template<typename lock_type>
+        bool timed_wait(lock_type& m,boost::xtime const& wait_until)
+        {
+            return do_wait(m,system_time(wait_until));
+        }
+
+        template<typename lock_type,typename duration_type>
+        bool timed_wait(lock_type& m,duration_type const& wait_duration)
+        {
+            return do_wait(m,wait_duration.total_milliseconds());
+        }
+
         template<typename lock_type,typename predicate_type>
         bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
         {
-            while (!pred())
-            {
-                if(!timed_wait(m, wait_until))
-                    return false;
-            }
-            return true;
+            return do_wait(m,wait_until,pred);
+        }
+
+        template<typename lock_type,typename predicate_type>
+        bool timed_wait(lock_type& m,boost::xtime const& wait_until,predicate_type pred)
+        {
+            return do_wait(m,system_time(wait_until),pred);
+        }
+
+        template<typename lock_type,typename duration_type,typename predicate_type>
+        bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
+        {
+            return do_wait(m,wait_duration.total_milliseconds(),pred);
         }
     };
 

include/boost/thread/win32/once.hpp

@@ -40,13 +40,11 @@ namespace boost
             explicit win32_mutex_scoped_lock(void* mutex_handle_):
                 mutex_handle(mutex_handle_)
             {
-                unsigned long const res=win32::WaitForSingleObject(mutex_handle,win32::infinite);
-                BOOST_ASSERT(!res);
+                BOOST_VERIFY(!win32::WaitForSingleObject(mutex_handle,win32::infinite));
             }
             ~win32_mutex_scoped_lock()
             {
-                bool const success=win32::ReleaseMutex(mutex_handle)!=0;
-                BOOST_ASSERT(success);
+                BOOST_VERIFY(win32::ReleaseMutex(mutex_handle)!=0);
             }
         };
 
@@ -96,9 +94,9 @@ namespace boost
             detail::int_to_string(win32::GetCurrentProcessId(), mutex_name + once_mutex_name_fixed_length + sizeof(void*)*2);
 
 #ifdef BOOST_NO_ANSI_APIS
-            return win32::CreateMutexW(NULL, 0, mutex_name);
+            return win32::CreateMutexW(0, 0, mutex_name);
 #else
-            return win32::CreateMutexA(NULL, 0, mutex_name);
+            return win32::CreateMutexA(0, 0, mutex_name);
 #endif
         }
 

include/boost/thread/win32/shared_mutex.hpp

@@ -48,23 +48,21 @@ namespace boost
         }
 
         state_data state;
-        void* semaphores[2];
-        void* &unlock_sem;
-        void* &exclusive_sem;
-        void* upgrade_sem;
+        detail::win32::handle semaphores[2];
+        detail::win32::handle &unlock_sem;
+        detail::win32::handle &exclusive_sem;
+        detail::win32::handle upgrade_sem;
 
         void release_waiters(state_data old_state)
         {
             if(old_state.exclusive_waiting)
             {
-                bool const success=detail::win32::ReleaseSemaphore(exclusive_sem,1,NULL)!=0;
-                BOOST_ASSERT(success);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(exclusive_sem,1,0)!=0);
             }
                         
             if(old_state.shared_waiting || old_state.exclusive_waiting)
             {
-                bool const success=detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),NULL)!=0;
-                BOOST_ASSERT(success);
+                BOOST_VERIFY(detail::win32::ReleaseSemaphore(unlock_sem,old_state.shared_waiting + (old_state.exclusive_waiting?1:0),0)!=0);
             }
         }
         
@@ -112,8 +110,7 @@ namespace boost
 
         void lock_shared()
         {
-            bool const success=timed_lock_shared(::boost::detail::get_system_time_sentinel());
-            BOOST_ASSERT(success);
+            BOOST_VERIFY(timed_lock_shared(::boost::detail::get_system_time_sentinel()));
         }
 
         bool timed_lock_shared(boost::system_time const& wait_until)
@@ -218,8 +215,7 @@ namespace boost
                     {
                         if(old_state.upgrade)
                         {
-                            bool const success=detail::win32::ReleaseSemaphore(upgrade_sem,1,NULL)!=0;
-                            BOOST_ASSERT(success);
+                            BOOST_VERIFY(detail::win32::ReleaseSemaphore(upgrade_sem,1,0)!=0);
                         }
                         else
                         {
@@ -235,8 +231,7 @@ namespace boost
 
         void lock()
         {
-            bool const success=timed_lock(::boost::detail::get_system_time_sentinel());
-            BOOST_ASSERT(success);
+            BOOST_VERIFY(timed_lock(::boost::detail::get_system_time_sentinel()));
         }
 
         bool timed_lock(boost::system_time const& wait_until)
@@ -364,8 +359,7 @@ namespace boost
                     return;
                 }
                     
-                unsigned long const res=detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite);
-                BOOST_ASSERT(res==0);
+                BOOST_VERIFY(!detail::win32::WaitForSingleObject(unlock_sem,detail::win32::infinite));
             }
         }
 
@@ -421,8 +415,7 @@ namespace boost
                 {
                     if(!last_reader)
                     {
-                        unsigned long const res=detail::win32::WaitForSingleObject(upgrade_sem,detail::win32::infinite);
-                        BOOST_ASSERT(res==0);
+                        BOOST_VERIFY(!detail::win32::WaitForSingleObject(upgrade_sem,detail::win32::infinite));
                     }
                     break;
                 }

include/boost/thread/win32/thread.hpp

@@ -0,0 +1,513 @@
+#ifndef BOOST_THREAD_THREAD_WIN32_HPP
+#define BOOST_THREAD_THREAD_WIN32_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007 Anthony Williams
+
+#include <exception>
+#include <boost/thread/exceptions.hpp>
+#include <ostream>
+#include <boost/thread/detail/move.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread_time.hpp>
+#include "thread_primitives.hpp"
+#include "thread_heap_alloc.hpp"
+#include <boost/utility.hpp>
+#include <boost/assert.hpp>
+#include <list>
+#include <algorithm>
+#include <boost/ref.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+    class thread_interrupted
+    {};
+
+    namespace detail
+    {
+        struct thread_exit_callback_node;
+        struct tss_data_node;
+        
+        struct thread_data_base
+        {
+            long count;
+            detail::win32::handle_manager thread_handle;
+            detail::win32::handle_manager interruption_handle;
+            boost::detail::thread_exit_callback_node* thread_exit_callbacks;
+            boost::detail::tss_data_node* tss_data;
+            bool interruption_enabled;
+            unsigned id;
+
+            thread_data_base():
+                count(0),thread_handle(detail::win32::invalid_handle_value),
+                interruption_handle(create_anonymous_event(detail::win32::manual_reset_event,detail::win32::event_initially_reset)),
+                thread_exit_callbacks(0),tss_data(0),
+                interruption_enabled(true),
+                id(0)
+            {}
+            virtual ~thread_data_base()
+            {}
+
+            friend void intrusive_ptr_add_ref(thread_data_base * p)
+            {
+                BOOST_INTERLOCKED_INCREMENT(&p->count);
+            }
+            
+            friend void intrusive_ptr_release(thread_data_base * p)
+            {
+                if(!BOOST_INTERLOCKED_DECREMENT(&p->count))
+                {
+                    detail::heap_delete(p);
+                }
+            }
+
+            void interrupt()
+            {
+                BOOST_VERIFY(detail::win32::SetEvent(interruption_handle)!=0);
+            }
+            
+
+            virtual void run()=0;
+        };
+
+        typedef boost::intrusive_ptr<detail::thread_data_base> thread_data_ptr;
+
+        struct timeout
+        {
+            unsigned long start;
+            uintmax_t milliseconds;
+            bool relative;
+            boost::system_time abs_time;
+
+            static unsigned long const max_non_infinite_wait=0xfffffffe;
+
+            timeout(uintmax_t milliseconds_):
+                start(win32::GetTickCount()),
+                milliseconds(milliseconds_),
+                relative(true),
+                abs_time(boost::get_system_time())
+            {}
+
+            timeout(boost::system_time const& abs_time_):
+                start(win32::GetTickCount()),
+                milliseconds(0),
+                relative(false),
+                abs_time(abs_time_)
+            {}
+
+            struct remaining_time
+            {
+                bool more;
+                unsigned long milliseconds;
+
+                remaining_time(uintmax_t remaining):
+                    more(remaining>max_non_infinite_wait),
+                    milliseconds(more?max_non_infinite_wait:(unsigned long)remaining)
+                {}
+            };
+
+            remaining_time remaining_milliseconds() const
+            {
+                if(is_sentinel())
+                {
+                    return remaining_time(win32::infinite);
+                }
+                else if(relative)
+                {
+                    unsigned long const now=win32::GetTickCount();
+                    unsigned long const elapsed=now-start;
+                    return remaining_time((elapsed<milliseconds)?(milliseconds-elapsed):0);
+                }
+                else
+                {
+                    system_time const now=get_system_time();
+                    if(abs_time<=now)
+                    {
+                        return remaining_time(0);
+                    }
+                    return remaining_time((abs_time-now).total_milliseconds()+1);
+                }
+            }
+
+            bool is_sentinel() const
+            {
+                return milliseconds==~uintmax_t(0);
+            }
+            
+
+            static timeout sentinel()
+            {
+                return timeout(sentinel_type());
+            }
+        private:
+            struct sentinel_type
+            {};
+                
+            explicit timeout(sentinel_type):
+                start(0),milliseconds(~uintmax_t(0)),relative(true)
+            {}
+        };
+    }
+
+    class BOOST_THREAD_DECL thread
+    {
+    private:
+        thread(thread&);
+        thread& operator=(thread&);
+
+        void release_handle();
+
+        template<typename F>
+        struct thread_data:
+            detail::thread_data_base
+        {
+            F f;
+
+            thread_data(F f_):
+                f(f_)
+            {}
+            thread_data(detail::thread_move_t<F> f_):
+                f(f_)
+            {}
+            
+            void run()
+            {
+                f();
+            }
+        };
+        
+        mutable boost::mutex thread_info_mutex;
+        detail::thread_data_ptr thread_info;
+
+        static unsigned __stdcall thread_start_function(void* param);
+
+        void start_thread();
+        
+        explicit thread(detail::thread_data_ptr data);
+
+        detail::thread_data_ptr get_thread_info() const;
+    public:
+        thread();
+        ~thread();
+
+        template <class F>
+        explicit thread(F f):
+            thread_info(detail::heap_new<thread_data<F> >(f))
+        {
+            start_thread();
+        }
+        template <class F>
+        thread(detail::thread_move_t<F> f):
+            thread_info(detail::heap_new<thread_data<F> >(f))
+        {
+            start_thread();
+        }
+
+        thread(detail::thread_move_t<thread> x);
+        thread& operator=(detail::thread_move_t<thread> x);
+        operator detail::thread_move_t<thread>();
+        detail::thread_move_t<thread> move();
+
+        void swap(thread& x);
+
+        class id;
+        id get_id() const;
+
+
+        bool joinable() const;
+        void join();
+        bool timed_join(const system_time& wait_until);
+
+        template<typename TimeDuration>
+        inline bool timed_join(TimeDuration const& rel_time)
+        {
+            return timed_join(get_system_time()+rel_time);
+        }
+        void detach();
+
+        static unsigned hardware_concurrency();
+
+        typedef detail::win32::handle native_handle_type;
+        native_handle_type native_handle();
+
+        // backwards compatibility
+        bool operator==(const thread& other) const;
+        bool operator!=(const thread& other) const;
+
+        static void yield();
+        static void sleep(const system_time& xt);
+
+        // extensions
+        void interrupt();
+        bool interruption_requested() const;
+    };
+
+    inline detail::thread_move_t<thread> move(thread& x)
+    {
+        return x.move();
+    }
+    
+    inline detail::thread_move_t<thread> move(detail::thread_move_t<thread> x)
+    {
+        return x;
+    }
+
+    template<typename F>
+    struct thread::thread_data<boost::reference_wrapper<F> >:
+        detail::thread_data_base
+    {
+        F& f;
+        
+        thread_data(boost::reference_wrapper<F> f_):
+            f(f_)
+        {}
+        
+        void run()
+        {
+            f();
+        }
+    };
+    
+
+    namespace this_thread
+    {
+        class BOOST_THREAD_DECL disable_interruption
+        {
+            disable_interruption(const disable_interruption&);
+            disable_interruption& operator=(const disable_interruption&);
+            
+            bool interruption_was_enabled;
+            friend class restore_interruption;
+        public:
+            disable_interruption();
+            ~disable_interruption();
+        };
+
+        class BOOST_THREAD_DECL restore_interruption
+        {
+            restore_interruption(const restore_interruption&);
+            restore_interruption& operator=(const restore_interruption&);
+        public:
+            explicit restore_interruption(disable_interruption& d);
+            ~restore_interruption();
+        };
+
+        thread::id BOOST_THREAD_DECL get_id();
+
+        bool BOOST_THREAD_DECL interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time);
+        inline bool interruptible_wait(unsigned long milliseconds)
+        {
+            return interruptible_wait(detail::win32::invalid_handle_value,milliseconds);
+        }
+
+        void BOOST_THREAD_DECL interruption_point();
+        bool BOOST_THREAD_DECL interruption_enabled();
+        bool BOOST_THREAD_DECL interruption_requested();
+
+        void BOOST_THREAD_DECL yield();
+        template<typename TimeDuration>
+        void sleep(TimeDuration const& rel_time)
+        {
+            interruptible_wait(static_cast<unsigned long>(rel_time.total_milliseconds()));
+        }
+    }
+
+    class thread::id
+    {
+    private:
+        detail::thread_data_ptr thread_data;
+            
+        id(detail::thread_data_ptr thread_data_):
+            thread_data(thread_data_)
+        {}
+        friend class thread;
+        friend id this_thread::get_id();
+    public:
+        id():
+            thread_data(0)
+        {}
+            
+        bool operator==(const id& y) const
+        {
+            return thread_data==y.thread_data;
+        }
+        
+        bool operator!=(const id& y) const
+        {
+            return thread_data!=y.thread_data;
+        }
+        
+        bool operator<(const id& y) const
+        {
+            return thread_data<y.thread_data;
+        }
+        
+        bool operator>(const id& y) const
+        {
+            return y.thread_data<thread_data;
+        }
+        
+        bool operator<=(const id& y) const
+        {
+            return !(y.thread_data<thread_data);
+        }
+        
+        bool operator>=(const id& y) const
+        {
+            return !(thread_data<y.thread_data);
+        }
+
+        template<class charT, class traits>
+        friend std::basic_ostream<charT, traits>& 
+        operator<<(std::basic_ostream<charT, traits>& os, const id& x)
+        {
+            if(x.thread_data)
+            {
+                return os<<x.thread_data;
+            }
+            else
+            {
+                return os<<"{Not-any-thread}";
+            }
+        }
+
+        void interrupt()
+        {
+            if(thread_data)
+            {
+                thread_data->interrupt();
+            }
+        }
+        
+    };
+
+    inline bool thread::operator==(const thread& other) const
+    {
+        return get_id()==other.get_id();
+    }
+    
+    inline bool thread::operator!=(const thread& other) const
+    {
+        return get_id()!=other.get_id();
+    }
+        
+    namespace detail
+    {
+        struct thread_exit_function_base
+        {
+            virtual ~thread_exit_function_base()
+            {}
+            virtual void operator()() const=0;
+        };
+        
+        template<typename F>
+        struct thread_exit_function:
+            thread_exit_function_base
+        {
+            F f;
+            
+            thread_exit_function(F f_):
+                f(f_)
+            {}
+            
+            void operator()() const
+            {
+                f();
+            }
+        };
+        
+        void add_thread_exit_function(thread_exit_function_base*);
+    }
+    
+    namespace this_thread
+    {
+        template<typename F>
+        void at_thread_exit(F f)
+        {
+            detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);
+            detail::add_thread_exit_function(thread_exit_func);
+        }
+    }
+
+    class thread_group:
+        private noncopyable
+    {
+    public:
+        ~thread_group()
+        {
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                delete *it;
+            }
+        }
+
+        template<typename F>
+        thread* create_thread(F threadfunc)
+        {
+            boost::lock_guard<mutex> guard(m);
+            thread* const new_thread=new thread(threadfunc);
+            threads.push_back(new_thread);
+            return new_thread;
+        }
+        
+        void add_thread(thread* thrd)
+        {
+            if(thrd)
+            {
+                boost::lock_guard<mutex> guard(m);
+                threads.push_back(thrd);
+            }
+        }
+            
+        void remove_thread(thread* thrd)
+        {
+            boost::lock_guard<mutex> guard(m);
+            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
+            if(it!=threads.end())
+            {
+                threads.erase(it);
+            }
+        }
+        
+        void join_all()
+        {
+            boost::lock_guard<mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->join();
+            }
+        }
+        
+        void interrupt_all()
+        {
+            boost::lock_guard<mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->interrupt();
+            }
+        }
+        
+        int size() const
+        {
+            boost::lock_guard<mutex> guard(m);
+            return threads.size();
+        }
+        
+    private:
+        std::list<thread*> threads;
+        mutable mutex m;
+    };
+}
+
+#endif

include/boost/thread/win32/thread_heap_alloc.hpp

@@ -0,0 +1,170 @@
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007 Anthony Williams
+#ifndef THREAD_HEAP_ALLOC_HPP
+#define THREAD_HEAP_ALLOC_HPP
+#include <new>
+#include "thread_primitives.hpp"
+#include <stdexcept>
+#include <boost/assert.hpp>
+
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            using ::GetProcessHeap;
+            using ::HeapAlloc;
+            using ::HeapFree;
+        }
+    }
+}
+
+#else
+
+# ifdef HeapAlloc
+# undef HeapAlloc
+# endif
+
+namespace boost
+{
+    namespace detail
+    {
+        namespace win32
+        {
+            extern "C"
+            {
+                __declspec(dllimport) handle __stdcall GetProcessHeap();
+                __declspec(dllimport) void* __stdcall HeapAlloc(handle,unsigned long,ulong_ptr);
+                __declspec(dllimport) int __stdcall HeapFree(handle,unsigned long,void*);
+            }
+        }
+    }
+}
+
+#endif
+
+namespace boost
+{
+    namespace detail
+    {
+        inline BOOST_THREAD_DECL void* allocate_raw_heap_memory(unsigned size)
+        {
+            void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size);
+            if(!heap_memory)
+            {
+                throw std::bad_alloc();
+            }
+            return heap_memory;
+        }
+
+        inline BOOST_THREAD_DECL void free_raw_heap_memory(void* heap_memory)
+        {
+            BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
+        }
+            
+        template<typename T>
+        T* heap_new()
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T();
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+
+        template<typename T,typename A1>
+        T* heap_new(A1 a1)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+        
+        template<typename T,typename A1,typename A2>
+        T* heap_new(A1 a1,A2 a2)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1,a2);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+
+        template<typename T,typename A1,typename A2,typename A3>
+        T* heap_new(A1 a1,A2 a2,A3 a3)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1,a2,a3);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+        
+        template<typename T,typename A1,typename A2,typename A3,typename A4>
+        T* heap_new(A1 a1,A2 a2,A3 a3,A4 a4)
+        {
+            void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
+            try
+            {
+                T* const data=new (heap_memory) T(a1,a2,a3,a4);
+                return data;
+            }
+            catch(...)
+            {
+                free_raw_heap_memory(heap_memory);
+                throw;
+            }
+        }
+        
+        template<typename T>
+        void heap_delete(T* data)
+        {
+            data->~T();
+            free_raw_heap_memory(data);
+        }
+
+        template<typename T>
+        struct do_heap_delete
+        {
+            void operator()(T* data) const
+            {
+                detail::heap_delete(data);
+            }
+        };
+    }
+}
+
+
+#endif

include/boost/thread/win32/thread_primitives.hpp

@@ -3,7 +3,8 @@
 
 //  win32_thread_primitives.hpp
 //
-//  (C) Copyright 2005-6 Anthony Williams 
+//  (C) Copyright 2005-7 Anthony Williams 
+//  (C) Copyright 2007 David Deakins 
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -12,6 +13,7 @@
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/thread/exceptions.hpp>
+#include <algorithm>
 
 #if defined( BOOST_USE_WINDOWS_H )
 # include <windows.h>
@@ -25,10 +27,17 @@ namespace boost
             typedef HANDLE handle;
             unsigned const infinite=INFINITE;
             unsigned const timeout=WAIT_TIMEOUT;
+            handle const invalid_handle_value=INVALID_HANDLE_VALUE;
 
+# ifdef BOOST_NO_ANSI_APIS
+            using ::CreateMutexW;
+            using ::CreateEventW;
+            using ::CreateSemaphoreW;
+# else
             using ::CreateMutexA;
             using ::CreateEventA;
             using ::CreateSemaphoreA;
+# endif
             using ::CloseHandle;
             using ::ReleaseMutex;
             using ::ReleaseSemaphore;
@@ -42,11 +51,36 @@ namespace boost
             using ::GetCurrentProcess;
             using ::DuplicateHandle;
             using ::SleepEx;
+            using ::Sleep;
             using ::QueueUserAPC;
+            using ::GetTickCount;
         }
     }
 }
 #elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+
+# ifdef UNDER_CE
+#  ifndef WINAPI
+#   ifndef _WIN32_WCE_EMULATION
+#    define WINAPI  __cdecl	// Note this doesn't match the desktop definition
+#   else
+#    define WINAPI  __stdcall
+#   endif
+#  endif
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif
+typedef int BOOL;
+typedef unsigned long DWORD;
+typedef void* HANDLE;
+
+#  include <kfuncs.h>
+#  ifdef __cplusplus
+}
+#  endif
+# endif
+
 namespace boost
 {
     namespace detail
@@ -62,28 +96,48 @@ namespace boost
             typedef void* handle;
             unsigned const infinite=~0U;
             unsigned const timeout=258U;
+            handle const invalid_handle_value=(handle)(-1);
 
             extern "C"
             {
                 struct _SECURITY_ATTRIBUTES;
+# ifdef BOOST_NO_ANSI_APIS
+                __declspec(dllimport) void* __stdcall CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
+                __declspec(dllimport) void* __stdcall CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+# else
                 __declspec(dllimport) void* __stdcall CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
                 __declspec(dllimport) void* __stdcall CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
                 __declspec(dllimport) void* __stdcall CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+# endif
                 __declspec(dllimport) int __stdcall CloseHandle(void*);
                 __declspec(dllimport) int __stdcall ReleaseMutex(void*);
-                __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
-                __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
                 __declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void*,unsigned long);
+                __declspec(dllimport) unsigned long __stdcall WaitForMultipleObjects(unsigned long nCount,void* const * lpHandles,int bWaitAll,unsigned long dwMilliseconds);
                 __declspec(dllimport) int __stdcall ReleaseSemaphore(void*,long,long*);
-                __declspec(dllimport) void* __stdcall GetCurrentThread();
-                __declspec(dllimport) void* __stdcall GetCurrentProcess();
                 __declspec(dllimport) int __stdcall DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long);
                 __declspec(dllimport) unsigned long __stdcall SleepEx(unsigned long,int);
+                __declspec(dllimport) void __stdcall Sleep(unsigned long);
                 typedef void (__stdcall *queue_user_apc_callback_function)(ulong_ptr);
                 __declspec(dllimport) unsigned long __stdcall QueueUserAPC(queue_user_apc_callback_function,void*,ulong_ptr);
+
+                __declspec(dllimport) unsigned long __stdcall GetTickCount();
+
+# ifndef UNDER_CE
+                __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
+                __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
+                __declspec(dllimport) void* __stdcall GetCurrentThread();
+                __declspec(dllimport) void* __stdcall GetCurrentProcess();
                 __declspec(dllimport) int __stdcall SetEvent(void*);
                 __declspec(dllimport) int __stdcall ResetEvent(void*);
-                __declspec(dllimport) unsigned long __stdcall WaitForMultipleObjects(unsigned long nCount,void* const * lpHandles,int bWaitAll,unsigned long dwMilliseconds);
+# else
+                using ::GetCurrentProcessId;
+                using ::GetCurrentThreadId;
+                using ::GetCurrentThread;
+                using ::GetCurrentProcess;
+                using ::SetEvent;
+                using ::ResetEvent;
+# endif
             }
         }
     }
@@ -112,7 +166,11 @@ namespace boost
             
             inline handle create_anonymous_event(event_type type,initial_event_state state)
             {
+#if !defined(BOOST_NO_ANSI_APIS)  
                 handle const res=win32::CreateEventA(0,type,state,0);
+#else
+                handle const res=win32::CreateEventW(0,type,state,0);
+#endif                
                 if(!res)
                 {
                     throw thread_resource_error();
@@ -122,7 +180,11 @@ namespace boost
 
             inline handle create_anonymous_semaphore(long initial_count,long max_count)
             {
-                handle const res=CreateSemaphoreA(NULL,initial_count,max_count,NULL);
+#if !defined(BOOST_NO_ANSI_APIS)  
+                handle const res=CreateSemaphoreA(0,initial_count,max_count,0);
+#else
+                handle const res=CreateSemaphoreW(0,initial_count,max_count,0);
+#endif               
                 if(!res)
                 {
                     throw thread_resource_error();
@@ -145,8 +207,7 @@ namespace boost
 
             inline void release_semaphore(handle semaphore,long count)
             {
-                bool const success=ReleaseSemaphore(semaphore,count,0)!=0;
-                BOOST_ASSERT(success);
+                BOOST_VERIFY(ReleaseSemaphore(semaphore,count,0)!=0);
             }
 
             class handle_manager
@@ -158,10 +219,9 @@ namespace boost
 
                 void cleanup()
                 {
-                    if(handle_to_manage)
+                    if(handle_to_manage && handle_to_manage!=invalid_handle_value)
                     {
-                        unsigned long result=CloseHandle(handle_to_manage);
-                        BOOST_ASSERT(result);
+                        BOOST_VERIFY(CloseHandle(handle_to_manage));
                     }
                 }
                 
@@ -185,6 +245,16 @@ namespace boost
                     return handle_to_manage;
                 }
 
+                handle duplicate() const
+                {
+                    return duplicate_handle(handle_to_manage);
+                }
+
+                void swap(handle_manager& other)
+                {
+                    std::swap(handle_to_manage,other.handle_to_manage);
+                }
+
                 handle release()
                 {
                     handle const res=handle_to_manage;

include/boost/thread/win32/tss.hpp

@@ -0,0 +1,103 @@
+#ifndef BOOST_THREAD_WIN32_TSS_HPP
+#define BOOST_THREAD_WIN32_TSS_HPP
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// (C) Copyright 2007 Anthony Williams
+
+#include <boost/shared_ptr.hpp>
+#include "thread_heap_alloc.hpp"
+
+namespace boost
+{
+    namespace detail
+    {
+        struct tss_cleanup_function
+        {
+            virtual ~tss_cleanup_function()
+            {}
+            
+            virtual void operator()(void* data)=0;
+        };
+        
+        BOOST_THREAD_DECL void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
+        BOOST_THREAD_DECL void* get_tss_data(void const* key);
+    }
+
+    template <typename T>
+    class thread_specific_ptr
+    {
+    private:
+        thread_specific_ptr(thread_specific_ptr&);
+        thread_specific_ptr& operator=(thread_specific_ptr&);
+
+        struct delete_data:
+            detail::tss_cleanup_function
+        {
+            void operator()(void* data)
+            {
+                delete static_cast<T*>(data);
+            }
+        };
+        
+        struct run_custom_cleanup_function:
+            detail::tss_cleanup_function
+        {
+            void (*cleanup_function)(T*);
+            
+            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
+                cleanup_function(cleanup_function_)
+            {}
+            
+            void operator()(void* data)
+            {
+                cleanup_function(data);
+            }
+        };
+
+
+        boost::shared_ptr<detail::tss_cleanup_function> cleanup;
+        
+    public:
+        thread_specific_ptr():
+            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
+        {}
+        explicit thread_specific_ptr(void (*func_)(T*)):
+            cleanup(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>())
+        {}
+        ~thread_specific_ptr()
+        {
+            reset();
+        }
+
+        T* get() const
+        {
+            return static_cast<T*>(detail::get_tss_data(this));
+        }
+        T* operator->() const
+        {
+            return get();
+        }
+        T& operator*() const
+        {
+            return *get();
+        }
+        T* release()
+        {
+            T* const temp=get();
+            detail::set_tss_data(this,0,0,false);
+            return temp;
+        }
+        void reset(T* new_value=0)
+        {
+            T* const current_value=get();
+            if(current_value!=new_value)
+            {
+                detail::set_tss_data(this,cleanup,new_value,true);
+            }
+        }
+    };
+}
+
+
+#endif

include/boost/thread/xtime.hpp

@@ -54,16 +54,6 @@ struct xtime
     
 };
 
-int BOOST_THREAD_DECL xtime_get(struct xtime* xtp, int clock_type);
-
-inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
-{
-    if (xt1.sec == xt2.sec)
-        return (int)(xt1.nsec - xt2.nsec);
-    else 
-        return (xt1.sec > xt2.sec) ? 1 : -1;
-}
-
 inline xtime get_xtime(boost::system_time const& abs_time)
 {
     xtime res={0};
@@ -74,6 +64,25 @@ inline xtime get_xtime(boost::system_time const& abs_time)
     return res;
 }
 
+inline int xtime_get(struct xtime* xtp, int clock_type)
+{
+    if (clock_type == TIME_UTC)
+    {
+        *xtp=get_xtime(get_system_time());
+        return clock_type;
+    }
+    return 0;
+}
+
+
+inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
+{
+    if (xt1.sec == xt2.sec)
+        return (int)(xt1.nsec - xt2.nsec);
+    else 
+        return (xt1.sec > xt2.sec) ? 1 : -1;
+}
+
 } // namespace boost
 
 #endif //BOOST_XTIME_WEK070601_HPP

index.html

@@ -1,6 +1,6 @@
 <!-- Copyright (c) 2002-2003 William E. Kempf.
      Subject to the Boost Software License, Version 1.0. 
-     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
+     (See accompanying file LICENSE_1_0.txt or  http://www.boost.org/LICENSE_1_0.txt)
 -->
 
 <html>

src/mac/debug_prefix.hpp

@@ -1,8 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#define TARGET_CARBON    1

src/mac/delivery_man.cpp

@@ -1,66 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "delivery_man.hpp"
-
-#include "os.hpp"
-#include "execution_context.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-delivery_man::delivery_man():
-    m_pPackage(NULL),
-    m_pSemaphore(kInvalidID),
-    m_bPackageWaiting(false)
-{
-    assert(at_st());
-
-    OSStatus lStatus = MPCreateSemaphore(1UL, 0UL, &m_pSemaphore);
-// TODO - throw on error here
-    assert(lStatus == noErr);
-}
-
-delivery_man::~delivery_man()
-{
-    assert(m_bPackageWaiting == false);
-
-    OSStatus lStatus = MPDeleteSemaphore(m_pSemaphore);
-    assert(lStatus == noErr);
-}
-
-
-void delivery_man::accept_deliveries()
-{
-    if(m_bPackageWaiting)
-    {
-        assert(m_pPackage != NULL);
-        m_pPackage->accept();
-        m_pPackage = NULL;
-        m_bPackageWaiting = false;
-
-    // signal to the thread making the call that we're done
-        OSStatus lStatus = MPSignalSemaphore(m_pSemaphore);
-        assert(lStatus == noErr);
-    }
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/delivery_man.hpp

@@ -1,84 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_DELIVERY_MAN_MJM012402_HPP
-#define BOOST_DELIVERY_MAN_MJM012402_HPP
-
-
-#include <boost/function.hpp>
-#include <boost/utility.hpp>
-
-#include <boost/thread/mutex.hpp>
-
-#include "package.hpp"
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class delivery_man is intended to move boost::function objects from MP tasks to
-//    other execution contexts (such as deferred task time or system task time).
-
-class delivery_man: private noncopyable
-{
-  public:
-    delivery_man();
-    ~delivery_man();
-
-  public:
-    template<class R>
-    R deliver(function<R> &rFunctor);
-
-    void accept_deliveries();
-
-  private:
-    base_package *m_pPackage;
-    mutex m_oMutex;
-    MPSemaphoreID m_pSemaphore;
-    bool m_bPackageWaiting;
-};
-
-
-template<class R>
-R delivery_man::deliver(function<R> &rFunctor)
-{
-    assert(at_mp());
-
-// lock our mutex
-    mutex::scoped_lock oLock(m_oMutex);
-
-// create a package and save it
-    package<R> oPackage(rFunctor);
-    m_pPackage = &oPackage;
-    m_bPackageWaiting = true;
-
-// wait on the semaphore
-    OSStatus lStatus = MPWaitOnSemaphore(m_pSemaphore, kDurationForever);
-    assert(lStatus == noErr);
-
-    return(oPackage.return_value());
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_DELIVERY_MAN_MJM012402_HPP

src/mac/dt_scheduler.cpp

@@ -1,93 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "dt_scheduler.hpp"
-
-#include "ot_context.hpp"
-
-
-#include <boost/thread/detail/singleton.hpp>
-
-#include <OpenTransportProtocol.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-const OTTimeout k_ulTimerTaskDelay = 1UL;
-
-
-dt_scheduler::dt_scheduler():
-    m_bReschedule(false),
-    m_uppTask(NULL),
-    m_lTask(0UL)
-{
-    using ::boost::detail::thread::singleton;
-
-    ot_context &rContext(singleton<ot_context>::instance());
-
-    m_uppTask = NewOTProcessUPP(task_entry);
-    m_lTask = OTCreateTimerTaskInContext(m_uppTask, this, rContext.get_context());
-}
-
-dt_scheduler::~dt_scheduler()
-{
-    OTDestroyTimerTask(m_lTask);
-    m_lTask = 0UL;
-    DisposeOTProcessUPP(m_uppTask);
-    m_uppTask = NULL;
-}
-
-
-void dt_scheduler::start_polling()
-{
-    m_bReschedule = true;
-    schedule_task();
-}
-
-void dt_scheduler::stop_polling()
-{
-    m_bReschedule = false;
-}
-
-
-void dt_scheduler::schedule_task()
-{
-    if(m_bReschedule)
-    {
-        OTScheduleTimerTask(m_lTask, k_ulTimerTaskDelay);
-    }
-}
-
-
-/*static*/ pascal void dt_scheduler::task_entry(void *pRefCon)
-{
-    dt_scheduler *pThis = reinterpret_cast<dt_scheduler *>(pRefCon);
-    assert(pThis != NULL);
-    pThis->task();
-}
-
-void dt_scheduler::task()
-{
-    periodic_function();
-    schedule_task();
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/dt_scheduler.hpp

@@ -1,63 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_DT_SCHEDULER_MJM012402_HPP
-#define BOOST_DT_SCHEDULER_MJM012402_HPP
-
-
-#include "periodical.hpp"
-
-#include <OpenTransport.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class dt_scheduler calls its pure-virtual periodic_function method periodically at
-//    deferred task time.  This is generally 1kHz under Mac OS 9.
-
-class dt_scheduler
-{
-  public:
-    dt_scheduler();
-    virtual ~dt_scheduler();
-
-  protected:
-    void start_polling();
-    void stop_polling();
-
-  private:
-    virtual void periodic_function() = 0;
-
-  private:
-    void schedule_task();
-    static pascal void task_entry(void *pRefCon);
-    void task();
-
-  private:
-    bool m_bReschedule;
-    OTProcessUPP m_uppTask;
-    long m_lTask;
-};
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_DT_SCHEDULER_MJM012402_HPP

src/mac/execution_context.cpp

@@ -1,60 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include <Debugging.h>
-#include <Multiprocessing.h>
-
-#include "execution_context.hpp"
-#include "init.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-
-execution_context_t execution_context()
-{
-// make sure that MP services are available the first time through
-    static bool bIgnored = detail::thread_init();
-
-// first check if we're an MP task
-    if(MPTaskIsPreemptive(kInvalidID))
-    {
-        return(k_eExecutionContextMPTask);
-    }
-
-#if TARGET_CARBON
-// Carbon has TaskLevel
-    UInt32 ulLevel = TaskLevel();
-
-    if(ulLevel == 0UL)
-    {
-        return(k_eExecutionContextSystemTask);
-    }
-
-    if(ulLevel & kInDeferredTaskMask)
-    {
-        return(k_eExecutionContextDeferredTask);
-    }
-
-    return(k_eExecutionContextOther);
-#else
-// this can be implemented using TaskLevel if you don't mind linking against
-//    DebugLib (and therefore breaking Mac OS 8.6 support), or CurrentExecutionLevel.
-#    error execution_context unimplimented
-#endif
-}
-
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/execution_context.hpp

@@ -1,47 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_EXECUTION_CONTEXT_MJM012402_HPP
-#define BOOST_EXECUTION_CONTEXT_MJM012402_HPP
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-
-// utility functions for figuring out what context your code is executing in.
-//    Bear in mind that at_mp and in_blue are the only functions guarenteed by
-//    Apple to work.  There is simply no way of being sure that you will not get
-//    false readings about task level at interrupt time in blue.
-
-typedef enum {
-    k_eExecutionContextSystemTask,
-    k_eExecutionContextDeferredTask,
-    k_eExecutionContextMPTask,
-    k_eExecutionContextOther
-} execution_context_t;
-
-execution_context_t execution_context();
-
-inline bool at_st()
-    {    return(execution_context() == k_eExecutionContextSystemTask);    }
-
-inline bool at_mp()
-    {    return(execution_context() == k_eExecutionContextMPTask);        }
-inline bool in_blue()
-    {    return(!at_mp());                                                }
-
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-#endif // BOOST_EXECUTION_CONTEXT_MJM012402_HPP

src/mac/init.cpp

@@ -1,58 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "init.hpp"
-
-#include "remote_call_manager.hpp"
-
-
-#include <boost/thread/detail/singleton.hpp>
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-namespace {
-
-// force these to get called by the end of static initialization time.
-static bool g_bInitialized = (thread_init() && create_singletons());
-
-}
-
-
-bool thread_init()
-{
-    static bool bResult = MPLibraryIsLoaded();
-
-    return(bResult);
-}
-
-bool create_singletons()
-{
-    using ::boost::detail::thread::singleton;
-
-    singleton<remote_call_manager>::instance();
-
-    return(true);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/init.hpp

@@ -1,34 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_INIT_MJM012402_HPP
-#define BOOST_INIT_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-bool thread_init();
-bool create_singletons();
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_INIT_MJM012402_HPP

src/mac/msl_replacements/assert.cpp

@@ -1,24 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include <cassert>
-#include <cstdio>
-
-#include <MacTypes.h>
-
-#include "remote_calls.hpp"
-
-// this function will be called when an assertion fails.  We redirect the assertion
-//    to DebugStr (MacsBug under Mac OS 1.x-9.x, Console under Mac OS X).
-void __assertion_failed(char const *pszAssertion, char const *pszFile, int nLine)
-{
-    using std::snprintf;
-    unsigned char strlDebug[sizeof(Str255) + 1];
-    char *pszDebug = reinterpret_cast<char *>(&strlDebug[1]);
-    strlDebug[0] = snprintf(pszDebug, sizeof(Str255), "assertion failed: \"%s\", %s, line %d", pszAssertion, pszFile, nLine);
-    boost::threads::mac::dt_remote_call(DebugStr, static_cast<ConstStringPtr>(strlDebug));
-}

src/mac/msl_replacements/console_io.cpp

@@ -1,128 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-//
-// includes
-//
-
-#include <abort_exit.h>
-#include <console.h>
-#include <console_io.h>
-#include <misc_io.h>
-#include <SIOUX.h>
-
-#include "remote_calls.hpp"
-
-
-//
-// using declarations
-//
-
-using std::__file_handle;
-using std::__idle_proc;
-using std::__io_error;
-using std::__no_io_error;
-using std::size_t;
-
-using boost::threads::mac::st_remote_call;
-
-
-//
-// prototypes
-//
-
-static bool check_console();
-static int do_read_console(__file_handle ulHandle, unsigned char *pBuffer, size_t *pCount, __idle_proc pfnIdleProc);
-static int do_write_console(__file_handle ulHandle, unsigned char *pBuffer, size_t *pCount, __idle_proc pfnIdleProc);
-
-
-//
-// MSL function replacements
-//
-
-// these two functions are called by cin and cout, respectively, as well as by (all?)
-//    other functions in MSL that do console I/O.  All that they do is as the remote
-//    call manager to ensure that their guts are called at system task time.
-int __read_console(__file_handle handle, unsigned char * buffer, size_t * count, __idle_proc idle_proc)
-{
-    return(st_remote_call(do_read_console, handle, buffer, count, idle_proc));
-}
-
-int __write_console(__file_handle handle, unsigned char * buffer, size_t * count, __idle_proc idle_proc)
-{
-    return(st_remote_call(do_write_console, handle, buffer, count, idle_proc));
-}
-
-
-//
-// implementations
-//
-
-static bool check_console()
-{
-    static bool s_bHaveConsole(false);
-    static bool s_bWontHaveConsole(false);
-
-    if(s_bHaveConsole)
-    {
-        return(true);
-    }
-
-    if(s_bWontHaveConsole == false)
-    {
-        __stdio_atexit();
-
-        if(InstallConsole(0) != 0)
-        {
-            s_bWontHaveConsole = true;
-            return(false);
-        }
-        __console_exit = RemoveConsole;
-        s_bHaveConsole = true;
-        return(true);
-    }
-
-    return(false);
-}
-
-
-int do_read_console(__file_handle /*ulHandle*/, unsigned char *pBuffer, size_t *pCount, __idle_proc /*pfnIdleProc*/)
-{
-    assert(pCount != NULL);
-    assert(pBuffer != NULL || *pCount == 0UL);
-
-    if(check_console() == false)
-    {
-        return(__io_error);
-    }
-    std::fflush(stdout);
-    long lCount = ReadCharsFromConsole(reinterpret_cast<char *>(pBuffer), static_cast<long>(*pCount));
-    *pCount = static_cast<size_t>(lCount);
-    if(lCount == -1L)
-    {
-        return(__io_error);
-    }
-
-    return(__no_io_error);
-}
-
-int do_write_console(__file_handle /*ulHandle*/, unsigned char *pBuffer, size_t *pCount, __idle_proc /*pfnIdleProc*/)
-{
-    if(check_console() == false)
-    {
-        return(__io_error);
-    }
-
-    long lCount = WriteCharsToConsole(reinterpret_cast<char *>(pBuffer), static_cast<long>(*pCount));
-    *pCount = static_cast<size_t>(lCount);
-    if(lCount == -1L)
-    {
-        return(__io_error);
-    }
-
-    return(__no_io_error);
-}

src/mac/msl_replacements/malloc.cpp

@@ -1,52 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-//
-// includes
-//
-
-#include <cstdlib>
-
-#include <Multiprocessing.h>
-
-
-//
-// using declarations
-//
-
-using std::size_t;
-
-
-extern "C" {
-
-//
-// prototypes
-//
-
-void *malloc(size_t ulSize);
-void free(void *pBlock);
-
-}
-
-
-//
-// MSL function replacements
-//
-
-// all allocation/deallocation currently goes through MPAllocateAligned/MPFree.  This
-//    solution is sub-optimal at best, but will have to do for now.
-void *malloc(size_t ulSize)
-{
-    static bool bIgnored = MPLibraryIsLoaded();
-    return(MPAllocateAligned(ulSize, kMPAllocateDefaultAligned, 0UL));
-}
-
-void free(void *pBlock)
-{
-    if(pBlock == NULL) return;
-    MPFree(pBlock);
-}

src/mac/msl_replacements/news_and_deletes.cpp

@@ -1,99 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-//
-// includes
-//
-
-#include <new>
-
-#include <Multiprocessing.h>
-
-
-//
-// using declarations
-//
-
-using std::size_t;
-using std::bad_alloc;
-using std::nothrow_t;
-using std::nothrow;
-
-
-//
-// local utility functions
-//
-
-// all allocation/deallocation currently goes through MPAllocateAligned/MPFree.  This
-//    solution is sub-optimal at best, but will have to do for now.
-inline static void *allocate(size_t ulSize, const nothrow_t &)
-{
-    static bool bIgnored = MPLibraryIsLoaded();
-    return(MPAllocateAligned(ulSize, kMPAllocateDefaultAligned, 0UL));
-}
-
-inline static void *allocate(size_t ulSize)
-{
-    void *pBlock = allocate(ulSize, nothrow);
-    if(pBlock == NULL)
-        throw(bad_alloc());
-    return(pBlock);
-}
-
-inline static void deallocate(void *pBlock)
-{
-    if(pBlock == NULL) return;
-    MPFree(pBlock);
-}
-
-
-//
-// global operators
-//
-
-void *operator new(size_t ulSize)
-{
-    return(allocate(ulSize));
-}
-
-void *operator new[](size_t ulSize)
-{
-    return(allocate(ulSize));
-}
-
-
-void *operator new(size_t ulSize, const nothrow_t &rNoThrow)
-{
-    return(allocate(ulSize, rNoThrow));
-}
-
-void *operator new[](size_t ulSize, const nothrow_t &rNoThrow)
-{
-    return(allocate(ulSize, rNoThrow));
-}
-
-
-void operator delete(void *pBlock)
-{
-    deallocate(pBlock);
-}
-
-void operator delete[](void *pBlock)
-{
-    deallocate(pBlock);
-}
-
-
-void operator delete(void *pBlock, const nothrow_t &)
-{
-    deallocate(pBlock);
-}
-
-void operator delete[](void *pBlock, const nothrow_t &)
-{
-    deallocate(pBlock);
-}

src/mac/msl_replacements/time.cpp

@@ -1,150 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include <cassert>
-// we include timesize.mac.h to get whether or not __TIMESIZE_DOUBLE__ is
-//  defined.  This is not safe, given that __TIMESIZE_DOUBLE__ affects MSL
-//  at MSL's compile time, not ours, so be forgiving if you have changed it
-//  since you have built MSL.
-#include <timesize.mac.h>
-#include <time.h>
-
-#include <boost/thread/detail/force_cast.hpp>
-#include <boost/thread/xtime.hpp>
-
-#include "execution_context.hpp"
-
-#include <DriverServices.h>
-
-
-extern "C"
-{
-    clock_t __get_clock();
-    time_t __get_time();
-    int __to_gm_time(time_t *pTime);
-    int __is_dst();
-}
-
-
-static inline uint64_t get_nanoseconds()
-{
-    using boost::detail::thread::force_cast;
-    return(force_cast<uint64_t>(AbsoluteToNanoseconds(UpTime())));
-}
-
-
-#ifdef __TIMESIZE_DOUBLE__
-
-// return number of microseconds since startup as a double
-clock_t __get_clock()
-{
-    static const double k_dNanosecondsPerMicrosecond(1000.0);
-
-    return(get_nanoseconds() / k_dNanosecondsPerMicrosecond);
-}
-
-#else
-
-// return number of ticks (60th of a second) since startup as a long
-clock_t __get_clock()
-{
-    static const uint64_t k_ullTicksPerSecond(60ULL);
-    static const uint64_t k_ullNanosecondsPerSecond(1000ULL * 1000ULL * 1000ULL);
-    static const uint64_t k_ullNanosecondsPerTick(k_ullNanosecondsPerSecond / k_ullTicksPerSecond);
-
-    return(get_nanoseconds() / k_ullNanosecondsPerTick);
-}
-
-#endif
-
-// return number of seconds elapsed since Jan 1, 1970
-time_t __get_time()
-{
-    boost::xtime sTime;
-    int nType = boost::xtime_get(&sTime, boost::TIME_UTC);
-    assert(nType == boost::TIME_UTC);
-    return(static_cast<time_t>(sTime.sec));
-}
-
-
-static inline MachineLocation &read_location()
-{
-    static MachineLocation s_sLocation;
-    assert(boost::threads::mac::at_st());
-    ReadLocation(&s_sLocation);
-    return(s_sLocation);
-}
-
-static inline MachineLocation &get_location()
-{
-    static MachineLocation &s_rLocation(read_location());
-    return(s_rLocation);
-}
-
-
-// force the machine location to be cached at static initlialization
-static MachineLocation &g_rIgnored(get_location());
-
-static inline long calculate_delta()
-{
-    MachineLocation &rLocation(get_location());
-
-// gmtDelta is a 24-bit, signed integer.  We need to strip out the lower 24 bits,
-//  then sign-extend what we have.
-    long lDelta = rLocation.u.gmtDelta & 0x00ffffffL;
-    if((lDelta & 0x00800000L) != 0L)
-    {
-        lDelta |= 0xFF000000;
-    }
-    return(lDelta);
-}
-
-static inline bool check_if_location_is_broken()
-{
-    MachineLocation &rLocation(get_location());
-    if(rLocation.latitude == 0 && rLocation.longitude == 0 && rLocation.u.gmtDelta == 0)
-        return(true);
-    return(false);
-}
-
-static inline bool location_is_broken()
-{
-    static bool s_bLocationIsBroken(check_if_location_is_broken());
-    return(s_bLocationIsBroken);
-}
-
-
-// translate time to GMT
-int __to_gm_time(time_t *pTime)
-{
-    if(location_is_broken())
-    {
-        return(0);
-    }
-
-    static long s_lDelta(calculate_delta());
-    *pTime -= s_lDelta;
-    return(1);
-}
-
-
-static inline bool is_daylight_savings_time()
-{
-    MachineLocation &rLocation(get_location());
-    return(rLocation.u.dlsDelta != 0);
-}
-
-// check if we're in daylight savings time
-int __is_dst()
-{
-    if(location_is_broken())
-    {
-        return(-1);
-    }
-    static bool bIsDaylightSavingsTime(is_daylight_savings_time());
-    return(static_cast<int>(bIsDaylightSavingsTime));
-}

src/mac/os.cpp

@@ -1,57 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "os.hpp"
-
-
-#include <cassert>
-
-#include <Gestalt.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace os {
-
-
-// read the OS version from Gestalt
-static inline long get_version()
-{
-    long lVersion;
-    OSErr nErr = Gestalt(gestaltSystemVersion, &lVersion);
-    assert(nErr == noErr);
-    return(lVersion);
-}
-
-
-// check if we're running under Mac OS X and cache that information
-bool x()
-{
-    static bool bX = (version() >= 0x1000);
-    return(bX);
-}
-
-
-// read the OS version and cache it
-long version()
-{
-    static long lVersion = get_version();
-    return(lVersion);
-}
-
-
-} // namespace os
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/os.hpp

@@ -1,37 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_OS_MJM012402_HPP
-#define BOOST_OS_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace os {
-
-
-// functions to determine the OS environment.  With namespaces, you get a cute call:
-//    mac::os::x
-
-bool x();
-long version();
-
-
-} // namespace os
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_OS_MJM012402_HPP

src/mac/ot_context.cpp

@@ -1,46 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "ot_context.hpp"
-
-#include "execution_context.hpp"
-
-
-#include <cassert>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-ot_context::ot_context()
-{
-    assert(at_st());
-
-    OSStatus lStatus = InitOpenTransportInContext(0UL, &m_pContext);
-// TODO - throw on error
-    assert(lStatus == noErr);
-}
-
-ot_context::~ot_context()
-{
-    CloseOpenTransportInContext(m_pContext);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/ot_context.hpp

@@ -1,58 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_OT_CONTEXT_MJM012402_HPP
-#define BOOST_OT_CONTEXT_MJM012402_HPP
-
-
-#include <OpenTransport.h>
-
-#include <boost/utility.hpp>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class ot_context is intended to be used only as a singleton.  All that this class
-//    does is ask OpenTransport to create him an OTClientContextPtr, and then doles
-//    this out to anyone who wants it.  ot_context should only be instantiated at
-//    system task time.
-
-class ot_context: private noncopyable
-{
-  protected:
-    ot_context();
-    ~ot_context();
-
-  public:
-    OTClientContextPtr get_context();
-
-  private:
-    OTClientContextPtr m_pContext;
-};
-
-
-inline OTClientContextPtr ot_context::get_context()
-    {    return(m_pContext);    }
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_OT_CONTEXT_MJM012402_HPP

src/mac/package.hpp

@@ -1,76 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_PACKAGE_MJM012402_HPP
-#define BOOST_PACKAGE_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-class base_package: private noncopyable
-{
-  public:
-    virtual void accept() = 0;
-};
-
-template<class R>
-class package: public base_package
-{
-  public:
-    inline package(function<R> &rFunctor):
-        m_rFunctor(rFunctor)
-        {    /* no-op */                }
-    inline ~package()
-        {    /* no-op */                }
-
-    virtual void accept()
-        {    m_oR = m_rFunctor();    }
-    inline R return_value()
-        {    return(m_oR);            }
-
-  private:
-    function<R> &m_rFunctor;
-    R m_oR;
-};
-
-template<>
-class package<void>: public base_package
-{
-  public:
-    inline package(function<void> &rFunctor):
-        m_rFunctor(rFunctor)
-        {    /* no-op */                }
-    inline ~package()
-        {    /* no-op */                }
-
-    virtual void accept()
-        {    m_rFunctor();            }
-    inline void return_value()
-        {    return;                    }
-
-  private:
-    function<void> &m_rFunctor;
-};
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_PACKAGE_MJM012402_HPP

src/mac/periodical.hpp

@@ -1,97 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_PERIODICAL_MJM012402_HPP
-#define BOOST_PERIODICAL_MJM012402_HPP
-
-
-#include <boost/function.hpp>
-#include <boost/utility.hpp>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class periodical inherits from its template parameter, which should follow the
-//    pattern set by classes dt_scheduler and st_scheduler.  periodical knows how to
-//    call a boost::function, where the xx_scheduler classes only know to to call a
-//    member periodically.
-
-template<class Scheduler>
-class periodical: private noncopyable, private Scheduler
-{
-  public:
-    periodical(function<void> &rFunction);
-    ~periodical();
-
-  public:
-    void start();
-    void stop();
-
-  protected:
-    virtual void periodic_function();
-
-  private:
-    function<void> m_oFunction;
-};
-
-
-template<class Scheduler>
-periodical<Scheduler>::periodical(function<void> &rFunction):
-    m_oFunction(rFunction)
-{
-// no-op
-}
-
-template<class Scheduler>
-periodical<Scheduler>::~periodical()
-{
-    stop();
-}
-
-template<class Scheduler>
-void periodical<Scheduler>::start()
-{
-    start_polling();
-}
-
-template<class Scheduler>
-void periodical<Scheduler>::stop()
-{
-    stop_polling();
-}
-
-
-template<class Scheduler>
-inline void periodical<Scheduler>::periodic_function()
-{
-    try
-    {
-        m_oFunction();
-    }
-    catch(...)
-    {
-    }
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_PERIODICAL_MJM012402_HPP

src/mac/prefix.hpp

@@ -1,9 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#define NDEBUG
-#define TARGET_CARBON    1

src/mac/remote_call_manager.cpp

@@ -1,48 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "remote_call_manager.hpp"
-
-#include <boost/bind.hpp>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-using detail::delivery_man;
-
-
-remote_call_manager::remote_call_manager():
-    m_oDTDeliveryMan(),
-    m_oSTDeliveryMan(),
-    m_oDTFunction(bind(&delivery_man::accept_deliveries, &m_oDTDeliveryMan)),
-    m_oSTFunction(bind(&delivery_man::accept_deliveries, &m_oSTDeliveryMan)),
-    m_oDTPeriodical(m_oDTFunction),
-    m_oSTPeriodical(m_oSTFunction)
-{
-    m_oDTPeriodical.start();
-    m_oSTPeriodical.start();
-}
-
-remote_call_manager::~remote_call_manager()
-{
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/remote_call_manager.hpp

@@ -1,102 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP
-#define BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP
-
-
-#include <boost/utility.hpp>
-
-#include "delivery_man.hpp"
-#include "dt_scheduler.hpp"
-#include "periodical.hpp"
-#include "execution_context.hpp"
-#include "st_scheduler.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class remote_call_manager is used by the remote call functions (dt_remote_call and
-//  st_remote_call) to execute functions in non-MP contexts.
-
-class remote_call_manager: private noncopyable
-{
-  protected:
-    remote_call_manager();
-    ~remote_call_manager();
-
-  public:
-    template<class R>
-    R execute_at_dt(function<R> &rFunctor);
-    template<class R>
-    R execute_at_st(function<R> &rFunctor);
-
-  private:
-    template<class R>
-    static R execute_now(function<R> &rFunctor);
-
-  private:
-    delivery_man m_oDTDeliveryMan;
-    delivery_man m_oSTDeliveryMan;
-    function<void> m_oDTFunction;
-    function<void> m_oSTFunction;
-    periodical<dt_scheduler> m_oDTPeriodical;
-    periodical<st_scheduler> m_oSTPeriodical;
-};
-
-
-template<class R>
-/*static*/ inline R remote_call_manager::execute_now(function<R> &rFunctor)
-{
-    return(rFunctor());
-}
-template<>
-/*static*/ inline void remote_call_manager::execute_now<void>(function<void> &rFunctor)
-{
-    rFunctor();
-}
-
-
-template<class R>
-inline R remote_call_manager::execute_at_dt(function<R> &rFunctor)
-{
-    if(at_mp())
-    {
-        return(m_oDTDeliveryMan.deliver(rFunctor));
-    }
-    return(execute_now(rFunctor));
-}
-
-template<class R>
-inline R remote_call_manager::execute_at_st(function<R> &rFunctor)
-{
-    if(at_mp())
-    {
-        return(m_oSTDeliveryMan.deliver(rFunctor));
-    }
-    assert(at_st());
-    return(execute_now(rFunctor));
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_REMOTE_CALL_MANAGER_MJM012402_HPP

src/mac/remote_calls.hpp

@@ -1,157 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_REMOTE_CALLS_MJM012402_HPP
-#define BOOST_REMOTE_CALLS_MJM012402_HPP
-
-
-#include <boost/bind.hpp>
-
-#include "remote_call_manager.hpp"
-#include <boost/thread/detail/singleton.hpp>
-
-
-// this file contains macros to generate functions with the signatures:
-//  ReturnType st_remote_call([pascal] ReturnType (*pfnFunction)(
-//                              [Argument1Type[, Argument2Type[...]]])
-//                            [, Argument1Type oArgument1[, Argument2Type oArgument2[...]]])
-// and
-//  ReturnType dt_remote_call([pascal] ReturnType (*pfnFunction)(
-//                              [Argument1Type[, Argument2Type[...]]])
-//                            [, Argument1Type oArgument1[, Argument2Type oArgument2[...]]])
-// in other words, identical to the function pointer versions of boost::bind, but
-//  with the return type returned.  The purpose of these functions is to be able to
-//  request that a function be called at system task time or deferred task time, then
-//  sleep until it is called, and finally get back its return value.
-
-#define BOOST_REMOTE_CALL_CLASS_LIST_0
-#define BOOST_REMOTE_CALL_CLASS_LIST_1 BOOST_REMOTE_CALL_CLASS_LIST_0, class A1
-#define BOOST_REMOTE_CALL_CLASS_LIST_2 BOOST_REMOTE_CALL_CLASS_LIST_1, class A2
-#define BOOST_REMOTE_CALL_CLASS_LIST_3 BOOST_REMOTE_CALL_CLASS_LIST_2, class A3
-#define BOOST_REMOTE_CALL_CLASS_LIST_4 BOOST_REMOTE_CALL_CLASS_LIST_3, class A4
-#define BOOST_REMOTE_CALL_CLASS_LIST_5 BOOST_REMOTE_CALL_CLASS_LIST_4, class A5
-#define BOOST_REMOTE_CALL_CLASS_LIST_6 BOOST_REMOTE_CALL_CLASS_LIST_5, class A6
-#define BOOST_REMOTE_CALL_CLASS_LIST_7 BOOST_REMOTE_CALL_CLASS_LIST_6, class A7
-#define BOOST_REMOTE_CALL_CLASS_LIST_8 BOOST_REMOTE_CALL_CLASS_LIST_7, class A8
-#define BOOST_REMOTE_CALL_CLASS_LIST_9 BOOST_REMOTE_CALL_CLASS_LIST_8, class A9
-
-
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_0
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_1 BOOST_REMOTE_CALL_ARGUMENT_LIST_0  A1 oA1
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_2 BOOST_REMOTE_CALL_ARGUMENT_LIST_1, A2 oA2
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_3 BOOST_REMOTE_CALL_ARGUMENT_LIST_2, A3 oA3
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_4 BOOST_REMOTE_CALL_ARGUMENT_LIST_3, A4 oA4
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_5 BOOST_REMOTE_CALL_ARGUMENT_LIST_4, A5 oA5
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_6 BOOST_REMOTE_CALL_ARGUMENT_LIST_5, A6 oA6
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_7 BOOST_REMOTE_CALL_ARGUMENT_LIST_6, A7 oA7
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_8 BOOST_REMOTE_CALL_ARGUMENT_LIST_7, A8 oA8
-#define BOOST_REMOTE_CALL_ARGUMENT_LIST_9 BOOST_REMOTE_CALL_ARGUMENT_LIST_8, A9 oA9
-
-
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_0
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_1 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_0, oA1
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_2 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_1, oA2
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_3 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_2, oA3
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_4 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_3, oA4
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_5 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_4, oA5
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_6 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_5, oA6
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_7 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_6, oA7
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_8 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_7, oA8
-#define BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_9 BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_8, oA9
-
-
-#define BOOST_REMOTE_CALL_COMMA_0
-#define BOOST_REMOTE_CALL_COMMA_1 ,
-#define BOOST_REMOTE_CALL_COMMA_2 ,
-#define BOOST_REMOTE_CALL_COMMA_3 ,
-#define BOOST_REMOTE_CALL_COMMA_4 ,
-#define BOOST_REMOTE_CALL_COMMA_5 ,
-#define BOOST_REMOTE_CALL_COMMA_6 ,
-#define BOOST_REMOTE_CALL_COMMA_7 ,
-#define BOOST_REMOTE_CALL_COMMA_8 ,
-#define BOOST_REMOTE_CALL_COMMA_9 ,
-
-
-// this is the macro that ties it all together.  From here, we generate all forms of
-//  dt_remote_call and st_remote_call.
-
-#define BOOST_REMOTE_CALL(context, stack, n)                                        \
-template<class R BOOST_REMOTE_CALL_CLASS_LIST_ ## n>                                \
-inline R context ## _remote_call(stack R (*pfnF)(                                   \
-                                      BOOST_REMOTE_CALL_ARGUMENT_LIST_ ## n)        \
-                                      BOOST_REMOTE_CALL_COMMA_ ## n                 \
-                                  BOOST_REMOTE_CALL_ARGUMENT_LIST_ ## n)            \
-{                                                                                   \
-    using ::boost::detail::thread::singleton;                                       \
-    using detail::remote_call_manager;                                              \
-    function<R> oFunc(bind(pfnF BOOST_REMOTE_CALL_FUNCTION_ARGUMENT_LIST_ ## n));   \
-    remote_call_manager &rManager(singleton<remote_call_manager>::instance());      \
-    return(rManager.execute_at_ ## context(oFunc));                                 \
-}
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-
-BOOST_REMOTE_CALL(st, , 0)
-BOOST_REMOTE_CALL(st, , 1)
-BOOST_REMOTE_CALL(st, , 2)
-BOOST_REMOTE_CALL(st, , 3)
-BOOST_REMOTE_CALL(st, , 4)
-BOOST_REMOTE_CALL(st, , 5)
-BOOST_REMOTE_CALL(st, , 6)
-BOOST_REMOTE_CALL(st, , 7)
-BOOST_REMOTE_CALL(st, , 8)
-BOOST_REMOTE_CALL(st, , 9)
-
-BOOST_REMOTE_CALL(dt, , 0)
-BOOST_REMOTE_CALL(dt, , 1)
-BOOST_REMOTE_CALL(dt, , 2)
-BOOST_REMOTE_CALL(dt, , 3)
-BOOST_REMOTE_CALL(dt, , 4)
-BOOST_REMOTE_CALL(dt, , 5)
-BOOST_REMOTE_CALL(dt, , 6)
-BOOST_REMOTE_CALL(dt, , 7)
-BOOST_REMOTE_CALL(dt, , 8)
-BOOST_REMOTE_CALL(dt, , 9)
-
-
-BOOST_REMOTE_CALL(st, pascal, 0)
-BOOST_REMOTE_CALL(st, pascal, 1)
-BOOST_REMOTE_CALL(st, pascal, 2)
-BOOST_REMOTE_CALL(st, pascal, 3)
-BOOST_REMOTE_CALL(st, pascal, 4)
-BOOST_REMOTE_CALL(st, pascal, 5)
-BOOST_REMOTE_CALL(st, pascal, 6)
-BOOST_REMOTE_CALL(st, pascal, 7)
-BOOST_REMOTE_CALL(st, pascal, 8)
-BOOST_REMOTE_CALL(st, pascal, 9)
-
-BOOST_REMOTE_CALL(dt, pascal, 0)
-BOOST_REMOTE_CALL(dt, pascal, 1)
-BOOST_REMOTE_CALL(dt, pascal, 2)
-BOOST_REMOTE_CALL(dt, pascal, 3)
-BOOST_REMOTE_CALL(dt, pascal, 4)
-BOOST_REMOTE_CALL(dt, pascal, 5)
-BOOST_REMOTE_CALL(dt, pascal, 6)
-BOOST_REMOTE_CALL(dt, pascal, 7)
-BOOST_REMOTE_CALL(dt, pascal, 8)
-BOOST_REMOTE_CALL(dt, pascal, 9)
-
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_REMOTE_CALLS_MJM012402_HPP

src/mac/safe.cpp

@@ -1,210 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include <DriverServices.h>
-#include <Events.h>
-#include <Multiprocessing.h>
-#include <Threads.h>
-
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
-
-#include <boost/thread/detail/force_cast.hpp>
-#include <limits>
-#include "execution_context.hpp"
-
-
-using boost::detail::thread::force_cast;
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-static OSStatus safe_wait(function<OSStatus, Duration> &rFunction, Duration lDuration);
-
-
-// we call WNE to allow tasks that own the resource the blue is waiting on system
-//    task time, in case they are blocked on an ST remote call (or a memory allocation
-//    for that matter).
-static void idle()
-{
-    if(at_st())
-    {
-        EventRecord sEvent;
-        bool bEvent = WaitNextEvent(0U, &sEvent, 0UL, NULL);
-    }
-}
-
-
-OSStatus safe_wait_on_semaphore(MPSemaphoreID pSemaphoreID, Duration lDuration)
-{
-    function<OSStatus, Duration> oWaitOnSemaphore;
-    oWaitOnSemaphore = bind(MPWaitOnSemaphore, pSemaphoreID, _1);
-    return(safe_wait(oWaitOnSemaphore, lDuration));
-}
-
-
-OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Duration lDuration, MPCriticalRegionID pCriticalRegionCriticalRegionID/* = kInvalidID*/)
-{
-    if(pCriticalRegionCriticalRegionID != kInvalidID)
-    {
-        if(at_mp())
-        {
-        // enter the critical region's critical region
-            OSStatus lStatus = noErr;
-            AbsoluteTime sExpiration;
-            if(lDuration != kDurationImmediate && lDuration != kDurationForever)
-            {
-                sExpiration = AddDurationToAbsolute(lDuration, UpTime());
-            }
-            lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, lDuration);
-            assert(lStatus == noErr || lStatus == kMPTimeoutErr);
-            if(lStatus == noErr)
-            {
-            // calculate a new duration
-                if(lDuration != kDurationImmediate && lDuration != kDurationForever)
-                {
-                // check if we have any time left
-                    AbsoluteTime sUpTime(UpTime());
-                    if(force_cast<uint64_t>(sExpiration) > force_cast<uint64_t>(sUpTime))
-                    {
-                    // reset our duration to our remaining time
-                        lDuration = AbsoluteDeltaToDuration(sExpiration, sUpTime);
-                    }
-                    else
-                    {
-                    // no time left
-                        lDuration = kDurationImmediate;
-                    }
-                }
-            // if we entered the critical region, exit it again
-                lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
-                assert(lStatus == noErr);
-            }
-            else
-            {
-            // otherwise, give up
-                return(lStatus);
-            }
-        }
-        else
-        {
-        // if we're at system task time, try to enter the critical region's critical
-        //    region until we succeed.  MP tasks will block on this until we let it go.
-            OSStatus lStatus;
-            do
-            {
-                lStatus = MPEnterCriticalRegion(pCriticalRegionCriticalRegionID, kDurationImmediate);
-            } while(lStatus == kMPTimeoutErr);
-            assert(lStatus == noErr);
-        }
-    }
-
-// try to enter the critical region
-    function<OSStatus, Duration> oEnterCriticalRegion;
-    oEnterCriticalRegion = bind(MPEnterCriticalRegion, pCriticalRegionID, _1);
-    OSStatus lStatus = safe_wait(oEnterCriticalRegion, lDuration);
-
-// if we entered the critical region's critical region to get the critical region,
-//    exit the critical region's critical region.
-    if(pCriticalRegionCriticalRegionID != kInvalidID && at_mp() == false)
-    {
-        lStatus = MPExitCriticalRegion(pCriticalRegionCriticalRegionID);
-        assert(lStatus == noErr);
-    }
-    return(lStatus);
-}
-
-OSStatus safe_wait_on_queue(MPQueueID pQueueID, void **pParam1, void **pParam2, void **pParam3, Duration lDuration)
-{
-    function<OSStatus, Duration> oWaitOnQueue;
-    oWaitOnQueue = bind(MPWaitOnQueue, pQueueID, pParam1, pParam2, pParam3, _1);
-    return(safe_wait(oWaitOnQueue, lDuration));
-}
-
-OSStatus safe_delay_until(AbsoluteTime *pWakeUpTime)
-{
-    if(execution_context() == k_eExecutionContextMPTask)
-    {
-        return(MPDelayUntil(pWakeUpTime));
-    }
-    else
-    {
-        uint64_t ullWakeUpTime = force_cast<uint64_t>(*pWakeUpTime);
-
-        while(force_cast<uint64_t>(UpTime()) < ullWakeUpTime)
-        {
-            idle();
-        }
-
-        return(noErr);
-    }
-}
-
-
-OSStatus safe_wait(function<OSStatus, Duration> &rFunction, Duration lDuration)
-{
-    if(execution_context() == k_eExecutionContextMPTask)
-    {
-        return(rFunction(lDuration));
-    }
-    else
-    {
-        uint64_t ullExpiration = 0ULL;
-
-    // get the expiration time in UpTime units
-        if(lDuration == kDurationForever)
-        {
-            ullExpiration = (::std::numeric_limits<uint64_t>::max)();
-        }
-        else if(lDuration == kDurationImmediate)
-        {
-            ullExpiration = force_cast<uint64_t>(UpTime());
-        }
-        else
-        {
-            AbsoluteTime sExpiration = AddDurationToAbsolute(lDuration, UpTime());
-            ullExpiration = force_cast<uint64_t>(sExpiration);
-        }
-
-        OSStatus lStatus;
-        bool bExpired = false;
-
-        do
-        {
-            lStatus = rFunction(kDurationImmediate);
-// mm - "if" #if 0'd out to allow task time to threads blocked on I/O
-#if 0
-            if(lStatus == kMPTimeoutErr)
-#endif
-            {
-                idle();
-            }
-            if(lDuration != kDurationForever)
-            {
-                bExpired = (force_cast<uint64_t>(UpTime()) < ullExpiration);
-            }
-        } while(lStatus == kMPTimeoutErr && bExpired == false);
-
-        return(lStatus);
-    }
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/safe.hpp

@@ -1,41 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_SAFE_MJM012402_HPP
-#define BOOST_SAFE_MJM012402_HPP
-
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// these functions are used to wain in an execution context-independent manor.  All of these
-//  functions are both MP- and ST-safe.
-
-OSStatus safe_wait_on_semaphore(MPSemaphoreID pSemaphoreID, Duration lDuration);
-OSStatus safe_enter_critical_region(MPCriticalRegionID pCriticalRegionID, Duration lDuration, MPCriticalRegionID pCriticalRegionCriticalRegionID = kInvalidID);
-OSStatus safe_wait_on_queue(MPQueueID pQueueID, void **pParam1, void **pParam2, void **pParam3, Duration lDuration);
-OSStatus safe_delay_until(AbsoluteTime *pWakeUpTime);
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-#endif // BOOST_SAFE_MJM012402_HPP

src/mac/scoped_critical_region.cpp

@@ -1,47 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "scoped_critical_region.hpp"
-
-#include "init.hpp"
-
-
-#include <cassert>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-scoped_critical_region::scoped_critical_region():
-    m_pCriticalRegionID(kInvalidID)
-{
-    static bool bIgnored = thread_init();
-    OSStatus lStatus = MPCreateCriticalRegion(&m_pCriticalRegionID);
-    if(lStatus != noErr || m_pCriticalRegionID == kInvalidID)
-        throw(thread_resource_error());
-}
-
-scoped_critical_region::~scoped_critical_region()
-{
-    OSStatus lStatus = MPDeleteCriticalRegion(m_pCriticalRegionID);
-    assert(lStatus == noErr);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/scoped_critical_region.hpp

@@ -1,63 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP
-#define BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP
-
-
-#include <boost/thread/exceptions.hpp>
-
-#include <Multiprocessing.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class scoped_critical_region probably needs a new name.  Although the current name
-//    is accurate, it can be read to mean that a critical region is entered for the
-//    current scope.  In reality, a critical region is _created_ for the current scope.
-//    This class is intended as a replacement for MPCriticalRegionID that will
-//    automatically create and dispose of itself.
-
-class scoped_critical_region
-{
-  public:
-    scoped_critical_region();
-    ~scoped_critical_region();
-
-  public:
-    operator const MPCriticalRegionID &() const;
-    const MPCriticalRegionID &get() const;
-
-  private:
-    MPCriticalRegionID m_pCriticalRegionID;
-};
-
-
-// these are inlined for speed.
-inline scoped_critical_region::operator const MPCriticalRegionID &() const
-    {    return(m_pCriticalRegionID);    }
-inline const MPCriticalRegionID &scoped_critical_region::get() const
-    {    return(m_pCriticalRegionID);    }
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_SCOPED_CRITICAL_REGION_MJM012402_HPP

src/mac/st_scheduler.cpp

@@ -1,85 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "st_scheduler.hpp"
-
-#include <cassert>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-#if TARGET_CARBON
-
-st_scheduler::st_scheduler():
-    m_uppTask(NULL),
-    m_pTimer(NULL)
-{
-    m_uppTask = NewEventLoopTimerUPP(task_entry);
-// TODO - throw on error
-    assert(m_uppTask != NULL);
-}
-
-st_scheduler::~st_scheduler()
-{
-    DisposeEventLoopTimerUPP(m_uppTask);
-    m_uppTask = NULL;
-}
-
-
-void st_scheduler::start_polling()
-{
-    assert(m_pTimer == NULL);
-    OSStatus lStatus = InstallEventLoopTimer(GetMainEventLoop(),
-                                                0 * kEventDurationSecond,
-                                                kEventDurationMillisecond,
-                                                m_uppTask,
-                                                this,
-                                                &m_pTimer);
-// TODO - throw on error
-    assert(lStatus == noErr);
-}
-
-void st_scheduler::stop_polling()
-{
-    assert(m_pTimer != NULL);
-    OSStatus lStatus = RemoveEventLoopTimer(m_pTimer);
-    assert(lStatus == noErr);
-    m_pTimer = NULL;
-}
-
-
-/*static*/ pascal void st_scheduler::task_entry(EventLoopTimerRef /*pTimer*/, void *pRefCon)
-{
-    st_scheduler *pThis = reinterpret_cast<st_scheduler *>(pRefCon);
-    assert(pThis != NULL);
-    pThis->task();
-}
-
-void st_scheduler::task()
-{
-    periodic_function();
-}
-
-#else
-#    error st_scheduler unimplemented!
-#endif
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/st_scheduler.hpp

@@ -1,67 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_ST_SCHEDULER_MJM012402_HPP
-#define BOOST_ST_SCHEDULER_MJM012402_HPP
-
-
-#include <CarbonEvents.h>
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-// class st_scheduler calls its pure-virtual periodic_function method periodically at
-//  system task time.  This is generally 40Hz under Mac OS 9.
-
-class st_scheduler
-{
-  public:
-    st_scheduler();
-    virtual ~st_scheduler();
-
-  protected:
-    void start_polling();
-    void stop_polling();
-
-  private:
-    virtual void periodic_function() = 0;
-
-#if TARGET_CARBON
-// use event loop timers under Carbon
-  private:
-    static pascal void task_entry(EventLoopTimerRef pTimer, void *pRefCon);
-    void task();
-
-  private:
-    EventLoopTimerUPP m_uppTask;
-    EventLoopTimerRef m_pTimer;
-#else
-// this can be implemented using OT system tasks.  This would be mostly a copy-and-
-//  paste of the dt_scheduler code, replacing DeferredTask with SystemTask and DT
-//  with ST.
-#   error st_scheduler unimplemented!
-#endif
-};
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_ST_SCHEDULER_MJM012402_HPP

src/mac/thread_cleanup.cpp

@@ -1,56 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#include "thread_cleanup.hpp"
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-namespace {
-
-TaskStorageIndex g_ulIndex(0UL);
-
-} // anonymous namespace
-
-
-void do_thread_startup()
-{
-    if(g_ulIndex == 0UL)
-    {
-        OSStatus lStatus = MPAllocateTaskStorageIndex(&g_ulIndex);
-        assert(lStatus == noErr);
-    }
-    set_thread_cleanup_task(NULL);
-}
-
-void do_thread_cleanup()
-{
-    void (*pfnTask)() = MPGetTaskValue(g_ulIndex)
-}
-
-
-void set_thread_cleanup_task(void (*pfnTask)())
-{
-    lStatus = MPSetTaskValue(g_ulIndex, reinterpret_cast<TaskStorageValue>(pfnTask));
-    assert(lStatus == noErr);
-}
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost

src/mac/thread_cleanup.hpp

@@ -1,36 +0,0 @@
-// (C) Copyright Mac Murrett 2001.
-// Use, modification and distribution are subject to the 
-// Boost Software License, Version 1.0. (See accompanying file 
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for most recent version.
-
-#ifndef BOOST_THREAD_CLEANUP_MJM012402_HPP
-#define BOOST_THREAD_CLEANUP_MJM012402_HPP
-
-
-namespace boost {
-
-namespace threads {
-
-namespace mac {
-
-namespace detail {
-
-
-void do_thread_startup();
-void do_thread_cleanup();
-
-void set_thread_cleanup_task();
-
-
-} // namespace detail
-
-} // namespace mac
-
-} // namespace threads
-
-} // namespace boost
-
-
-#endif // BOOST_THREAD_CLEANUP_MJM012402_HPP