passenger 6.0.11 → 6.0.14

data/src/cxx_supportlib/vendor-modified/boost/regex/v4/unicode_iterator.hpp

@@ -62,7 +62,6 @@ Accepts UTF-32 code points and forwards them on as UTF-16 code points.
 #define BOOST_REGEX_V4_UNICODE_ITERATOR_HPP
 #include <boost/cstdint.hpp>
 #include <boost/regex/config.hpp>
-#include <boost/iterator/iterator_facade.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/throw_exception.hpp>
 #include <stdexcept>
@@ -145,10 +144,7 @@ inline void invalid_utf32_code_point(::boost::uint32_t val)
 
 template <class BaseIterator, class U16Type = ::boost::uint16_t>
 class u32_to_u16_iterator
-   : public boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type>
 {
-   typedef boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type> base_type;
-
 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
    typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
 
@@ -157,14 +153,19 @@ class u32_to_u16_iterator
 #endif
 
 public:
-   typename base_type::reference
-      dereference()const
+   typedef std::ptrdiff_t     difference_type;
+   typedef U16Type            value_type;
+   typedef value_type const*  pointer;
+   typedef value_type const   reference;
+   typedef std::bidirectional_iterator_tag iterator_category;
+
+   reference operator*()const
    {
       if(m_current == 2)
          extract_current();
       return m_values[m_current];
    }
-   bool equal(const u32_to_u16_iterator& that)const
+   bool operator==(const u32_to_u16_iterator& that)const
    {
       if(m_position == that.m_position)
       {
@@ -174,7 +175,11 @@ public:
       }
       return false;
    }
-   void increment()
+   bool operator!=(const u32_to_u16_iterator& that)const
+   {
+      return !(*this == that);
+   }
+   u32_to_u16_iterator& operator++()
    {
       // if we have a pending read then read now, so that we know whether
       // to skip a position, or move to a low-surrogate:
@@ -191,8 +196,15 @@ public:
          m_current = 2;
          ++m_position;
       }
+      return *this;
    }
