passenger 3.0.0 → 3.0.1

data/ext/boost/exception/detail/is_output_streamable.hpp

@@ -20,8 +20,21 @@ boost
     namespace
     to_string_detail
         {
-        template <class T,class CharT,class Traits>
-        char operator<<( std::basic_ostream<CharT,Traits> &, T const & );
+        struct
+        partial_ordering_helper1
+            {
+            template <class CharT,class Traits>
+            partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
+            };
+
+        struct
+        partial_ordering_helper2
+            {
+            template <class T>
+            partial_ordering_helper2( T const & );
+            };
+
+        char operator<<( partial_ordering_helper1, partial_ordering_helper2 );
 
         template <class T,class CharT,class Traits>
         struct

data/ext/boost/exception/detail/type_info.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -15,31 +15,35 @@
 #include <boost/detail/sp_typeinfo.hpp>
 #include <boost/current_function.hpp>
 #include <boost/config.hpp>
+#ifndef BOOST_NO_TYPEID
+#include <boost/units/detail/utility.hpp>
+#endif
+#include <string>
 
 namespace
 boost
     {
     template <class T>
     inline
-    char const *
+    std::string
     tag_type_name()
         {
 #ifdef BOOST_NO_TYPEID
         return BOOST_CURRENT_FUNCTION;
 #else
-        return typeid(T*).name();
+        return units::detail::demangle(typeid(T*).name());
 #endif
         }
 
     template <class T>
     inline
-    char const *
+    std::string
     type_name()
         {
 #ifdef BOOST_NO_TYPEID
         return BOOST_CURRENT_FUNCTION;
 #else
-        return typeid(T).name();
+        return units::detail::demangle(typeid(T).name());
 #endif
         }
 

data/ext/boost/exception/diagnostic_information.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -15,7 +15,9 @@
 #include <boost/config.hpp>
 #include <boost/exception/get_error_info.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/config.hpp>
+#ifndef BOOST_NO_RTTI
+#include <boost/units/detail/utility.hpp>
+#endif
 #include <exception>
 #include <sstream>
 #include <string>
@@ -135,7 +137,7 @@ boost
                 }
 #ifndef BOOST_NO_RTTI
             tmp << std::string("Dynamic exception type: ") <<
-                (be?BOOST_EXCEPTION_DYNAMIC_TYPEID(*be):BOOST_EXCEPTION_DYNAMIC_TYPEID(*se)).type_.name() << '\n';
+                units::detail::demangle((be?BOOST_EXCEPTION_DYNAMIC_TYPEID(*be):BOOST_EXCEPTION_DYNAMIC_TYPEID(*se)).type_.name()) << '\n';
 #endif
             if( with_what && se )
                 tmp << "std::exception::what: " << wh << '\n';

data/ext/boost/exception/exception.hpp

@@ -75,8 +75,8 @@ boost
             void
             release()
                 {
-                if( px_ )
-                    px_->release();
+                if( px_ && px_->release() )
+                    px_=0;
                 }
             };
         }
@@ -132,21 +132,9 @@ boost
             }
         };
 
-    template <class E,class Tag,class T>
-    E const & operator<<( E const &, error_info<Tag,T> const & );
-
-    template <class E>
-    E const & operator<<( E const &, throw_function const & );
-
-    template <class E>
-    E const & operator<<( E const &, throw_file const & );
-
-    template <class E>
-    E const & operator<<( E const &, throw_line const & );
-
     class exception;
 
-    template <class>
+    template <class T>
     class shared_ptr;
 
     namespace
@@ -162,7 +150,8 @@ boost
             virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
             virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
             virtual void add_ref() const = 0;
-            virtual void release() const = 0;
+            virtual bool release() const = 0;
+            virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
 
             protected:
 
@@ -184,6 +173,20 @@ boost
         struct get_info<throw_line>;
 
         char const * get_diagnostic_information( exception const &, char const * );
+
+        void copy_boost_exception( exception *, exception const * );
+
+        template <class E,class Tag,class T>
+        E const & set_info( E const &, error_info<Tag,T> const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_function const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_file const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_line const & );
         }
 
     class
@@ -216,30 +219,31 @@ boost
 #endif
             ;
 
-#if defined(__MWERKS__) && __MWERKS__<=0x3207
+#if (defined(__MWERKS__) && __MWERKS__<=0x3207) || (defined(_MSC_VER) && _MSC_VER<=1310)
         public:
 #else
         private:
 
         template <class E>
-        friend E const & operator<<( E const &, throw_function const & );
+        friend E const & exception_detail::set_info( E const &, throw_function const & );
 
         template <class E>
-        friend E const & operator<<( E const &, throw_file const & );
+        friend E const & exception_detail::set_info( E const &, throw_file const & );
 
         template <class E>
