-// Copyright (C) 2001-2003

-// William E. Kempf

-//

-// 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/thread/exceptions.hpp>

-#include <cstring>

-#include <string>

-

-namespace boost {

-

-thread_exception::thread_exception()

- : m_sys_err(0)

-{

-}

-

-thread_exception::thread_exception(int sys_err_code)

- : m_sys_err(sys_err_code)

-{

-}

-

-thread_exception::~thread_exception() throw()

-{

-}

-

-int thread_exception::native_error() const

-{

- return m_sys_err;

-}

-

-lock_error::lock_error()

-{

-}

-

-lock_error::lock_error(int sys_err_code)

- : thread_exception(sys_err_code)

-{

-}

-

-lock_error::~lock_error() throw()

-{

-}

-

-const char* lock_error::what() const throw()

-{

- return "boost::lock_error";

-}

-

-thread_resource_error::thread_resource_error()

-{

-}

-

-thread_resource_error::thread_resource_error(int sys_err_code)

- : thread_exception(sys_err_code)

-{

-}

-

-thread_resource_error::~thread_resource_error() throw()

-{

-}

-

-const char* thread_resource_error::what() const throw()

-{

- return "boost::thread_resource_error";

-}

-

-unsupported_thread_option::unsupported_thread_option()

-{

-}

-

-unsupported_thread_option::unsupported_thread_option(int sys_err_code)

- : thread_exception(sys_err_code)

-{

-}

-

-unsupported_thread_option::~unsupported_thread_option() throw()

-{

-}

-

-const char* unsupported_thread_option::what() const throw()

-{

- return "boost::unsupported_thread_option";

-}

-

-invalid_thread_argument::invalid_thread_argument()

-{

-}

-

-invalid_thread_argument::invalid_thread_argument(int sys_err_code)

- : thread_exception(sys_err_code)

-{

-}

-

-invalid_thread_argument::~invalid_thread_argument() throw()

-{

-}

-

-const char* invalid_thread_argument::what() const throw()

-{

- return "boost::invalid_thread_argument";

-}

-

-thread_permission_error::thread_permission_error()

-{

-}

-

-thread_permission_error::thread_permission_error(int sys_err_code)

- : thread_exception(sys_err_code)

-{

-}

-

-thread_permission_error::~thread_permission_error() throw()

-{

-}

-

-const char* thread_permission_error::what() const throw()

-{

- return "boost::thread_permission_error";

-}

-

-} // namespace boost

-// 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

-// (C) Copyright 2007 David Deakins

-

-#define _WIN32_WINNT 0x400

-#define WINVER 0x400

-

-#include <boost/thread/thread.hpp>

-#include <algorithm>

-#include <windows.h>

-#ifndef UNDER_CE

-#include <process.h>

-#endif

-#include <stdio.h>

-#include <boost/thread/once.hpp>

-#include <boost/thread/tss.hpp>

-#include <boost/assert.hpp>

-#include <boost/thread/detail/tss_hooks.hpp>

-#include <boost/date_time/posix_time/conversion.hpp>

-

-namespace boost

-{

- namespace

- {

- boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;

- DWORD current_thread_tls_key=0;

-

- void create_current_thread_tls_key()

- {

- tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in

- current_thread_tls_key=TlsAlloc();

- BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);

- }

-

- void cleanup_tls_key()

- {

- if(current_thread_tls_key)

- {

- TlsFree(current_thread_tls_key);

- current_thread_tls_key=0;

- }

- }

-

- detail::thread_data_base* get_current_thread_data()

- {

- if(!current_thread_tls_key)

- {

- return 0;

- }

- return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);

- }

-

- void set_current_thread_data(detail::thread_data_base* new_data)

- {

- boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);

- BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));

- }

-

-#ifdef BOOST_NO_THREADEX

-// Windows CE doesn't define _beginthreadex

-

- struct ThreadProxyData

- {

- typedef unsigned (__stdcall* func)(void*);

- func start_address_;

- void* arglist_;

- ThreadProxyData(func start_address,void* arglist) : start_address_(start_address), arglist_(arglist) {}

- };

-

- DWORD WINAPI ThreadProxy(LPVOID args)