-   void decrement()
+   u32_to_u16_iterator operator++(int)
+   {
+      u32_to_u16_iterator r(*this);
+      ++(*this);
+      return r;
+   }
+   u32_to_u16_iterator& operator--()
    {
       if(m_current != 1)
       {
@@ -205,6 +217,13 @@ public:
       {
          m_current = 0;
       }
+      return *this;
+   }
+   u32_to_u16_iterator operator--(int)
+   {
+      u32_to_u16_iterator r(*this);
+      --(*this);
+      return r;
    }
    BaseIterator base()const
    {
@@ -258,9 +277,7 @@ private:
 
 template <class BaseIterator, class U32Type = ::boost::uint32_t>
 class u16_to_u32_iterator
-   : public boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>
 {
-   typedef boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;
    // special values for pending iterator reads:
    BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);
 
@@ -272,31 +289,54 @@ class u16_to_u32_iterator
 #endif
 
 public:
-   typename base_type::reference
-      dereference()const
+   typedef std::ptrdiff_t     difference_type;
+   typedef U32Type            value_type;
+   typedef value_type const*  pointer;
+   typedef value_type const   reference;
+   typedef std::bidirectional_iterator_tag iterator_category;
+
+   reference operator*()const
    {
       if(m_value == pending_read)
          extract_current();
       return m_value;
    }
-   bool equal(const u16_to_u32_iterator& that)const
+   bool operator==(const u16_to_u32_iterator& that)const
    {
       return m_position == that.m_position;
    }
-   void increment()
+   bool operator!=(const u16_to_u32_iterator& that)const
+   {
+      return !(*this == that);
+   }
+   u16_to_u32_iterator& operator++()
    {
       // skip high surrogate first if there is one:
       if(detail::is_high_surrogate(*m_position)) ++m_position;
       ++m_position;
       m_value = pending_read;
+      return *this;
    }
-   void decrement()
+   u16_to_u32_iterator operator++(int)
+   {
+      u16_to_u32_iterator r(*this);
+      ++(*this);
+      return r;
+   }
+   u16_to_u32_iterator& operator--()
    {
       --m_position;
       // if we have a low surrogate then go back one more:
       if(detail::is_low_surrogate(*m_position)) 
          --m_position;
       m_value = pending_read;
+      return *this;
+   }
+   u16_to_u32_iterator operator--(int)
+   {
+      u16_to_u32_iterator r(*this);
+      --(*this);
+      return r;
    }
    BaseIterator base()const
    {
@@ -375,10 +415,7 @@ private:
 
 template <class BaseIterator, class U8Type = ::boost::uint8_t>
 class u32_to_u8_iterator
-   : public boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type>
 {
-   typedef boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type> base_type;
-   
 #if !defined(BOOST_NO_STD_ITERATOR_TRAITS)
    typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
 
@@ -387,14 +424,19 @@ class u32_to_u8_iterator
 #endif
 
 public:
-   typename base_type::reference
-      dereference()const
+   typedef std::ptrdiff_t     difference_type;
+   typedef U8Type             value_type;
+   typedef value_type const*  pointer;
+   typedef value_type const   reference;
+   typedef std::bidirectional_iterator_tag iterator_category;
+
+   reference operator*()const
    {
       if(m_current == 4)
          extract_current();
       return m_values[m_current];
    }
-   bool equal(const u32_to_u8_iterator& that)const
+   bool operator==(const u32_to_u8_iterator& that)const
    {
       if(m_position == that.m_position)
       {
@@ -405,7 +447,11 @@ public:
       }
       return false;
    }
-   void increment()
+   bool operator!=(const u32_to_u8_iterator& that)const
+   {
+      return !(*this == that);
+   }
+   u32_to_u8_iterator& operator++()
    {
       // if we have a pending read then read now, so that we know whether
       // to skip a position, or move to a low-surrogate:
@@ -422,8 +468,15 @@ public:
          m_current = 4;
          ++m_position;
       }
+      return *this;
    }
-   void decrement()
+   u32_to_u8_iterator operator++(int)
+   {
+      u32_to_u8_iterator r(*this);
+      ++(*this);
+      return r;
+   }
+   u32_to_u8_iterator& operator--()
    {
       if((m_current & 3) == 0)
       {
@@ -435,6 +488,13 @@ public:
       }
       else
          --m_current;
+      return *this;
+   }
+   u32_to_u8_iterator operator--(int)
+   {
+      u32_to_u8_iterator r(*this);
+      --(*this);
+      return r;
    }
    BaseIterator base()const
    {
@@ -501,9 +561,7 @@ private:
 
 template <class BaseIterator, class U32Type = ::boost::uint32_t>
 class u8_to_u32_iterator
-   : public boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>
 {
-   typedef boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;
    // special values for pending iterator reads:
    BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);
 
@@ -515,18 +573,27 @@ class u8_to_u32_iterator
 #endif
 
 public:
-   typename base_type::reference
-      dereference()const
+   typedef std::ptrdiff_t     difference_type;
+   typedef U32Type            value_type;
+   typedef value_type const*  pointer;
+   typedef value_type const   reference;
+   typedef std::bidirectional_iterator_tag iterator_category;
+
+   reference operator*()const
    {
       if(m_value == pending_read)
          extract_current();
       return m_value;
    }
-   bool equal(const u8_to_u32_iterator& that)const
+   bool operator==(const u8_to_u32_iterator& that)const
    {
       return m_position == that.m_position;
    }
-   void increment()
+   bool operator!=(const u8_to_u32_iterator& that)const
+   {
+      return !(*this == that);
+   }
+   u8_to_u32_iterator& operator++()
    {
       // We must not start with a continuation character:
       if((static_cast<boost::uint8_t>(*m_position) & 0xC0) == 0x80)
@@ -549,8 +616,15 @@ public:
          std::advance(m_position, c);
       }
       m_value = pending_read;
+      return *this;
    }
-   void decrement()
+   u8_to_u32_iterator operator++(int)
+   {
+      u8_to_u32_iterator r(*this);
+      ++(*this);
+      return r;
+   }
+   u8_to_u32_iterator& operator--()
    {
       // Keep backtracking until we don't have a trailing character:
       unsigned count = 0;
@@ -559,6 +633,13 @@ public:
       if(count != detail::utf8_trailing_byte_count(*m_position))
          invalid_sequence();
       m_value = pending_read;
+      return *this;
+   }
+   u8_to_u32_iterator operator--(int)
+   {
+      u8_to_u32_iterator r(*this);
+      --(*this);
+      return r;
    }
    BaseIterator base()const
    {

data/src/cxx_supportlib/vendor-modified/boost/regex/v5/basic_regex_parser.hpp

@@ -1098,6 +1098,9 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
                   }
                   else
                      contin = false;
+                  break;
+               default:
+                  contin = false;
                }
             }
             else

data/src/cxx_supportlib/vendor-modified/boost/regex/v5/mem_block_cache.hpp

@@ -85,10 +85,10 @@ struct mem_block_node
 struct mem_block_cache
 {
    // this member has to be statically initialsed:
-   mem_block_node* next;
-   unsigned cached_blocks;
+   mem_block_node* next { nullptr };
+   unsigned cached_blocks { 0 };
 #ifdef BOOST_HAS_THREADS
-   boost::static_mutex mut;
+   std::mutex mut;
 #endif
 
    ~mem_block_cache()
@@ -133,11 +133,7 @@ struct mem_block_cache
    }
    static mem_block_cache& instance()
    {
-#ifdef BOOST_HAS_THREADS
-      static mem_block_cache block_cache = { 0, 0, BOOST_STATIC_MUTEX_INIT, };
-#else
-      static mem_block_cache block_cache = { 0, 0, };
-#endif
+      static mem_block_cache block_cache;
       return block_cache;
    }
 };

