Only return an 8 bit result from report_errors

QNX provides cxxabi.h from LLVM libc++abi, which does not declare
__cxa_get_globals but provides its implementation in the library.
To make things more fun, QNX developers commented _LIBCPPABI_VERSION
definition, which breaks detection of libc++abi in uncaught_exceptions.hpp.

There is also cxxabi.h from glibcxx that does provide __cxa_get_globals
declaration. We want to use that declaration, if possible, to avoid possible
mismatch in attributes.

This commit adds non-glibcxx cxxabi.h on QNX to the list of platforms that
need our declaration of __cxa_get_globals.

Fixes https://github.com/boostorg/core/issues/59.

.travis.yml

@@ -291,6 +291,7 @@ install:
   - git submodule init libs/config
   - git submodule init libs/predef
   - git submodule init libs/static_assert
+  - git submodule init libs/throw_exception
   - git submodule init libs/type_traits
   - git submodule init tools/build
   - git submodule init tools/boost_install

appveyor.yml

@@ -1,4 +1,4 @@
-# Copyright 2016, 2017 Peter Dimov
+# Copyright 2016-2019 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
@@ -14,37 +14,39 @@ branches:
 
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
 
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-14.0
+      TOOLSET: msvc-12.0,msvc-14.0
+      ADDRMD: 32,64
 
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
+      TOOLSET: msvc-14.1,clang-win
+      ADDRMD: 32,64
       CXXSTD: 14,17
 
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\cygwin\bin;
       TOOLSET: gcc
       CXXSTD: 03,11,14,1z
 
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\cygwin64\bin;
       TOOLSET: gcc
       CXXSTD: 03,11,14,1z
 
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\mingw\bin;
       TOOLSET: gcc
       CXXSTD: 03,11,14,1z
 
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
       TOOLSET: gcc
       CXXSTD: 03,11,14,1z
 
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
       TOOLSET: gcc
       CXXSTD: 03,11,14,1z
@@ -60,11 +62,12 @@ install:
   - git submodule init libs/config
   - git submodule init libs/predef
   - git submodule init libs/static_assert
+  - git submodule init libs/throw_exception
   - git submodule init libs/type_traits
   - git submodule init tools/build
   - git submodule init tools/boost_install
   - git submodule update --jobs 4
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core\
   - cmd /c bootstrap
   - b2 headers
 
@@ -73,4 +76,5 @@ build: off
 test_script:
   - PATH=%ADDPATH%%PATH%
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release

doc/Jamfile.v2

@@ -49,7 +49,7 @@ boostbook standalone
     <xsl:param>boost.root=../../../..
     <xsl:param>generate.section.toc.level=1
     <xsl:param>toc.max.depth=1
-    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/core/doc/html
+    <format>pdf:<xsl:param>boost.url.prefix="http://www.boost.org/doc/libs/release/libs/core/doc/html"
   ;
 
 ###############################################################################

doc/alloc_construct.qbk

