passenger 5.1.12 → 5.2.0

data/src/cxx_supportlib/vendor-modified/boost/integer/integer_log2.hpp

@@ -0,0 +1,112 @@
+// -----------------------------------------------------------
+// integer_log2.hpp
+//
+//   Gives the integer part of the logarithm, in base 2, of a
+// given number. Behavior is undefined if the argument is <= 0.
+//
+//         Copyright (c) 2003-2004, 2008 Gennaro Prota
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// -----------------------------------------------------------
+
+#ifndef BOOST_INTEGER_INTEGER_LOG2_HPP
+#define BOOST_INTEGER_INTEGER_LOG2_HPP
+
+#include <assert.h>
+#ifdef __BORLANDC__
+#include <climits>
+#endif
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
+
+
+namespace boost {
+ namespace detail {
+
+  template <typename T>
+  int integer_log2_impl(T x, int n) {
+
+      int result = 0;
+
+      while (x != 1) {
+
+          const T t = static_cast<T>(x >> n);
+          if (t) {
+              result += n;
+              x = t;
+          }
+          n /= 2;
+
+      }
+
+      return result;
+  }
+
+
+
+  // helper to find the maximum power of two
+  // less than p (more involved than necessary,
+  // to avoid PTS)
+  //
+  template <int p, int n>
+  struct max_pow2_less {
+
+      enum { c = 2*n < p };
+
+      BOOST_STATIC_CONSTANT(int, value =
+          c ? (max_pow2_less< c*p, 2*c*n>::value) : n);
+
+  };
+
+  template <>
+  struct max_pow2_less<0, 0> {
+
+      BOOST_STATIC_CONSTANT(int, value = 0);
+  };
+
+  // this template is here just for Borland :(
+  // we could simply rely on numeric_limits but sometimes
+  // Borland tries to use numeric_limits<const T>, because
+  // of its usual const-related problems in argument deduction
+  // - gps
+  template <typename T>
+  struct width {
+
+#ifdef __BORLANDC__
+      BOOST_STATIC_CONSTANT(int, value = sizeof(T) * CHAR_BIT);
+#else
+      BOOST_STATIC_CONSTANT(int, value = (std::numeric_limits<T>::digits));
+#endif
+
+  };
+
+ } // detail
+
+
+ // ---------
+ // integer_log2
+ // ---------------
+ //
+ template <typename T>
+ int integer_log2(T x) {
+
+     assert(x > 0);
+
+     const int n = detail::max_pow2_less<
+                     detail::width<T> :: value, 4
+                   > :: value;
+
+     return detail::integer_log2_impl(x, n);
+
+ }
+
+
+
+}
+
+
+
+#endif // include guard

data/src/cxx_supportlib/vendor-modified/boost/integer/integer_mask.hpp