data/src/cxx_supportlib/vendor-modified/boost/regex/v5/unicode_iterator.hpp

@@ -67,8 +67,6 @@ Accepts UTF-32 code points and forwards them on as UTF-16 code points.
 #include <ios>
 #include <limits.h> // CHAR_BIT
 
-#include <iostream>
-
 #ifndef BOOST_REGEX_STANDALONE
 #include <boost/throw_exception.hpp>
 #endif

data/src/cxx_supportlib/vendor-modified/boost/regex/v5/w32_regex_traits.hpp

@@ -29,8 +29,12 @@
 #include <boost/regex/v5/primary_transform.hpp>
 #include <boost/regex/v5/object_cache.hpp>
 
-#define VC_EXTRALEAN
-#define WIN32_LEAN_AND_MEAN
+#ifndef VC_EXTRALEAN
+#  define VC_EXTRALEAN
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
 #include <windows.h>
 
 #if defined(_MSC_VER) && !defined(_WIN32_WCE) && !defined(UNDER_CE)

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/shared_count.hpp

@@ -387,7 +387,7 @@ public:
     {
         typedef typename sp_convert_reference<D>::type D2;
 
-        D2 d2( r.get_deleter() );
+        D2 d2( static_cast<D&&>( r.get_deleter() ) );
         pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
 
 #ifdef BOOST_NO_EXCEPTIONS

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/sp_counted_impl.hpp

@@ -145,7 +145,7 @@ template<class P, class D> class BOOST_SYMBOL_VISIBLE sp_counted_impl_pd: public
 private:
 
     P ptr; // copy constructor must not throw
-    D del; // copy constructor must not throw
+    D del; // copy/move constructor must not throw
 
     sp_counted_impl_pd( sp_counted_impl_pd const & );
     sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
@@ -156,10 +156,20 @@ public:
 
     // pre: d(p) must not throw
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( static_cast< D&& >( d ) )
+    {
+    }
+
+#else
+
     sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
     {
     }
 
+#endif
+
     sp_counted_impl_pd( P p ): ptr( p ), del()
     {
     }
@@ -218,7 +228,7 @@ template<class P, class D, class A> class BOOST_SYMBOL_VISIBLE sp_counted_impl_p
 private:
 
     P p_; // copy constructor must not throw
-    D d_; // copy constructor must not throw
+    D d_; // copy/move constructor must not throw
     A a_; // copy constructor must not throw
 
     sp_counted_impl_pda( sp_counted_impl_pda const & );
@@ -230,10 +240,20 @@ public:
 
     // pre: d( p ) must not throw
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( static_cast< D&& >( d ) ), a_( a )
+    {
+    }
+
+#else
+
     sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
     {
     }
 
+#endif
+
     sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
     {
     }

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/shared_ptr.hpp

@@ -374,39 +374,81 @@ public:
     }
 
     //