- {

- ThreadProxyData* data=reinterpret_cast<ThreadProxyData*>(args);

- DWORD ret=data->start_address_(data->arglist_);

- delete data;

- return ret;

- }

-

- typedef void* uintptr_t;

-

- inline uintptr_t const _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*),

- void* arglist, unsigned initflag, unsigned* thrdaddr)

- {

- DWORD threadID;

- HANDLE hthread=CreateThread(static_cast<LPSECURITY_ATTRIBUTES>(security),stack_size,ThreadProxy,

- new ThreadProxyData(start_address,arglist),initflag,&threadID);

- if (hthread!=0)

- *thrdaddr=threadID;

- return reinterpret_cast<uintptr_t const>(hthread);

- }

-

-#endif

-

- }

-

- namespace detail

- {

- struct thread_exit_callback_node

- {

- boost::detail::thread_exit_function_base* func;

- thread_exit_callback_node* next;

-

- thread_exit_callback_node(boost::detail::thread_exit_function_base* func_,

- thread_exit_callback_node* next_):

- func(func_),next(next_)

- {}

- };

-

- struct tss_data_node

- {

- void const* key;

- boost::shared_ptr<boost::detail::tss_cleanup_function> func;

- void* value;

- tss_data_node* next;

-

- tss_data_node(void const* key_,boost::shared_ptr<boost::detail::tss_cleanup_function> func_,void* value_,

- tss_data_node* next_):

- key(key_),func(func_),value(value_),next(next_)

- {}

- };

-

- }

-

- namespace

- {

- void run_thread_exit_callbacks()

- {

- detail::thread_data_ptr current_thread_data(get_current_thread_data(),false);

- if(current_thread_data)

- {

- while(current_thread_data->tss_data || current_thread_data->thread_exit_callbacks)

- {

- while(current_thread_data->thread_exit_callbacks)

- {

- detail::thread_exit_callback_node* const current_node=current_thread_data->thread_exit_callbacks;

- current_thread_data->thread_exit_callbacks=current_node->next;

- if(current_node->func)

- {

- (*current_node->func)();

- boost::detail::heap_delete(current_node->func);

- }

- boost::detail::heap_delete(current_node);

- }

- while(current_thread_data->tss_data)

- {

- detail::tss_data_node* const current_node=current_thread_data->tss_data;

- current_thread_data->tss_data=current_node->next;

- if(current_node->func)

- {

- (*current_node->func)(current_node->value);

- }

- boost::detail::heap_delete(current_node);

- }

- }

-

- set_current_thread_data(0);

- }

- }

-

- unsigned __stdcall thread_start_function(void* param)

- {

- detail::thread_data_base* const thread_info(reinterpret_cast<detail::thread_data_base*>(param));

- set_current_thread_data(thread_info);

- try

- {

- thread_info->run();

- }

- catch(thread_interrupted const&)

- {

- }

-// Removed as it stops the debugger identifying the cause of the exception

-// Unhandled exceptions still cause the application to terminate

-// catch(...)

-// {

-// std::terminate();

-// }

- run_thread_exit_callbacks();

- return 0;

- }

- }

-

- thread::thread()

- {}

-

- void thread::start_thread()

- {

- uintptr_t const new_thread=_beginthreadex(0,0,&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);

- if(!new_thread)

- {

- throw thread_resource_error();

- }

- intrusive_ptr_add_ref(thread_info.get());

- thread_info->thread_handle=(detail::win32::handle)(new_thread);

- ResumeThread(thread_info->thread_handle);

- }

-

- thread::thread(detail::thread_data_ptr data):

- thread_info(data)

- {}

-

- namespace

- {

- struct externally_launched_thread:

- detail::thread_data_base

- {

- externally_launched_thread()

- {

- ++count;

- interruption_enabled=false;

- }

-

- void run()

- {}

- private:

- externally_launched_thread(externally_launched_thread&);

- void operator=(externally_launched_thread&);

- };

-

- void make_external_thread_data()

- {

- externally_launched_thread* me=detail::heap_new<externally_launched_thread>();

- set_current_thread_data(me);

- }

-

- detail::thread_data_base* get_or_make_current_thread_data()

- {

- detail::thread_data_base* current_thread_data(get_current_thread_data());

- if(!current_thread_data)

- {

- make_external_thread_data();

- current_thread_data=get_current_thread_data();

- }

- return current_thread_data;

- }

-

- }

-

- thread::~thread()

- {

- detach();

- }

-

- thread::id thread::get_id() const

- {

- return thread::id(get_thread_info());

- }

-

- bool thread::joinable() const

- {

- return get_thread_info();

- }

-

- void thread::join()

- {

- detail::thread_data_ptr local_thread_info=get_thread_info();

- if(local_thread_info)

- {

- this_thread::interruptible_wait(local_thread_info->thread_handle,detail::timeout::sentinel());

- release_handle();

- }

- }

-

- bool thread::timed_join(boost::system_time const& wait_until)

- {

- detail::thread_data_ptr local_thread_info=get_thread_info();

- if(local_thread_info)

- {

- if(!this_thread::interruptible_wait(local_thread_info->thread_handle,get_milliseconds_until(wait_until)))

- {

- return false;

- }

- release_handle();

- }

- return true;

- }

-

- void thread::detach()

- {

- release_handle();

- }

-

- void thread::release_handle()

- {

- lock_guard<mutex> l1(thread_info_mutex);

- thread_info=0;

- }

-

- void thread::interrupt()

- {

- detail::thread_data_ptr local_thread_info=get_thread_info();

- if(local_thread_info)

- {

- local_thread_info->interrupt();

- }

- }

-

- bool thread::interruption_requested() const

- {

- detail::thread_data_ptr local_thread_info=get_thread_info();

- return local_thread_info.get() && (detail::win32::WaitForSingleObject(local_thread_info->interruption_handle,0)==0);

- }

-

- unsigned thread::hardware_concurrency()

- {

- SYSTEM_INFO info={0};

- GetSystemInfo(&info);

- return info.dwNumberOfProcessors;

- }

-

- thread::native_handle_type thread::native_handle()

- {

- detail::thread_data_ptr local_thread_info=get_thread_info();

- return local_thread_info?(detail::win32::handle)local_thread_info->thread_handle:detail::win32::invalid_handle_value;

- }

-

- detail::thread_data_ptr thread::get_thread_info() const

- {

- boost::mutex::scoped_lock l(thread_info_mutex);

- return thread_info;

- }

-

- namespace this_thread