@@ -0,0 +1,126 @@
+//  Boost integer/integer_mask.hpp header file  ------------------------------//
+
+//  (C) Copyright Daryle Walker 2001.
+//  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_INTEGER_INTEGER_MASK_HPP
+#define BOOST_INTEGER_INTEGER_MASK_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+#include <boost/config.hpp>   // for BOOST_STATIC_CONSTANT
+#include <boost/integer.hpp>  // for boost::uint_t
+
+#include <climits>  // for UCHAR_MAX, etc.
+#include <cstddef>  // for std::size_t
+
+#include <boost/limits.hpp>  // for std::numeric_limits
+
+//
+// We simply cannot include this header on gcc without getting copious warnings of the kind:
+//
+// boost/integer/integer_mask.hpp:93:35: warning: use of C99 long long integer constant
+//
+// And yet there is no other reasonable implementation, so we declare this a system header
+// to suppress these warnings.
+//
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#pragma GCC system_header
+#endif
+
+namespace boost
+{
+
+
+//  Specified single-bit mask class declaration  -----------------------------//
+//  (Lowest bit starts counting at 0.)
+
+template < std::size_t Bit >
+struct high_bit_mask_t
+{
+    typedef typename uint_t<(Bit + 1)>::least  least;
+    typedef typename uint_t<(Bit + 1)>::fast   fast;
+
+    BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << Bit) );
+    BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << Bit) );
+
+    BOOST_STATIC_CONSTANT( std::size_t, bit_position = Bit );
+
+};  // boost::high_bit_mask_t
+
+
+//  Specified bit-block mask class declaration  ------------------------------//
+//  Makes masks for the lowest N bits
+//  (Specializations are needed when N fills up a type.)
+
+template < std::size_t Bits >
+struct low_bits_mask_t
+{
+    typedef typename uint_t<Bits>::least  least;
+    typedef typename uint_t<Bits>::fast   fast;
+
+    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
+
+    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
+
+};  // boost::low_bits_mask_t
+
+
+#define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
+  template <  >  struct low_bits_mask_t< std::numeric_limits<Type>::digits >  { \
+      typedef std::numeric_limits<Type>           limits_type;                  \
+      typedef uint_t<limits_type::digits>::least  least;                        \
+      typedef uint_t<limits_type::digits>::fast   fast;                         \
+      BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );              \
+      BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );            \
+      BOOST_STATIC_CONSTANT( std::size_t, bit_count = limits_type::digits );    \
+  }
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4245)  // 'initializing' : conversion from 'int' to 'const boost::low_bits_mask_t<8>::least', signed/unsigned mismatch
+#endif
+
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned char );
+
+#if USHRT_MAX > UCHAR_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned short );
+#endif
+
+#if UINT_MAX > USHRT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned int );
+#endif
+
+#if ULONG_MAX > UINT_MAX
+BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned long );
+#endif
+
+#if defined(BOOST_HAS_LONG_LONG)
+    #if ((defined(ULLONG_MAX) && (ULLONG_MAX > ULONG_MAX)) ||\
+        (defined(ULONG_LONG_MAX) && (ULONG_LONG_MAX > ULONG_MAX)) ||\
+        (defined(ULONGLONG_MAX) && (ULONGLONG_MAX > ULONG_MAX)) ||\
+        (defined(_ULLONG_MAX) && (_ULLONG_MAX > ULONG_MAX)))
+    BOOST_LOW_BITS_MASK_SPECIALIZE( boost::ulong_long_type );
+    #endif
+#elif defined(BOOST_HAS_MS_INT64)
+    #if 18446744073709551615ui64 > ULONG_MAX
+    BOOST_LOW_BITS_MASK_SPECIALIZE( unsigned __int64 );
+    #endif
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#undef BOOST_LOW_BITS_MASK_SPECIALIZE
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_INTEGER_MASK_HPP

data/src/cxx_supportlib/vendor-modified/boost/integer/static_min_max.hpp

@@ -0,0 +1,51 @@
+//  Boost integer/static_min_max.hpp header file  ----------------------------//
+
+//  (C) Copyright Daryle Walker 2001.
+//  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_INTEGER_STATIC_MIN_MAX_HPP
+#define BOOST_INTEGER_STATIC_MIN_MAX_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+
+namespace boost
+{
+
+//  Compile-time extrema class declarations  ---------------------------------//
+//  Get the minimum or maximum of two values, signed or unsigned.
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+struct static_signed_min
+{
+    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 > Value2) ? Value2 : Value1 );
+};
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+struct static_signed_max
+{
+    BOOST_STATIC_CONSTANT(static_min_max_signed_type, value = (Value1 < Value2) ? Value2 : Value1 );
+};
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+struct static_unsigned_min
+{
+    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
+     = (Value1 > Value2) ? Value2 : Value1 );
+};
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+struct static_unsigned_max
+{
+    BOOST_STATIC_CONSTANT(static_min_max_unsigned_type, value
+     = (Value1 < Value2) ? Value2 : Value1 );
+};
+
+
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_STATIC_MIN_MAX_HPP

data/src/cxx_supportlib/vendor-modified/boost/libs/chrono/src/chrono.cpp

@@ -0,0 +1,15 @@
+//  chrono.cpp  --------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2008
+//  Copyright Vicente J. Botet Escriba 2009-2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+// define BOOST_CHRONO_SOURCE so that <boost/filesystem/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+
+#define BOOST_CHRONO_SOURCE
+
+#include <boost/chrono/detail/inlined/chrono.hpp>
+

