Extend Clang 6 workaround to Clang 7 under Android. Fixes #100.

include/boost/system/detail/config.hpp

@@ -64,7 +64,9 @@
 
 // BOOST_SYSTEM_CLANG_6
 
-#if defined(__clang__) && (__clang_major__ < 7 || (defined(__APPLE__) && __clang_major__ < 11))
+// Android NDK r18b has Clang 7.0.2 that still needs the workaround
+// https://github.com/boostorg/system/issues/100
+#if defined(__clang__) && (__clang_major__ < 7 || (defined(__APPLE__) && __clang_major__ < 11) || (defined(__ANDROID__) && __clang_major__ == 7))
 # define BOOST_SYSTEM_CLANG_6
 #endif
 

include/boost/system/detail/error_category_impl.hpp

@@ -143,7 +143,7 @@ inline void error_category::init_stdcat() const
 
     if( sc_init_.load( std::memory_order_acquire ) == 0 )
     {
-        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, 0 );
+        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, system::detail::id_wrapper<0>() );
         sc_init_.store( 1, std::memory_order_release );
     }
 }
@@ -160,7 +160,7 @@ inline BOOST_NOINLINE error_category::operator std::error_category const & () co
 // This condition must be the same as the one in error_condition.hpp
 #if defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)
 
-        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
+        static const boost::system::detail::std_category generic_instance( this, system::detail::id_wrapper<0x1F4D3>() );
         return generic_instance;
 
 #else
@@ -175,7 +175,7 @@ inline BOOST_NOINLINE error_category::operator std::error_category const & () co
 // This condition must be the same as the one in error_code.hpp
 #if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)
 
-        static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
+        static const boost::system::detail::std_category system_instance( this, system::detail::id_wrapper<0x1F4D7>() );
         return system_instance;
 
 #else

include/boost/system/detail/error_code.hpp

@@ -403,7 +403,12 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( lhs.lc_flags_ == 1 && rhs.lc_flags_ == 1 )
+        bool s1 = lhs.lc_flags_ == 1;
+        bool s2 = rhs.lc_flags_ == 1;
+
+        if( s1 != s2 ) return false;
+
+        if( s1 && s2 )
         {
             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_ );
@@ -421,7 +426,13 @@ public:
     {
 #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
-        if( lhs.lc_flags_ == 1 && rhs.lc_flags_ == 1 )
+        bool s1 = lhs.lc_flags_ == 1;
+        bool s2 = rhs.lc_flags_ == 1;
+
+        if( s1 < s2 ) return true;
+        if( s2 < s1 ) return false;
+
+        if( s1 && s2 )
         {
             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_ );

include/boost/system/detail/std_category.hpp

@@ -11,6 +11,7 @@
 // See library home page at http://www.boost.org/libs/system
 
 #include <boost/system/detail/error_category.hpp>
+#include <boost/config.hpp>
 #include <system_error>
 
 //
@@ -24,6 +25,8 @@ namespace system
 namespace detail
 {
 
+template<unsigned Id> struct id_wrapper {};
+
 class BOOST_SYMBOL_VISIBLE std_category: public std::error_category
 {
 private:
@@ -39,20 +42,22 @@ public:
 
 public:
 
-    explicit std_category( boost::system::error_category const * pc, unsigned id ): pc_( pc )
+    template<unsigned Id>
+    explicit std_category( boost::system::error_category const * pc, id_wrapper<Id> ): pc_( pc )
     {
-        if( id != 0 )
-        {
 #if defined(_MSC_VER) && defined(_CPPLIB_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
 
-            // Poking into the protected _Addr member of std::error_category
-            // is not a particularly good programming practice, but what can
-            // you do
+        // We used to assign to the protected _Addr member of std::error_category
+        // here when Id != 0, but this should never happen now because this code
+        // path is no longer used
 
-            _Addr = id;
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+
+        static_assert( Id == 0, "This constructor should only be called with Id == 0 under MS STL 14.0+" );
+
+#endif
 
 #endif
-        }
     }
 
     const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE

test/CMakeLists.txt

@@ -132,6 +132,8 @@ boost_test(TYPE run SOURCES std_interop_test15.cpp)
 
 boost_test(TYPE run SOURCES win32_generic_test.cpp)
 
+boost_test(TYPE run SOURCES ec_hash_value_test.cpp)
+
 # result
 
 set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)

test/Jamfile.v2

@@ -160,6 +160,8 @@ run std_interop_test15.cpp ;
 
 run win32_generic_test.cpp ;
 
+run ec_hash_value_test.cpp ;
+
 # result
 
 import ../../config/checks/config : requires ;

test/ec_hash_value_test.cpp

@@ -0,0 +1,132 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+#include <system_error>
+#endif
+
+namespace sys = boost::system;
+
+int main()
+{
+    // normal against normal (equal, system)
+    {
+        sys::error_code e2( 0, sys::system_category() );
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (equal, generic)
+    {
+        sys::error_code e2( EINVAL, sys::generic_category() );
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (inequal, value, generic)
+    {
+        sys::error_code e2( 0, sys::generic_category() );
+        sys::error_code e3( EINVAL, sys::generic_category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (inequal, value, system)
+    {
+        sys::error_code e2( 1, sys::system_category() );
+        sys::error_code e3( 2, sys::system_category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal against normal (inequal, category)
+    {
+        sys::error_code e2( 0, sys::system_category() );
+        sys::error_code e3( 0, sys::generic_category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // empty against normal
+    {
+        sys::error_code e2;
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    // std:: wrapping against normal
+    {
+        std::error_code e1( EINVAL, std::generic_category() );
+
+        sys::error_code e2( e1 );
+        sys::error_code e3( e2.value(), e2.category() );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // empty against wrapping std:: empty
+    {
+        std::error_code e1;
+
+        sys::error_code e2( e1 );
+        sys::error_code e3;
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // empty against roundtrip via std
+    {
+        sys::error_code e2;
+
+        std::error_code e1( e2 );
+        sys::error_code e3( e1 );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal/generic against roundtrip via std
+    {
+        sys::error_code e2( EINVAL, boost::system::generic_category() );
+
+        std::error_code e1( e2 );
+        sys::error_code e3( e1 );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+    // normal/system against roundtrip via std
+    {
+        sys::error_code e2( 0, boost::system::system_category() );
+
+        std::error_code e1( e2 );
+        sys::error_code e3( e1 );
+
+        BOOST_TEST( e2 != e3 || hash_value( e2 ) == hash_value( e3 ) );
+        BOOST_TEST( e2 == e3 || hash_value( e2 ) != hash_value( e3 ) );
+    }
+
+#endif
+
+    return boost::report_errors();
+}