Disable the tn_holder<wchar_t> specialization when BOOST_NO_INTRINSIC_WCHAR_T. Refs #173.

.github/workflows/ci.yml

@@ -310,15 +310,15 @@ jobs:
               - libc++-15-dev
               - libc++abi-15-dev
 
-          - toolset: clang
-            cxxstd: "03,11,14,17,2a"
-            os: macos-11
           - toolset: clang
             cxxstd: "03,11,14,17,20,2b"
             os: macos-12
           - toolset: clang
             cxxstd: "03,11,14,17,20,2b"
             os: macos-13
+          - toolset: clang
+            cxxstd: "03,11,14,17,20,2b"
+            os: macos-14
 
     timeout-minutes: 45
     runs-on: ${{matrix.os}}
@@ -611,9 +611,9 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
           - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
     timeout-minutes: 10
@@ -678,9 +678,9 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
           - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
     timeout-minutes: 10
@@ -755,9 +755,9 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
           - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
     timeout-minutes: 20

doc/pointer_in_range.qbk

@@ -33,7 +33,7 @@ template<class T, class N>
 void
 Allocator<T, N>::deallocate(pointer ptr, size_type)
 {
-    if (!boost::pointer_in_range(ptr, &buffer_[0], &buffer_[N])) {
+    if (!boost::pointer_in_range(ptr, buffer_, buffer_ + N)) {
         ::operator delete(ptr);
     }
 }
@@ -56,8 +56,9 @@ constexpr bool pointer_in_range(const T* ptr, const T* begin, const T* end);
 
 [variablelist
 [[`template<class T> constexpr bool pointer_in_range(const T* ptr,
-const T* begin, T* end);`]
+const T* begin, const T* end);`]
 [[variablelist
+[[Requires][`[begin,end)` is a valid range.]]
 [[Returns][`true` if `ptr` is in range `[begin,end)`, otherwise `false`.]]]]]]
 
 [endsect]

include/boost/core/detail/minstd_rand.hpp

@@ -0,0 +1,58 @@
+#ifndef BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED
+
+// Copyright 2017 Peter Dimov
+//
+// 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
+//
+// An implementation of minstd_rand that does not require
+// the Random library
+
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+namespace detail
+{
+
+class minstd_rand
+{
+private:
+
+    boost::uint_least32_t x_;
+
+    enum { a = 48271, m = 2147483647 };
+
+public:
+
+    minstd_rand(): x_( 1 )
+    {
+    }
+
+    explicit minstd_rand( boost::uint_least32_t x ): x_( x % m )
+    {
+        if( x_ == 0 )
+        {
+            x_ = 1;
+        }
+    }
+
+    boost::uint_least32_t operator()()
+    {
+        boost::uint_least64_t y = x_;
+
+        y = ( a * y ) % m;
+
+        x_ = static_cast<boost::uint_least32_t>( y );
+
+        return x_;
+    }
+};
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_MINSTD_RAND_HPP_INCLUDED

include/boost/core/span.hpp

@@ -351,8 +351,10 @@ private:
     detail::span_store<T, E> s_;
 };
 
+#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
 template<class T, std::size_t E>
 constexpr std::size_t span<T, E>::extent;
+#endif
 
 #ifdef __cpp_deduction_guides
 template<class I, class L>

include/boost/core/type_name.hpp

@@ -103,7 +103,8 @@ inline std::string fix_typeid_name( char const* n )
 }
 
 // class types can be incomplete
-template<class T> std::string typeid_name_impl( int T::* )
+// but also abstract (T[1] doesn't form)
+template<class T> std::string typeid_name_impl( int T::*, T(*)[1] )
 {
     std::string r = fix_typeid_name( typeid(T[1]).name() );
     return r.substr( 0, r.size() - 4 ); // remove ' [1]' suffix
@@ -116,7 +117,7 @@ template<class T> std::string typeid_name_impl( ... )
 
 template<class T> std::string typeid_name()
 {
-    return typeid_name_impl<T>( 0 );
+    return typeid_name_impl<T>( 0, 0 );
 }
 
 // template names
@@ -345,6 +346,8 @@ template<> struct tn_holder<boost::uint128_type>
 
 #endif
 
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+
 template<> struct tn_holder<wchar_t>
 {
     static std::string type_name( std::string const& suffix )
@@ -353,6 +356,8 @@ template<> struct tn_holder<wchar_t>
     }
 };
 
+#endif
+
 #if !defined(BOOST_NO_CXX11_CHAR16_T)
 
 template<> struct tn_holder<char16_t>

test/Jamfile.v2

@@ -440,5 +440,8 @@ run yield_prim_pthread_cancel_test.cpp : ;
 run pointer_in_range_test.cpp ;
 compile pointer_in_range_constexpr_test.cpp ;
 
+run minstd_rand_test.cpp
+  : : : $(pedantic-errors) ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/minstd_rand_test.cpp

@@ -0,0 +1,38 @@
+// Test for boost/core/detail/minstd_rand.hpp
+//
+// Copyright 2022, 2024 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/minstd_rand.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/cstdint.hpp>
+
+int main()
+{
+    {
+        boost::detail::minstd_rand rng;
+
+        boost::uint_least32_t r1 = rng(), x1 = 48271;
+        BOOST_TEST_EQ( r1, x1 );
+
+        for( int i = 0; i < 1000; ++i ) rng();
+
+        boost::uint_least32_t r2 = rng(), x2 = 2076422031;
+        BOOST_TEST_EQ( r2, x2 );
+    }
+
+    {
+        boost::detail::minstd_rand rng( 12345 );
+
+        boost::uint_least32_t r1 = rng(), x1 = 595905495;
+        BOOST_TEST_EQ( r1, x1 );
+
+        for( int i = 0; i < 1000; ++i ) rng();
+
+        boost::uint_least32_t r2 = rng(), x2 = 1065162103;
+        BOOST_TEST_EQ( r2, x2 );
+    }
+
+    return boost::report_errors();
+}

test/type_name_test.cpp

@@ -55,6 +55,13 @@ template<class T1, class T2> struct X
 
 template<class T1, class T2> struct Y;
 
+class W
+{
+public:
+
+    virtual void f() = 0;
+};
+
 enum E1
 {
     e1
@@ -122,6 +129,7 @@ int main()
     TEST(A);
     TEST(B);
     TEST(C);
+    TEST(W);
 
     TEST(E1);
 
@@ -143,6 +151,9 @@ int main()
     TEST(C&);
     TEST(C const&);
 
+    TEST(W const);
+    TEST(W&);
+
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 
     TEST(B&&);
@@ -156,6 +167,8 @@ int main()
     TEST(C*);
     TEST(C const* volatile*);
 
+    TEST(W volatile*);
+
     TEST(void*);
     TEST(void const* volatile*);
 
@@ -307,6 +320,8 @@ int main()
 
     TEST(std::pair<C, C>);
 
+    TEST(std::pair<W, W>);
+
     TEST(std::pair<void, void>);
     TEST(std::pair<std::pair<void, void>, void>);
 
@@ -336,9 +351,11 @@ int main()
     TEST(X<A const&, B&> volatile&);
 
     TEST(X<C, C>);
+    TEST(X<W, W>);
 
     TEST(Y<A, B>);
     TEST(Y<C, C>);
+    TEST(Y<W, W>);
 
     TEST(X<std::pair<void, void>, void>);