data/src/cxx_supportlib/vendor-modified/boost/libs/chrono/src/process_cpu_clocks.cpp

@@ -0,0 +1,18 @@
+//  boost process_cpu_clocks.cpp  -----------------------------------------------------------//
+
+//  Copyright 2009-2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+// define BOOST_CHRONO_SOURCE so that <boost/chrono/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+
+#define BOOST_CHRONO_SOURCE
+
+#include <boost/chrono/detail/inlined/process_cpu_clocks.hpp>
+

data/src/cxx_supportlib/vendor-modified/boost/libs/chrono/src/thread_clock.cpp

@@ -0,0 +1,19 @@
+//  boost thread_clock.cpp  -----------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/chrono for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+
+// define BOOST_CHRONO_SOURCE so that <boost/chrono/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+
+#define BOOST_CHRONO_SOURCE
+
+#include <boost/chrono/detail/inlined/thread_clock.hpp>
+

data/src/cxx_supportlib/vendor-modified/boost/libs/random/src/random_device.cpp

@@ -0,0 +1,250 @@
+/* boost random_device.cpp implementation
+ *
+ * Copyright Jens Maurer 2000
+ * Copyright Steven Watanabe 2010-2011
+ * 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)
+ *
+ * $Id$
+ *
+ */
+
+#define BOOST_RANDOM_SOURCE
+
+#include <boost/random/random_device.hpp>
+#include <boost/config.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/system/error_code.hpp>
+#include <string>
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+//  A definition is required even for integral static constants
+const bool boost::random::random_device::has_fixed_range;
+#endif
+
+// WinRT target.
+#if !defined(BOOST_RANDOM_WINDOWS_RUNTIME)
+# if defined(__cplusplus_winrt)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#   define BOOST_RANDOM_WINDOWS_RUNTIME 1
+#  endif
+# endif
+#endif
+
+#if defined(BOOST_WINDOWS)
+
+#if !defined(BOOST_RANDOM_WINDOWS_RUNTIME)
+#include <windows.h>
+#include <wincrypt.h>
+#include <stdexcept>  // std::invalid_argument
+#else
+using namespace Platform;
+using namespace Windows::Security::Cryptography;
+#endif
+
+#define BOOST_AUTO_LINK_NOMANGLE
+#define BOOST_LIB_NAME "Advapi32"
+#include <boost/config/auto_link.hpp>
+
+#ifdef __MINGW32__
+
+extern "C" {
+
+// mingw's wincrypt.h appears to be missing some things
+WINADVAPI
+BOOL
+WINAPI
+CryptEnumProvidersA(
+    DWORD dwIndex,
+    DWORD *pdwReserved,
+    DWORD dwFlags,
+    DWORD *pdwProvType,
+    LPSTR szProvName,
+    DWORD *pcbProvName
+    );
+
+}
+
+#endif
+
+namespace {
+#if !defined(BOOST_RANDOM_WINDOWS_RUNTIME)
+const char * const default_token = MS_DEF_PROV_A;
+#else
+const char * const default_token = "";
+#endif
+}
+
+class boost::random::random_device::impl
+{
+public:
+  impl(const std::string & token) : provider(token) {
+#if !defined(BOOST_RANDOM_WINDOWS_RUNTIME)
+    char buffer[80];
+    DWORD type;
+    DWORD len;
+
+    // Find the type of a specific provider
+    for(DWORD i = 0; ; ++i) {
+      len = sizeof(buffer);
+      if(!CryptEnumProvidersA(i, NULL, 0, &type, buffer, &len)) {
+        if (GetLastError() == ERROR_NO_MORE_ITEMS) break;
+        continue;
+      }
+      if(buffer == provider) {
+        break;
+      }
+    }
+
+    if(!CryptAcquireContextA(&hProv, NULL, provider.c_str(), type,
+        CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
+      error("Could not acquire CSP context");
+    }
+#endif
+  }
+
+#if !defined(BOOST_RANDOM_WINDOWS_RUNTIME)
+  ~impl() {
+    if(!CryptReleaseContext(hProv, 0)) error("Could not release CSP context");
+  }
+#endif
+
+  unsigned int next() {
+    unsigned int result;
+
+#if !defined(BOOST_RANDOM_WINDOWS_RUNTIME)
+    if(!CryptGenRandom(hProv, sizeof(result),
+        static_cast<BYTE*>(static_cast<void*>(&result)))) {
+      error("error while reading");
+    }
+#else
+    auto buffer = CryptographicBuffer::GenerateRandom(sizeof(result));
+    auto data = ref new Array<unsigned char>(buffer->Length);
+    CryptographicBuffer::CopyToByteArray(buffer, &data);
+    memcpy(&result, data->begin(), data->end() - data->begin());
+#endif
+
+    return result;
+  }
+
+private:
+#if !defined(BOOST_RANDOM_WINDOWS_RUNTIME)
+  void error(const char * msg) {
+    DWORD error_code = GetLastError();
+    boost::throw_exception(
+      boost::system::system_error(
+        error_code, boost::system::system_category(),
+        std::string("boost::random_device: ") + msg + 
+        " Cryptographic Service Provider " + provider));
+  }
+  HCRYPTPROV hProv;
+#endif
+  const std::string provider;
+};
+
+#else
+
+namespace {
+// the default is the unlimited capacity device, using some secure hash
+// try "/dev/random" for blocking when the entropy pool has drained
+const char * const default_token = "/dev/urandom";
+}
+
+/*
+ * This uses the POSIX interface for unbuffered reading.
+ * Using buffered std::istream would consume entropy which may
+ * not actually be used.  Entropy is a precious good we avoid
+ * wasting.
+ */
+
+#if defined(__GNUC__) && defined(_CXXRT_STD_NAME)
+// I have severe difficulty to get the POSIX includes to work with
+// -fhonor-std and Dietmar Kuhl's standard C++ library.  Hack around that
+// problem for now.
+extern "C" {
+static const int O_RDONLY = 0;
+extern int open(const char *__file, int __oflag, ...);
+extern int read(int __fd, __ptr_t __buf, size_t __nbytes);
+extern int close(int __fd);
+}
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>    // open
+#include <unistd.h>   // read, close
+#endif
+
+#include <errno.h>    // errno
+#include <string.h>   // strerror
+#include <stdexcept>  // std::invalid_argument
+
+
+class boost::random::random_device::impl
+{
+public:
+  impl(const std::string & token) : path(token) {
+    fd = open(token.c_str(), O_RDONLY);
+    if(fd < 0)
+      error("cannot open");
+  }
+
+  ~impl() { if(close(fd) < 0) error("could not close"); }
+
+  unsigned int next() {
+    unsigned int result;
+    std::size_t offset = 0;
+    do {
+      long sz = read(fd, reinterpret_cast<char *>(&result) + offset, sizeof(result) - offset);
+      if(sz == -1)
+        error("error while reading");
+      else if(sz == 0) {
+        errno = 0;
+        error("EOF while reading");
+      }
+      offset += sz;
+    } while(offset < sizeof(result));
+    return result;
+  }
+
+private:
+  void error(const char * msg) {
+    int error_code = errno;
+    boost::throw_exception(
+      boost::system::system_error(
+        error_code, boost::system::system_category(),
+        std::string("boost::random_device: ") + msg + 
+        " random-number pseudo-device " + path));
+  }
+  const std::string path;
+  int fd;
+};
+
+#endif // BOOST_WINDOWS
+
+BOOST_RANDOM_DECL boost::random::random_device::random_device()
+  : pimpl(new impl(default_token))
+{}
+
+BOOST_RANDOM_DECL boost::random::random_device::random_device(const std::string& token)
+  : pimpl(new impl(token))
+{}
+
+BOOST_RANDOM_DECL boost::random_device::~random_device()
+{
+  delete pimpl;
+}
+
+BOOST_RANDOM_DECL double boost::random_device::entropy() const
+{
+  return 10;
+}
+
+BOOST_RANDOM_DECL unsigned int boost::random_device::operator()()
+{
+  return pimpl->next();
+}