-    // Requirements: D's copy constructor must not throw
+    // Requirements: D's copy/move constructors must not throw
     //
     // shared_ptr will release p by calling d(p)
     //
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, static_cast< D&& >( d ) )
+    {
+        boost::detail::sp_deleter_construct( this, p );
+    }
+
+#else
+
     template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
     {
         boost::detail::sp_deleter_construct( this, p );
     }
 
+#endif
+
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, static_cast< D&& >( d ) )
+    {
+    }
+
+#else
+
     template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
     {
     }
 
+#endif
+
 #endif
 
     // As above, but with allocator. A's copy constructor shall not throw.
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, static_cast< D&& >( d ), a )
+    {
+        boost::detail::sp_deleter_construct( this, p );
+    }
+
+#else
+
     template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
     {
         boost::detail::sp_deleter_construct( this, p );
     }
 
+#endif
+
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, static_cast< D&& >( d ), a )
+    {
+    }
+
+#else
+
     template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
     {
     }
 
 #endif
 
+#endif
+
 //  generated copy constructor, destructor are fine...
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
@@ -693,6 +735,20 @@ public:
         this_type( p ).swap( *this );
     }
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y, class D> void reset( Y * p, D d )
+    {
+        this_type( p, static_cast< D&& >( d ) ).swap( *this );
+    }
+
+    template<class Y, class D, class A> void reset( Y * p, D d, A a )
+    {
+        this_type( p, static_cast< D&& >( d ), a ).swap( *this );
+    }
+
+#else
+
     template<class Y, class D> void reset( Y * p, D d )
     {
         this_type( p, d ).swap( *this );
@@ -703,6 +759,8 @@ public:
         this_type( p, d, a ).swap( *this );
     }
 
+#endif
+
     template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
     {
         this_type( r, p ).swap( *this );

data/src/cxx_supportlib/vendor-modified/boost/system/detail/config.hpp

@@ -13,20 +13,10 @@
 
 // BOOST_SYSTEM_HAS_SYSTEM_ERROR
 
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
+#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_CXX11_HDR_ATOMIC)
 # define BOOST_SYSTEM_HAS_SYSTEM_ERROR
 #endif
 
-#if BOOST_WORKAROUND(BOOST_GCC, < 40600)
-// g++ 4.4's <map> is not good enough
-# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
-
-#if defined(BOOST_NO_CXX11_HDR_MUTEX)
-// Required for thread-safe map manipulation
-# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
-
 // BOOST_SYSTEM_NOEXCEPT
 // Retained for backward compatibility
 
@@ -60,8 +50,16 @@
 # endif
 #elif defined(_MSC_VER)
 #  define BOOST_SYSTEM_DEPRECATED(msg) __declspec(deprecated(msg))
+#elif defined(__sun)
+#  define BOOST_SYSTEM_DEPRECATED(msg) __attribute__((deprecated(msg)))
 #else
 # define BOOST_SYSTEM_DEPRECATED(msg)
 #endif
 
+// BOOST_SYSTEM_CLANG_6
+
+#if defined(__clang__) && (__clang_major__ < 7 || (defined(__APPLE__) && __clang_major__ < 11))
+# define BOOST_SYSTEM_CLANG_6
+#endif
+
 #endif // BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED