add boost on mac

macx64/include/boost/pool/detail/guard.hpp

@@ -0,0 +1,69 @@
+// Copyright (C) 2000 Stephen Cleary
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POOL_GUARD_HPP
+#define BOOST_POOL_GUARD_HPP
+
+/*!
+  \file
+  \brief Extremely Light-Weight guard class.
+  \details Auto-lock/unlock-er
+  detail/guard.hpp provides a type guard<Mutex>
+  that allows scoped access to the Mutex's locking and unlocking operations.
+  It is used to ensure that a Mutex is unlocked, even if an exception is thrown.
+*/
+
+namespace boost {
+
+namespace details {
+namespace pool {
+
+template <typename Mutex> //!< \tparam Mutex (platform-specific) mutex class.
+class guard
+{ //! Locks the mutex, binding guard<Mutex> to Mutex.
+	/*! Example:
+	Given a (platform-specific) mutex class, we can wrap code as follows:
+
+	extern mutex global_lock;
+
+	static void f()
+	{
+		boost::details::pool::guard<mutex> g(global_lock);
+		// g's constructor locks "global_lock"
+
+		... // do anything:
+				//   throw exceptions
+				//   return
+				//   or just fall through
+	} // g's destructor unlocks "global_lock"
+	*/
+  private:
+    Mutex & mtx;
+
+    guard(const guard &); //!< Guards the mutex, ensuring unlocked on destruction, even if exception is thrown.
+    void operator=(const guard &);
+
+  public:
+    explicit guard(Mutex & nmtx)
+    :mtx(nmtx)
+    { //! Locks the mutex of the guard class.
+			mtx.lock();
+		}
+
+    ~guard()
+    { //! destructor unlocks the mutex of the guard class.
+			mtx.unlock();
+		}
+}; // class guard
+
+} // namespace pool
+} // namespace details
+
+} // namespace boost
+
+#endif

macx64/include/boost/pool/detail/mutex.hpp

@@ -0,0 +1,144 @@
+// Copyright (C) 2000 Stephen Cleary
+// Copyright (C) 2018 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_POOL_MUTEX_HPP
+#define BOOST_POOL_MUTEX_HPP
+
+#include <boost/config.hpp>
+
+namespace boost{ namespace details{ namespace pool{
+
+class null_mutex
+{
+private:
+
+    null_mutex(const null_mutex &);
+    void operator=(const null_mutex &);
+
+public:
+
+    null_mutex() {}
+
+    static void lock() {}
+    static void unlock() {}
+};
+
+}}} // namespace boost::details::pool
+
+#if !defined(BOOST_HAS_THREADS) || defined(BOOST_NO_MT) || defined(BOOST_POOL_NO_MT)
+
+namespace boost{ namespace details{ namespace pool{
+
+typedef null_mutex default_mutex;
+
+}}} // namespace boost::details::pool
+
+#elif !defined(BOOST_NO_CXX11_HDR_MUTEX)
+
+#include <mutex>
+
+namespace boost{ namespace details{ namespace pool{
+
+typedef std::mutex default_mutex;
+
+}}} // namespace boost::details::pool
+
+#elif defined(BOOST_HAS_PTHREADS)
+
+#include <boost/assert.hpp>
+#include <pthread.h>
+
+namespace boost{ namespace details{ namespace pool{
+
+class pt_mutex
+{
+private:
+
+    pthread_mutex_t m_;
+
+    pt_mutex(pt_mutex const &);
+    pt_mutex & operator=(pt_mutex const &);
+
+public:
+
+    pt_mutex()
+    {
+        BOOST_VERIFY( pthread_mutex_init( &m_, 0 ) == 0 );
+    }
+
+    ~pt_mutex()
+    {
+        BOOST_VERIFY( pthread_mutex_destroy( &m_ ) == 0 );
+    }
+
+    void lock()
+    {
+        BOOST_VERIFY( pthread_mutex_lock( &m_ ) == 0 );
+    }
+
+    void unlock()
+    {
+        BOOST_VERIFY( pthread_mutex_unlock( &m_ ) == 0 );
+    }
+};
+
+typedef pt_mutex default_mutex;
+
+}}} // namespace boost::details::pool
+
+#elif defined(BOOST_HAS_WINTHREADS) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+
+#include <boost/winapi/critical_section.hpp>
+
+namespace boost{ namespace details{ namespace pool{
+
+class cs_mutex
+{
+private:
+
+    boost::winapi::CRITICAL_SECTION_ cs_;
+
+    cs_mutex(cs_mutex const &);
+    cs_mutex & operator=(cs_mutex const &);
+
+public:
+
+    cs_mutex()
+    {
+        boost::winapi::InitializeCriticalSection( &cs_ );
+    }
+
+    ~cs_mutex()
+    {
+        boost::winapi::DeleteCriticalSection( &cs_ );
+    }
+
+    void lock()
+    {
+        boost::winapi::EnterCriticalSection( &cs_ );
+    }
+
+    void unlock()
+    {
+        boost::winapi::LeaveCriticalSection( &cs_ );
+    }
+};
+
+typedef cs_mutex default_mutex;
+
+}}} // namespace boost::details::pool
+
+#else
+
+// Use #define BOOST_DISABLE_THREADS to avoid this error
+#  error Unrecognized threading platform
+
+#endif
+
+#endif // #ifndef BOOST_POOL_MUTEX_HPP

macx64/include/boost/pool/detail/pool_construct.ipp

@@ -0,0 +1,852 @@
+// Copyright (C) 2000 Stephen Cleary
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompany-
+// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org for updates, documentation, and revision history.
+
+// This file was AUTOMATICALLY GENERATED from "stdin"
+//  Do NOT include directly!
+//  Do NOT edit!
+
+template <typename T0>
+element_type * construct(T0 & a0)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0>
+element_type * construct(const T0 & a0)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0>
+element_type * construct(volatile T0 & a0)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0>
+element_type * construct(const volatile T0 & a0)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(T0 & a0, T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const T0 & a0, T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(volatile T0 & a0, T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const volatile T0 & a0, T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(T0 & a0, const T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const T0 & a0, const T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(volatile T0 & a0, const T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const volatile T0 & a0, const T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(T0 & a0, volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const T0 & a0, volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(volatile T0 & a0, volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const volatile T0 & a0, volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(T0 & a0, const volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const T0 & a0, const volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(volatile T0 & a0, const volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const volatile T0 & a0, const volatile T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const volatile T1 & a1, T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+

macx64/include/boost/pool/detail/pool_construct_simple.ipp

@@ -0,0 +1,43 @@
+// Copyright (C) 2000 Stephen Cleary
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org for updates, documentation, and revision history.
+
+// This file was AUTOMATICALLY GENERATED from "stdin"
+//  Do NOT include directly!
+//  Do NOT edit!
+
+template <typename T0>
+element_type * construct(const T0 & a0)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1>
+element_type * construct(const T0 & a0, const T1 & a1)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+template <typename T0, typename T1, typename T2>
+element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2)
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(a0, a1, a2); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+