stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

depends/x86_64-pc-linux-gnu/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

depends/x86_64-pc-linux-gnu/include/boost/pool/detail/mutex.hpp

@@ -0,0 +1,50 @@
+// 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_MUTEX_HPP
+#define BOOST_POOL_MUTEX_HPP
+
+#include <boost/config.hpp>  // for workarounds                                                                        
+#if defined (BOOST_HAS_THREADS) && !defined(BOOST_POOL_NO_MT)                                                          
+#if defined (BOOST_NO_CXX11_HDR_MUTEX)                                                                                 
+#include <boost/thread/mutex.hpp>                                                                                      
+#else                                                                                                                  
+#include <mutex>                                                                                                       
+#endif                                                                                                                 
+#endif
+
+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() { }
+};
+
+#if !defined(BOOST_HAS_THREADS) || defined(BOOST_NO_MT) || defined(BOOST_POOL_NO_MT)                                   
+  typedef null_mutex default_mutex;                                                                                    
+#else                                                                                                                  
+#if defined (BOOST_NO_CXX11_HDR_MUTEX)                                                                                 
+  typedef boost::mutex default_mutex;                                                                                  
+#else                                                                                                                  
+  typedef std::mutex default_mutex;                                                                                    
+#endif                                                                                                                 
+#endif
+
+} // namespace pool
+} // namespace details
+} // namespace boost
+
+#endif

depends/x86_64-pc-linux-gnu/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;
+}
+

depends/x86_64-pc-linux-gnu/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;
+}
+