@@ -0,0 +1,149 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:alloc_construct alloc_construct, alloc_destroy]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/alloc_construct.hpp> provides function templates
+`alloc_construct`, `alloc_construct_n`, `alloc_destroy`, and `alloc_destroy_n`
+for allocator aware and exception safe construction and destruction of objects
+and arrays.
+
+[endsect]
+
+[section Example]
+
+The following example allocates storage for an array of `n` elements of `T`
+using an allocator `a` and constructs `T` elements in that storage. If any
+exception was thrown during construction of an element, the constructed
+elements are destroyed in reverse order.
+
+```
+template<class A>
+auto create(A& a, std::size_t n)
+{
+    auto p = a.allocate(n);
+    try {
+        boost::alloc_construct_n(a, boost::to_address(p), n);
+    } catch (...) {
+        a.deallocate(p, n);
+        throw;
+    }
+    return p;
+}
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class A, class T>
+void alloc_destroy(A& a, T* p);
+
+template<class A, class T>
+void alloc_destroy_n(A& a, T* p, std::size_t n);
+
+template<class A, class T, class Args>
+void alloc_construct(A& a, T* p, Args&&... args);
+
+template<class A, class T>
+void alloc_construct_n(A& a, T* p, std::size_t n);
+
+template<class A, class T>
+void alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m);
+
+template<class A, class T, class I>
+void alloc_construct_n(A& a, T* p, std::size_t n, I begin);
+
+} /* boost */
+```
+
+[section Functions]
+
+[variablelist
+[[`template<class A, class T> void alloc_destroy(A& a, T* p);`]
+[[variablelist
+[[Requires][`A` is an /Allocator/]]
+[[Effects][`std::allocator_traits<A>::destroy(a, p)`.]]]]]
+[[`template<class A, class T> void alloc_destroy_n(A& a, T* p,
+std::size_t n);`]
+[[variablelist
+[[Requires][`A` is an /Allocator/]]
+[[Effects]
+[Destroys each `i`-th element in reverse order by calling
+`std::allocator_traits<A>::destroy(a, &p[i])`.]]]]]
+[[`template<class A, class T, class Args> void alloc_construct(A& a, T* p,
+Args&&... args);`]
+[[variablelist
+[[Requires][`A` is an /Allocator/]]
+[[Effects]
+[`std::allocator_traits<A>::construct(a, p, std::forward<Args>(args)...)`.]]]]]
+[[`template<class A, class T> void alloc_construct_n(A& a, T* p,
+std::size_t n);`]
+[[variablelist
+[[Requires][`A` is an /Allocator/]]
+[[Effects]
+[Constructs each `i`-th element in order by calling
+`std::allocator_traits<A>::construct(a, &p[i])`.]]
+[[Remarks]
+[If an exception is thrown destroys each already constructed `j`-th element in
+reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]
+[[`template<class A, class T> void alloc_construct_n(A& a, T* p, std::size_t n,
+const T* l, std::size_t m);`]
+[[variablelist
+[[Requires][`A` is an /Allocator/]]
+[[Effects]
+[Constructs each `i`-th element in order by calling
+`std::allocator_traits<A>::construct(a, &p[i], l[i % m])`.]]
+[[Remarks]
+[If an exception is thrown destroys each already constructed `j`-th element in
+reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]
+[[`template<class A, class T, class I> void alloc_construct_n(A& a, T* p,
+std::size_t n, I begin);`]
+[[variablelist
+[[Requires]
+[[itemized_list
+[`A` is an /Allocator/][`I` is an /InputIterator/]]]]
+[[Effects]
+[Constructs each `i`-th element in order by calling
+`std::allocator_traits<A>::construct(a, &p[i], *begin++])`.]]
+[[Remarks]
+[If an exception is thrown destroys each already constructed `j`-th element in
+reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]]
+
+[endsect]
+
+[endsect]
+
+[section Compatibility]
+
+When `BOOST_NO_CXX11_ALLOCATOR` is defined, and the C++11 allocator model is
+not supported, these functions invoke constructors and destructors directly
+without going through the supplied allocator.
+
+[endsect]
+
+[section Acknowledgments]
+
+Glen Fernandes originally implemented this functionality in Boost.Smart_Ptr and
+later moved these functions to Boost.Core for use in other Boost libraries,
+such as Boost.Multi_Array and Boost.Histogram.
+
+[endsect]
+
+[endsect]

doc/core.qbk

@@ -39,16 +39,20 @@ criteria for inclusion is that the utility component be:
 [endsect]
 
 [include addressof.qbk]
+[include alloc_construct.qbk]
 [include checked_delete.qbk]
+[include default_allocator.qbk]
 [include demangle.qbk]
 [include empty_value.qbk]
 [include enable_if.qbk]
 [include exchange.qbk]
 [include explicit_operator_bool.qbk]
+[include first_scalar.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
 [include lightweight_test.qbk]
 [include no_exceptions_support.qbk]
+[include noinit_adaptor.qbk]
 [include noncopyable.qbk]
 [include null_deleter.qbk]
 [include pointer_traits.qbk]
@@ -58,3 +62,4 @@ criteria for inclusion is that the utility component be:
 [include swap.qbk]
 [include typeinfo.qbk]
 [include uncaught_exceptions.qbk]
+[include use_default.qbk]

doc/default_allocator.qbk

@@ -0,0 +1,140 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:default_allocator default_allocator]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/default_allocator.hpp> provides the class template
+`boost::default_allocator` to serve as a minimal default allocator that:
+
+* Like C++2a's `std::allocator`, does not provide members such as `construct()`
+and `destroy()` to be eligible for optimizations by allocator-aware code that
+detects the absence of these members to provide more optimal construction.
+* Supports `BOOST_NO_EXCEPTIONS` in allocation.
+* Does not have `std` as an associated namespace.
+
+[endsect]
+
+[section Examples]
+
+The following snippet shows the use of this allocator as the default allocator
+for a container.
+
+```
+template<class Key, class Compare = std::less<Key>,
+    class Allocator = boost::default_allocator<Key> >
+class FlatSet;
+```
+
+Facilities like `make_shared` can be implemented using `allocate_shared` with
+`default_allocator`.
+
+```
+template<class T, class... Args>
+enable_if_t<!is_array_v<T>, shared_ptr<T> >
+make_shared(Args&&... args)
+{
+    return allocate_shared<T>(boost::default_allocator<remove_cv_t<T> >(),
+        std::forward<Args>(args)...);
+}
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class T>
+struct default_allocator {
+    typedef T value_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef std::add_lvalue_reference_t<T> reference;
+    typedef std::add_lvalue_reference_t<const T> const_reference;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef ``['true_type]`` propagate_on_container_move_assignment;
+    typedef ``['true_type]`` is_always_equal;
+
+    template<class U>
+    struct rebind {
+        typedef default_allocator<U> other;
+    };
+
+    constexpr default_allocator() = default;
+
+    template<class U>
+    constexpr default_allocator(const default_allocator<U>&) noexcept { }
+
+    constexpr std::size_t max_size() const noexcept;
+    T* allocate(std::size_t n);
+    void deallocate(T* p, std::size_t);
+};
+
+template<class T, class U>
+constexpr bool operator==(const default_allocator<T>&,
+    const default_allocator<U>&) noexcept;
+
+template<class T, class U>
+constexpr bool operator!=(const default_allocator<T>&,
+    const default_allocator<U>&) noexcept;
+
+} /* boost */
+```
+
+[section Members]
+
+[variablelist
+[[`constexpr std::size_t max_size() const noexcept;`]
+[[variablelist
+[[Returns][The largest value `N` for which the call `allocate(N)` might
+succeed.]]]]]
+[[`T* allocate(std::size_t n);`]
+[[variablelist
+[[Returns]
+[A pointer to the initial element of an array of storage of size
+`n * sizeof(T)`, aligned appropriately for objects of type `T`.]]
+[[Remarks][The storage is obtained by calling `::operator new`.]]
+[[Throws][`std::bad_alloc` if the storage cannot be obtained.]]]]]
+[[`void deallocate(T* p, std::size_t n);`]
+[[variablelist
+[[Requires]
+[`p` shall be a pointer value obtained from `allocate()`. `n` shall equal the
+value passed as the first argument to the invocation of `allocate` which
+returned `p`.]]
+[[Effects][Deallocates the storage referenced by `p`.]]
+[[Remarks][Uses `::operator delete`.]]]]]]
+
+[endsect]
+
+[section Operators]
+
+[variablelist
+[[`template<class T, class U> constexpr bool operator==(const
+default_allocator<T>&, const default_allocator<U>&) noexcept;`]
+[[variablelist
+[[Returns][`true`.]]]]]
+[[`template<class T, class U> constexpr bool operator!=(const
+default_allocator<T>&, const default_allocator<U>&) noexcept;`]
+[[variablelist
+[[Returns][`false`.]]]]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/empty_value.qbk

@@ -111,7 +111,8 @@ public:
 
 [section Member types]
 
-[variablelist [[`type`][The template parameter `T`]]]
+[variablelist
+[[`type`][The template parameter `T`]]]
 
 [endsect]
 

doc/exchange.qbk

@@ -18,7 +18,8 @@ Distributed under the Boost Software License, Version 1.0.
 
 The header <boost/core/exchange.hpp> provides the function template
 `boost::exchange` which is an implementation of the `std::exchange`
-function introduced in C++14.
+function introduced in C++14. `boost::exchange(o, v)` replaces the
+value of `o` with `v` and returns the old value of `o`.
 
 [endsect]
 

doc/first_scalar.qbk

@@ -0,0 +1,91 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:first_scalar first_scalar]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/first_scalar.hpp> provides the function templates
+`boost::first_scalar` that can be used to obtain a pointer to the first scalar
+element of an array. Given a pointer of type `T*` they return a pointer of
+type `remove_all_extents_t<T>*`. The functions are `constexpr` and can be used
+in constant expressions.
+
+[endsect]
+
+[section Examples]
+
+The following function uses an allocator to allocate an array of arrays and
+constructs each scalar element in it.
+
+```
+#include <boost/alloc_construct.hpp>
+#include <boost/first_scalar.hpp>
+
+template<class A>
+auto create(const A& allocator)
+{
+    typename std::allocator_traits<A>::template
+        rebind_alloc<int[2][3]> other(allocator);
+    auto ptr = other.allocate(4);
+    try {
+        boost::alloc_construct_n(other,
+            boost::first_scalar(boost::to_address(ptr)), 24);
+    } catch (...) {
+        other.deallocate(ptr, 4);
+        throw;
+    }
+    return ptr;
+}
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class T>
+constexpr T* first_scalar(T* p) noexcept;
+
+template<class T, std::size_t N>
+constexpr auto first_scalar(T (*p)[N]) noexcept;
+
+} /* boost */
+```
+
+[section Functions]
+
+[variablelist
+[[`template<class T> constexpr T* first_scalar(T* p) noexcept;`]
+[[variablelist
+[[Returns][`p`.]]]]]
+[[`template<class T, std::size_t N> constexpr auto first_scalar(T (*p)[N])
+noexcept;`]
+[[variablelist
+[[Returns][`first_scalar(&(*p)[0])`.]]]]]]
+
+[endsect]
+
+[endsect]
+
+[section History]
+
+Glen Fernandes implemented `first_scalar`. Peter Dimov suggested a change for
+GCC to support an additional `constexpr` use.
+
+[endsect]
+
+[endsect]

doc/noinit_adaptor.qbk

@@ -0,0 +1,172 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:noinit_adaptor noinit_adaptor]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/noinit_adaptor.hpp> provides the class
+template `boost::noinit_adaptor` that converts any allocator into
+one whose `construct(ptr)` performs default initialization via placement new,
+and whose `destroy(ptr)` invokes `value_type` destructor directly.
+
+[endsect]
+
+[section Examples]
+
+The following example shows use of this allocator adaptor to achieve default
+initialization of elements of a trivial type, which are later assigned values.
+
+```
+#include <boost/core/noinit_adaptor.hpp>
+#include <numeric>
+#include <vector>
+
+int main()
+{
+    std::vector<int, boost::noinit_adaptor<std::allocator<int> > > v(5);
+    std::iota(v.begin(), v.end(), 1);
+}
+```
+
+The `allocate_shared_noinit` function templates are now implemented simply
+using `allocate_shared` with `noinit_adaptor`.
+
+```
+template<class T, class A>
+enable_if_t<is_unbounded_array_v<T>, shared_ptr<T> >
+allocate_shared_noinit(const A& a, size_t n)
+{
+    return allocate_shared<T>(boost::noinit_adapt(a), n);
+}
+
+template<class T, class A>
+enable_if_t<!is_unbounded_array_v<T>, shared_ptr<T> >
+allocate_shared_noinit(const A& a)
+{
+    return allocate_shared<T>(boost::noinit_adapt(a));
+}
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+template<class A>
+struct noinit_adaptor
+    : A {
+    template<class U>
+    struct rebind {
+        typedef noinit_adaptor<typename std::allocator_traits<A>::template
+            rebind_alloc<U> > other;
+    };
+
+    noinit_adaptor() noexcept;
+
+    template<class U>
+    noinit_adaptor(U&& u) noexcept;
+
+    template<class U>
+    noinit_adaptor(const noinit_adaptor<U>& u) noexcept;
+
+    template<class U>
+    void construct(U* p);
+
+    template<class U, class V, class... Args>
+    void construct(U* p, V&& v, Args&&... args);
+
+    template<class U>
+    void destroy(U* p);
+};
+
+template<class T, class U>
+bool operator==(const noinit_adaptor<T>& lhs,
+    const noinit_adaptor<U>& rhs) noexcept;
+
+template<class T, class U>
+bool operator!=(const noinit_adaptor<T>& lhs,
+    const noinit_adaptor<U>& rhs) noexcept;
+
+template<class A>
+noinit_adaptor<A> noinit_adapt(const A& a) noexcept;
+
+} /* boost */
+```
+
+[section Constructors]
+
+[variablelist
+[[`noinit_adaptor() noexcept;`]
+[[variablelist
+[[Effects][Value initializes the A base class.]]]]]
+[[`template<class U> noinit_adaptor(U&& u) noexcept;`]
+[[variablelist
+[[Requires][`A` shall be constructible from `U`.]]
+[[Effects][Initializes the `A` base class with `std::forward<U>(u)`.]]]]]
+[[`template<class U> noinit_adaptor(const noinit_adaptor<U>& u) noexcept;`]
+[[variablelist
+[[Requires][`A` shall be constructible from `U`.]]
+[[Effects][Initializes the `A` base class with
+`static_cast<const U&>(u)`.]]]]]]
+
+[endsect]
+
+[section Member functions]
+
+[variablelist
+[[`template<class U> void construct(U* p);`]
+[[variablelist
+[[Effects][`::new((void*)p) U`.]]]]]
+[[`template<class U, class V, class... Args> void construct(U* p, V&& v,
+Args&&... args);`]
+[[variablelist
+[[Effects][`::new(void*)p) U(std::forward<V>(v),
+std::forward<Args>(args)...)`.]]]]]
+[[`template<class U> void destroy(U* p);`]
+[[variablelist
+[[Effects][`p->~U()`.]]]]]]
+
+[endsect]
+
+[section Operators]
+
+[variablelist
+[[`template<class T, class U> constexpr bool
+operator==(const noinit_adaptor<T>& lhs,
+const noinit_adaptor<U>& rhs) noexcept;`]
+[[variablelist
+[[Returns][`static_cast<const T&>(lhs) == static_cast<const U&>(rhs)`.]]]]]
+[[`template<class T, class U> constexpr bool
+operator!=(const noinit_adaptor<T>& lhs,
+const noinit_adaptor<U>& rhs) noexcept;`]
+[[variablelist
+[[Returns][`!(lhs == rhs)`.]]]]]]
+
+[endsect]
+
+[section Free functions]
+
+[variablelist
+[[`template<class A> noinit_adaptor<A> noinit_adapt(const A& a) noexcept;`]
+[[variablelist
+[[Returns][`noinit_adaptor<A>(a)`.]]]]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/pointer_traits.qbk

@@ -109,7 +109,7 @@ namespace boost {
 [[Remark]
 [If `element_type` is a void type, the type of `v` is unspecified; otherwise,
   it is `element_type&`.]]
-[[Returns] [`addressof(v)`.]]]]]]
+[[Returns][`addressof(v)`.]]]]]]
 
 [endsect]
 
@@ -131,9 +131,11 @@ namespace boost {
 
 [variablelist
 [[`template<class T> constexpr T* to_address(T* v) noexcept;`]
-[[variablelist [[Returns] [`v`.]]]]]
+[[variablelist
+[[Returns][`v`.]]]]]
 [[`template<class T> auto to_address(const T& v) noexcept;`]
-[[variablelist [[Returns] [`pointer_traits<T>::to_address(v)` if that
+[[variablelist
+[[Returns][`pointer_traits<T>::to_address(v)` if that
   expression is well-formed, otherwise `to_address(v.operator->())`.]]]]]]
 
 [endsect]

doc/scoped_enum.qbk

@@ -67,9 +67,9 @@ The enumeration can be forward declared:
 
     BOOST_SCOPED_ENUM_FORWARD_DECLARE(future_errc);
 
-There are however some limitations. First, the emulated scoped enum is not a C++ enum, so `is_enum< future_errc >` will be `false_type`.
+There are however some limitations. The emulated scoped enum is not a C++ enum, so `is_enum< future_errc >` will be `false_type`.
 
-Second, the emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some helpers. Instead of
+The emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some helpers. Instead of
 
     switch (ev)
     {
@@ -99,10 +99,29 @@ use
     {
     };
 
-Lastly, explicit conversion to the underlying type should be performed with `boost::underlying_cast` instead of `static_cast`:
+Explicit conversion to the underlying type should be performed with `boost::underlying_cast` instead of `static_cast`:
 
     unsigned int val = boost::underlying_cast< unsigned int >(ev);
 
+In C++03, scoped enums behave differently in case of calling an overloaded function when one overload takes a scoped enum as a parameter, and the other takes a parameter of an integral type. Consider the following code:
+
+    enum enum_regular { REGULAR_A, REGULAR_B };
+
+    BOOST_SCOPED_ENUM_DECLARE_BEGIN(enum_scoped)
+    {
+        a, b
+    }
+    BOOST_SCOPED_ENUM_DECLARE_END(enum_scoped)
+
+    void regular_or_int(enum_regular); // (1)
+    void regular_or_int(int);          // (2)
+    void scoped_or_int(enum_scoped);   // (3)
+    void scoped_or_int(int);           // (4)
+
+    regular_or_int(REGULAR_A);                  // calls (1) in C++03 and C++11
+    scoped_or_int(enum_scoped::a);              // calls (3) in C++11 but (4) in C++03!
+    scoped_or_int(enum_scoped(enum_scoped::a)); // calls (3) in C++03 and C++11
+
 Here is usage example:
 
     BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(algae, char)

doc/use_default.qbk

@@ -0,0 +1,47 @@
+[/
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:use_default use_default]
+
+[section Overview]
+
+The header <boost/core/use_default.hpp> provides the type `boost::use_default`
+which is used by other Boost libraries as a sentinel type in a templates to
+indicate defaults.
+
+[endsect]
+
+[section Example]
+
+```
+template<class Derived, class Base,
+   class Value = boost::use_default,
+   class CategoryOrTraversal = boost::use_default,
+   class Reference = boost::use_default,
+   class Difference = boost::use_default>
+class iterator_adaptor;
+
+template<class Value>
+class node_iterator
+    : public iterator_adaptor<node_iterator<Value>, Value*,
+        boost::use_default, boost::forward_traversal_tag>;
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+  struct use_default { };
+}
+```
+
+[endsect]
+
+[endsect]

include/boost/core/alloc_construct.hpp

@@ -0,0 +1,245 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_ALLOC_CONSTRUCT_HPP
+#define BOOST_CORE_ALLOC_CONSTRUCT_HPP
+
+#include <boost/core/noinit_adaptor.hpp>
+
+namespace boost {
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class A, class T>
+inline void
+alloc_destroy(A& a, T* p)
+{
+    std::allocator_traits<A>::destroy(a, p);
+}
+
+template<class A, class T>
+inline void
+alloc_destroy_n(A& a, T* p, std::size_t n)
+{
+    while (n > 0) {
+        std::allocator_traits<A>::destroy(a, p + --n);
+    }
+}
+#else
+template<class A, class T>
+inline void
+alloc_destroy(A&, T* p)
+{
+    p->~T();
+}
+
+template<class A, class T>
+inline void
+alloc_destroy_n(A&, T* p, std::size_t n)
+{
+    while (n > 0) {
+        p[--n].~T();
+    }
+}
+#endif
+
+namespace detail {
+
+template<class A, class T>
+class alloc_destroyer {
+public:
+    alloc_destroyer(A& a, T* p) BOOST_NOEXCEPT
+        : a_(a),
+          p_(p),
+          n_(0) { }
+
+    ~alloc_destroyer() {
+        boost::alloc_destroy_n(a_, p_, n_);
+    }
+
+    std::size_t& size() BOOST_NOEXCEPT {
+        return n_;
+    }
+
+private:
+    alloc_destroyer(const alloc_destroyer&);
+    alloc_destroyer& operator=(const alloc_destroyer&);
+
+    A& a_;
+    T* p_;
+    std::size_t n_;
+};
+
+} /* detail */
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class A, class T>
+inline void
+alloc_construct(A& a, T* p)
+{
+    std::allocator_traits<A>::construct(a, p);
+}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<class A, class T, class U, class... V>
+inline void
+alloc_construct(A& a, T* p, U&& u, V&&... v)
+{
+    std::allocator_traits<A>::construct(a, p, std::forward<U>(u),
+        std::forward<V>(v)...);
+}
+#else
+template<class A, class T, class U>
+inline void
+alloc_construct(A& a, T* p, U&& u)
+{
+    std::allocator_traits<A>::construct(a, p, std::forward<U>(u));
+}
+#endif
+#else
+template<class A, class T, class U>
+inline void
+alloc_construct(A& a, T* p, const U& u)
+{
+    std::allocator_traits<A>::construct(a, p, u);
+}
+
+template<class A, class T, class U>
+inline void
+alloc_construct(A& a, T* p, U& u)
+{
+    std::allocator_traits<A>::construct(a, p, u);
+}
+#endif
+
+template<class A, class T>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; ++i) {
+        std::allocator_traits<A>::construct(a, p + i);
+    }
+    hold.size() = 0;
+}
+
+template<class A, class T>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; ++i) {
+        std::allocator_traits<A>::construct(a, p + i, l[i % m]);
+    }
+    hold.size() = 0;
+}
+
+template<class A, class T, class I>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n, I b)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; void(++i), void(++b)) {
+        std::allocator_traits<A>::construct(a, p + i, *b);
+    }
+    hold.size() = 0;
+}
+#else
+template<class A, class T>
+inline void
+alloc_construct(A&, T* p)
+{
+    ::new(static_cast<void*>(p)) T();
+}
+
+template<class A, class T>
+inline void
+alloc_construct(noinit_adaptor<A>&, T* p)
+{
+    ::new(static_cast<void*>(p)) T;
+}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<class A, class T, class U, class... V>
+inline void
+alloc_construct(A&, T* p, U&& u, V&&... v)
+{
+    ::new(static_cast<void*>(p)) T(std::forward<U>(u), std::forward<V>(v)...);
+}
+#else
+template<class A, class T, class U>
+inline void
+alloc_construct(A& a, T* p, U&& u)
+{
+    ::new(static_cast<void*>(p)) T(std::forward<U>(u));
+}
+#endif
+#else
+template<class A, class T, class U>
+inline void
+alloc_construct(A&, T* p, const U& u)
+{
+    ::new(static_cast<void*>(p)) T(u);
+}
+
+template<class A, class T, class U>
+inline void
+alloc_construct(A&, T* p, U& u)
+{
+    ::new(static_cast<void*>(p)) T(u);
+}
+#endif
+
+template<class A, class T>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; ++i) {
+        ::new(static_cast<void*>(p + i)) T();
+    }
+    hold.size() = 0;
+}
+
+template<class A, class T>
+inline void
+alloc_construct_n(noinit_adaptor<A>& a, T* p, std::size_t n)
+{
+    detail::alloc_destroyer<noinit_adaptor<A>, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; ++i) {
+        ::new(static_cast<void*>(p + i)) T;
+    }
+    hold.size() = 0;
+}
+
+template<class A, class T>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; ++i) {
+        ::new(static_cast<void*>(p + i)) T(l[i % m]);
+    }
+    hold.size() = 0;
+}
+
+template<class A, class T, class I>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n, I b)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; void(++i), void(++b)) {
+        ::new(static_cast<void*>(p + i)) T(*b);
+    }
+    hold.size() = 0;
+}
+#endif
+
+} /* boost */
+
+#endif