-        friend E const & operator<<( E const &, throw_line const & );
-
-        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
+        friend E const & exception_detail::set_info( E const &, throw_line const & );
 
         template <class E,class Tag,class T>
-        friend E const & operator<<( E const &, error_info<Tag,T> const & );
+        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
+
+        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
 
         template <class>
         friend struct exception_detail::get_info;
         friend struct exception_detail::get_info<throw_function>;
         friend struct exception_detail::get_info<throw_file>;
         friend struct exception_detail::get_info<throw_line>;
+        friend void exception_detail::copy_boost_exception( exception *, exception const * );
 #endif
         mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
         mutable char const * throw_function_;
@@ -253,28 +257,32 @@ boost
         {
         }
 
-    template <class E>
-    E const &
-    operator<<( E const & x, throw_function const & y )
+    namespace
+    exception_detail
         {
-        x.throw_function_=y.v_;
-        return x;
-        }
+        template <class E>
+        E const &
+        set_info( E const & x, throw_function const & y )
+            {
+            x.throw_function_=y.v_;
+            return x;
+            }
 
-    template <class E>
-    E const &
-    operator<<( E const & x, throw_file const & y )
-        {
-        x.throw_file_=y.v_;
-        return x;
-        }
+        template <class E>
+        E const &
+        set_info( E const & x, throw_file const & y )
+            {
+            x.throw_file_=y.v_;
+            return x;
+            }
 
-    template <class E>
-    E const &
-    operator<<( E const & x, throw_line const & y )
-        {
-        x.throw_line_=y.v_;
-        return x;
+        template <class E>
+        E const &
+        set_info( E const & x, throw_line const & y )
+            {
+            x.throw_line_=y.v_;
+            return x;
+            }
         }
 
     ////////////////////////////////////////////////////////////////////////
@@ -300,10 +308,10 @@ boost
             };
 
         struct large_size { char c[256]; };
-        large_size dispatch( exception * );
+        large_size dispatch_boost_exception( exception const * );
 
         struct small_size { };
-        small_size dispatch( void * );
+        small_size dispatch_boost_exception( void const * );
 
         template <class,int>
         struct enable_error_info_helper;
@@ -326,7 +334,7 @@ boost
         struct
         enable_error_info_return_type
             {
-            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch((T*)0))>::type type;
+            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception((T*)0))>::type type;
             };
         }
 
@@ -363,7 +371,13 @@ boost
         void
         copy_boost_exception( exception * a, exception const * b )
             {
-            *a = *b;
+            refcount_ptr<error_info_container> data;
+            if( error_info_container * d=b->data_.get() )
+                data = d->clone();
+            a->throw_file_ = b->throw_file_;
+            a->throw_line_ = b->throw_line_;
+            a->throw_function_ = b->throw_function_;
+            a->data_ = data;
             }
 
         inline

data/ext/boost/exception/info.hpp

@@ -1,4 +1,4 @@
-//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
+//Copyright (c) 2006-2010 Emil Dotchevski and Reverge Studios, Inc.
 
 //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)
@@ -47,7 +47,7 @@ boost
 
     template <class Tag,class T>
     inline
-    char const *
+    std::string
     error_info<Tag,T>::
     tag_typeid_name() const
         {
@@ -114,8 +114,8 @@ boost
                     tmp << header;
                     for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
                         {
-                        shared_ptr<error_info_base const> const & x = i->second;
-                        tmp << '[' << x->tag_typeid_name() << "] = " << x->value_as_string() << '\n';
+                        error_info_base const & x = *i->second;
+                        tmp << '[' << x.tag_typeid_name() << "] = " << x.value_as_string() << '\n';
                         }
                     tmp.str().swap(diagnostic_info_str_);
                     }
@@ -131,33 +131,66 @@ boost
             mutable std::string diagnostic_info_str_;
             mutable int count_;
 
+            error_info_container_impl( error_info_container_impl const & );
+            error_info_container_impl & operator=( error_info_container const & );
+
             void
             add_ref() const
                 {
                 ++count_;
                 }
 
-            void
+            bool
             release() const
                 {
-                if( !--count_ )
+                if( --count_ )
+                    return false;
+                else
+                    {
                     delete this;
+                    return true;
+                    }
+                }
+
+            refcount_ptr<error_info_container>
+            clone() const
+                {
+                refcount_ptr<error_info_container> p;
+                error_info_container_impl * c=new error_info_container_impl;
+                p.adopt(c);
+                c->info_ = info_;
+                return p;
                 }
             };
+
+        template <class E,class Tag,class T>
+        inline
+        E const &
+        set_info( E const & x, error_info<Tag,T> const & v )
+            {
+            typedef error_info<Tag,T> error_info_tag_t;
+            shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
+            exception_detail::error_info_container * c=x.data_.get();
+            if( !c )
+                x.data_.adopt(c=new exception_detail::error_info_container_impl);
+            c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
+            return x;
+            }
+
+        template <class T>
+        struct
+        derives_boost_exception
+            {
+            enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
+            };
         }
 
     template <class E,class Tag,class T>
     inline
