]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Remove a BOOST src directory we don't use. 14746/head
authorWolfgang Bangerth <bangerth@colostate.edu>
Mon, 30 Jan 2023 19:51:22 +0000 (12:51 -0700)
committerWolfgang Bangerth <bangerth@colostate.edu>
Mon, 30 Jan 2023 19:51:22 +0000 (12:51 -0700)
bundled/boost-1.70.0/libs/thread/src/CMakeLists.txt [deleted file]
bundled/boost-1.70.0/libs/thread/src/future.cpp [deleted file]
bundled/boost-1.70.0/libs/thread/src/pthread/once.cpp [deleted file]
bundled/boost-1.70.0/libs/thread/src/pthread/once_atomic.cpp [deleted file]
bundled/boost-1.70.0/libs/thread/src/pthread/thread.cpp [deleted file]
bundled/boost-1.70.0/libs/thread/src/tss_null.cpp [deleted file]
bundled/boost-1.70.0/libs/thread/src/win32/thread.cpp [deleted file]
bundled/boost-1.70.0/libs/thread/src/win32/tss_dll.cpp [deleted file]
bundled/boost-1.70.0/libs/thread/src/win32/tss_pe.cpp [deleted file]

diff --git a/bundled/boost-1.70.0/libs/thread/src/CMakeLists.txt b/bundled/boost-1.70.0/libs/thread/src/CMakeLists.txt
deleted file mode 100644 (file)
index 0dea7c2..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-## ---------------------------------------------------------------------
-## $Id$
-##
-## Copyright (C) 2012 - 2019 by the deal.II authors
-##
-## This file is part of the deal.II library.
-##
-## The deal.II library is free software; you can use it, redistribute
-## it, and/or modify it under the terms of the GNU Lesser General
-## Public License as published by the Free Software Foundation; either
-## version 2.1 of the License, or (at your option) any later version.
-## The full text of the license can be found in the file LICENSE.md at
-## the top level directory of deal.II.
-##
-## ---------------------------------------------------------------------
-
-if(DEAL_II_USE_MT_POSIX)
-  set(src_boost_thread
-    pthread/once.cpp
-    pthread/thread.cpp
-    )
-else()
-  set(src_boost_thread
-    win32/thread.cpp
-    win32/tss_dll.cpp
-    win32/tss_pe.cpp
-    )
-endif()
-
-deal_ii_add_library(obj_boost_thread OBJECT ${src_boost_thread})
-deal_ii_add_definitions(obj_boost_thread
-  "BOOST_THREAD_BUILD_LIB" "BOOST_ALL_NO_LIB"
-  )
-
-if(CMAKE_SYSTEM_NAME MATCHES "Windows")
-  deal_ii_add_definitions(obj_boost_thread "BOOST_HAS_WINTHREADS")
-else()
-  deal_ii_add_definitions(obj_boost_thread "BOOST_THREAD_POSIX")
-endif()
-
diff --git a/bundled/boost-1.70.0/libs/thread/src/future.cpp b/bundled/boost-1.70.0/libs/thread/src/future.cpp
deleted file mode 100644 (file)
index a477e70..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// (C) Copyright 2012 Vicente J. Botet Escriba
-// 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>
-
-#ifndef BOOST_NO_EXCEPTIONS
-
-#include <boost/thread/futures/future_error_code.hpp>
-#include <string>
-
-namespace boost
-{
-
-  namespace thread_detail
-  {
-
-    class  future_error_category :
-      public boost::system::error_category
-    {
-    public:
-        virtual const char* name() const BOOST_NOEXCEPT;
-        virtual std::string message(int ev) const;
-    };
-
-    const char*
-    future_error_category::name() const BOOST_NOEXCEPT
-    {
-        return "future";
-    }
-
-    std::string
-    future_error_category::message(int ev) const
-    {
-        switch (BOOST_SCOPED_ENUM_NATIVE(future_errc)(ev))
-        {
-        case future_errc::broken_promise:
-            return std::string("The associated promise has been destructed prior "
-                          "to the associated state becoming ready.");
-        case future_errc::future_already_retrieved:
-            return std::string("The future has already been retrieved from "
-                          "the promise or packaged_task.");
-        case future_errc::promise_already_satisfied:
-            return std::string("The state of the promise has already been set.");
-        case future_errc::no_state:
-            return std::string("Operation not permitted on an object without "
-                          "an associated state.");
-        }
-        return std::string("unspecified future_errc value\n");
-    }
-    future_error_category future_error_category_var;
-  }
-
-  BOOST_THREAD_DECL
-  const system::error_category&
-  future_category() BOOST_NOEXCEPT
-  {
-      return thread_detail::future_error_category_var;
-  }
-
-}
-#endif
-
diff --git a/bundled/boost-1.70.0/libs/thread/src/pthread/once.cpp b/bundled/boost-1.70.0/libs/thread/src/pthread/once.cpp
deleted file mode 100644 (file)
index 2395cff..0000000
+++ /dev/null
@@ -1,83 +0,0 @@
-// 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>
-#ifdef BOOST_THREAD_ONCE_ATOMIC
-#include "./once_atomic.cpp"
-#else
-#define __STDC_CONSTANT_MACROS
-#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
-#include <boost/thread/once.hpp>
-#include <boost/assert.hpp>
-#include <boost/throw_exception.hpp>
-#include <pthread.h>
-#include <stdlib.h>
-#include <memory>
-#include <string.h> // memcmp.
-namespace boost
-{
-    namespace thread_detail
-    {
-        BOOST_THREAD_DECL uintmax_atomic_t once_global_epoch=BOOST_THREAD_DETAIL_UINTMAX_ATOMIC_MAX_C;
-        BOOST_THREAD_DECL pthread_mutex_t once_epoch_mutex=PTHREAD_MUTEX_INITIALIZER;
-        BOOST_THREAD_DECL pthread_cond_t once_epoch_cv = PTHREAD_COND_INITIALIZER;
-
-        namespace
-        {
-            pthread_key_t epoch_tss_key;
-            pthread_once_t epoch_tss_key_flag=PTHREAD_ONCE_INIT;
-
-            extern "C"
-            {
-                static void delete_epoch_tss_data(void* data)
-                {
-                    free(data);
-                }
-
-                static void create_epoch_tss_key()
-                {
-                    BOOST_VERIFY(!pthread_key_create(&epoch_tss_key,delete_epoch_tss_data));
-                }
-            }
-
-#if defined BOOST_THREAD_PATCH
-            const pthread_once_t pthread_once_init_value=PTHREAD_ONCE_INIT;
-            struct BOOST_THREAD_DECL delete_epoch_tss_key_on_dlclose_t
-            {
-                delete_epoch_tss_key_on_dlclose_t()
-                {
-                }
-                ~delete_epoch_tss_key_on_dlclose_t()
-                {
-                    if(memcmp(&epoch_tss_key_flag, &pthread_once_init_value, sizeof(pthread_once_t)))
-                    {
-                        void* data = pthread_getspecific(epoch_tss_key);
-                        if (data)
-                            delete_epoch_tss_data(data);
-                        pthread_key_delete(epoch_tss_key);
-                    }
-                }
-            };
-            delete_epoch_tss_key_on_dlclose_t delete_epoch_tss_key_on_dlclose;
-#endif
-        }
-
-        uintmax_atomic_t& get_once_per_thread_epoch()
-        {
-            BOOST_VERIFY(!pthread_once(&epoch_tss_key_flag,create_epoch_tss_key));
-            void* data=pthread_getspecific(epoch_tss_key);
-            if(!data)
-            {
-                data=malloc(sizeof(thread_detail::uintmax_atomic_t));
-                if(!data) BOOST_THROW_EXCEPTION(std::bad_alloc());
-                BOOST_VERIFY(!pthread_setspecific(epoch_tss_key,data));
-                *static_cast<thread_detail::uintmax_atomic_t*>(data)=BOOST_THREAD_DETAIL_UINTMAX_ATOMIC_MAX_C;
-            }
-            return *static_cast<thread_detail::uintmax_atomic_t*>(data);
-        }
-    }
-
-}
-#endif //
diff --git a/bundled/boost-1.70.0/libs/thread/src/pthread/once_atomic.cpp b/bundled/boost-1.70.0/libs/thread/src/pthread/once_atomic.cpp
deleted file mode 100644 (file)
index 595ad7f..0000000
+++ /dev/null
@@ -1,90 +0,0 @@
-//  (C) Copyright 2013 Andrey Semashev
-//  (C) Copyright 2013 Vicente J. Botet Escriba
-//
-//  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)
-
-//#define __STDC_CONSTANT_MACROS
-#include <boost/thread/detail/config.hpp>
-#include <boost/thread/once.hpp>
-#include <boost/thread/pthread/pthread_mutex_scoped_lock.hpp>
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/atomic.hpp>
-#include <boost/memory_order.hpp>
-#include <pthread.h>
-
-namespace boost
-{
-  namespace thread_detail
-  {
-
-    enum flag_states
-    {
-      uninitialized, in_progress, initialized
-    };
-
-
-#ifndef BOOST_THREAD_PROVIDES_ONCE_CXX11
-    BOOST_STATIC_ASSERT_MSG(sizeof(atomic_int_type) == sizeof(atomic_type), "Boost.Thread: unsupported platform");
-#endif
-
-    static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER;
-    static pthread_cond_t once_cv = PTHREAD_COND_INITIALIZER;
-
-    BOOST_THREAD_DECL bool enter_once_region(once_flag& flag) BOOST_NOEXCEPT
-    {
-      atomic_type& f = get_atomic_storage(flag);
-      if (f.load(memory_order_acquire) != initialized)
-      {
-        pthread::pthread_mutex_scoped_lock lk(&once_mutex);
-        if (f.load(memory_order_acquire) != initialized)
-        {
-          for (;;)
-          {
-            atomic_int_type expected = uninitialized;
-            if (f.compare_exchange_strong(expected, in_progress, memory_order_acq_rel, memory_order_acquire))
-            {
-              // We have set the flag to in_progress
-              return true;
-            }
-            else if (expected == initialized)
-            {
-              // Another thread managed to complete the initialization
-              return false;
-            }
-            else
-            {
-              // Wait until the initialization is complete
-              //pthread::pthread_mutex_scoped_lock lk(&once_mutex);
-              BOOST_VERIFY(!pthread_cond_wait(&once_cv, &once_mutex));
-            }
-          }
-        }
-      }
-      return false;
-    }
-
-    BOOST_THREAD_DECL void commit_once_region(once_flag& flag) BOOST_NOEXCEPT
-    {
-      atomic_type& f = get_atomic_storage(flag);
-      {
-        pthread::pthread_mutex_scoped_lock lk(&once_mutex);
-        f.store(initialized, memory_order_release);
-      }
-      BOOST_VERIFY(!pthread_cond_broadcast(&once_cv));
-    }
-
-    BOOST_THREAD_DECL void rollback_once_region(once_flag& flag) BOOST_NOEXCEPT
-    {
-      atomic_type& f = get_atomic_storage(flag);
-      {
-        pthread::pthread_mutex_scoped_lock lk(&once_mutex);
-        f.store(uninitialized, memory_order_release);
-      }
-      BOOST_VERIFY(!pthread_cond_broadcast(&once_cv));
-    }
-
-  } // namespace thread_detail
-
-} // namespace boost
diff --git a/bundled/boost-1.70.0/libs/thread/src/pthread/thread.cpp b/bundled/boost-1.70.0/libs/thread/src/pthread/thread.cpp
deleted file mode 100644 (file)
index f318635..0000000
+++ /dev/null
@@ -1,799 +0,0 @@
-// Copyright (C) 2001-2003
-// William E. Kempf
-// Copyright (C) 2007-8 Anthony Williams
-// (C) Copyright 2011-2012 Vicente J. Botet Escriba
-//
-//  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/thread_only.hpp>
-#if defined BOOST_THREAD_USES_DATETIME
-#include <boost/thread/xtime.hpp>
-#endif
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/locks.hpp>
-#include <boost/thread/once.hpp>
-#include <boost/thread/tss.hpp>
-#include <boost/thread/future.hpp>
-
-#ifdef __GLIBC__
-#include <sys/sysinfo.h>
-#elif defined(__APPLE__) || defined(__FreeBSD__)
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#elif defined BOOST_HAS_UNISTD_H
-#include <unistd.h>
-#endif
-
-#if defined(__VXWORKS__)
-#include <vxCpuLib.h>
-#endif
-
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/lexical_cast.hpp>
-
-#include <fstream>
-#include <string>
-#include <set>
-#include <vector>
-#include <string.h> // memcmp.
-
-namespace boost
-{
-    namespace detail
-    {
-        thread_data_base::~thread_data_base()
-        {
-            for (notify_list_t::iterator i = notify.begin(), e = notify.end();
-                    i != e; ++i)
-            {
-                i->second->unlock();
-                i->first->notify_all();
-            }
-//#ifndef BOOST_NO_EXCEPTIONS
-            for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
-                    i != e; ++i)
-            {
-                (*i)->notify_deferred();
-            }
-//#endif
-        }
-
-        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_)
-            {}
-        };
-
-        namespace
-        {
-#ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11
-          boost::once_flag current_thread_tls_init_flag;
-#else
-            boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
-#endif
-            pthread_key_t current_thread_tls_key;
-
-            extern "C"
-            {
-                static void tls_destructor(void* data)
-                {
-                    //boost::detail::thread_data_base* thread_info=static_cast<boost::detail::thread_data_base*>(data);
-                    boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(data)->shared_from_this();
-
-                    if(thread_info)
-                    {
-                        while(!thread_info->tss_data.empty() || thread_info->thread_exit_callbacks)
-                        {
-
-                            while(thread_info->thread_exit_callbacks)
-                            {
-                                detail::thread_exit_callback_node* const current_node=thread_info->thread_exit_callbacks;
-                                thread_info->thread_exit_callbacks=current_node->next;
-                                if(current_node->func)
-                                {
-                                    (*current_node->func)();
-                                    delete current_node->func;
-                                }
-                                delete current_node;
-                            }
-                            while (!thread_info->tss_data.empty())
-                            {
-                                std::map<void const*,detail::tss_data_node>::iterator current
-                                    = thread_info->tss_data.begin();
-                                if(current->second.func && (current->second.value!=0))
-                                {
-                                    (*current->second.caller)(current->second.func,current->second.value);
-                                }
-                                thread_info->tss_data.erase(current);
-                            }
-                        }
-                        thread_info->self.reset();
-                    }
-                }
-            }
-
-#if defined BOOST_THREAD_PATCH
-            struct  delete_current_thread_tls_key_on_dlclose_t
-            {
-                delete_current_thread_tls_key_on_dlclose_t()
-                {
-                }
-                ~delete_current_thread_tls_key_on_dlclose_t()
-                {
-                    const boost::once_flag uninitialized = BOOST_ONCE_INIT;
-                    if (memcmp(&current_thread_tls_init_flag, &uninitialized, sizeof(boost::once_flag)))
-                    {
-                        void* data = pthread_getspecific(current_thread_tls_key);
-                        if (data)
-                            tls_destructor(data);
-                        pthread_key_delete(current_thread_tls_key);
-                    }
-                }
-            };
-            delete_current_thread_tls_key_on_dlclose_t delete_current_thread_tls_key_on_dlclose;
-#endif
-            void create_current_thread_tls_key()
-            {
-                BOOST_VERIFY(!pthread_key_create(&current_thread_tls_key,&tls_destructor));
-            }
-        }
-
-        boost::detail::thread_data_base* get_current_thread_data()
-        {
-            boost::call_once(current_thread_tls_init_flag,&create_current_thread_tls_key);
-            return (boost::detail::thread_data_base*)pthread_getspecific(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(!pthread_setspecific(current_thread_tls_key,new_data));
-        }
-    }
-
-    namespace
-    {
-        extern "C"
-        {
-            static void* thread_proxy(void* param)
-            {
-                //boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->self;
-                boost::detail::thread_data_ptr thread_info = static_cast<boost::detail::thread_data_base*>(param)->shared_from_this();
-                thread_info->self.reset();
-                detail::set_current_thread_data(thread_info.get());
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-                BOOST_TRY
-                {
-#endif
-                    thread_info->run();
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-
-                }
-                BOOST_CATCH (thread_interrupted const&)
-                {
-                }
-// Removed as it stops the debugger identifying the cause of the exception
-// Unhandled exceptions still cause the application to terminate
-//                 BOOST_CATCH(...)
-//                 {
-//                   throw;
-//
-//                     std::terminate();
-//                 }
-                BOOST_CATCH_END
-#endif
-                detail::tls_destructor(thread_info.get());
-                detail::set_current_thread_data(0);
-                boost::lock_guard<boost::mutex> lock(thread_info->data_mutex);
-                thread_info->done=true;
-                thread_info->done_condition.notify_all();
-
-                return 0;
-            }
-        }
-    }
-    namespace detail
-    {
-        struct externally_launched_thread:
-            detail::thread_data_base
-        {
-            externally_launched_thread()
-            {
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-                interrupt_enabled=false;
-#endif
-            }
-            ~externally_launched_thread() {
-              BOOST_ASSERT(notify.empty());
-              notify.clear();
-//#ifndef BOOST_NO_EXCEPTIONS
-              BOOST_ASSERT(async_states_.empty());
-              async_states_.clear();
-//#endif
-            }
-            void run()
-            {}
-            void notify_all_at_thread_exit(condition_variable*, mutex*)
-            {}
-
-        private:
-            externally_launched_thread(externally_launched_thread&);
-            void operator=(externally_launched_thread&);
-        };
-
-        thread_data_base* make_external_thread_data()
-        {
-            thread_data_base* const me(detail::heap_new<externally_launched_thread>());
-            me->self.reset(me);
-            set_current_thread_data(me);
-            return me;
-        }
-
-
-        thread_data_base* get_or_make_current_thread_data()
-        {
-            thread_data_base* current_thread_data(get_current_thread_data());
-            if(!current_thread_data)
-            {
-                current_thread_data=make_external_thread_data();
-            }
-            return current_thread_data;
-        }
-
-    }
-
-
-    thread::thread() BOOST_NOEXCEPT
-    {}
-
-    bool thread::start_thread_noexcept()
-    {
-        thread_info->self=thread_info;
-        int const res = pthread_create(&thread_info->thread_handle, 0, &thread_proxy, thread_info.get());
-        if (res != 0)
-        {
-            thread_info->self.reset();
-            return false;
-        }
-        return true;
-    }
-
-    bool thread::start_thread_noexcept(const attributes& attr)
-    {
-        thread_info->self=thread_info;
-        const attributes::native_handle_type* h = attr.native_handle();
-        int res = pthread_create(&thread_info->thread_handle, h, &thread_proxy, thread_info.get());
-        if (res != 0)
-        {
-            thread_info->self.reset();
-            return false;
-        }
-        int detached_state;
-        res = pthread_attr_getdetachstate(h, &detached_state);
-        if (res != 0)
-        {
-            thread_info->self.reset();
-            return false;
-        }
-        if (PTHREAD_CREATE_DETACHED==detached_state)
-        {
-          detail::thread_data_ptr local_thread_info;
-          thread_info.swap(local_thread_info);
-
-          if(local_thread_info)
-          {
-              //lock_guard<mutex> lock(local_thread_info->data_mutex);
-              if(!local_thread_info->join_started)
-              {
-                  //BOOST_VERIFY(!pthread_detach(local_thread_info->thread_handle));
-                  local_thread_info->join_started=true;
-                  local_thread_info->joined=true;
-              }
-          }
-        }
-        return true;
-    }
-
-
-
-    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    {
-        return thread_info;
-    }
-
-    bool thread::join_noexcept()
-    {
-        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
-        if(local_thread_info)
-        {
-            bool do_join=false;
-
-            {
-                unique_lock<mutex> lock(local_thread_info->data_mutex);
-                while(!local_thread_info->done)
-                {
-                    local_thread_info->done_condition.wait(lock);
-                }
-                do_join=!local_thread_info->join_started;
-
-                if(do_join)
-                {
-                    local_thread_info->join_started=true;
-                }
-                else
-                {
-                    while(!local_thread_info->joined)
-                    {
-                        local_thread_info->done_condition.wait(lock);
-                    }
-                }
-            }
-            if(do_join)
-            {
-                void* result=0;
-                BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result));
-                lock_guard<mutex> lock(local_thread_info->data_mutex);
-                local_thread_info->joined=true;
-                local_thread_info->done_condition.notify_all();
-            }
-
-            if(thread_info==local_thread_info)
-            {
-                thread_info.reset();
-            }
-            return true;
-        }
-        else
-        {
-          return false;
-        }
-    }
-
-    bool thread::do_try_join_until_noexcept(detail::internal_platform_timepoint const &timeout, bool& res)
-    {
-        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
-        if(local_thread_info)
-        {
-            bool do_join=false;
-
-            {
-                unique_lock<mutex> lock(local_thread_info->data_mutex);
-                while(!local_thread_info->done)
-                {
-                    if(!local_thread_info->done_condition.do_wait_until(lock,timeout)) break; // timeout occurred
-                }
-                if(!local_thread_info->done)
-                {
-                  res=false;
-                  return true;
-                }
-                do_join=!local_thread_info->join_started;
-
-                if(do_join)
-                {
-                    local_thread_info->join_started=true;
-                }
-                else
-                {
-                    while(!local_thread_info->joined)
-                    {
-                        local_thread_info->done_condition.wait(lock);
-                    }
-                }
-            }
-            if(do_join)
-            {
-                void* result=0;
-                BOOST_VERIFY(!pthread_join(local_thread_info->thread_handle,&result));
-                lock_guard<mutex> lock(local_thread_info->data_mutex);
-                local_thread_info->joined=true;
-                local_thread_info->done_condition.notify_all();
-            }
-
-            if(thread_info==local_thread_info)
-            {
-                thread_info.reset();
-            }
-            res=true;
-            return true;
-        }
-        else
-        {
-          return false;
-        }
-    }
-
-    bool thread::joinable() const BOOST_NOEXCEPT
-    {
-        return (get_thread_info)()?true:false;
-    }
-
-
-    void thread::detach()
-    {
-        detail::thread_data_ptr local_thread_info;
-        thread_info.swap(local_thread_info);
-
-        if(local_thread_info)
-        {
-            lock_guard<mutex> lock(local_thread_info->data_mutex);
-            if(!local_thread_info->join_started)
-            {
-                BOOST_VERIFY(!pthread_detach(local_thread_info->thread_handle));
-                local_thread_info->join_started=true;
-                local_thread_info->joined=true;
-            }
-        }
-    }
-
-    namespace this_thread
-    {
-      namespace no_interruption_point
-      {
-        namespace hidden
-        {
-          void BOOST_THREAD_DECL sleep_for_internal(const detail::platform_duration& ts)
-          {
-                if (ts > detail::platform_duration::zero())
-                {
-                  // Use pthread_delay_np or nanosleep whenever possible here in the no_interruption_point
-                  // namespace because they do not provide an interruption point.
-    #   if defined(BOOST_HAS_PTHREAD_DELAY_NP)
-    #     if defined(__IBMCPP__) ||  defined(_AIX)
-                  BOOST_VERIFY(!pthread_delay_np(const_cast<timespec*>(&ts.getTs())));
-    #     else
-                  BOOST_VERIFY(!pthread_delay_np(&ts.getTs()));
-    #     endif
-    #   elif defined(BOOST_HAS_NANOSLEEP)
-                  nanosleep(&ts.getTs(), 0);
-    #   else
-                  // This should never be reached due to BOOST_THREAD_SLEEP_FOR_IS_STEADY
-    #   endif
-                }
-          }
-        }
-      }
-
-        void yield() BOOST_NOEXCEPT
-        {
-#   if defined(BOOST_HAS_SCHED_YIELD)
-            BOOST_VERIFY(!sched_yield());
-#   elif defined(BOOST_HAS_PTHREAD_YIELD)
-            BOOST_VERIFY(!pthread_yield());
-//#   elif defined BOOST_THREAD_USES_DATETIME
-//            ::boost::xtime xt;
-//            xtime_get(&xt, TIME_UTC_);
-//            sleep(xt);
-//            sleep_for(chrono::milliseconds(0));
-#   else
-            mutex mx;
-            unique_lock<mutex> lock(mx);
-            condition_variable cond;
-            cond.do_wait_until(lock, detail::internal_platform_clock::now());
-#   endif
-        }
-    }
-    unsigned thread::hardware_concurrency() BOOST_NOEXCEPT
-    {
-#if defined(PTW32_VERSION) || defined(__hpux)
-        return pthread_num_processors_np();
-#elif defined(__APPLE__) || defined(__FreeBSD__)
-        int count;
-        size_t size=sizeof(count);
-        return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
-#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
-        int const count=sysconf(_SC_NPROCESSORS_ONLN);
-        return (count>0)?count:0;
-#elif defined(__VXWORKS__)
-        cpuset_t set =  ::vxCpuEnabledGet();
-  #ifdef __DCC__
-        int i;
-        for( i = 0; set; ++i)
-        {
-           set &= set -1;
-        }
-        return(i);
-  #else
-        return (__builtin_popcount(set) );
-  #endif
-#elif defined(__GLIBC__)
-        return get_nprocs();
-#else
-        return 0;
-#endif
-    }
-
-    unsigned thread::physical_concurrency() BOOST_NOEXCEPT
-    {
-#ifdef __linux__
-        try {
-            using namespace std;
-
-            ifstream proc_cpuinfo ("/proc/cpuinfo");
-
-            const string physical_id("physical id"), core_id("core id");
-
-            typedef std::pair<unsigned, unsigned> core_entry; // [physical ID, core id]
-
-            std::set<core_entry> cores;
-
-            core_entry current_core_entry;
-
-            string line;
-            while ( getline(proc_cpuinfo, line) ) {
-                if (line.empty())
-                    continue;
-
-                vector<string> key_val(2);
-                boost::split(key_val, line, boost::is_any_of(":"));
-
-                if (key_val.size() != 2)
-                  return hardware_concurrency();
-
-                string key   = key_val[0];
-                string value = key_val[1];
-                boost::trim(key);
-                boost::trim(value);
-
-                if (key == physical_id) {
-                    current_core_entry.first = boost::lexical_cast<unsigned>(value);
-                    continue;
-                }
-
-                if (key == core_id) {
-                    current_core_entry.second = boost::lexical_cast<unsigned>(value);
-                    cores.insert(current_core_entry);
-                    continue;
-                }
-            }
-            // Fall back to hardware_concurrency() in case
-            // /proc/cpuinfo is formatted differently than we expect.
-            return cores.size() != 0 ? cores.size() : hardware_concurrency();
-        } catch(...) {
-          return hardware_concurrency();
-        }
-#elif defined(__APPLE__)
-        int count;
-        size_t size=sizeof(count);
-        return sysctlbyname("hw.physicalcpu",&count,&size,NULL,0)?0:count;
-#else
-        return hardware_concurrency();
-#endif
-    }
-
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-    void thread::interrupt()
-    {
-        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
-        if(local_thread_info)
-        {
-            lock_guard<mutex> lk(local_thread_info->data_mutex);
-            local_thread_info->interrupt_requested=true;
-            if(local_thread_info->current_cond)
-            {
-                boost::pthread::pthread_mutex_scoped_lock internal_lock(local_thread_info->cond_mutex);
-                BOOST_VERIFY(!pthread_cond_broadcast(local_thread_info->current_cond));
-            }
-        }
-    }
-
-    bool thread::interruption_requested() const BOOST_NOEXCEPT
-    {
-        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
-        if(local_thread_info)
-        {
-            lock_guard<mutex> lk(local_thread_info->data_mutex);
-            return local_thread_info->interrupt_requested;
-        }
-        else
-        {
-            return false;
-        }
-    }
-#endif
-
-    thread::native_handle_type thread::native_handle()
-    {
-        detail::thread_data_ptr const local_thread_info=(get_thread_info)();
-        if(local_thread_info)
-        {
-            lock_guard<mutex> lk(local_thread_info->data_mutex);
-            return local_thread_info->thread_handle;
-        }
-        else
-        {
-            return pthread_t();
-        }
-    }
-
-
-
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-    namespace this_thread
-    {
-        void interruption_point()
-        {
-#ifndef BOOST_NO_EXCEPTIONS
-            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
-            if(thread_info && thread_info->interrupt_enabled)
-            {
-                lock_guard<mutex> lg(thread_info->data_mutex);
-                if(thread_info->interrupt_requested)
-                {
-                    thread_info->interrupt_requested=false;
-                    throw thread_interrupted();
-                }
-            }
-#endif
-        }
-
-        bool interruption_enabled() BOOST_NOEXCEPT
-        {
-            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
-            return thread_info && thread_info->interrupt_enabled;
-        }
-
-        bool interruption_requested() BOOST_NOEXCEPT
-        {
-            boost::detail::thread_data_base* const thread_info=detail::get_current_thread_data();
-            if(!thread_info)
-            {
-                return false;
-            }
-            else
-            {
-                lock_guard<mutex> lg(thread_info->data_mutex);
-                return thread_info->interrupt_requested;
-            }
-        }
-
-        disable_interruption::disable_interruption() BOOST_NOEXCEPT:
-            interruption_was_enabled(interruption_enabled())
-        {
-            if(interruption_was_enabled)
-            {
-                detail::get_current_thread_data()->interrupt_enabled=false;
-            }
-        }
-
-        disable_interruption::~disable_interruption() BOOST_NOEXCEPT
-        {
-            if(detail::get_current_thread_data())
-            {
-                detail::get_current_thread_data()->interrupt_enabled=interruption_was_enabled;
-            }
-        }
-
-        restore_interruption::restore_interruption(disable_interruption& d) BOOST_NOEXCEPT
-        {
-            if(d.interruption_was_enabled)
-            {
-                detail::get_current_thread_data()->interrupt_enabled=true;
-            }
-        }
-
-        restore_interruption::~restore_interruption() BOOST_NOEXCEPT
-        {
-            if(detail::get_current_thread_data())
-            {
-                detail::get_current_thread_data()->interrupt_enabled=false;
-            }
-        }
-    }
-#endif
-
-    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)
-            {
-                std::map<void const*,tss_data_node>::iterator current_node=
-                    current_thread_data->tss_data.find(key);
-                if(current_node!=current_thread_data->tss_data.end())
-                {
-                    return &current_node->second;
-                }
-            }
-            return 0;
-        }
-
-        void* get_tss_data(void const* key)
-        {
-            if(tss_data_node* const current_node=find_tss_data(key))
-            {
-                return current_node->value;
-            }
-            return 0;
-        }
-
-        void add_new_tss_node(void const* key,
-                              detail::tss_data_node::cleanup_caller_t caller,
-                              detail::tss_data_node::cleanup_func_t func,
-                              void* tss_data)
-        {
-            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(caller,func,tss_data)));
-        }
-
-        void erase_tss_node(void const* key)
-        {
-            detail::thread_data_base* const current_thread_data(get_current_thread_data());
-            if(current_thread_data)
-            {
-                current_thread_data->tss_data.erase(key);
-            }
-        }
-
-        void set_tss_data(void const* key,
-                          detail::tss_data_node::cleanup_caller_t caller,
-                          detail::tss_data_node::cleanup_func_t func,
-                          void* tss_data,bool cleanup_existing)
-        {
-            if(tss_data_node* const current_node=find_tss_data(key))
-            {
-                if(cleanup_existing && current_node->func && (current_node->value!=0))
-                {
-                    (*current_node->caller)(current_node->func,current_node->value);
-                }
-                if(func || (tss_data!=0))
-                {
-                    current_node->caller=caller;
-                    current_node->func=func;
-                    current_node->value=tss_data;
-                }
-                else
-                {
-                    erase_tss_node(key);
-                }
-            }
-            else if(func || (tss_data!=0))
-            {
-                add_new_tss_node(key,caller,func,tss_data);
-            }
-        }
-    }
-
-    BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
-    {
-      detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
-      if(current_thread_data)
-      {
-        current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
-      }
-    }
-
-//#ifndef BOOST_NO_EXCEPTIONS
-namespace detail {
-
-    void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
-    {
-      detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
-      if(current_thread_data)
-      {
-        current_thread_data->make_ready_at_thread_exit(as);
-      }
-    }
-}
-//#endif
-
-
-}
diff --git a/bundled/boost-1.70.0/libs/thread/src/tss_null.cpp b/bundled/boost-1.70.0/libs/thread/src/tss_null.cpp
deleted file mode 100644 (file)
index e5e8151..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-// (C) Copyright Michael Glassford 2004.
-// (C) Copyright 2007 Anthony Williams
-// 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_THREAD_WIN32) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))
-
-namespace boost
-{
-    /*
-    This file is a "null" implementation of tss cleanup; it's
-    purpose is to to eliminate link errors in cases
-    where it is known that tss cleanup is not needed.
-    */
-
-    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_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)
diff --git a/bundled/boost-1.70.0/libs/thread/src/win32/thread.cpp b/bundled/boost-1.70.0/libs/thread/src/win32/thread.cpp
deleted file mode 100644 (file)
index e1ae050..0000000
+++ /dev/null
@@ -1,980 +0,0 @@
-// 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
-// (C) Copyright 2011-2018 Vicente J. Botet Escriba
-
-//#define BOOST_THREAD_VERSION 3
-
-#include <boost/winapi/config.hpp>
-#include <boost/thread/thread_only.hpp>
-#include <boost/thread/once.hpp>
-#include <boost/thread/tss.hpp>
-#include <boost/thread/condition_variable.hpp>
-#include <boost/thread/detail/tss_hooks.hpp>
-#include <boost/thread/future.hpp>
-#include <boost/assert.hpp>
-#include <boost/cstdint.hpp>
-#if defined BOOST_THREAD_USES_DATETIME
-#include <boost/date_time/posix_time/conversion.hpp>
-#include <boost/thread/thread_time.hpp>
-#endif
-#include <boost/thread/csbl/memory/unique_ptr.hpp>
-#include <memory>
-#include <algorithm>
-#ifndef UNDER_CE
-#include <process.h>
-#endif
-#include <stdio.h>
-#include <windows.h>
-#include <boost/predef/platform.h>
-
-#if BOOST_PLAT_WINDOWS_RUNTIME
-#include <mutex>
-#include <atomic>
-#include <Activation.h>
-#include <wrl\client.h>
-#include <wrl\event.h>
-#include <wrl\wrappers\corewrappers.h>
-#include <wrl\ftm.h>
-#include <windows.system.threading.h>
-#pragma comment(lib, "runtimeobject.lib")
-#endif
-
-namespace boost
-{
-  namespace detail
-  {
-    thread_data_base::~thread_data_base()
-    {
-        for (notify_list_t::iterator i = notify.begin(), e = notify.end();
-                i != e; ++i)
-        {
-            i->second->unlock();
-            i->first->notify_all();
-        }
-//#ifndef BOOST_NO_EXCEPTIONS
-        for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();
-                i != e; ++i)
-        {
-            (*i)->notify_deferred();
-        }
-//#endif
-    }
-  }
-
-    namespace
-    {
-#ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11
-        boost::once_flag current_thread_tls_init_flag;
-#else
-        boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;
-#endif
-#if defined(UNDER_CE)
-        // Windows CE does not define the TLS_OUT_OF_INDEXES constant.
-#define TLS_OUT_OF_INDEXES 0xFFFFFFFF
-#endif
-#if !BOOST_PLAT_WINDOWS_RUNTIME
-        DWORD current_thread_tls_key=TLS_OUT_OF_INDEXES;
-#else
-        __declspec(thread) boost::detail::thread_data_base* current_thread_data_base;
-#endif
-
-        void create_current_thread_tls_key()
-        {
-            tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in
-#if !BOOST_PLAT_WINDOWS_RUNTIME
-            current_thread_tls_key=TlsAlloc();
-            BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);
-#endif
-        }
-
-        void cleanup_tls_key()
-        {
-#if !BOOST_PLAT_WINDOWS_RUNTIME
-            if(current_thread_tls_key!=TLS_OUT_OF_INDEXES)
-            {
-                TlsFree(current_thread_tls_key);
-                current_thread_tls_key=TLS_OUT_OF_INDEXES;
-            }
-#endif
-        }
-
-        void set_current_thread_data(detail::thread_data_base* new_data)
-        {
-            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);
-#if BOOST_PLAT_WINDOWS_RUNTIME
-            current_thread_data_base = new_data;
-#else
-            if (current_thread_tls_key != TLS_OUT_OF_INDEXES)
-            {
-                BOOST_VERIFY(TlsSetValue(current_thread_tls_key, new_data));
-            }
-            else
-            {
-                BOOST_VERIFY(false);
-                //boost::throw_exception(thread_resource_error());
-            }
-#endif
-        }
-    }
-
-    namespace detail
-    {
-      thread_data_base* get_current_thread_data()
-      {
-#if BOOST_PLAT_WINDOWS_RUNTIME
-          return current_thread_data_base;
-#else
-          if (current_thread_tls_key == TLS_OUT_OF_INDEXES)
-          {
-              return 0;
-          }
-          return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);
-#endif
-      }
-    }
-
-    namespace
-    {
-#ifndef BOOST_HAS_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)
-        {
-            boost::csbl::unique_ptr<ThreadProxyData> data(reinterpret_cast<ThreadProxyData*>(args));
-            DWORD ret=data->start_address_(data->arglist_);
-            return ret;
-        }
-
-        inline uintptr_t _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*),
-                                              void* arglist, unsigned initflag, unsigned* thrdaddr)
-        {
-            DWORD threadID;
-            ThreadProxyData* data = new ThreadProxyData(start_address,arglist);
-            HANDLE hthread=CreateThread(static_cast<LPSECURITY_ATTRIBUTES>(security),stack_size,ThreadProxy,
-                                        data,initflag,&threadID);
-            if (hthread==0) {
-              delete data;
-              return 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_)
-            {}
-        };
-
-    }
-
-#if BOOST_PLAT_WINDOWS_RUNTIME
-    namespace detail
-    {
-        std::atomic_uint threadCount;
-
-        bool win32::scoped_winrt_thread::start(thread_func address, void *parameter, unsigned int *thrdId)
-        {
-            Microsoft::WRL::ComPtr<ABI::Windows::System::Threading::IThreadPoolStatics> threadPoolFactory;
-            HRESULT hr = ::Windows::Foundation::GetActivationFactory(
-                Microsoft::WRL::Wrappers::HStringReference(RuntimeClass_Windows_System_Threading_ThreadPool).Get(),
-                &threadPoolFactory);
-            if (hr != S_OK)
-            {
-                return false;
-            }
-
-            // Create event for tracking work item completion.
-            *thrdId = ++threadCount;
-            handle completionHandle = CreateEventExW(NULL, NULL, 0, EVENT_ALL_ACCESS);
-            if (!completionHandle)
-            {
-                return false;
-            }
-            m_completionHandle = completionHandle;
-
-            // Create new work item.
-            Microsoft::WRL::ComPtr<ABI::Windows::System::Threading::IWorkItemHandler> workItem =
-                Microsoft::WRL::Callback<Microsoft::WRL::Implements<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, ABI::Windows::System::Threading::IWorkItemHandler, Microsoft::WRL::FtmBase>>
-                ([address, parameter, completionHandle](ABI::Windows::Foundation::IAsyncAction *)
-            {
-                // Add a reference since we need to access the completionHandle after the thread_start_function.
-                // This is to handle cases where detach() was called and run_thread_exit_callbacks() would end
-                // up closing the handle.
-                ::boost::detail::thread_data_base* const thread_info(reinterpret_cast<::boost::detail::thread_data_base*>(parameter));
-                intrusive_ptr_add_ref(thread_info);
-
-                __try
-                {
-                    address(parameter);
-                }
-                __finally
-                {
-                    SetEvent(completionHandle);
-                    intrusive_ptr_release(thread_info);
-                }
-                return S_OK;
-            });
-
-            // Schedule work item on the threadpool.
-            Microsoft::WRL::ComPtr<ABI::Windows::Foundation::IAsyncAction> asyncAction;
-            hr = threadPoolFactory->RunWithPriorityAndOptionsAsync(
-                workItem.Get(),
-                ABI::Windows::System::Threading::WorkItemPriority_Normal,
-                ABI::Windows::System::Threading::WorkItemOptions_TimeSliced,
-                &asyncAction);
-            return hr == S_OK;
-        }
-    }
-#endif
-
-    namespace
-    {
-        void run_thread_exit_callbacks()
-        {
-            detail::thread_data_ptr current_thread_data(detail::get_current_thread_data(),false);
-            if(current_thread_data)
-            {
-                while(! current_thread_data->tss_data.empty() || 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.empty())
-                    {
-                        std::map<void const*,detail::tss_data_node>::iterator current
-                            = current_thread_data->tss_data.begin();
-                        if(current->second.func && (current->second.value!=0))
-                        {
-                            (*current->second.caller)(current->second.func,current->second.value);
-                        }
-                        current_thread_data->tss_data.erase(current);
-                    }
-                }
-                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);
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            BOOST_TRY
-            {
-#endif
-                thread_info->run();
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            }
-            BOOST_CATCH(thread_interrupted const&)
-            {
-            }
-            // Unhandled exceptions still cause the application to terminate
-            BOOST_CATCH_END
-#endif
-            run_thread_exit_callbacks();
-            return 0;
-        }
-    }
-
-    thread::thread() BOOST_NOEXCEPT
-    {}
-
-    bool thread::start_thread_noexcept()
-    {
-#if BOOST_PLAT_WINDOWS_RUNTIME
-         intrusive_ptr_add_ref(thread_info.get());
-         if (!thread_info->thread_handle.start(&thread_start_function, thread_info.get(), &thread_info->id))
-         {
-             intrusive_ptr_release(thread_info.get());
-             return false;
-         }
-         return true;
-#else
-        uintptr_t const new_thread=_beginthreadex(0,0,&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);
-        if(!new_thread)
-        {
-            return false;
-        }
-        intrusive_ptr_add_ref(thread_info.get());
-        thread_info->thread_handle=(detail::win32::handle)(new_thread);
-        ResumeThread(thread_info->thread_handle);
-        return true;
-#endif
-    }
-
-    bool thread::start_thread_noexcept(const attributes& attr)
-    {
-#if BOOST_PLAT_WINDOWS_RUNTIME
-        // Stack size isn't supported with Windows Runtime.
-        attr;
-        return start_thread_noexcept();
-#else
-      uintptr_t const new_thread=_beginthreadex(0,static_cast<unsigned int>(attr.get_stack_size()),&thread_start_function,thread_info.get(),
-                                                CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION, &thread_info->id);
-      if(!new_thread)
-      {
-        return false;
-      }
-      intrusive_ptr_add_ref(thread_info.get());
-      thread_info->thread_handle=(detail::win32::handle)(new_thread);
-      ResumeThread(thread_info->thread_handle);
-      return true;
-#endif
-    }
-
-    thread::thread(detail::thread_data_ptr data):
-        thread_info(data)
-    {}
-
-    namespace
-    {
-        struct externally_launched_thread:
-            detail::thread_data_base
-        {
-            externally_launched_thread()
-            {
-                ++count;
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-                interruption_enabled=false;
-#endif
-            }
-            ~externally_launched_thread() {
-              BOOST_ASSERT(notify.empty());
-              notify.clear();
-//#ifndef BOOST_NO_EXCEPTIONS
-              BOOST_ASSERT(async_states_.empty());
-              async_states_.clear();
-//#endif
-            }
-
-            void run()
-            {}
-            void notify_all_at_thread_exit(condition_variable*, mutex*)
-            {}
-
-        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>();
-            BOOST_TRY
-            {
-                set_current_thread_data(me);
-            }
-            BOOST_CATCH(...)
-            {
-                detail::heap_delete(me);
-                BOOST_RETHROW
-            }
-            BOOST_CATCH_END
-        }
-
-        detail::thread_data_base* get_or_make_current_thread_data()
-        {
-            detail::thread_data_base* current_thread_data(detail::get_current_thread_data());
-            if(!current_thread_data)
-            {
-                make_external_thread_data();
-                current_thread_data=detail::get_current_thread_data();
-            }
-            return current_thread_data;
-        }
-    }
-
-    thread::id thread::get_id() const BOOST_NOEXCEPT
-    {
-#if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
-        detail::thread_data_ptr local_thread_info=(get_thread_info)();
-        if(!local_thread_info)
-        {
-            return 0;
-        }
-        return local_thread_info->id;
-#else
-        return thread::id((get_thread_info)());
-#endif
-    }
-
-    bool thread::joinable() const BOOST_NOEXCEPT
-    {
-        detail::thread_data_ptr local_thread_info = (get_thread_info)();
-        if(!local_thread_info)
-        {
-            return false;
-        }
-        return true;
-    }
-    bool thread::join_noexcept()
-    {
-        detail::thread_data_ptr local_thread_info=(get_thread_info)();
-        if(local_thread_info)
-        {
-            this_thread::interruptible_wait(this->native_handle(), detail::internal_platform_timepoint::getMax());
-            release_handle();
-            return true;
-        }
-        else
-        {
-          return false;
-        }
-    }
-
-    bool thread::do_try_join_until_noexcept(detail::internal_platform_timepoint const &timeout, bool& res)
-    {
-      detail::thread_data_ptr local_thread_info=(get_thread_info)();
-      if(local_thread_info)
-      {
-          if(!this_thread::interruptible_wait(this->native_handle(), timeout))
-          {
-            res=false;
-            return true;
-          }
-          release_handle();
-          res=true;
-          return true;
-      }
-      else
-      {
-        return false;
-      }
-    }
-
-    void thread::detach()
-    {
-        release_handle();
-    }
-
-    void thread::release_handle()
-    {
-        thread_info=0;
-    }
-
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-    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 BOOST_NOEXCEPT
-    {
-        detail::thread_data_ptr local_thread_info=(get_thread_info)();
-        return local_thread_info.get() && (winapi::WaitForSingleObjectEx(local_thread_info->interruption_handle,0,0)==0);
-    }
-
-#endif
-
-    unsigned thread::hardware_concurrency() BOOST_NOEXCEPT
-    {
-        detail::win32::system_info info;
-        detail::win32::get_system_info(&info);
-        return info.dwNumberOfProcessors;
-    }
-
-    unsigned thread::physical_concurrency() BOOST_NOEXCEPT
-    {
-      // a bit too strict: Windows XP with SP3 would be sufficient
-#if BOOST_PLAT_WINDOWS_RUNTIME                                    \
-    || ( BOOST_USE_WINAPI_VERSION <= BOOST_WINAPI_VERSION_WINXP ) \
-    || ( ( defined(__MINGW32__) && !defined(__MINGW64__) ) && _WIN32_WINNT < 0x0600)
-        return 0;
-#else
-        unsigned cores = 0;
-        DWORD size = 0;
-
-        GetLogicalProcessorInformation(NULL, &size);
-        if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
-            return 0;
-        const size_t Elements = size / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
-
-        std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(Elements);
-        if (GetLogicalProcessorInformation(&buffer.front(), &size) == FALSE)
-            return 0;
-
-
-        for (size_t i = 0; i < Elements; ++i) {
-            if (buffer[i].Relationship == RelationProcessorCore)
-                ++cores;
-        }
-        return cores;
-#endif
-    }
-
-    thread::native_handle_type thread::native_handle()
-    {
-        detail::thread_data_ptr local_thread_info=(get_thread_info)();
-        if(!local_thread_info)
-        {
-            return detail::win32::invalid_handle_value;
-        }
-#if BOOST_PLAT_WINDOWS_RUNTIME
-        // There is no 'real' Win32 handle so we return a handle that at least can be waited on.
-        return local_thread_info->thread_handle.waitable_handle();
-#else
-        return (detail::win32::handle)local_thread_info->thread_handle;
-#endif
-    }
-
-    detail::thread_data_ptr thread::get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    {
-        return thread_info;
-    }
-
-    namespace this_thread
-    {
-#ifndef UNDER_CE
-#if !BOOST_PLAT_WINDOWS_RUNTIME
-        namespace detail_
-        {
-            typedef struct _REASON_CONTEXT {
-                ULONG Version;
-                DWORD Flags;
-                union {
-                    LPWSTR SimpleReasonString;
-                    struct {
-                        HMODULE LocalizedReasonModule;
-                        ULONG   LocalizedReasonId;
-                        ULONG   ReasonStringCount;
-                        LPWSTR  *ReasonStrings;
-                    } Detailed;
-                } Reason;
-            } REASON_CONTEXT, *PREASON_CONTEXT;
-            typedef BOOL (WINAPI *setwaitabletimerex_t)(HANDLE, const LARGE_INTEGER *, LONG, PTIMERAPCROUTINE, LPVOID, PREASON_CONTEXT, ULONG);
-            static inline BOOL WINAPI SetWaitableTimerEx_emulation(HANDLE hTimer, const LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext, ULONG TolerableDelay)
-            {
-                return SetWaitableTimer(hTimer, lpDueTime, lPeriod, pfnCompletionRoutine, lpArgToCompletionRoutine, FALSE);
-            }
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 6387) // MSVC sanitiser warns that GetModuleHandleA() might fail
-#endif
-            static inline setwaitabletimerex_t SetWaitableTimerEx()
-            {
-                static setwaitabletimerex_t setwaitabletimerex_impl;
-                if(setwaitabletimerex_impl)
-                    return setwaitabletimerex_impl;
-                void (*addr)()=(void (*)()) GetProcAddress(
-#if !defined(BOOST_NO_ANSI_APIS)
-                    GetModuleHandleA("KERNEL32.DLL"),
-#else
-                    GetModuleHandleW(L"KERNEL32.DLL"),
-#endif
-                    "SetWaitableTimerEx");
-                if(addr)
-                    setwaitabletimerex_impl=(setwaitabletimerex_t) addr;
-                else
-                    setwaitabletimerex_impl=&SetWaitableTimerEx_emulation;
-                return setwaitabletimerex_impl;
-            }
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-        }
-#endif
-#endif
-        bool interruptible_wait(detail::win32::handle handle_to_wait_for, detail::internal_platform_timepoint const &timeout)
-        {
-            detail::win32::handle handles[4]={0};
-            unsigned handle_count=0;
-            unsigned wait_handle_index=~0U;
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            unsigned interruption_index=~0U;
-#endif
-            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 defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-            if(detail::get_current_thread_data() && detail::get_current_thread_data()->interruption_enabled)
-            {
-                interruption_index=handle_count;
-                handles[handle_count++]=detail::get_current_thread_data()->interruption_handle;
-            }
-#endif
-            detail::win32::handle_manager timer_handle;
-
-#ifndef UNDER_CE
-#if !BOOST_PLAT_WINDOWS_RUNTIME
-            // Preferentially use coalescing timers for better power consumption and timer accuracy
-            if(timeout != detail::internal_platform_timepoint::getMax())
-            {
-                boost::intmax_t const time_left_msec = (timeout - detail::internal_platform_clock::now()).getMs();
-                timer_handle=CreateWaitableTimer(NULL,false,NULL);
-                if(timer_handle!=0)
-                {
-                    ULONG tolerable=32; // Empirical testing shows Windows ignores this when <= 26
-                    if(time_left_msec/20>tolerable)  // 5%
-                        tolerable=static_cast<ULONG>(time_left_msec/20);
-                    LARGE_INTEGER due_time={{0,0}};
-                    if(time_left_msec>0)
-                    {
-                        due_time.QuadPart=-(time_left_msec*10000); // negative indicates relative time
-                    }
-                    bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,NULL,tolerable)!=0;
-                    if(set_time_succeeded)
-                    {
-                        timeout_index=handle_count;
-                        handles[handle_count++]=timer_handle;
-                    }
-                }
-            }
-#endif
-#endif
-
-            bool const using_timer=timeout_index!=~0u;
-            boost::intmax_t time_left_msec(INFINITE);
-            if(!using_timer && timeout != detail::internal_platform_timepoint::getMax())
-            {
-                time_left_msec = (timeout - detail::internal_platform_clock::now()).getMs();
-                if(time_left_msec < 0)
-                {
-                    time_left_msec = 0;
-                }
-            }
-
-            do
-            {
-                if(handle_count)
-                {
-                    unsigned long const notified_index=winapi::WaitForMultipleObjectsEx(handle_count,handles,false,static_cast<DWORD>(time_left_msec), 0);
-                    if(notified_index<handle_count)
-                    {
-                        if(notified_index==wait_handle_index)
-                        {
-                            return true;
-                        }
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-                        else if(notified_index==interruption_index)
-                        {
-                            winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
-                            throw thread_interrupted();
-                        }
-#endif
-                        else if(notified_index==timeout_index)
-                        {
-                            return false;
-                        }
-                    }
-                }
-                else
-                {
-                    detail::win32::sleep(static_cast<unsigned long>(time_left_msec));
-                }
-
-                if(!using_timer && timeout != detail::internal_platform_timepoint::getMax())
-                {
-                    time_left_msec = (timeout - detail::internal_platform_clock::now()).getMs();
-                }
-            }
-            while(time_left_msec == INFINITE || time_left_msec > 0);
-            return false;
-        }
-
-        namespace no_interruption_point
-        {
-        bool non_interruptible_wait(detail::win32::handle handle_to_wait_for, detail::internal_platform_timepoint const &timeout)
-        {
-            detail::win32::handle handles[3]={0};
-            unsigned handle_count=0;
-            unsigned wait_handle_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;
-            }
-            detail::win32::handle_manager timer_handle;
-
-#ifndef UNDER_CE
-#if !BOOST_PLAT_WINDOWS_RUNTIME
-            // Preferentially use coalescing timers for better power consumption and timer accuracy
-            if(timeout != detail::internal_platform_timepoint::getMax())
-            {
-                boost::intmax_t const time_left_msec = (timeout - detail::internal_platform_clock::now()).getMs();
-                timer_handle=CreateWaitableTimer(NULL,false,NULL);
-                if(timer_handle!=0)
-                {
-                    ULONG tolerable=32; // Empirical testing shows Windows ignores this when <= 26
-                    if(time_left_msec/20>tolerable)  // 5%
-                        tolerable=static_cast<ULONG>(time_left_msec/20);
-                    LARGE_INTEGER due_time={{0,0}};
-                    if(time_left_msec>0)
-                    {
-                        due_time.QuadPart=-(time_left_msec*10000); // negative indicates relative time
-                    }
-                    bool const set_time_succeeded=detail_::SetWaitableTimerEx()(timer_handle,&due_time,0,0,0,NULL,tolerable)!=0;
-                    if(set_time_succeeded)
-                    {
-                        timeout_index=handle_count;
-                        handles[handle_count++]=timer_handle;
-                    }
-                }
-            }
-#endif
-#endif
-
-            bool const using_timer=timeout_index!=~0u;
-            boost::intmax_t time_left_msec(INFINITE);
-            if(!using_timer && timeout != detail::internal_platform_timepoint::getMax())
-            {
-                time_left_msec = (timeout - detail::internal_platform_clock::now()).getMs();
-                if(time_left_msec < 0)
-                {
-                    time_left_msec = 0;
-                }
-            }
-
-            do
-            {
-                if(handle_count)
-                {
-                    unsigned long const notified_index=winapi::WaitForMultipleObjectsEx(handle_count,handles,false,static_cast<DWORD>(time_left_msec), 0);
-                    if(notified_index<handle_count)
-                    {
-                        if(notified_index==wait_handle_index)
-                        {
-                            return true;
-                        }
-                        else if(notified_index==timeout_index)
-                        {
-                            return false;
-                        }
-                    }
-                }
-                else
-                {
-                    detail::win32::sleep(static_cast<unsigned long>(time_left_msec));
-                }
-
-                if(!using_timer && timeout != detail::internal_platform_timepoint::getMax())
-                {
-                    time_left_msec = (timeout - detail::internal_platform_clock::now()).getMs();
-                }
-            }
-            while(time_left_msec == INFINITE || time_left_msec > 0);
-            return false;
-        }
-        }
-
-        thread::id get_id() BOOST_NOEXCEPT
-        {
-#if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
-#if BOOST_PLAT_WINDOWS_RUNTIME
-            detail::thread_data_base* current_thread_data(detail::get_current_thread_data());
-            if (current_thread_data)
-            {
-                return current_thread_data->id;
-            }
-#endif
-            return winapi::GetCurrentThreadId();
-#else
-            return thread::id(get_or_make_current_thread_data());
-#endif
-        }
-
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-        void interruption_point()
-        {
-            if(interruption_enabled() && interruption_requested())
-            {
-                winapi::ResetEvent(detail::get_current_thread_data()->interruption_handle);
-                throw thread_interrupted();
-            }
-        }
-
-        bool interruption_enabled() BOOST_NOEXCEPT
-        {
-            return detail::get_current_thread_data() && detail::get_current_thread_data()->interruption_enabled;
-        }
-
-        bool interruption_requested() BOOST_NOEXCEPT
-        {
-            return detail::get_current_thread_data() && (winapi::WaitForSingleObjectEx(detail::get_current_thread_data()->interruption_handle,0,0)==0);
-        }
-#endif
-
-        void yield() BOOST_NOEXCEPT
-        {
-            detail::win32::sleep(0);
-        }
-
-#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
-        disable_interruption::disable_interruption() BOOST_NOEXCEPT:
-            interruption_was_enabled(interruption_enabled())
-        {
-            if(interruption_was_enabled)
-            {
-                detail::get_current_thread_data()->interruption_enabled=false;
-            }
-        }
-
-        disable_interruption::~disable_interruption() BOOST_NOEXCEPT
-        {
-            if(detail::get_current_thread_data())
-            {
-                detail::get_current_thread_data()->interruption_enabled=interruption_was_enabled;
-            }
-        }
-
-        restore_interruption::restore_interruption(disable_interruption& d) BOOST_NOEXCEPT
-        {
-            if(d.interruption_was_enabled)
-            {
-                detail::get_current_thread_data()->interruption_enabled=true;
-            }
-        }
-
-        restore_interruption::~restore_interruption() BOOST_NOEXCEPT
-        {
-            if(detail::get_current_thread_data())
-            {
-                detail::get_current_thread_data()->interruption_enabled=false;
-            }
-        }
-#endif
-    }
-
-    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)
-            {
-                std::map<void const*,tss_data_node>::iterator current_node=
-                    current_thread_data->tss_data.find(key);
-                if(current_node!=current_thread_data->tss_data.end())
-                {
-                    return &current_node->second;
-                }
-            }
-            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 add_new_tss_node(void const* key,
-                              detail::tss_data_node::cleanup_caller_t caller,
-                              detail::tss_data_node::cleanup_func_t func,
-                              void* tss_data)
-        {
-            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.insert(std::make_pair(key,tss_data_node(caller,func,tss_data)));
-        }
-
-        void erase_tss_node(void const* key)
-        {
-            detail::thread_data_base* const current_thread_data(get_or_make_current_thread_data());
-            current_thread_data->tss_data.erase(key);
-        }
-
-        void set_tss_data(void const* key,
-                          detail::tss_data_node::cleanup_caller_t caller,
-                          detail::tss_data_node::cleanup_func_t func,
-                          void* tss_data,bool cleanup_existing)
-        {
-            if(tss_data_node* const current_node=find_tss_data(key))
-            {
-                if(cleanup_existing && current_node->func && (current_node->value!=0))
-                {
-                    (*current_node->caller)(current_node->func,current_node->value);
-                }
-                if(func || (tss_data!=0))
-                {
-                    current_node->caller=caller;
-                    current_node->func=func;
-                    current_node->value=tss_data;
-                }
-                else
-                {
-                    erase_tss_node(key);
-                }
-            }
-            else if(func || (tss_data!=0))
-            {
-                add_new_tss_node(key,caller,func,tss_data);
-            }
-        }
-    }
-
-    BOOST_THREAD_DECL void __cdecl on_process_enter()
-    {}
-
-    BOOST_THREAD_DECL void __cdecl on_thread_enter()
-    {}
-
-    BOOST_THREAD_DECL void __cdecl on_process_exit()
-    {
-        boost::cleanup_tls_key();
-    }
-
-    BOOST_THREAD_DECL void __cdecl on_thread_exit()
-    {
-        boost::run_thread_exit_callbacks();
-    }
-
-    BOOST_THREAD_DECL void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
-    {
-      detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
-      if(current_thread_data)
-      {
-        current_thread_data->notify_all_at_thread_exit(&cond, lk.release());
-      }
-    }
-}
-
diff --git a/bundled/boost-1.70.0/libs/thread/src/win32/tss_dll.cpp b/bundled/boost-1.70.0/libs/thread/src/win32/tss_dll.cpp
deleted file mode 100644 (file)
index caddabf..0000000
+++ /dev/null
@@ -1,85 +0,0 @@
-// (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/winapi/config.hpp>
-#include <boost/thread/detail/config.hpp>
-
-
-#if defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_DLL)
-
-    #include <boost/thread/detail/tss_hooks.hpp>
-
-    #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:
-            {
-                boost::on_process_enter();
-                boost::on_thread_enter();
-                break;
-            }
-
-            case DLL_THREAD_ATTACH:
-            {
-                boost::on_thread_enter();
-                break;
-            }
-
-            case DLL_THREAD_DETACH:
-            {
-                boost::on_thread_exit();
-                break;
-            }
-
-            case DLL_PROCESS_DETACH:
-            {
-                boost::on_thread_exit();
-                boost::on_process_exit();
-                break;
-            }
-        }
-
-        return TRUE;
-    }
-
-namespace boost
-{
-    void tss_cleanup_implemented()
-    {
-        /*
-        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.
-        */
-    }
-}
-
-#else //defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_DLL)
-
-#ifdef _MSC_VER
-// Prevent LNK4221 warning with link=static
-namespace boost { namespace link_static_warning_inhibit {
-    extern __declspec(dllexport) void foo() { }
-} }
-#endif
-
-#endif //defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_DLL)
diff --git a/bundled/boost-1.70.0/libs/thread/src/win32/tss_pe.cpp b/bundled/boost-1.70.0/libs/thread/src/win32/tss_pe.cpp
deleted file mode 100644 (file)
index e7fafea..0000000
+++ /dev/null
@@ -1,337 +0,0 @@
-// $Id$
-// (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/winapi/config.hpp>
-#include <boost/thread/detail/config.hpp>
-
-#if defined(BOOST_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_LIB)
-
-#if (defined(__MINGW32__) && !defined(_WIN64)) || defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR)
-
-#include <boost/thread/detail/tss_hooks.hpp>
-
-#include <windows.h>
-
-#include <cstdlib>
-
-namespace boost
-{
-    void tss_cleanup_implemented() {}
-}
-
-namespace {
-    void NTAPI on_tls_callback(void* , DWORD dwReason, PVOID )
-    {
-        switch (dwReason)
-        {
-        case DLL_THREAD_DETACH:
-        {
-            boost::on_thread_exit();
-            break;
-        }
-        }
-    }
-}
-
-#if defined(__MINGW64__) || (__MINGW64_VERSION_MAJOR) || (__MINGW32__) || (__MINGW32_MAJOR_VERSION >3) ||   \
-    ((__MINGW32_MAJOR_VERSION==3) && (__MINGW32_MINOR_VERSION>=18))
-extern "C"
-{
-    PIMAGE_TLS_CALLBACK __crt_xl_tls_callback__ __attribute__ ((section(".CRT$XLB"))) = on_tls_callback;
-}
-#else
-extern "C" {
-
-    void (* after_ctors )() __attribute__((section(".ctors")))     = boost::on_process_enter;
-    void (* before_dtors)() __attribute__((section(".dtors")))     = boost::on_thread_exit;
-    void (* after_dtors )() __attribute__((section(".dtors.zzz"))) = boost::on_process_exit;
-
-    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_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
-};
-#endif
-
-
-#elif  defined(_MSC_VER) && !defined(UNDER_CE)
-
-    #include <boost/thread/detail/tss_hooks.hpp>
-
-    #include <stdlib.h>
-
-    #include <windows.h>
-
-
-// _pRawDllMainOrig can be defined by including boost/thread/win32/mfc_thread_init.hpp
-// into your dll; it ensures that MFC-Dll-initialization will be done properly
-// The following code is adapted from the MFC-Dll-init code
-/*
- * _pRawDllMainOrig MUST be an extern const variable, which will be aliased to
- * _pDefaultRawDllMainOrig if no real user definition is present, thanks to the
- * alternatename directive.
- */
-
-// work at least with _MSC_VER 1500 (MSVC++ 9.0, VS 2008)
-#if (_MSC_VER >= 1500)
-
-extern "C" {
-extern BOOL (WINAPI * const _pRawDllMainOrig)(HINSTANCE, DWORD, LPVOID);
-extern BOOL (WINAPI * const _pDefaultRawDllMainOrig)(HINSTANCE, DWORD, LPVOID) = NULL;
-#if defined (_M_IX86)
-#pragma comment(linker, "/alternatename:__pRawDllMainOrig=__pDefaultRawDllMainOrig")
-#elif defined (_M_X64) || defined (_M_ARM)
-#pragma comment(linker, "/alternatename:_pRawDllMainOrig=_pDefaultRawDllMainOrig")
-#else  /* defined (_M_X64) || defined (_M_ARM) */
-#error Unsupported platform
-#endif  /* defined (_M_X64) || defined (_M_ARM) */
-}
-
-#endif
-
-
-
-
-    //Definitions required by implementation
-    #if (_MSC_VER < 1300) || ((_MSC_VER > 1900) && (_MSC_VER < 1910)) // 1300 == VC++ 7.0, 1900 == VC++ 14.0, 1910 == VC++ 2017
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef void ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I void __cdecl
-    #elif (_MSC_VER >= 1910)
-        typedef void ( __cdecl *_PVFV_ )();
-        typedef int ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V
-        #define INIRETSUCCESS_I 0
-        #define PVAPI_V void __cdecl
-        #define PVAPI_I int __cdecl
-    #else
-        typedef int ( __cdecl *_PVFV_ )();
-        typedef int ( __cdecl *_PIFV_ )();
-        #define INIRETSUCCESS_V 0
-        #define INIRETSUCCESS_I 0
-        #define PVAPI_V int __cdecl
-        #define PVAPI_I int __cdecl
-    #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_I on_tls_prepare();
-        static PVAPI_V on_process_init();
-        static PVAPI_V on_process_term();
-        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"))_PIFV_ 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 _PIFV_ 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_I on_tls_prepare()
-        {
-            //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_I;
-        }
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-        PVAPI_V on_process_init()
-        {
-            //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(boost::on_thread_exit);
-
-            //Call Boost process entry callback here
-
-            boost::on_process_enter();
-
-            return INIRETSUCCESS_V;
-        }
-
-        PVAPI_V on_process_term()
-        {
-            boost::on_process_exit();
-            return INIRETSUCCESS_V;
-        }
-
-        void NTAPI on_tls_callback(HINSTANCE /*h*/, DWORD dwReason, PVOID /*pv*/)
-        {
-            switch (dwReason)
-            {
-            case DLL_THREAD_DETACH:
-                boost::on_thread_exit();
-                break;
-            }
-        }
-
-#if (_MSC_VER >= 1500)
-        BOOL WINAPI dll_callback(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
-#else
-        BOOL WINAPI dll_callback(HINSTANCE, DWORD dwReason, LPVOID)
-#endif
-        {
-            switch (dwReason)
-            {
-            case DLL_THREAD_DETACH:
-                boost::on_thread_exit();
-                break;
-            case DLL_PROCESS_DETACH:
-                boost::on_process_exit();
-                break;
-            }
-
-#if (_MSC_VER >= 1500)
-            if( _pRawDllMainOrig )
-            {
-                return _pRawDllMainOrig(hInstance, dwReason, lpReserved);
-            }
-#endif
-            return true;
-        }
-    } //namespace
-
-extern "C"
-{
-    extern BOOL (WINAPI * const _pRawDllMain)(HINSTANCE, DWORD, LPVOID)=&dll_callback;
-}
-namespace boost
-{
-    void tss_cleanup_implemented()
-    {
-        /*
-        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_THREAD_WIN32) && defined(BOOST_THREAD_BUILD_LIB)

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.