- {

- namespace

- {

- LARGE_INTEGER get_due_time(detail::timeout const& target_time)

- {

- LARGE_INTEGER due_time={0};

- if(target_time.relative)

- {

- unsigned long const elapsed_milliseconds=GetTickCount()-target_time.start;

- LONGLONG const remaining_milliseconds=(target_time.milliseconds-elapsed_milliseconds);

- LONGLONG const hundred_nanoseconds_in_one_millisecond=10000;

-

- if(remaining_milliseconds>0)

- {

- due_time.QuadPart=-(remaining_milliseconds*hundred_nanoseconds_in_one_millisecond);

- }

- }

- else

- {

- SYSTEMTIME target_system_time={0};

- target_system_time.wYear=target_time.abs_time.date().year();

- target_system_time.wMonth=target_time.abs_time.date().month();

- target_system_time.wDay=target_time.abs_time.date().day();

- target_system_time.wHour=(WORD)target_time.abs_time.time_of_day().hours();

- target_system_time.wMinute=(WORD)target_time.abs_time.time_of_day().minutes();

- target_system_time.wSecond=(WORD)target_time.abs_time.time_of_day().seconds();

-

- if(!SystemTimeToFileTime(&target_system_time,((FILETIME*)&due_time)))

- {

- due_time.QuadPart=0;

- }

- else

- {

- long const hundred_nanoseconds_in_one_second=10000000;

- due_time.QuadPart+=target_time.abs_time.time_of_day().fractional_seconds()*(hundred_nanoseconds_in_one_second/target_time.abs_time.time_of_day().ticks_per_second());

- }

- }

- return due_time;

- }

- }

-

-

- bool interruptible_wait(detail::win32::handle handle_to_wait_for,detail::timeout target_time)

- {

- detail::win32::handle handles[3]={0};

- unsigned handle_count=0;

- unsigned wait_handle_index=~0U;

- unsigned interruption_index=~0U;

- unsigned timeout_index=~0U;

- if(handle_to_wait_for!=detail::win32::invalid_handle_value)

- {

- wait_handle_index=handle_count;

- handles[handle_count++]=handle_to_wait_for;

- }

- if(get_current_thread_data() && get_current_thread_data()->interruption_enabled)

- {

- interruption_index=handle_count;

- handles[handle_count++]=get_current_thread_data()->interruption_handle;

- }

-

- detail::win32::handle_manager timer_handle;

-

-#ifndef UNDER_CE

- unsigned const min_timer_wait_period=20;

-

- if(!target_time.is_sentinel())

- {

- detail::timeout::remaining_time const time_left=target_time.remaining_milliseconds();

- if(time_left.milliseconds > min_timer_wait_period)

- {

- // for a long-enough timeout, use a waitable timer (which tracks clock changes)

- timer_handle=CreateWaitableTimer(NULL,false,NULL);

- if(timer_handle!=0)

- {

- LARGE_INTEGER due_time=get_due_time(target_time);

-

- bool const set_time_succeeded=SetWaitableTimer(timer_handle,&due_time,0,0,0,false)!=0;

- if(set_time_succeeded)

- {

- timeout_index=handle_count;

- handles[handle_count++]=timer_handle;

- }

- }

- }

- else if(!target_time.relative)

- {

- // convert short absolute-time timeouts into relative ones, so we don't race against clock changes

- target_time=detail::timeout(time_left.milliseconds);

- }

- }

-#endif

-

- bool const using_timer=timeout_index!=~0u;

- detail::timeout::remaining_time time_left(0);

-

- do

- {

- if(!using_timer)

- {

- time_left=target_time.remaining_milliseconds();

- }

-

- if(handle_count)

- {

- unsigned long const notified_index=detail::win32::WaitForMultipleObjects(handle_count,handles,false,using_timer?INFINITE:time_left.milliseconds);

- if(notified_index<handle_count)

- {

- if(notified_index==wait_handle_index)

- {

- return true;

- }

- else if(notified_index==interruption_index)

- {

- detail::win32::ResetEvent(get_current_thread_data()->interruption_handle);

- throw thread_interrupted();

- }

- else if(notified_index==timeout_index)

- {

- return false;

- }

- }

- }

- else

- {

- detail::win32::Sleep(time_left.milliseconds);

- }

- if(target_time.relative)

- {

- target_time.milliseconds-=detail::timeout::max_non_infinite_wait;

- }

- }

- while(time_left.more);

- return false;

- }

-

- thread::id get_id()

- {

- return thread::id(get_or_make_current_thread_data());

- }

-

- void interruption_point()

- {

- if(interruption_enabled() && interruption_requested())

- {

- detail::win32::ResetEvent(get_current_thread_data()->interruption_handle);

- throw thread_interrupted();

- }

- }

-

- bool interruption_enabled()

- {

- return get_current_thread_data() && get_current_thread_data()->interruption_enabled;

- }

-

- bool interruption_requested()

- {

- return get_current_thread_data() && (detail::win32::WaitForSingleObject(get_current_thread_data()->interruption_handle,0)==0);

- }

-

- void yield()

- {

- detail::win32::Sleep(0);

- }

-

- disable_interruption::disable_interruption():

- interruption_was_enabled(interruption_enabled())

- {

- if(interruption_was_enabled)

- {

- get_current_thread_data()->interruption_enabled=false;

- }

- }

-

- disable_interruption::~disable_interruption()

- {

- if(get_current_thread_data())

- {

- get_current_thread_data()->interruption_enabled=interruption_was_enabled;

- }

- }

-

- restore_interruption::restore_interruption(disable_interruption& d)

- {

- if(d.interruption_was_enabled)

- {

- get_current_thread_data()->interruption_enabled=true;

- }

- }

-

- restore_interruption::~restore_interruption()

- {

- if(get_current_thread_data())

- {

- get_current_thread_data()->interruption_enabled=false;

- }

- }

- }

-

- namespace detail

- {

- void add_thread_exit_function(thread_exit_function_base* func)

- {

- detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());

- thread_exit_callback_node* const new_node=

- heap_new<thread_exit_callback_node>(func,

- current_thread_data->thread_exit_callbacks);

- current_thread_data->thread_exit_callbacks=new_node;

- }

-

- tss_data_node* find_tss_data(void const* key)

- {

- detail::thread_data_base* const current_thread_data(get_current_thread_data());

- if(current_thread_data)

- {

- detail::tss_data_node* current_node=current_thread_data->tss_data;

- while(current_node)

- {

- if(current_node->key==key)

- {

- return current_node;

- }

- current_node=current_node->next;

- }

- }

- return NULL;

- }

-

- void* get_tss_data(void const* key)

- {

- if(tss_data_node* const current_node=find_tss_data(key))

- {

- return current_node->value;

- }

- return NULL;

- }

-

- void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing)

- {

- if(tss_data_node* const current_node=find_tss_data(key))

- {

- if(cleanup_existing && current_node->func.get())

- {

- (*current_node->func)(current_node->value);

- }

- current_node->func=func;

- current_node->value=tss_data;

- }

- else

- {

- detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());

- tss_data_node* const new_node=heap_new<tss_data_node>(key,func,tss_data,current_thread_data->tss_data);

- current_thread_data->tss_data=new_node;

- }

- }

- }

-}

-

-

-extern "C" BOOST_THREAD_DECL void on_process_enter()

-{}

-

-extern "C" BOOST_THREAD_DECL void on_thread_enter()

-{}

-

-extern "C" BOOST_THREAD_DECL void on_process_exit()

-{

- boost::cleanup_tls_key();

-}

-

-extern "C" BOOST_THREAD_DECL void on_thread_exit()

-{

- boost::run_thread_exit_callbacks();

-}

-

-// Copyright (C) 2001-2003

-// William E. Kempf

-//

-// 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)

-

-// boostinspect:nounnamed

-

-namespace {

-const int MILLISECONDS_PER_SECOND = 1000;

-const int NANOSECONDS_PER_SECOND = 1000000000;

-const int NANOSECONDS_PER_MILLISECOND = 1000000;

-

-const int MICROSECONDS_PER_SECOND = 1000000;

-const int NANOSECONDS_PER_MICROSECOND = 1000;

-

-inline void to_time(int milliseconds, boost::xtime& xt)

-{

- int res = 0;

- res = boost::xtime_get(&xt, boost::TIME_UTC);

- assert(res == boost::TIME_UTC);

-

- xt.sec += (milliseconds / MILLISECONDS_PER_SECOND);

- xt.nsec += ((milliseconds % MILLISECONDS_PER_SECOND) *

- NANOSECONDS_PER_MILLISECOND);

-

- if (xt.nsec >= NANOSECONDS_PER_SECOND)

- {

- ++xt.sec;

- xt.nsec -= NANOSECONDS_PER_SECOND;

- }

-}

-

-#if defined(BOOST_HAS_PTHREADS)

-inline void to_timespec(const boost::xtime& xt, timespec& ts)

-{

- ts.tv_sec = static_cast<int>(xt.sec);

- ts.tv_nsec = static_cast<int>(xt.nsec);

- if(ts.tv_nsec >= NANOSECONDS_PER_SECOND)

- {

- ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;

- ts.tv_nsec %= NANOSECONDS_PER_SECOND;

- }

-}

-

-inline void to_time(int milliseconds, timespec& ts)

-{

- boost::xtime xt;

- to_time(milliseconds, xt);

- to_timespec(xt, ts);

-}

-

-inline void to_timespec_duration(const boost::xtime& xt, timespec& ts)

-{

- boost::xtime cur;

- int res = 0;

- res = boost::xtime_get(&cur, boost::TIME_UTC);

- assert(res == boost::TIME_UTC);

-

- if (boost::xtime_cmp(xt, cur) <= 0)

- {

- ts.tv_sec = 0;

- ts.tv_nsec = 0;

- }

- else

- {

- ts.tv_sec = xt.sec - cur.sec;

- ts.tv_nsec = xt.nsec - cur.nsec;

-

- if( ts.tv_nsec < 0 )

- {

- ts.tv_sec -= 1;

- ts.tv_nsec += NANOSECONDS_PER_SECOND;

- }

- if(ts.tv_nsec >= NANOSECONDS_PER_SECOND)

- {

- ts.tv_sec += ts.tv_nsec / NANOSECONDS_PER_SECOND;

- ts.tv_nsec %= NANOSECONDS_PER_SECOND;

- }

- }

-}

-#endif

-

-inline void to_duration(boost::xtime xt, int& milliseconds)

-{

- boost::xtime cur;

- int res = 0;

- res = boost::xtime_get(&cur, boost::TIME_UTC);

- assert(res == boost::TIME_UTC);

-

- if (boost::xtime_cmp(xt, cur) <= 0)

- milliseconds = 0;

- else

- {

- if (cur.nsec > xt.nsec)

- {

- xt.nsec += NANOSECONDS_PER_SECOND;

- --xt.sec;

- }

- milliseconds = (int)((xt.sec - cur.sec) * MILLISECONDS_PER_SECOND) +

- (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MILLISECOND/2)) /

- NANOSECONDS_PER_MILLISECOND);

- }