-    E const &
+    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
     operator<<( E const & x, error_info<Tag,T> const & v )
         {
-        typedef error_info<Tag,T> error_info_tag_t;
-        shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
-        exception_detail::error_info_container * c=x.data_.get();
-        if( !c )
-            x.data_.adopt(c=new exception_detail::error_info_container_impl);
-        c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
-        return x;
+        return exception_detail::set_info(x,v);
         }
     }
 

data/ext/boost/function/function_base.hpp

@@ -264,12 +264,12 @@ namespace boost {
           A(a)
         {
         }
-	
-	functor_wrapper(const functor_wrapper& f) :
+        
+        functor_wrapper(const functor_wrapper& f) :
           F(static_cast<const F&>(f)),
           A(static_cast<const A&>(f))
-	{
-	}
+        {
+        }
       };
 
       /**

data/ext/boost/integer.hpp

@@ -57,6 +57,8 @@ namespace boost
   //  no specializations for 0 and 5: requests for a type > long are in error
 #ifdef BOOST_HAS_LONG_LONG
   template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
+#elif defined(BOOST_HAS_MS_INT64)
+  template<> struct int_least_helper<1> { typedef __int64 least; };
 #endif
   template<> struct int_least_helper<2> { typedef long least; };
   template<> struct int_least_helper<3> { typedef int least; };
@@ -64,6 +66,8 @@ namespace boost
   template<> struct int_least_helper<5> { typedef signed char least; };
 #ifdef BOOST_HAS_LONG_LONG
   template<> struct int_least_helper<6> { typedef boost::ulong_long_type least; };
+#elif defined(BOOST_HAS_MS_INT64)
+  template<> struct int_least_helper<6> { typedef unsigned __int64 least; };
 #endif
   template<> struct int_least_helper<7> { typedef unsigned long least; };
   template<> struct int_least_helper<8> { typedef unsigned int least; };

data/ext/boost/integer_fwd.hpp

@@ -77,12 +77,18 @@ template <  >
 template <  >
     class integer_traits< unsigned long >;
 
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64))
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
 template <  >
-    class integer_traits<  ::boost::long_long_type>;
+class integer_traits<  ::boost::long_long_type>;
 
 template <  >
-    class integer_traits<  ::boost::ulong_long_type >;
+class integer_traits<  ::boost::ulong_long_type >;
+#elif !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_MS_INT64)
+template <  >
+class integer_traits<__int64>;
+
+template <  >
+class integer_traits<unsigned __int64>;
 #endif
 
 

data/ext/boost/iterator/iterator_concepts.hpp

@@ -0,0 +1,284 @@
+// (C) Copyright Jeremy Siek 2002.
+// 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_ITERATOR_CONCEPTS_HPP
+#define BOOST_ITERATOR_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
+#include <boost/detail/iterator.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_integral.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+
+#include <boost/static_assert.hpp>
+
+// Use boost/limits to work around missing limits headers on some compilers
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
+
+#include <algorithm>
+
+#include <boost/concept/detail/concept_def.hpp>
+
+namespace boost_concepts
+{
+  // Used a different namespace here (instead of "boost") so that the
+  // concept descriptions do not take for granted the names in
+  // namespace boost.
+
+  //===========================================================================
+  // Iterator Access Concepts
+
+  BOOST_concept(ReadableIterator,(Iterator))
+    : boost::Assignable<Iterator>
+    , boost::CopyConstructible<Iterator>
+
+  {
+      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
+      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;
+
+      BOOST_CONCEPT_USAGE(ReadableIterator)
+      {
+
+          value_type v = *i;
+          boost::ignore_unused_variable_warning(v);
+      }
+  private:
+      Iterator i;
+  };
+  
+  template <
+      typename Iterator
+    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+  >
+  struct WritableIterator
+    : boost::CopyConstructible<Iterator>
+  {
+      BOOST_CONCEPT_USAGE(WritableIterator)
+      {
+          *i = v;
+      }
+  private:
+      ValueType v;
+      Iterator i;
+  };
+
+  template <
+      typename Iterator
+    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+  >
+  struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
+  
+  BOOST_concept(SwappableIterator,(Iterator))
+  {
+      BOOST_CONCEPT_USAGE(SwappableIterator)
+      {
+          std::iter_swap(i1, i2);
+      }
+  private:
+      Iterator i1;
+      Iterator i2;
+  };
+
+  BOOST_concept(LvalueIterator,(Iterator))
+  {
+      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
+      
+      BOOST_CONCEPT_USAGE(LvalueIterator)
+      {
+        value_type& r = const_cast<value_type&>(*i);
+        boost::ignore_unused_variable_warning(r);
+      }
+  private:
+      Iterator i;
+  };
+
+  
+  //===========================================================================
+  // Iterator Traversal Concepts
+
+  BOOST_concept(IncrementableIterator,(Iterator))
+    : boost::Assignable<Iterator>
+    , boost::CopyConstructible<Iterator>
+  {
+      typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
+
+      BOOST_CONCEPT_ASSERT((
+        boost::Convertible<
+            traversal_category
+          , boost::incrementable_traversal_tag
+        >));
+
+      BOOST_CONCEPT_USAGE(IncrementableIterator)
+      {
+          ++i;
+          (void)i++;
+      }
+  private:
+      Iterator i;
+  };
+
+  BOOST_concept(SinglePassIterator,(Iterator))
+    : IncrementableIterator<Iterator>
+    , boost::EqualityComparable<Iterator>
+
+  {
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME SinglePassIterator::traversal_category
+           , boost::single_pass_traversal_tag
+          > ));
+  };
+
+  BOOST_concept(ForwardTraversal,(Iterator))
+    : SinglePassIterator<Iterator>
+    , boost::DefaultConstructible<Iterator>
+  {
+      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+      
+      BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
+      BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME ForwardTraversal::traversal_category
+           , boost::forward_traversal_tag
+          > ));
+  };
+  
+  BOOST_concept(BidirectionalTraversal,(Iterator))
+    : ForwardTraversal<Iterator>
+  {
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME BidirectionalTraversal::traversal_category
+           , boost::bidirectional_traversal_tag
+          > ));
+
+      BOOST_CONCEPT_USAGE(BidirectionalTraversal)
+      {
+          --i;
+          (void)i--;
+      }
+   private:
+      Iterator i;
+  };
+
+  BOOST_concept(RandomAccessTraversal,(Iterator))
+    : BidirectionalTraversal<Iterator>
+  {
+      BOOST_CONCEPT_ASSERT((
+          boost::Convertible<
+             BOOST_DEDUCED_TYPENAME RandomAccessTraversal::traversal_category
+           , boost::random_access_traversal_tag
+          > ));
+
+      BOOST_CONCEPT_USAGE(RandomAccessTraversal)
+      {
+          i += n;
+          i = i + n;
+          i = n + i;
+          i -= n;
+          i = i - n;
+          n = i - j;
+      }
+      
+   private:
+      typename BidirectionalTraversal<Iterator>::difference_type n;
+      Iterator i, j;
+  };
+
+  //===========================================================================
+  // Iterator Interoperability 
+
+  namespace detail
+  {
+    template <typename Iterator1, typename Iterator2>
+    void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
+    {
+        bool b;
+        b = i1 == i2;
+        b = i1 != i2;
+
+        b = i2 == i1;
+        b = i2 != i1;
+        boost::ignore_unused_variable_warning(b);
+    }
+
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(
+        Iterator1 const& i1, Iterator2 const& i2,
+        boost::random_access_traversal_tag, boost::random_access_traversal_tag)
+    {
+        bool b;
+        typename boost::detail::iterator_traits<Iterator2>::difference_type n;
+        b = i1 <  i2;
+        b = i1 <= i2;
+        b = i1 >  i2;
+        b = i1 >= i2;
+        n = i1 -  i2;
+
+        b = i2 <  i1;
+        b = i2 <= i1;
+        b = i2 >  i1;
+        b = i2 >= i1;
+        n = i2 -  i1;
+        boost::ignore_unused_variable_warning(b);
+        boost::ignore_unused_variable_warning(n);
+    }
+
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(
+        Iterator1 const&, Iterator2 const&,
+        boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
+    { }
+
+  } // namespace detail
+
+  BOOST_concept(InteroperableIterator,(Iterator)(ConstIterator))
+  {
+   private:
+      typedef typename boost::detail::pure_traversal_tag<
+          typename boost::iterator_traversal<
+              Iterator
+          >::type
+      >::type traversal_category;
+
+      typedef typename boost::detail::pure_traversal_tag<
+          typename boost::iterator_traversal<
+              ConstIterator
+          >::type
+      >::type const_traversal_category;
+      
+  public:
+      BOOST_CONCEPT_ASSERT((SinglePassIterator<Iterator>));
+      BOOST_CONCEPT_ASSERT((SinglePassIterator<ConstIterator>));
+
+      BOOST_CONCEPT_USAGE(InteroperableIterator)
+      {
+          detail::interop_single_pass_constraints(i, ci);
+          detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
+
+          ci = i;
+      }
+      
+   private:
+      Iterator      i;
+      ConstIterator ci;
+  };
+
+} // namespace boost_concepts
+
+#include <boost/concept/detail/concept_undef.hpp>
+
+#endif // BOOST_ITERATOR_CONCEPTS_HPP