passenger 4.0.60 → 5.0.0.beta1

data/ext/boost/pool/detail/pool_construct.m4

@@ -0,0 +1,84 @@
+m4_dnl
+m4_dnl Copyright (C) 2000 Stephen Cleary
+m4_dnl
+m4_dnl Distributed under the Boost Software License, Version 1.0. (See accompany-
+m4_dnl ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+m4_dnl
+m4_dnl See http://www.boost.org for updates, documentation, and revision history.
+m4_dnl
+m4_dnl
+m4_dnl
+m4_dnl Avoid the use of any m4_* identifiers in this header file,
+m4_dnl  as that may cause incompatibility problems with future
+m4_dnl  versions of m4.
+m4_dnl
+m4_dnl This is a normal header file, except that lines starting
+m4_dnl  with `m4_dnl' will be stripped, TBA_FOR
+m4_dnl  macros will be replaced with repeated text, and text in
+m4_dnl  single quotes (`...') will have their single quotes
+m4_dnl  stripped.
+m4_dnl
+m4_dnl
+m4_dnl Check to make sure NumberOfArguments was defined.  If it's not defined,
+m4_dnl  default to 3
+m4_dnl
+m4_ifdef(`NumberOfArguments', , `m4_errprint(m4___file__:m4___line__`: NumberOfArguments is not defined; defaulting to 3
+')m4_define(`NumberOfArguments', 3)')m4_dnl
+m4_ifelse(NumberOfArguments, , `m4_errprint(m4___file__:m4___line__`: NumberOfArguments is defined to be empty; defaulting to 3
+')m4_define(`NumberOfArguments', 3)')m4_dnl
+m4_dnl
+m4_dnl Check to make sure NumberOfArguments >= 1.  If it's not, then fatal error.
+m4_dnl
+m4_ifelse(m4_eval(NumberOfArguments < 1), 1, `m4_errprint(m4___file__:m4___line__`: NumberOfArguments ('NumberOfArguments`) is less than 1
+')m4_m4exit(1)')m4_dnl
+m4_dnl
+m4_dnl Include the BOOST_M4_FOR macro definition
+m4_dnl
+m4_include(`for.m4')`'m4_dnl
+m4_dnl
+m4_dnl Begin the generated file.
+m4_dnl
+// 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.
+
+m4_dnl These warnings apply to the file generated from this file.
+m4_dnl Of course, you may freely edit this file.
+// This file was AUTOMATICALLY GENERATED from "m4___file__"
+//  Do NOT include directly!
+//  Do NOT edit!
+
+m4_dnl
+m4_dnl First we define a simple 'cv_qual' macro which takes a number, either
+m4_dnl   0, 1, 2, or 3, and determines cv-qualification.
+m4_dnl
+m4_define(`cv_qual',
+`m4_ifelse($1, 0, `',
+`m4_ifelse($1, 1, `const ',
+`m4_ifelse($1, 2, `volatile ',
+`m4_ifelse($1, 3, `const volatile ',
+`m4_errprint(m4___file__:m4___line__: `Boost m4 script: cv-determiner: Not 0, 1, 2, or 3 (was '$1`)')'
+)')')')')m4_dnl
+m4_dnl
+m4_dnl Next we go through the actual loop.  For each number of arguments from
+m4_dnl   1 to NumberOfArguments, we create a template function that takes that
+m4_dnl   many template arguments, and also generate all cv-qualified permutations
+m4_dnl   of that function.
+m4_dnl
+BOOST_M4_FOR(N, 1, NumberOfArguments + 1,
+`BOOST_M4_FOR(cv, 0, m4_eval(4 ** N),
+  `template <BOOST_M4_FOR(i, 0, N, `typename T`'i', `, ')>
+element_type * construct(BOOST_M4_FOR(i, 0, N,
+    `cv_qual(m4_eval((cv >> (i * 2)) % 4))T`'i & a`'i', `, '))
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(BOOST_M4_FOR(i, 0, N, `a`'i', `, ')); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+')')

data/ext/boost/pool/detail/pool_construct.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+#
+# 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.
+#
+
+m4 -P -E -DNumberOfArguments=$1 pool_construct.m4 > pool_construct.ipp
+

data/ext/boost/pool/detail/pool_construct_simple.bat

@@ -0,0 +1,25 @@
+@echo off
+rem
+rem Copyright (C) 2001 Stephen Cleary
+rem
+rem Distributed under the Boost Software License, Version 1.0. (See accompany-
+rem ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+rem
+rem See http://www.boost.org for updates, documentation, and revision history.
+rem
+
+rem Check for Windows NT
+if %OS%==Windows_NT goto NT
+
+rem Not NT - run m4 as normal, then exit
+m4 -P -E -DNumberOfArguments=%1 pool_construct_simple.m4 > pool_construct_simple.ipp
+goto end
+
+rem DJGPP programs (including m4) running on Windows/NT do NOT support long
+rem  file names (see the DJGPP v2 FAQ, question 8.1)
+rem Note that the output doesn't have to be a short name because it's an
+rem  argument to the command shell, not m4.
+:NT
+m4 -P -E -DNumberOfArguments=%1 < pool_construct_simple.m4 > pool_construct_simple.ipp
+
+:end

data/ext/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;
+}
+

data/ext/boost/pool/detail/pool_construct_simple.m4

@@ -0,0 +1,72 @@
+m4_dnl
+m4_dnl Copyright (C) 2001 Stephen Cleary
+m4_dnl
+m4_dnl Distributed under the Boost Software License, Version 1.0. (See accompany-
+m4_dnl ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+m4_dnl
+m4_dnl See http://www.boost.org for updates, documentation, and revision history.
+m4_dnl
+m4_dnl
+m4_dnl
+m4_dnl Avoid the use of any m4_* identifiers in this header file,
+m4_dnl  as that may cause incompatibility problems with future
+m4_dnl  versions of m4.
+m4_dnl
+m4_dnl This is a normal header file, except that lines starting
+m4_dnl  with `m4_dnl' will be stripped, TBA_FOR
+m4_dnl  macros will be replaced with repeated text, and text in
+m4_dnl  single quotes (`...') will have their single quotes
+m4_dnl  stripped.
+m4_dnl
+m4_dnl
+m4_dnl Check to make sure NumberOfArguments was defined.  If it's not defined,
+m4_dnl  default to 3
+m4_dnl
+m4_ifdef(`NumberOfArguments', , `m4_errprint(m4___file__:m4___line__`: NumberOfArguments is not defined; defaulting to 3
+')m4_define(`NumberOfArguments', 3)')m4_dnl
+m4_ifelse(NumberOfArguments, , `m4_errprint(m4___file__:m4___line__`: NumberOfArguments is defined to be empty; defaulting to 3
+')m4_define(`NumberOfArguments', 3)')m4_dnl
+m4_dnl
+m4_dnl Check to make sure NumberOfArguments >= 1.  If it's not, then fatal error.
+m4_dnl
+m4_ifelse(m4_eval(NumberOfArguments < 1), 1, `m4_errprint(m4___file__:m4___line__`: NumberOfArguments ('NumberOfArguments`) is less than 1
+')m4_m4exit(1)')m4_dnl
+m4_dnl
+m4_dnl Include the BOOST_M4_FOR macro definition
+m4_dnl
+m4_include(`for.m4')`'m4_dnl
+m4_dnl
+m4_dnl Begin the generated file.
+m4_dnl
+// 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.
+
+m4_dnl These warnings apply to the file generated from this file.
+m4_dnl Of course, you may freely edit this file.
+// This file was AUTOMATICALLY GENERATED from "m4___file__"
+//  Do NOT include directly!
+//  Do NOT edit!
+
+m4_dnl
+m4_dnl Here we go through the actual loop.  For each number of arguments from
+m4_dnl   1 to NumberOfArguments, we create a template function that takes that
+m4_dnl   many template arguments.
+m4_dnl
+BOOST_M4_FOR(N, 1, NumberOfArguments + 1,
+`template <BOOST_M4_FOR(i, 0, N, `typename T`'i', `, ')>
+element_type * construct(BOOST_M4_FOR(i, 0, N,
+    `const T`'i & a`'i', `, '))
+{
+  element_type * const ret = (malloc)();
+  if (ret == 0)
+    return ret;
+  try { new (ret) element_type(BOOST_M4_FOR(i, 0, N, `a`'i', `, ')); }
+  catch (...) { (free)(ret); throw; }
+  return ret;
+}
+')

data/ext/boost/pool/detail/pool_construct_simple.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+#
+# Copyright (C) 2001 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.
+#
+
+m4 -P -E -DNumberOfArguments=$1 pool_construct_simple.m4 > pool_construct_simple.ipp
+

data/ext/boost/pool/object_pool.hpp

@@ -0,0 +1,287 @@
+// Copyright (C) 2000, 2001 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_OBJECT_POOL_HPP
+#define BOOST_OBJECT_POOL_HPP
+/*!
+\file
+\brief  Provides a template type boost::object_pool<T, UserAllocator>
+that can be used for fast and efficient memory allocation of objects of type T.
+It also provides automatic destruction of non-deallocated objects.
+*/
+
+#include <boost/pool/poolfwd.hpp>
+
+// boost::pool
+#include <boost/pool/pool.hpp>
+
+// The following code will be put into Boost.Config in a later revision
+#if defined(BOOST_MSVC) || defined(__KCC)
+# define BOOST_NO_TEMPLATE_CV_REF_OVERLOADS
+#endif
+
+// The following code might be put into some Boost.Config header in a later revision
+#ifdef __BORLANDC__
+# pragma option push -w-inl
+#endif
+
+// There are a few places in this file where the expression "this->m" is used.
+// This expression is used to force instantiation-time name lookup, which I am
+//   informed is required for strict Standard compliance.  It's only necessary
+//   if "m" is a member of a base class that is dependent on a template
+//   parameter.
+// Thanks to Jens Maurer for pointing this out!
+
+namespace boost {
+
+/*! \brief A template class
+that can be used for fast and efficient memory allocation of objects.
+It also provides automatic destruction of non-deallocated objects.
+
+\details
+
+<b>T</b> The type of object to allocate/deallocate.
+T must have a non-throwing destructor.
+
+<b>UserAllocator</b>
+Defines the allocator that the underlying Pool will use to allocate memory from the system.
+See <a href="boost_pool/pool/pooling.html#boost_pool.pool.pooling.user_allocator">User Allocators</a> for details.
+
+Class object_pool is a template class
+that can be used for fast and efficient memory allocation of objects.
+It also provides automatic destruction of non-deallocated objects.
+
+When the object pool is destroyed, then the destructor for type T
+is called for each allocated T that has not yet been deallocated. O(N).
+
+Whenever an object of type ObjectPool needs memory from the system,
+it will request it from its UserAllocator template parameter.
+The amount requested is determined using a doubling algorithm;
+that is, each time more system memory is allocated,
+the amount of system memory requested is doubled.
+Users may control the doubling algorithm by the parameters passed
+to the object_pool's constructor.
+*/
+
+template <typename T, typename UserAllocator>
+class object_pool: protected pool<UserAllocator>
+{ //!
+  public:
+    typedef T element_type; //!< ElementType
+    typedef UserAllocator user_allocator; //!<
+    typedef typename pool<UserAllocator>::size_type size_type; //!<   pool<UserAllocator>::size_type
+    typedef typename pool<UserAllocator>::difference_type difference_type; //!< pool<UserAllocator>::difference_type
+
+  protected:
+    //! \return The underlying boost:: \ref pool storage used by *this.
+    pool<UserAllocator> & store()
+    { 
+      return *this;
+    }
+    //! \return The underlying boost:: \ref pool storage used by *this.
+    const pool<UserAllocator> & store() const
+    { 
+      return *this;
+    }
+
+    // for the sake of code readability :)
+    static void * & nextof(void * const ptr)
+    { //! \returns The next memory block after ptr (for the sake of code readability :)
+      return *(static_cast<void **>(ptr));
+    }
+
+  public:
+    explicit object_pool(const size_type arg_next_size = 32, const size_type arg_max_size = 0)
+    :
+    pool<UserAllocator>(sizeof(T), arg_next_size, arg_max_size)
+    { //! Constructs a new (empty by default) ObjectPool.
+      //! \param next_size Number of chunks to request from the system the next time that object needs to allocate system memory (default 32).
+      //! \pre next_size != 0.
+      //! \param max_size Maximum number of chunks to ever request from the system - this puts a cap on the doubling algorithm
+      //! used by the underlying pool.
+    }
+
+    ~object_pool();
+
+    // Returns 0 if out-of-memory.
+    element_type * malloc BOOST_PREVENT_MACRO_SUBSTITUTION()
+    { //! Allocates memory that can hold one object of type ElementType.
+      //!
+      //! If out of memory, returns 0. 
+      //!
+      //! Amortized O(1).
+      return static_cast<element_type *>(store().ordered_malloc());
+    }
+    void free BOOST_PREVENT_MACRO_SUBSTITUTION(element_type * const chunk)
+    { //! De-Allocates memory that holds a chunk of type ElementType.
+      //!
+      //!  Note that p may not be 0.\n
+      //!
+      //! Note that the destructor for p is not called. O(N).
+      store().ordered_free(chunk);
+    }
+    bool is_from(element_type * const chunk) const
+    { /*! \returns true  if chunk was allocated from *this or
+      may be returned as the result of a future allocation from *this.
+
+      Returns false if chunk was allocated from some other pool or
+      may be returned as the result of a future allocation from some other pool.
+
+      Otherwise, the return value is meaningless.
+
+      \note This function may NOT be used to reliably test random pointer values!
+    */
+      return store().is_from(chunk);
+    }
+
+    element_type * construct()
+    { //! \returns A pointer to an object of type T, allocated in memory from the underlying pool
+      //! and default constructed.  The returned objected can be freed by a call to \ref destroy.
+      //! Otherwise the returned object will be automatically destroyed when *this is destroyed.
+      element_type * const ret = (malloc)();
+      if (ret == 0)
+        return ret;
+      try { new (ret) element_type(); }
+      catch (...) { (free)(ret); throw; }
+      return ret;
+    }
+
+
+#if defined(BOOST_DOXYGEN)
+    template <class Arg1, ... class ArgN>
+    element_type * construct(Arg1&, ... ArgN&)
+    {
+       //! \returns A pointer to an object of type T, allocated in memory from the underlying pool
+       //! and constructed from arguments Arg1 to ArgN.  The returned objected can be freed by a call to \ref destroy.
+       //! Otherwise the returned object will be automatically destroyed when *this is destroyed.
+       //!
+       //! \note Since the number and type of arguments to this function is totally arbitrary, a simple system has been 
+       //! set up to automatically generate template construct functions. This system is based on the macro preprocessor 
+       //! m4, which is standard on UNIX systems and also available for Win32 systems.\n\n
+       //! detail/pool_construct.m4, when run with m4, will create the file detail/pool_construct.ipp, which only defines 
+       //! the construct functions for the proper number of arguments. The number of arguments may be passed into the 
+       //! file as an m4 macro, NumberOfArguments; if not provided, it will default to 3.\n\n
+       //! For each different number of arguments (1 to NumberOfArguments), a template function is generated. There 
+       //! are the same number of template parameters as there are arguments, and each argument's type is a reference 
+       //! to that (possibly cv-qualified) template argument. Each possible permutation of the cv-qualifications is also generated.\n\n
+       //! Because each permutation is generated for each possible number of arguments, the included file size grows 
+       //! exponentially in terms of the number of constructor arguments, not linearly. For the sake of rational 
+       //! compile times, only use as many arguments as you need.\n\n
+       //! detail/pool_construct.bat and detail/pool_construct.sh are also provided to call m4, defining NumberOfArguments 
+       //! to be their command-line parameter. See these files for more details.
+    }
+#else
+// Include automatically-generated file for family of template construct() functions.
+// Copy .inc renamed .ipp to conform to Doxygen include filename expectations, PAB 12 Jan 11.
+// But still get Doxygen warning:
+// I:/boost-sandbox/guild/pool/boost/pool/object_pool.hpp:82:
+// Warning: include file boost/pool/detail/pool_construct.ipp
+// not found, perhaps you forgot to add its directory to INCLUDE_PATH?
+// But the file IS found and referenced OK, but cannot view code.
+// This seems because not at the head of the file
+// But if moved this up, Doxygen is happy, but of course it won't compile,
+// because the many constructors *must* go here.
+
+#ifndef BOOST_NO_TEMPLATE_CV_REF_OVERLOADS
+#   include <boost/pool/detail/pool_construct.ipp>
+#else
+#   include <boost/pool/detail/pool_construct_simple.ipp>
+#endif
+#endif
+    void destroy(element_type * const chunk)
+    { //! Destroys an object allocated with \ref construct. 
+      //!
+      //! Equivalent to:
+      //!
+      //! p->~ElementType(); this->free(p);
+      //!
+      //! \pre p must have been previously allocated from *this via a call to \ref construct.
+      chunk->~T();
+      (free)(chunk);
+    }
+
+    size_type get_next_size() const
+    { //! \returns The number of chunks that will be allocated next time we run out of memory.
+      return store().get_next_size();
+    }
+    void set_next_size(const size_type x)
+    { //! Set a new number of chunks to allocate the next time we run out of memory.
+      //! \param x wanted next_size (must not be zero).
+      store().set_next_size(x);
+    }
+};
+
+template <typename T, typename UserAllocator>
+object_pool<T, UserAllocator>::~object_pool()
+{
+#ifndef BOOST_POOL_VALGRIND
+  // handle trivial case of invalid list.
+  if (!this->list.valid())
+    return;
+
+  details::PODptr<size_type> iter = this->list;
+  details::PODptr<size_type> next = iter;
+
+  // Start 'freed_iter' at beginning of free list
+  void * freed_iter = this->first;
+
+  const size_type partition_size = this->alloc_size();
+
+  do
+  {
+    // increment next
+    next = next.next();
+
+    // delete all contained objects that aren't freed.
+
+    // Iterate 'i' through all chunks in the memory block.
+    for (char * i = iter.begin(); i != iter.end(); i += partition_size)
+    {
+      // If this chunk is free,
+      if (i == freed_iter)
+      {
+        // Increment freed_iter to point to next in free list.
+        freed_iter = nextof(freed_iter);
+
+        // Continue searching chunks in the memory block.
+        continue;
+      }
+
+      // This chunk is not free (allocated), so call its destructor,
+      static_cast<T *>(static_cast<void *>(i))->~T();
+      // and continue searching chunks in the memory block.
+    }
+
+    // free storage.
+    (UserAllocator::free)(iter.begin());
+
+    // increment iter.
+    iter = next;
+  } while (iter.valid());
+
+  // Make the block list empty so that the inherited destructor doesn't try to
+  // free it again.
+  this->list.invalidate();
+#else
+   // destruct all used elements:
+   for(std::set<void*>::iterator pos = this->used_list.begin(); pos != this->used_list.end(); ++pos)
+   {
+      static_cast<T*>(*pos)->~T();
+   }
+   // base class will actually free the memory...
+#endif
+}
+
+} // namespace boost
+
+// The following code might be put into some Boost.Config header in a later revision
+#ifdef __BORLANDC__
+# pragma option pop
+#endif
+
+#endif