-}

-

-inline void to_microduration(boost::xtime xt, int& microseconds)

-{

- boost::xtime cur;

- int res = 0;

- res = boost::xtime_get(&cur, boost::TIME_UTC);

- assert(res == boost::TIME_UTC);

-

- if (boost::xtime_cmp(xt, cur) <= 0)

- microseconds = 0;

- else

- {

- if (cur.nsec > xt.nsec)

- {

- xt.nsec += NANOSECONDS_PER_SECOND;

- --xt.sec;

- }

- microseconds = (int)((xt.sec - cur.sec) * MICROSECONDS_PER_SECOND) +

- (((xt.nsec - cur.nsec) + (NANOSECONDS_PER_MICROSECOND/2)) /

- NANOSECONDS_PER_MICROSECOND);

- }

-}

-}

-

-// Change Log:

-// 1 Jun 01 Initial creation.

-// (C) Copyright Michael Glassford 2004.

-// 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)

-

-#include <boost/thread/detail/config.hpp>

-

-#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)

-

- #include <boost/thread/detail/tss_hooks.hpp>

-

- #define WIN32_LEAN_AND_MEAN

- #include <windows.h>

-

- #if defined(__BORLANDC__)

- extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)

- #elif defined(_WIN32_WCE)

- extern "C" BOOL WINAPI DllMain(HANDLE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)

- #else

- extern "C" BOOL WINAPI DllMain(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID /*lpReserved*/)

- #endif

- {

- switch(dwReason)

- {

- case DLL_PROCESS_ATTACH:

- {

- on_process_enter();

- on_thread_enter();

- break;

- }

-

- case DLL_THREAD_ATTACH:

- {

- on_thread_enter();

- break;

- }

-

- case DLL_THREAD_DETACH:

- {

- on_thread_exit();

- break;

- }

-

- case DLL_PROCESS_DETACH:

- {

- on_thread_exit();

- on_process_exit();

- break;

- }

- }

-

- return TRUE;

- }

-

- extern "C" void tss_cleanup_implemented(void)

- {

- /*

- This function's sole purpose is to cause a link error in cases where

- automatic tss cleanup is not implemented by Boost.Threads as a

- reminder that user code is responsible for calling the necessary

- functions at the appropriate times (and for implementing an a

- tss_cleanup_implemented() function to eliminate the linker's

- missing symbol error).

-

- If Boost.Threads later implements automatic tss cleanup in cases

- where it currently doesn't (which is the plan), the duplicate

- symbol error will warn the user that their custom solution is no

- longer needed and can be removed.

- */

- }

-

-#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_DLL)

-// $Id: tss_pe.cpp 49324 2008-10-13 20:30:13Z anthonyw $

-// (C) Copyright Aaron W. LaFramboise, Roland Schwarz, Michael Glassford 2004.

-// (C) Copyright 2007 Roland Schwarz

-// (C) Copyright 2007 Anthony Williams

-// (C) Copyright 2007 David Deakins

-// 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)

-

-#include <boost/thread/detail/config.hpp>

-

-#if defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)

-

-#if defined(__MINGW32__) && !defined(_WIN64)

-

-#include <boost/thread/detail/tss_hooks.hpp>

-

-#include <windows.h>

-

-#include <cstdlib>

-

-extern "C" void tss_cleanup_implemented(void) {}

-

-namespace {

- void NTAPI on_tls_callback(void* h, DWORD dwReason, PVOID pv)

- {

- switch (dwReason)

- {

- case DLL_THREAD_DETACH:

- {

- on_thread_exit();

- break;

- }

- }

- }

-

- void on_after_ctors(void)

- {

- on_process_enter();

- }

-

- void on_before_dtors(void)

- {

- on_thread_exit();

- }

-

- void on_after_dtors(void)

- {

- on_process_exit();

- }

-}

-

-extern "C" {

-

- void (* after_ctors )(void) __attribute__((section(".ctors"))) = on_after_ctors;

- void (* before_dtors)(void) __attribute__((section(".dtors"))) = on_before_dtors;

- void (* after_dtors )(void) __attribute__((section(".dtors.zzz"))) = on_after_dtors;

-

- ULONG __tls_index__ = 0;

- char __tls_end__ __attribute__((section(".tls$zzz"))) = 0;

- char __tls_start__ __attribute__((section(".tls"))) = 0;

-

-

- PIMAGE_TLS_CALLBACK __crt_xl_start__ __attribute__ ((section(".CRT$XLA"))) = 0;

- PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;

- PIMAGE_TLS_CALLBACK __crt_xl_end__ __attribute__ ((section(".CRT$XLZ"))) = 0;

-}

-

-extern "C" const IMAGE_TLS_DIRECTORY32 _tls_used __attribute__ ((section(".rdata$T"))) =

-{

- (DWORD) &__tls_start__,

- (DWORD) &__tls_end__,

- (DWORD) &__tls_index__,

- (DWORD) (&__crt_xl_start__+1),

- (DWORD) 0,

- (DWORD) 0

-};

-

-

-#elif defined(_MSC_VER) && !defined(UNDER_CE)

-

- #include <boost/thread/detail/tss_hooks.hpp>

-

- #include <stdlib.h>

-

- #define WIN32_LEAN_AND_MEAN

- #include <windows.h>

-

- //Definitions required by implementation

-

- #if (_MSC_VER < 1300) // 1300 == VC++ 7.0

- typedef void (__cdecl *_PVFV)(void);

- #define INIRETSUCCESS

- #define PVAPI void

- #else

- typedef int (__cdecl *_PVFV)(void);

- #define INIRETSUCCESS 0

- #define PVAPI int

- #endif

-

- typedef void (NTAPI* _TLSCB)(HINSTANCE, DWORD, PVOID);

-

- //Symbols for connection to the runtime environment

-

- extern "C"

- {

- extern DWORD _tls_used; //the tls directory (located in .rdata segment)

- extern _TLSCB __xl_a[], __xl_z[]; //tls initializers */

- }

-

- namespace

- {

- //Forward declarations

-

- static PVAPI on_tls_prepare(void);

- static PVAPI on_process_init(void);

- static PVAPI on_process_term(void);

- static void NTAPI on_tls_callback(HINSTANCE, DWORD, PVOID);

-

- //The .CRT$Xxx information is taken from Codeguru:

- //http://www.codeguru.com/Cpp/misc/misc/threadsprocesses/article.php/c6945__2/

-

-#if (_MSC_VER >= 1400)

-#pragma section(".CRT$XIU",long,read)

-#pragma section(".CRT$XCU",long,read)

-#pragma section(".CRT$XTU",long,read)

-#pragma section(".CRT$XLC",long,read)

- __declspec(allocate(".CRT$XLC")) _TLSCB __xl_ca=on_tls_callback;

- __declspec(allocate(".CRT$XIU"))_PVFV p_tls_prepare = on_tls_prepare;

- __declspec(allocate(".CRT$XCU"))_PVFV p_process_init = on_process_init;

- __declspec(allocate(".CRT$XTU"))_PVFV p_process_term = on_process_term;

-#else

- #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0

- # pragma data_seg(push, old_seg)

- #endif

- //Callback to run tls glue code first.

- //I don't think it is necessary to run it

- //at .CRT$XIB level, since we are only

- //interested in thread detachement. But

- //this could be changed easily if required.

-

- #pragma data_seg(".CRT$XIU")

- static _PVFV p_tls_prepare = on_tls_prepare;

- #pragma data_seg()

-

- //Callback after all global ctors.

-

- #pragma data_seg(".CRT$XCU")

- static _PVFV p_process_init = on_process_init;

- #pragma data_seg()

-

- //Callback for tls notifications.

-

- #pragma data_seg(".CRT$XLB")

- _TLSCB p_thread_callback = on_tls_callback;

- #pragma data_seg()

- //Callback for termination.

-

- #pragma data_seg(".CRT$XTU")

- static _PVFV p_process_term = on_process_term;

- #pragma data_seg()

- #if (_MSC_VER >= 1300) // 1300 == VC++ 7.0

- # pragma data_seg(pop, old_seg)

- #endif

-#endif

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable:4189)

