passenger 6.0.13 → 6.0.15

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

@@ -3,7 +3,7 @@
 
 //  Copyright Beman Dawes 2006, 2007
 //  Copyright Christoper Kohlhoff 2007
-//  Copyright Peter Dimov 2017, 2018
+//  Copyright Peter Dimov 2017-2021
 //
 //  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)
@@ -18,12 +18,20 @@
 #include <boost/system/detail/interop_category.hpp>
 #include <boost/system/detail/enable_if.hpp>
 #include <boost/system/detail/is_same.hpp>
+#include <boost/system/detail/append_int.hpp>
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/system/detail/config.hpp>
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+# include <boost/system/detail/std_category.hpp>
+#endif
+
+#include <boost/assert/source_location.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/config.hpp>
 #include <ostream>
 #include <new>
+#include <cstdio>
 
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 # include <system_error>
@@ -77,36 +85,94 @@ private:
     // 1: holds std::error_code in d2_
     // 2: holds error code in d1_, failed == false
     // 3: holds error code in d1_, failed == true
-    unsigned flags_;
+    // >3: pointer to source_location, failed_ in lsb
+    boost::uintptr_t lc_flags_;
+
+private:
+
+    char const* category_name() const BOOST_NOEXCEPT
+    {
+        // return category().name();
+
+        if( lc_flags_ == 0 )
+        {
+            // must match detail::system_error_category::name()
+            return "system";
+        }
+        else if( lc_flags_ == 1 )
+        {
+            // must match detail::interop_error_category::name()
+            return "std:unknown";
+        }
+        else
+        {
+            return d1_.cat_->name();
+        }
+    }
 
 public:
 
     // constructors:
 
     BOOST_SYSTEM_CONSTEXPR error_code() BOOST_NOEXCEPT:
-        d1_(), flags_( 0 )
+        d1_(), lc_flags_( 0 )
     {
     }
 
     BOOST_SYSTEM_CONSTEXPR error_code( int val, const error_category & cat ) BOOST_NOEXCEPT:
-        d1_(), flags_( 2 + detail::failed_impl( val, cat ) )
+        d1_(), lc_flags_( 2 + detail::failed_impl( val, cat ) )
+    {
+        d1_.val_ = val;
+        d1_.cat_ = &cat;
+    }
+
+    error_code( int val, const error_category & cat, source_location const * loc ) BOOST_NOEXCEPT:
+        d1_(), lc_flags_( ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | +detail::failed_impl( val, cat ) )
     {
         d1_.val_ = val;
         d1_.cat_ = &cat;
     }
 
     template<class ErrorCodeEnum> BOOST_SYSTEM_CONSTEXPR error_code( ErrorCodeEnum e,
-        typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type* = 0 ) BOOST_NOEXCEPT
+        typename detail::enable_if<
+            is_error_code_enum<ErrorCodeEnum>::value
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+            || std::is_error_code_enum<ErrorCodeEnum>::value
+#endif
+        >::type* = 0 ) BOOST_NOEXCEPT: d1_(), lc_flags_( 0 )
     {
         *this = make_error_code( e );
     }
 
+    error_code( error_code const& ec, source_location const * loc ) BOOST_NOEXCEPT:
+        d1_(), lc_flags_( 0 )
+    {
+        *this = ec;
+
+        if( ec.lc_flags_ != 0 && ec.lc_flags_ != 1 )
+        {
+            lc_flags_ = ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | ( ec.lc_flags_ & 1 );
+        }
+    }
+
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
     error_code( std::error_code const& ec ) BOOST_NOEXCEPT:
-        flags_( 1 )
+        d1_(), lc_flags_( 0 )
     {
-        ::new( d2_ ) std::error_code( ec );
+#ifndef BOOST_NO_RTTI
+
+        if( detail::std_category const* pc2 = dynamic_cast< detail::std_category const* >( &ec.category() ) )
+        {
+            *this = boost::system::error_code( ec.value(), pc2->original_category() );
+        }
+        else
+
+#endif
+        {
+            ::new( d2_ ) std::error_code( ec );
+            lc_flags_ = 1;
+        }
     }
 
 #endif
@@ -118,6 +184,16 @@ public:
         *this = error_code( val, cat );
     }
 
+    void assign( int val, const error_category & cat, source_location const * loc ) BOOST_NOEXCEPT
+    {
+        *this = error_code( val, cat, loc );
+    }
+
+    void assign( error_code const& ec, source_location const * loc ) BOOST_NOEXCEPT
+    {
+        *this = error_code( ec, loc );
+    }
+
     template<typename ErrorCodeEnum>
         BOOST_SYSTEM_CONSTEXPR typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
         operator=( ErrorCodeEnum val ) BOOST_NOEXCEPT
@@ -135,7 +211,7 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR int value() const BOOST_NOEXCEPT
     {
-        if( flags_ != 1 )
+        if( lc_flags_ != 1 )
         {
             return d1_.val_;
         }
@@ -144,7 +220,11 @@ public:
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
             std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
-            return ec.value() + 1000 * static_cast<unsigned>( reinterpret_cast<boost::uintptr_t>( &ec.category() ) % 2097143 ); // 2^21-9, prime
+
+            unsigned cv = static_cast<unsigned>( ec.value() );
+            unsigned ch = static_cast<unsigned>( reinterpret_cast<boost::uintptr_t>( &ec.category() ) % 2097143 ); // 2^21-9, prime
+
+            return static_cast<int>( cv + 1000 * ch );
 #else
 
             return -1;
@@ -154,11 +234,11 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR const error_category & category() const BOOST_NOEXCEPT
     {
-        if( flags_ == 0 )
+        if( lc_flags_ == 0 )
         {
             return system_category();
         }
-        else if( flags_ == 1 )
+        else if( lc_flags_ == 1 )
         {
             return detail::interop_category();
         }
@@ -178,7 +258,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
             std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
             return ec.message();
@@ -186,47 +266,66 @@ public:
 
 #endif
 
-        return category().message( value() );
+        if( lc_flags_ == 0 )
+        {
+            return detail::system_error_category_message( value() );
+        }
+        else
+        {
+            return category().message( value() );
+        }
     }
 
     char const * message( char * buffer, std::size_t len ) const BOOST_NOEXCEPT
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-        if( flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
+            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
+
 #if !defined(BOOST_NO_EXCEPTIONS)
             try
 #endif
             {
-                std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
                 detail::snprintf( buffer, len, "%s", ec.message().c_str() );
                 return buffer;
             }
 #if !defined(BOOST_NO_EXCEPTIONS)
             catch( ... )
             {
+                detail::snprintf( buffer, len, "No message text available for error std:%s:%d", ec.category().name(), ec.value() );
+                return buffer;
             }
 #endif
         }
 #endif
 
-        return category().message( value(), buffer, len );
+        if( lc_flags_ == 0 )
+        {
+            return detail::system_error_category_message( value(), buffer, len );
+        }
+        else
+        {
+            return category().message( value(), buffer, len );
+        }
     }
 
     BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
     {
-#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-        if( flags_ == 1 )
+        if( lc_flags_ & 1 )
         {
-            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
-            return ec.value() != 0;
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+            if( lc_flags_ == 1 )
+            {
+                std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
+                return ec.value() != 0;
+            }
+#endif
+            return true;
         }
         else
-
-#endif
         {
-            return (flags_ & 1) != 0;
+            return false;
         }
     }
 
@@ -254,8 +353,43 @@ public:
 
 #endif
 
+    bool has_location() const BOOST_NOEXCEPT
+    {
+        return lc_flags_ >= 4;
+    }
+
+    source_location const & location() const BOOST_NOEXCEPT
+    {
+        BOOST_STATIC_CONSTEXPR source_location loc;
+        return lc_flags_ >= 4? *reinterpret_cast<source_location const*>( lc_flags_ &~ static_cast<boost::uintptr_t>( 1 ) ): loc;
+    }
+
     // relationals:
 
+private:
+
+    // private equality for use in error_category::equivalent
+
+    friend class error_category;
+
+    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const BOOST_NOEXCEPT
+    {
+        if( lc_flags_ == 0 )
+        {
+            return val == 0 && cat.id_ == detail::system_category_id;
+        }
+        else if( lc_flags_ == 1 )
+        {
+            return cat.id_ == detail::interop_category_id && val == value();
+        }
+        else
+        {
+            return val == d1_.val_ && cat == *d1_.cat_;
+        }
+    }
+
+public:
+
     //  the more symmetrical non-member syntax allows enum
     //  conversions work for both rhs and lhs.
 
@@ -263,7 +397,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( lhs.flags_ == 1 && rhs.flags_ == 1 )
+        if( lhs.lc_flags_ == 1 && rhs.lc_flags_ == 1 )
         {
             std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
             std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );
@@ -281,7 +415,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( lhs.flags_ == 1 && rhs.flags_ == 1 )
+        if( lhs.lc_flags_ == 1 && rhs.lc_flags_ == 1 )
         {
             std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
             std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );
@@ -304,7 +438,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( code.flags_ == 1 )
+        if( code.lc_flags_ == 1 )
         {
             return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
         }
@@ -320,7 +454,7 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( code.flags_ == 1 )
+        if( code.lc_flags_ == 1 )
         {
             return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
         }
@@ -444,14 +578,22 @@ public:
 
     operator std::error_code () const
     {
-        if( flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
             return *reinterpret_cast<std::error_code const*>( d2_ );
         }
-        else if( flags_ == 0 )
+        else if( lc_flags_ == 0 )
         {
-            //return std::error_code();
+// This condition must be the same as the one in error_category_impl.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)
+
             return std::error_code( 0, boost::system::system_category() );
+
+#else
+
+            return std::error_code();
+
+#endif
         }
         else
         {
@@ -468,11 +610,11 @@ public:
       class E = typename detail::enable_if<detail::is_same<T, std::error_code>::value>::type>
       operator T& ()
     {
-        if( flags_ != 1 )
+        if( lc_flags_ != 1 )
         {
             std::error_code e2( *this );
             ::new( d2_ ) std::error_code( e2 );
-            flags_ = 1;
+            lc_flags_ = 1;
         }
 
         return *reinterpret_cast<std::error_code*>( d2_ );
@@ -488,24 +630,51 @@ public:
 
 #endif
 
-    template<class Ch, class Tr>
-        inline friend std::basic_ostream<Ch, Tr>&
-        operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
+    std::string to_string() const
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( ec.flags_ == 1 )
+        if( lc_flags_ == 1 )
         {
-            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( ec.d2_ );
-            os << "std:" << e2.category().name() << ':' << e2.value();
+            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( d2_ );
+
+            std::string r( "std:" );
+            r += e2.category().name();
+            detail::append_int( r, e2.value() );
+
+            return r;
         }
         else
 #endif
         {
-            os << ec.category().name() << ':' << ec.value();
+            std::string r = category_name();
+            detail::append_int( r, value() );
+            return r;
+        }
+    }
+
+    template<class Ch, class Tr>
+        inline friend std::basic_ostream<Ch, Tr>&
+        operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
+    {
+        return os << ec.to_string().c_str();
+    }
+
+    std::string what() const
+    {
+        std::string r = message();
+
+        r += " [";
+        r += to_string();
+
+        if( has_location() )
+        {
+            r += " at ";
+            r += location().to_string();
         }
 
-        return os;
+        r += "]";
+        return r;
     }
 };
 
@@ -513,7 +682,7 @@ inline std::size_t hash_value( error_code const & ec )
 {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-    if( ec.flags_ == 1 )
+    if( ec.lc_flags_ == 1 )
     {
         std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( ec.d2_ );
         return std::hash<std::error_code>()( e2 );

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

@@ -3,7 +3,7 @@
 
 //  Copyright Beman Dawes 2006, 2007
 //  Copyright Christoper Kohlhoff 2007
-//  Copyright Peter Dimov 2017, 2018
+//  Copyright Peter Dimov 2017-2021
 //
 //  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,6 +15,7 @@
 #include <boost/system/detail/enable_if.hpp>
 #include <boost/system/detail/is_same.hpp>
 #include <boost/system/detail/errc.hpp>
+#include <boost/system/detail/append_int.hpp>
 #include <boost/system/is_error_condition_enum.hpp>
 #include <boost/system/detail/config.hpp>
 #include <boost/config.hpp>
@@ -45,25 +46,31 @@ class error_condition
 private:
 
     int val_;
-    bool failed_;
     error_category const * cat_;
 
+private:
+
+    boost::ulong_long_type cat_id() const BOOST_NOEXCEPT
+    {
+        return cat_? cat_->id_: detail::generic_category_id;
+    }
+
 public:
 
     // constructors:
 
     BOOST_SYSTEM_CONSTEXPR error_condition() BOOST_NOEXCEPT:
-        val_( 0 ), failed_( false ), cat_( 0 )
+        val_( 0 ), cat_( 0 )
     {
     }
 
     BOOST_SYSTEM_CONSTEXPR error_condition( int val, const error_category & cat ) BOOST_NOEXCEPT:
-        val_( val ), failed_( detail::failed_impl( val, cat ) ), cat_( &cat )
+        val_( val ), cat_( &cat )
     {
     }
 
     BOOST_SYSTEM_CONSTEXPR explicit error_condition( boost::system::detail::generic_value_tag vt ) BOOST_NOEXCEPT:
-        val_( vt.value ), failed_( vt.value != 0 ), cat_( 0 )
+        val_( vt.value ), cat_( 0 )
     {
     }
 
@@ -77,7 +84,7 @@ public:
 
     template<class ErrorConditionEnum> BOOST_SYSTEM_CONSTEXPR error_condition( ErrorConditionEnum e,
       typename detail::enable_if<boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value>::type* = 0) BOOST_NOEXCEPT:
-        val_( e ), failed_( e != 0 ), cat_( 0 )
+        val_( e ), cat_( 0 )
     {
     }
 
@@ -86,7 +93,6 @@ public:
     BOOST_SYSTEM_CONSTEXPR void assign( int val, const error_category & cat ) BOOST_NOEXCEPT
     {
         val_ = val;
-        failed_ = detail::failed_impl( val, cat );
         cat_ = &cat;
     }
 
@@ -101,7 +107,6 @@ public:
     BOOST_SYSTEM_CONSTEXPR void clear() BOOST_NOEXCEPT
     {
         val_ = 0;
-        failed_ = false;
         cat_ = 0;
     }
 
@@ -125,7 +130,7 @@ public:
         }
         else
         {
-            return generic_category().message( value() );
+            return detail::generic_error_category_message( value() );
         }
     }
 
@@ -137,20 +142,27 @@ public:
         }
         else
         {
-            return generic_category().message( value(), buffer, len );
+            return detail::generic_error_category_message( value(), buffer, len );
         }
     }
 
     BOOST_SYSTEM_CONSTEXPR bool failed() const BOOST_NOEXCEPT
     {
-        return failed_;
+        if( cat_ )
+        {
+            return detail::failed_impl( val_, *cat_ );
+        }
+        else
+        {
+            return val_ != 0;
+        }
     }
 
 #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
 
     BOOST_SYSTEM_CONSTEXPR explicit operator bool() const BOOST_NOEXCEPT  // true if error
     {
-        return failed_;
+        return failed();
     }
 
 #else
@@ -160,12 +172,12 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR operator unspecified_bool_type() const BOOST_NOEXCEPT  // true if error
     {
-        return failed_? unspecified_bool_true: 0;
+        return failed()? unspecified_bool_true: 0;
     }
 
     BOOST_SYSTEM_CONSTEXPR bool operator!() const BOOST_NOEXCEPT  // true if no error
     {
-        return !failed_;
+        return !failed();
     }
 
 #endif
@@ -176,7 +188,22 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
     {
-        return lhs.val_ == rhs.val_ && lhs.category() == rhs.category();
+        if( lhs.val_ != rhs.val_ )
+        {
+            return false;
+        }
+        else if( lhs.cat_ == 0 )
+        {
+            return rhs.cat_id() == detail::generic_category_id;
+        }
+        else if( rhs.cat_ == 0 )
+        {
+            return lhs.cat_id() == detail::generic_category_id;
+        }
+        else
+        {
+            return *lhs.cat_ == *rhs.cat_;
+        }
     }
 
     BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
@@ -195,7 +222,23 @@ public:
 
     operator std::error_condition () const
     {
+// This condition must be the same as the one in error_category_impl.hpp
+#if defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)
+
         return std::error_condition( value(), category() );
+
+#else
+
+        if( cat_ )
+        {
+            return std::error_condition( val_, *cat_ );
+        }
+        else
+        {
+            return std::error_condition( val_, std::generic_category() );
+        }
+
+#endif
     }
 
     inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) BOOST_NOEXCEPT
@@ -220,14 +263,29 @@ public:
 
 #endif
 
-    template<class Ch, class Tr>
-        inline friend std::basic_ostream<Ch, Tr>&
-        operator<< (std::basic_ostream<Ch, Tr>& os, error_condition const & en)
+    std::string to_string() const
     {
+        std::string r( "cond:" );
+
+        if( cat_ )
+        {
+            r += cat_->name();
+        }
+        else
         {
-            os << "cond:" << en.category().name() << ':' << en.value();
+            r += "generic";
         }
 
+        detail::append_int( r, value() );
+
+        return r;
+    }
+
+    template<class Ch, class Tr>
+        inline friend std::basic_ostream<Ch, Tr>&
+        operator<< (std::basic_ostream<Ch, Tr>& os, error_condition const & en)
+    {
+        os << en.to_string();
         return os;
     }
 };

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

@@ -49,6 +49,9 @@ inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
 
 #else
 
+#if defined(__GNUC__) && __GNUC__ >= 3
+__attribute__((__format__ (__printf__, 3, 4)))
+#endif
 inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
 {
     va_list args;