include/boost/core/default_allocator.hpp

@@ -0,0 +1,158 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_DEFAULT_ALLOCATOR_HPP
+#define BOOST_CORE_DEFAULT_ALLOCATOR_HPP
+
+#include <boost/config.hpp>
+#include <new>
+#include <climits>
+
+#if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 60000
+#define BOOST_CORE_NO_CXX11_ALLOCATOR
+#endif
+
+namespace boost {
+
+#if defined(BOOST_NO_EXCEPTIONS)
+void throw_exception(const std::exception&);
+#endif
+
+namespace default_ {
+
+struct true_type {
+    typedef bool value_type;
+    typedef true_type type;
+
+    BOOST_STATIC_CONSTANT(bool, value = true);
+
+    BOOST_CONSTEXPR operator bool() const BOOST_NOEXCEPT {
+        return true;
+    }
+
+    BOOST_CONSTEXPR bool operator()() const BOOST_NOEXCEPT {
+        return true;
+    }
+};
+
+template<class T>
+struct add_reference {
+    typedef T& type;
+};
+
+template<>
+struct add_reference<void> {
+    typedef void type;
+};
+
+template<>
+struct add_reference<const void> {
+    typedef const void type;
+};
+
+template<class T>
+struct default_allocator {
+    typedef T value_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef typename add_reference<T>::type reference;
+    typedef typename add_reference<const T>::type const_reference;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef true_type propagate_on_container_move_assignment;
+    typedef true_type is_always_equal;
+
+    template<class U>
+    struct rebind {
+        typedef default_allocator<U> other;
+    };
+
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    default_allocator() = default;
+#else
+    BOOST_CONSTEXPR default_allocator() BOOST_NOEXCEPT { }
+#endif
+
+    template<class U>
+    BOOST_CONSTEXPR default_allocator(const default_allocator<U>&)
+        BOOST_NOEXCEPT { }
+
+#if defined(PTRDIFF_MAX) && defined(SIZE_MAX)
+    BOOST_CONSTEXPR std::size_t max_size() const BOOST_NOEXCEPT {
+        return PTRDIFF_MAX < SIZE_MAX / sizeof(T)
+            ? PTRDIFF_MAX : SIZE_MAX / sizeof(T);
+    }
+#else
+    BOOST_CONSTEXPR std::size_t max_size() const BOOST_NOEXCEPT {
+        return ~static_cast<std::size_t>(0) / sizeof(T);
+    }
+#endif
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+    T* allocate(std::size_t n) {
+        if (n > max_size()) {
+            throw std::bad_alloc();
+        }
+        return static_cast<T*>(::operator new(sizeof(T) * n));
+    }
+
+    void deallocate(T* p, std::size_t) {
+        ::operator delete(p);
+    }
+#else
+    T* allocate(std::size_t n) {
+        if (n > max_size()) {
+            boost::throw_exception(std::bad_alloc());
+        }
+        void* p = ::operator new(sizeof(T) * n, std::nothrow);
+        if (!p) {
+            boost::throw_exception(std::bad_alloc());
+        }
+        return static_cast<T*>(p);
+    }
+
+    void deallocate(T* p, std::size_t) {
+        ::operator delete(p, std::nothrow);
+    }
+#endif
+
+#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_CORE_NO_CXX11_ALLOCATOR)
+    template<class U, class V>
+    void construct(U* p, const V& v) {
+        ::new(p) U(v);
+    }
+
+    template<class U>
+    void destroy(U* p) {
+        p->~U();
+    }
+#endif
+};
+
+template<class T, class U>
+BOOST_CONSTEXPR inline bool
+operator==(const default_allocator<T>&,
+    const default_allocator<U>&) BOOST_NOEXCEPT
+{
+    return true;
+}
+
+template<class T, class U>
+BOOST_CONSTEXPR inline bool
+operator!=(const default_allocator<T>&,
+    const default_allocator<U>&) BOOST_NOEXCEPT
+{
+    return false;
+}
+
+} /* default_ */
+
+using default_::default_allocator;
+
+} /* boost */
+
+#endif

include/boost/core/empty_value.hpp

@@ -71,6 +71,10 @@ public:
     template<class U>
     empty_value(boost::empty_init_t, const U& value)
         : value_(value) { }
+
+    template<class U>
+    empty_value(boost::empty_init_t, U& value)
+        : value_(value) { }
 #endif
 
     const T& get() const BOOST_NOEXCEPT {
@@ -115,6 +119,10 @@ public:
     template<class U>
     empty_value(boost::empty_init_t, const U& value)
         : T(value) { }
+
+    template<class U>
+    empty_value(boost::empty_init_t, U& value)
+        : T(value) { }
 #endif
 
     const T& get() const BOOST_NOEXCEPT {

include/boost/core/first_scalar.hpp

@@ -0,0 +1,45 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_FIRST_SCALAR_HPP
+#define BOOST_CORE_FIRST_SCALAR_HPP
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace detail {
+
+template<class T>
+struct make_scalar {
+    typedef T type;
+};
+
+template<class T, std::size_t N>
+struct make_scalar<T[N]> {
+    typedef typename make_scalar<T>::type type;
+};
+
+} /* detail */
+
+template<class T>
+BOOST_CONSTEXPR inline T*
+first_scalar(T* p) BOOST_NOEXCEPT
+{
+    return p;
+}
+
+template<class T, std::size_t N>
+BOOST_CONSTEXPR inline typename detail::make_scalar<T>::type*
+first_scalar(T (*p)[N]) BOOST_NOEXCEPT
+{
+    return boost::first_scalar(&(*p)[0]);
+}
+
+} /* boost */
+
+#endif

include/boost/core/lightweight_test.hpp

@@ -22,8 +22,8 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/core/no_exceptions_support.hpp>
 #include <boost/current_function.hpp>
+#include <boost/config.hpp>
 #include <iostream>
 #include <iterator>
 #include <cstdlib>
@@ -379,18 +379,20 @@ inline int report_errors()
     result.done();
 
     int errors = result.errors();
+
     if( errors == 0 )
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
           << "No errors detected." << std::endl;
-        return 0;
     }
     else
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
           << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
-        return 1;
     }
+
+    // `return report_errors();` from main only supports 8 bit exit codes
+    return errors < 256? errors: 255;
 }
 
 } // namespace boost

include/boost/core/lightweight_test_trait.hpp

@@ -13,6 +13,9 @@
 //
 // Copyright 2014 Peter Dimov
 //
+// Copyright 2019 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
+//
 // 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
@@ -20,6 +23,7 @@
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/typeinfo.hpp>
 #include <boost/core/is_same.hpp>
+#include <boost/config.hpp>
 
 namespace boost
 {
@@ -27,6 +31,50 @@ namespace boost
 namespace detail
 {
 
+template<class, int = 0> struct test_print { };
+
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 2>)
+{
+    return o << boost::core::demangled_name(BOOST_CORE_TYPEID(T));
+}
+
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 1>)
+{
+    return o << test_print<T, 2>();
+}
+
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const T, 1>)
+{
+    return o << test_print<T, 2>() << " const";
+}
+
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<volatile T, 1>)
+{
+    return o << test_print<T, 2>() << " volatile";
+}
+
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const volatile T, 1>)
+{
+    return o << test_print<T, 2>() << " const volatile";
+}
+
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T>)
+{
+    return o << test_print<T, 1>();
+}
+
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&>)
+{
+    return o << test_print<T, 1>() << " &";
+}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&&>)
+{
+    return o << test_print<T, 1>() << " &&";
+}
+#endif
+
 template< class T > inline void test_trait_impl( char const * trait, void (*)( T ),
   bool expected, char const * file, int line, char const * function )
 {
@@ -64,8 +112,8 @@ template<class T1, class T2> inline void test_trait_same_impl( char const * type
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
             << file << "(" << line << "): test 'is_same<" << types << ">'"
             << " failed in function '" << function
-            << "' ('" << boost::core::demangled_name( BOOST_CORE_TYPEID(T1) )
-            << "' != '" << boost::core::demangled_name( BOOST_CORE_TYPEID(T2) ) << "')"
+            << "' ('" << test_print<T1>()
+            << "' != '" << test_print<T2>() << "')"
             << std::endl;
 
         ++test_results().errors();

include/boost/core/no_exceptions_support.hpp

@@ -32,9 +32,21 @@
 #    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #        define BOOST_TRY { if ("")
 #        define BOOST_CATCH(x) else if (!"")
-#    else
+#    elif !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
 #        define BOOST_TRY { if (true)
 #        define BOOST_CATCH(x) else if (false)
+#    else
+         // warning C4127: conditional expression is constant
+#        define BOOST_TRY { \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (true) \
+             __pragma(warning(pop))
+#        define BOOST_CATCH(x) else \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (false) \
+             __pragma(warning(pop))
 #    endif
 #    define BOOST_RETHROW
 #    define BOOST_CATCH_END }

include/boost/core/noinit_adaptor.hpp

@@ -0,0 +1,112 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_NOINIT_ADAPTOR_HPP
+#define BOOST_CORE_NOINIT_ADAPTOR_HPP
+
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <memory>
+#endif
+#include <new>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <utility>
+#endif
+
+namespace boost {
+
+template<class A>
+struct noinit_adaptor
+    : A {
+    template<class U>
+    struct rebind {
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+        typedef noinit_adaptor<typename std::allocator_traits<A>::template
+            rebind_alloc<U> > other;
+#else
+        typedef noinit_adaptor<typename A::template rebind<U>::other> other;
+#endif
+    };
+
+    noinit_adaptor()
+        : A() { }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    template<class U>
+    noinit_adaptor(U&& u) BOOST_NOEXCEPT
+        : A(std::forward<U>(u)) { }
+#else
+    template<class U>
+    noinit_adaptor(const U& u) BOOST_NOEXCEPT
+        : A(u) { }
+#endif
+
+    template<class U>
+    noinit_adaptor(const noinit_adaptor<U>& u) BOOST_NOEXCEPT
+        : A(static_cast<const U&>(u)) { }
+
+    template<class U>
+    void construct(U* p) {
+        ::new((void*)p) U;
+    }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<class U, class V, class... Args>
+    void construct(U* p, V&& v, Args&&... args) {
+        ::new((void*)p) U(std::forward<V>(v), std::forward<Args>(args)...);
+    }
+#else
+    template<class U, class V>
+    void construct(U* p, V&& v) {
+        ::new((void*)p) U(std::forward<V>(v));
+    }
+#endif
+#else
+    template<class U, class V>
+    void construct(U* p, const V& v) {
+        ::new((void*)p) U(v);
+    }
+
+    template<class U, class V>
+    void construct(U* p, V& v) {
+        ::new((void*)p) U(v);
+    }
+#endif
+
+    template<class U>
+    void destroy(U* p) {
+        p->~U();
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const noinit_adaptor<T>& lhs,
+    const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
+{
+    return static_cast<const T&>(lhs) == static_cast<const U&>(rhs);
+}
+
+template<class T, class U>
+inline bool
+operator!=(const noinit_adaptor<T>& lhs,
+    const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
+{
+    return !(lhs == rhs);
+}
+
+template<class A>
+inline noinit_adaptor<A>
+noinit_adapt(const A& a) BOOST_NOEXCEPT
+{
+    return noinit_adaptor<A>(a);
+}
+
+} /* boost */
+
+#endif

include/boost/core/typeinfo.hpp

@@ -47,7 +47,7 @@ public:
 
     bool operator==( typeinfo const& rhs ) const
     {
-#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
 
         return lib_id_ == rhs.lib_id_? this == &rhs: std::strcmp( name_, rhs.name_ ) == 0;
 
@@ -65,7 +65,7 @@ public:
 
     bool before( typeinfo const& rhs ) const
     {
-#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
 
         return lib_id_ == rhs.lib_id_? std::less< typeinfo const* >()( this, &rhs ): std::strcmp( name_, rhs.name_ ) < 0;
 

include/boost/core/uncaught_exceptions.hpp

@@ -9,7 +9,7 @@
  * \author Andrey Semashev
  * \date   2018-11-10
  *
- * \brief  This header provides an `uncaught_exception` function implementation, which was introduced in C++17.
+ * \brief  This header provides an `uncaught_exceptions` function implementation, which was introduced in C++17.
  *
  * The code in this file is based on the implementation by Evgeny Panasyuk:
  *
@@ -56,10 +56,15 @@
 // On Linux with clang and libc++ and on OS X, there is a version of cxxabi.h from libc++abi that doesn't declare __cxa_get_globals, but provides __cxa_uncaught_exceptions.
 // The function only appeared in version _LIBCPPABI_VERSION >= 1002 of the library. Unfortunately, there are linking errors about undefined reference to __cxa_uncaught_exceptions
 // on Ubuntu Trusty and OS X, so we avoid using it and forward-declare __cxa_get_globals instead.
+// On QNX SDP 7.0 (QCC 5.4.0), there are multiple cxxabi.h, one from glibcxx from gcc and another from libc++abi from LLVM. Which one is included will be determined by the qcc
+// command line arguments (-V and/or -Y; http://www.qnx.com/developers/docs/7.0.0/#com.qnx.doc.neutrino.utilities/topic/q/qcc.html). The LLVM libc++abi is missing the declaration
+// of __cxa_get_globals but it is also patched by QNX developers to not define _LIBCPPABI_VERSION. Older QNX SDP versions, up to and including 6.6, don't provide LLVM and libc++abi.
+// See https://github.com/boostorg/core/issues/59.
 #if !defined(__FreeBSD__) && \
     ( \
         (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407) || \
         defined(__OpenBSD__) || \
+        (defined(__QNXNTO__) && !defined(__GLIBCXX__) && !defined(__GLIBCPP__)) || \
         defined(_LIBCPPABI_VERSION) \
     )
 namespace __cxxabiv1 {

include/boost/core/use_default.hpp

@@ -0,0 +1,17 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_USE_DEFAULT_HPP
+#define BOOST_CORE_USE_DEFAULT_HPP
+
+namespace boost {
+
+struct use_default { };
+
+} /* boost */
+
+#endif

include/boost/detail/sp_typeinfo.hpp

@@ -18,6 +18,9 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/core/typeinfo.hpp>
+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED( "<boost/core/typeinfo.hpp>" )
 
 namespace boost
 {

test/Jamfile.v2

@@ -69,15 +69,15 @@ run get_pointer_test.cpp ;
 run lightweight_test_test.cpp ;
 run lightweight_test_test.cpp : : : <exception-handling>off : lightweight_test_test_no_except ;
 run lightweight_test_test2.cpp ;
-run lightweight_test_all_eq_test.cpp ;
 run lightweight_test_all_with_test.cpp ;
-run lightweight_test_all_with_fail.cpp ;
 run lightweight_test_lt_le_test.cpp ;
 run lightweight_test_gt_ge_test.cpp ;
 run lightweight_test_eq_nullptr.cpp ;
 run lightweight_test_test3.cpp ;
 run lightweight_test_test4.cpp ;
-run lightweight_test_test5.cpp ;
+
+run-fail lightweight_test_all_eq_test.cpp ;
+run-fail lightweight_test_all_with_fail.cpp ;
 
 run-fail lightweight_test_fail.cpp ;
 run-fail lightweight_test_fail2.cpp ;
@@ -92,6 +92,7 @@ run-fail lightweight_test_fail8.cpp : : : <rtti>off : lightweight_test_fail8_no_
 run-fail lightweight_test_fail9.cpp ;
 run-fail lightweight_test_fail10.cpp ;
 run-fail lightweight_test_fail11.cpp ;
+run-fail lightweight_test_fail12.cpp ;
 run-fail lightweight_test_lt_fail.cpp ;
 run-fail lightweight_test_le_fail.cpp ;
 run-fail lightweight_test_gt_fail.cpp ;
@@ -126,22 +127,37 @@ run to_address_test.cpp ;
 run exchange_test.cpp ;
 run exchange_move_test.cpp ;
 
+run first_scalar_test.cpp ;
+compile first_scalar_constexpr_test.cpp ;
+
 run empty_value_test.cpp ;
 run empty_value_size_test.cpp ;
+run empty_value_final_test.cpp ;
 
 run quick_exit_test.cpp ;
 run-fail quick_exit_fail.cpp ;
 
+compile use_default_test.cpp ;
+
+run default_allocator_test.cpp ;
+run noinit_adaptor_test.cpp ;
+run alloc_construct_test.cpp ;
+run alloc_construct_throws_test.cpp ;
+run alloc_construct_cxx11_test.cpp ;
+
 lib lib_typeid : lib_typeid.cpp : <link>shared:<define>LIB_TYPEID_DYN_LINK=1 ;
 
 run test_lib_typeid.cpp lib_typeid : : : <link>shared : test_lib_typeid_shared ;
 run test_lib_typeid.cpp lib_typeid : : : <link>static : test_lib_typeid_static ;
 
 run test_lib_typeid.cpp lib_typeid : : : <link>shared <rtti>off : test_lib_typeid_shared_no_rtti ;
-run test_lib_typeid.cpp lib_typeid : : : <link>static <rtti>off  : test_lib_typeid_static_no_rtti ;
+run test_lib_typeid.cpp lib_typeid : : : <link>static <rtti>off : test_lib_typeid_static_no_rtti ;
 
 run uncaught_exceptions.cpp : : : <exception-handling>on ;
 run uncaught_exceptions_np.cpp : : : <exception-handling>on ;
 
+run no_exceptions_support_test.cpp ;
+run no_exceptions_support_test.cpp : : : <exception-handling>off : no_exceptions_support_test_nx ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/alloc_construct_cxx11_test.cpp

@@ -0,0 +1,78 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <boost/core/alloc_construct.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class type {
+public:
+    explicit type(int x)
+        : value_(x) { }
+
+    int value() const {
+        return value_;
+    }
+
+    static int count;
+
+private:
+    type(const type&);
+    type& operator=(const type&);
+
+    int value_;
+};
+
+int type::count = 0;
+
+template<class T>
+struct creator {
+    typedef T value_type;
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+
+    template<class V>
+    void construct(type* ptr, const V& value) {
+        ::new(static_cast<void*>(ptr)) type(value + 1);
+        ++type::count;
+    }
+
+    void destroy(type* ptr) {
+        ptr->~type();
+        --type::count;
+    }
+};
+
+int main()
+{
+    creator<type> a;
+    type* p = a.allocate(1);
+    boost::alloc_construct(a, p, 1);
+    BOOST_TEST_EQ(type::count, 1);
+    BOOST_TEST_EQ(p->value(), 2);
+    boost::alloc_destroy(a, p);
+    BOOST_TEST_EQ(type::count, 0);
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/alloc_construct_test.cpp

@@ -0,0 +1,135 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/alloc_construct.hpp>
+#include <boost/core/default_allocator.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class type {
+public:
+    explicit type(int x = 0, int y = 0)
+        : value_(x + y) {
+        ++count;
+    }
+
+    type(const type& other)
+        : value_(other.value_) {
+        ++count;
+    }
+
+    ~type() {
+        --count;
+    }
+
+    int value() const {
+        return value_;
+    }
+
+    static int count;
+
+private:
+    int value_;
+};
+
+int type::count = 0;
+
+void test_construct()
+{
+    boost::default_allocator<type> a;
+    type* p = a.allocate(1);
+    boost::alloc_construct(a, p);
+    BOOST_TEST_EQ(type::count, 1);
+    BOOST_TEST_EQ(p->value(), 0);
+    boost::alloc_destroy(a, p);
+    BOOST_TEST_EQ(type::count, 0);
+    a.deallocate(p, 1);
+}
+
+void test_construct_value()
+{
+    boost::default_allocator<type> a;
+    type* p = a.allocate(1);
+    boost::alloc_construct(a, p, 1);
+    BOOST_TEST_EQ(type::count, 1);
+    BOOST_TEST_EQ(p->value(), 1);
+    boost::alloc_destroy(a, p);
+    BOOST_TEST_EQ(type::count, 0);
+    a.deallocate(p, 1);
+}
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+void test_construct_args()
+{
+    boost::default_allocator<type> a;
+    type* p = a.allocate(1);
+    boost::alloc_construct(a, p, 1, 2);
+    BOOST_TEST_EQ(type::count, 1);
+    BOOST_TEST_EQ(p->value(), 3);
+    boost::alloc_destroy(a, p);
+    BOOST_TEST_EQ(type::count, 0);
+    a.deallocate(p, 1);
+}
+#endif
+
+void test_construct_n()
+{
+    boost::default_allocator<type> a;
+    type* p = a.allocate(3);
+    boost::alloc_construct_n(a, p, 3);
+    BOOST_TEST_EQ(type::count, 3);
+    BOOST_TEST_EQ(p[0].value(), 0);
+    BOOST_TEST_EQ(p[1].value(), 0);
+    BOOST_TEST_EQ(p[2].value(), 0);
+    boost::alloc_destroy_n(a, p, 3);
+    BOOST_TEST_EQ(type::count, 0);
+    a.deallocate(p, 3);
+}
+
+void test_construct_n_list()
+{
+    boost::default_allocator<type> a;
+    type* p = a.allocate(3);
+    type q(1);
+    boost::alloc_construct_n(a, p, 3, &q, 1);
+    BOOST_TEST_EQ(type::count, 4);
+    BOOST_TEST_EQ(p[0].value(), 1);
+    BOOST_TEST_EQ(p[1].value(), 1);
+    BOOST_TEST_EQ(p[2].value(), 1);
+    boost::alloc_destroy_n(a, p, 3);
+    BOOST_TEST_EQ(type::count, 1);
+    a.deallocate(p, 3);
+}
+
+void test_construct_n_iterator()
+{
+    boost::default_allocator<type> a;
+    type* p = a.allocate(3);
+    type l[] = { type(1), type(2), type(3) };
+    boost::alloc_construct_n(a, p, 3, &l[0]);
+    BOOST_TEST_EQ(type::count, 6);
+    BOOST_TEST_EQ(p[0].value(), 1);
+    BOOST_TEST_EQ(p[1].value(), 2);
+    BOOST_TEST_EQ(p[2].value(), 3);
+    boost::alloc_destroy_n(a, p, 3);
+    BOOST_TEST_EQ(type::count, 3);
+    a.deallocate(p, 3);
+}
+
+int main()
+{
+    test_construct();
+    test_construct_value();
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    test_construct_args();
+#endif
+    test_construct_n();
+    test_construct_n_list();
+    test_construct_n_iterator();
+    return boost::report_errors();
+}

test/alloc_construct_throws_test.cpp

@@ -0,0 +1,46 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/alloc_construct.hpp>
+#include <boost/core/default_allocator.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class type {
+public:
+    type() {
+        if (count == 4) {
+            throw true;
+        }
+        ++count;
+    }
+
+    ~type() {
+        --count;
+    }
+
+    static int count;
+
+private:
+    type(const type&);
+    type& operator=(const type&);
+};
+
+int type::count = 0;
+
+int main()
+{
+    boost::default_allocator<type> a;
+    type* p = a.allocate(5);
+    try {
+        boost::alloc_construct_n(a, p, 5);
+        BOOST_ERROR("construct_n did not throw");
+    } catch (...) {
+        BOOST_TEST_EQ(type::count, 0);
+    }
+    a.deallocate(p, 5);
+    return boost::report_errors();
+}

test/default_allocator_test.cpp

@@ -0,0 +1,277 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/default_allocator.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <vector>
+#include <list>
+
+class type {
+public:
+    explicit type(double value)
+        : value_(value) { }
+
+private:
+    type(const type&);
+    type& operator=(const type&);
+
+    double value_;
+};
+
+void test_value_type()
+{
+    BOOST_TEST_TRAIT_SAME(int,
+        boost::default_allocator<int>::value_type);
+    BOOST_TEST_TRAIT_SAME(type,
+        boost::default_allocator<type>::value_type);
+    BOOST_TEST_TRAIT_SAME(int[5],
+        boost::default_allocator<int[5]>::value_type);
+    BOOST_TEST_TRAIT_SAME(void,
+        boost::default_allocator<void>::value_type);
+}
+
+void test_pointer()
+{
+    BOOST_TEST_TRAIT_SAME(int*,
+        boost::default_allocator<int>::pointer);
+    BOOST_TEST_TRAIT_SAME(type*,
+        boost::default_allocator<type>::pointer);
+    BOOST_TEST_TRAIT_SAME(int(*)[5],
+        boost::default_allocator<int[5]>::pointer);
+    BOOST_TEST_TRAIT_SAME(void*,
+        boost::default_allocator<void>::pointer);
+}
+
+void test_const_pointer()
+{
+    BOOST_TEST_TRAIT_SAME(const int*,
+        boost::default_allocator<int>::const_pointer);
+    BOOST_TEST_TRAIT_SAME(const type*,
+        boost::default_allocator<type>::const_pointer);
+    BOOST_TEST_TRAIT_SAME(const int(*)[5],
+        boost::default_allocator<int[5]>::const_pointer);
+    BOOST_TEST_TRAIT_SAME(const void*,
+        boost::default_allocator<void>::const_pointer);
+}
+
+void test_reference()
+{
+    BOOST_TEST_TRAIT_SAME(int&,
+        boost::default_allocator<int>::reference);
+    BOOST_TEST_TRAIT_SAME(type&,
+        boost::default_allocator<type>::reference);
+    BOOST_TEST_TRAIT_SAME(int(&)[5],
+        boost::default_allocator<int[5]>::reference);
+    BOOST_TEST_TRAIT_SAME(void,
+        boost::default_allocator<void>::reference);
+}
+
+void test_const_reference()
+{
+    BOOST_TEST_TRAIT_SAME(const int&,
+        boost::default_allocator<int>::const_reference);
+    BOOST_TEST_TRAIT_SAME(const type&,
+        boost::default_allocator<type>::const_reference);
+    BOOST_TEST_TRAIT_SAME(const int(&)[5],
+        boost::default_allocator<int[5]>::const_reference);
+    BOOST_TEST_TRAIT_SAME(const void,
+        boost::default_allocator<void>::const_reference);
+}
+
+void test_size_type()
+{
+    BOOST_TEST_TRAIT_SAME(std::size_t,
+        boost::default_allocator<int>::size_type);
+    BOOST_TEST_TRAIT_SAME(std::size_t,
+        boost::default_allocator<type>::size_type);
+    BOOST_TEST_TRAIT_SAME(std::size_t,
+        boost::default_allocator<int[5]>::size_type);
+    BOOST_TEST_TRAIT_SAME(std::size_t,
+        boost::default_allocator<void>::size_type);
+}
+
+void test_difference_type()
+{
+    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
+        boost::default_allocator<int>::difference_type);
+    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
+        boost::default_allocator<type>::difference_type);
+    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
+        boost::default_allocator<int[5]>::difference_type);
+    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
+        boost::default_allocator<void>::difference_type);
+}
+
+void test_propagate_on_container_move_assignment()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int>::
+        propagate_on_container_move_assignment));
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<type>::
+        propagate_on_container_move_assignment));
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int[5]>::
+        propagate_on_container_move_assignment));
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<void>::
+        propagate_on_container_move_assignment));
+}
+
+void test_is_always_equal()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int>::is_always_equal));
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<type>::is_always_equal));
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int[5]>::is_always_equal));
+    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<void>::is_always_equal));
+}
+
+void test_rebind()
+{
+    BOOST_TEST_TRAIT_SAME(boost::default_allocator<type>,
+        boost::default_allocator<int>::rebind<type>::other);
+    BOOST_TEST_TRAIT_SAME(boost::default_allocator<int[5]>,
+        boost::default_allocator<type>::rebind<int[5]>::other);
+    BOOST_TEST_TRAIT_SAME(boost::default_allocator<void>,
+        boost::default_allocator<int[5]>::rebind<void>::other);
+    BOOST_TEST_TRAIT_SAME(boost::default_allocator<int>,
+        boost::default_allocator<void>::rebind<int>::other);
+}
+
+void test_default_construct()
+{
+    boost::default_allocator<int> a1;
+    (void)a1;
+    boost::default_allocator<type> a2;
+    (void)a2;
+    boost::default_allocator<int[5]> a3;
+    (void)a3;
+    boost::default_allocator<void> a4;
+    (void)a4;
+}
+
+void test_copy()
+{
+    boost::default_allocator<int> a1;
+    boost::default_allocator<int> a2(a1);
+    (void)a2;
+    boost::default_allocator<int[5]> a3;
+    boost::default_allocator<int[5]> a4(a3);
+    (void)a4;
+    boost::default_allocator<void> a5;
+    boost::default_allocator<void> a6(a5);
+    (void)a6;
+}
+
+void test_construct_other()
+{
+    boost::default_allocator<int> a1;
+    boost::default_allocator<type> a2(a1);
+    boost::default_allocator<int[5]> a3(a2);
+    boost::default_allocator<void> a4(a3);
+    boost::default_allocator<int> a5(a4);
+    (void)a5;
+}
+
+#if defined(PTRDIFF_MAX) && defined(SIZE_MAX)
+template<class T>
+std::size_t max_size()
+{
+    return PTRDIFF_MAX < SIZE_MAX / sizeof(T)
+        ? PTRDIFF_MAX : SIZE_MAX / sizeof(T);
+}
+#else
+template<class T>
+std::size_t max_size()
+{
+    return ~static_cast<std::size_t>(0) / sizeof(T);
+}
+#endif
+
+void test_max_size()
+{
+    BOOST_TEST_EQ(max_size<int>(),
+        boost::default_allocator<int>().max_size());
+    BOOST_TEST_EQ(max_size<type>(),
+        boost::default_allocator<type>().max_size());
+    BOOST_TEST_EQ(max_size<int[5]>(),
+        boost::default_allocator<int[5]>().max_size());
+}
+
+template<class T>
+void test_allocate()
+{
+    boost::default_allocator<T> a;
+    T* p = a.allocate(1);
+    BOOST_TEST(p != 0);
+    a.deallocate(p, 1);
+    p = a.allocate(0);
+    a.deallocate(p, 0);
+    BOOST_TEST_THROWS(a.allocate(a.max_size() + 1), std::bad_alloc);
+}
+
+void test_allocate_deallocate()
+{
+    test_allocate<int>();
+    test_allocate<type>();
+    test_allocate<int[5]>();
+}
+
+void test_equals()
+{
+    BOOST_TEST(boost::default_allocator<int>() ==
+        boost::default_allocator<type>());
+    BOOST_TEST(boost::default_allocator<type>() ==
+        boost::default_allocator<int[5]>());
+    BOOST_TEST(boost::default_allocator<int[5]>() ==
+        boost::default_allocator<void>());
+    BOOST_TEST(boost::default_allocator<void>() ==
+        boost::default_allocator<int>());
+}
+
+void test_not_equals()
+{
+    BOOST_TEST(!(boost::default_allocator<int>() !=
+        boost::default_allocator<type>()));
+    BOOST_TEST(!(boost::default_allocator<type>() !=
+        boost::default_allocator<int[5]>()));
+    BOOST_TEST(!(boost::default_allocator<int[5]>() !=
+        boost::default_allocator<void>()));
+    BOOST_TEST(!(boost::default_allocator<void>() !=
+        boost::default_allocator<int>()));
+}
+
+void test_container()
+{
+    std::vector<int, boost::default_allocator<int> > v;
+    v.push_back(1);
+    BOOST_TEST(v.size() == 1);
+    BOOST_TEST(v.front() == 1);
+    std::list<int, boost::default_allocator<int> > l;
+    l.push_back(1);
+    BOOST_TEST(l.size() == 1);
+    BOOST_TEST(l.front() == 1);
+}
+
+int main()
+{
+    test_value_type();
+    test_pointer();
+    test_const_pointer();
+    test_reference();
+    test_const_reference();
+    test_size_type();
+    test_difference_type();
+    test_propagate_on_container_move_assignment();
+    test_is_always_equal();
+    test_rebind();
+    test_default_construct();
+    test_copy();
+    test_construct_other();
+    test_max_size();
+    test_allocate_deallocate();
+    test_equals();
+    test_not_equals();
+    test_container();
+    return boost::report_errors();
+}

test/empty_value_final_test.cpp

@@ -0,0 +1,62 @@
+/*
+Copyright 2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/empty_value.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#if !defined(BOOST_NO_CXX11_FINAL)
+class type final {
+public:
+    explicit type(int count)
+        : value_(count) { }
+    int value() const {
+        return value_ + 1;
+    }
+    int value() {
+        return value_ + 2;
+    }
+private:
+    int value_;
+};
+
+struct empty final {
+    int value() const {
+        return 1;
+    }
+    int value() {
+        return 2;
+    }
+};
+
+void test_type()
+{
+    const boost::empty_value<type> v1(boost::empty_init_t(), 3);
+    BOOST_TEST(v1.get().value() == 4);
+    boost::empty_value<type> v2(boost::empty_init_t(), 3);
+    BOOST_TEST(v2.get().value() == 5);
+}
+
+void test_empty()
+{
+    const boost::empty_value<empty> v1 = boost::empty_init_t();
+    BOOST_TEST(v1.get().value() == 1);
+    boost::empty_value<empty> v2;
+    BOOST_TEST(v2.get().value() == 2);
+}
+
+int main()
+{
+    test_type();
+    test_empty();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/empty_value_test.cpp

@@ -9,67 +9,63 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/core/lightweight_test.hpp>
 
 struct empty {
-    operator bool() const {
-        return false;
+    int value() const {
+        return 1;
     }
-    operator bool() {
-        return true;
+    int value() {
+        return 2;
     }
 };
 
 class type {
 public:
-    type()
-        : value_(false) { }
-    explicit type(bool value)
-        : value_(value) { }
-    operator bool() const {
-        return value_;
+    explicit type(int count)
+        : value_(count) { }
+    int value() const {
+        return value_ + 1;
+    }
+    int value() {
+        return value_ + 2;
     }
 private:
-    bool value_;
+    int value_;
 };
 
-void test_bool()
+void test_int()
 {
-    const boost::empty_value<bool> v1(boost::empty_init_t(), true);
-    BOOST_TEST(v1.get());
-    boost::empty_value<bool> v2 = boost::empty_init_t();
-    BOOST_TEST(!v2.get());
+    const boost::empty_value<int> v1(boost::empty_init_t(), 7);
+    BOOST_TEST(v1.get() == 7);
+    boost::empty_value<int> v2 = boost::empty_init_t();
+    BOOST_TEST(v2.get() == 0);
     v2 = v1;
-    BOOST_TEST(v2.get());
-    v2.get() = false;
-    BOOST_TEST(!v2.get());
+    BOOST_TEST(v2.get() == 7);
+    v2.get() = 8;
+    BOOST_TEST(v2.get() == 8);
 }
 
 void test_empty()
 {
-    empty e;
-    const boost::empty_value<empty> v1(boost::empty_init_t(), e);
-    BOOST_TEST(!v1.get());
+    const boost::empty_value<empty> v1 = boost::empty_init_t();
+    BOOST_TEST(v1.get().value() == 1);
     boost::empty_value<empty> v2;
-    BOOST_TEST(v2.get());
-    v2 = v1;
-    BOOST_TEST(v2.get());
-    v2.get() = empty();
-    BOOST_TEST(v2.get());
+    BOOST_TEST(v2.get().value() == 2);
 }
 
 void test_type()
 {
-    const boost::empty_value<type> v1(boost::empty_init_t(), true);
-    BOOST_TEST(v1.get());
-    boost::empty_value<type> v2;
-    BOOST_TEST(!v2.get());
+    const boost::empty_value<type> v1(boost::empty_init_t(), 2);
+    BOOST_TEST(v1.get().value() == 3);
+    boost::empty_value<type> v2(boost::empty_init_t(), 3);
+    BOOST_TEST(v2.get().value() == 5);
     v2 = v1;
-    BOOST_TEST(v2.get());
-    v2.get() = type();
-    BOOST_TEST(!v2.get());
+    BOOST_TEST(v2.get().value() == 4);
+    v2.get() = type(4);
+    BOOST_TEST(v2.get().value() == 6);
 }
 
 int main()
 {
-    test_bool();
+    test_int();
     test_empty();
     test_type();
     return boost::report_errors();

test/first_scalar_constexpr_test.cpp

@@ -0,0 +1,19 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX14_CONSTEXPR)
+#include <boost/core/first_scalar.hpp>
+#include <boost/static_assert.hpp>
+
+static int i1 = 0;
+BOOST_STATIC_ASSERT(boost::first_scalar(&i1) == &i1);
+static int i2[4] = { };
+BOOST_STATIC_ASSERT(boost::first_scalar(i2) == &i2[0]);
+static int i3[2][4][6] = { };
+BOOST_STATIC_ASSERT(boost::first_scalar(i3) == &i3[0][0][0]);
+#endif

test/first_scalar_test.cpp

@@ -0,0 +1,20 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/first_scalar.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    int i1 = 0;
+    BOOST_TEST_EQ(boost::first_scalar(&i1), &i1);
+    int i2[4] = { };
+    BOOST_TEST_EQ(boost::first_scalar(i2), &i2[0]);
+    int i3[2][4][6] = { };
+    BOOST_TEST_EQ(boost::first_scalar(i3), &i3[0][0][0]);
+    return boost::report_errors();
+}

test/lightweight_test_all_eq_test.cpp

@@ -120,5 +120,5 @@ int main()
         ++test_cases;
     }
 
-    return !boost::report_errors();
+    return boost::report_errors() == test_cases;
 }

test/lightweight_test_all_with_fail.cpp

@@ -101,5 +101,5 @@ int main()
     test_cases += fail_vector();
     test_cases += fail_tolerance_predicate();
 
-    return !boost::report_errors();
+    return boost::report_errors() == test_cases;
 }

test/lightweight_test_fail12.cpp

@@ -9,6 +9,7 @@
 //
 
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/config.hpp>
 
 struct X
 {
@@ -20,6 +21,21 @@ template<class T1, class T2> struct Y
     typedef T1 type;
 };
 
+typedef int I1;
+typedef const int I2;
+typedef volatile int I3;
+typedef const volatile int I4;
+typedef int& I5;
+typedef const int& I6;
+typedef volatile int& I7;
+typedef const volatile int& I8;
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+typedef int&& I9;
+typedef const int&& I10;
+typedef volatile int&& I11;
+typedef const volatile int&& I12;
+#endif
+
 int main()
 {
     BOOST_TEST_TRAIT_SAME(char[1], char[2]);
@@ -32,6 +48,21 @@ int main()
     BOOST_TEST_TRAIT_SAME(X, Y<void, void>);
     BOOST_TEST_TRAIT_SAME(X::type, Y<float, int>::type);
     BOOST_TEST_TRAIT_SAME(Y<int, float>, Y<int, double>);
+    BOOST_TEST_TRAIT_SAME(I1, I2);
+    BOOST_TEST_TRAIT_SAME(I3, I4);
+    BOOST_TEST_TRAIT_SAME(I5, I6);
+    BOOST_TEST_TRAIT_SAME(I7, I8);
 
-    return boost::report_errors() == 10;
+    int expected = 14;
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+    BOOST_TEST_TRAIT_SAME(I9, I10);
+    BOOST_TEST_TRAIT_SAME(I11, I12);
+
+    expected += 2;
+
+#endif
+
+    return boost::report_errors() == expected;
 }

test/no_exceptions_support_test.cpp

@@ -0,0 +1,52 @@
+//
+// Test for no_exceptions_support.hpp
+//
+// Copyright 2019 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
+//
+
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/core/quick_exit.hpp>
+#include <boost/throw_exception.hpp>
+#include <exception>
+
+void f()
+{
+    boost::throw_exception( std::exception() );
+}
+
+int main()
+{
+    BOOST_TRY
+    {
+        f();
+    }
+    BOOST_CATCH( std::exception const& )
+    {
+        return 0;
+    }
+    BOOST_CATCH( ... )
+    {
+        return 1;
+    }
+    BOOST_CATCH_END
+
+    return 1;
+}
+
+#if defined(BOOST_NO_EXCEPTIONS)
+
+namespace boost
+{
+
+void throw_exception( std::exception const& )
+{
+    boost::quick_exit( 0 );
+}
+
+}
+
+#endif

test/noinit_adaptor_test.cpp

@@ -0,0 +1,100 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#include <boost/core/noinit_adaptor.hpp>
+#include <boost/core/default_allocator.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <vector>
+
+template<class T>
+class creator
+    : public boost::default_allocator<T> {
+public:
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator(int state)
+        : state_(state) { }
+
+    template<class U>
+    creator(const creator<U>& other)
+        : state_(other.state()) { }
+
+    template<class U, class V>
+    void construct(U*, const V&) {
+        BOOST_ERROR("construct");
+    }
+
+    template<class U>
+    void destroy(U*) {
+        BOOST_ERROR("destroy");
+    }
+
+    int state() const {
+        return state_;
+    }
+
+private:
+    int state_;
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>& lhs, const creator<U>& rhs)
+{
+    return lhs.state() == rhs.state();
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>& lhs, const creator<U>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+class type {
+public:
+    type() { }
+
+    type(int value)
+        : value_(value) { }
+
+    int value() const {
+        return value_;
+    }
+
+private:
+    int value_;
+};
+
+inline bool
+operator==(const type& lhs, const type& rhs)
+{
+    return lhs.value() == rhs.value();
+}
+
+template<class A>
+void test(const A& allocator)
+{
+    std::vector<typename A::value_type, A> v(allocator);
+    v.push_back(1);
+    BOOST_TEST(v.front() == 1);
+    v.clear();
+    v.resize(5);
+    v.front() = 1;
+}
+
+int main()
+{
+    test(boost::noinit_adaptor<creator<int> >(1));
+    test(boost::noinit_adaptor<creator<type> >(2));
+    test(boost::noinit_adapt(creator<int>(3)));
+    test(boost::noinit_adapt(creator<type>(4)));
+    return boost::report_errors();
+}

test/quick.cpp

@@ -24,7 +24,6 @@
 #include <boost/core/pointer_traits.hpp>
 #include <boost/ref.hpp>
 #include <boost/core/scoped_enum.hpp>
-#include <boost/detail/sp_typeinfo.hpp>
 #include <boost/core/typeinfo.hpp>
 #include <boost/core/underlying_type.hpp>
 #include <boost/visit_each.hpp>

test/sp_typeinfo_test.cpp

@@ -8,6 +8,8 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#define BOOST_ALLOW_DEPRECATED_HEADERS
+
 #include <boost/detail/sp_typeinfo.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>

test/use_default_test.cpp

@@ -0,0 +1,15 @@
+/*
+Copyright 2019 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include <boost/core/use_default.hpp>
+
+template<class, class = boost::use_default>
+struct type { };
+
+template class type<int>;
+template class type<void, boost::use_default>;