-#endif

-

- PVAPI on_tls_prepare(void)

- {

- //The following line has an important side effect:

- //if the TLS directory is not already there, it will

- //be created by the linker. In other words, it forces a tls

- //directory to be generated by the linker even when static tls

- //(i.e. __declspec(thread)) is not used.

- //The volatile should prevent the optimizer

- //from removing the reference.

-

- DWORD volatile dw = _tls_used;

-

- #if (_MSC_VER < 1300) // 1300 == VC++ 7.0

- _TLSCB* pfbegin = __xl_a;

- _TLSCB* pfend = __xl_z;

- _TLSCB* pfdst = pfbegin;

- //pfdst = (_TLSCB*)_tls_used.AddressOfCallBacks;

-

- //The following loop will merge the address pointers

- //into a contiguous area, since the tlssup code seems

- //to require this (at least on MSVC 6)

-

- while (pfbegin < pfend)

- {

- if (*pfbegin != 0)

- {

- *pfdst = *pfbegin;

- ++pfdst;

- }

- ++pfbegin;

- }

-

- *pfdst = 0;

- #endif

-

- return INIRETSUCCESS;

- }

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

- PVAPI on_process_init(void)

- {

- //Schedule on_thread_exit() to be called for the main

- //thread before destructors of global objects have been

- //called.

-

- //It will not be run when 'quick' exiting the

- //library; however, this is the standard behaviour

- //for destructors of global objects, so that

- //shouldn't be a problem.

-

- atexit(on_thread_exit);

-

- //Call Boost process entry callback here

-

- on_process_enter();

-

- return INIRETSUCCESS;

- }

-

- PVAPI on_process_term(void)

- {

- on_process_exit();

- return INIRETSUCCESS;

- }

-

- void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)

- {

- switch (dwReason)

- {

- case DLL_THREAD_DETACH:

- on_thread_exit();

- break;

- }

- }

-

- BOOL WINAPI dll_callback(HANDLE, DWORD dwReason, LPVOID)

- {

- switch (dwReason)

- {

- case DLL_THREAD_DETACH:

- on_thread_exit();

- break;

- case DLL_PROCESS_DETACH:

- on_process_exit();

- break;

- }

- return true;

- }

- } //namespace

-

-extern "C"

-{

- extern BOOL (WINAPI * const _pRawDllMain)(HANDLE, DWORD, LPVOID)=&dll_callback;

-}

-

- extern "C" void tss_cleanup_implemented(void)

- {

- /*

- This function's sole purpose is to cause a link error in cases where

- automatic tss cleanup is not implemented by Boost.Threads as a

- reminder that user code is responsible for calling the necessary

- functions at the appropriate times (and for implementing an a

- tss_cleanup_implemented() function to eliminate the linker's

- missing symbol error).

-

- If Boost.Threads later implements automatic tss cleanup in cases

- where it currently doesn't (which is the plan), the duplicate

- symbol error will warn the user that their custom solution is no

- longer needed and can be removed.

- */

- }

-#endif //defined(_MSC_VER) && !defined(UNDER_CE)

-

-#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB)