Add test/cmake_subdir_test

This should resolve gcc errors caused by mismatch of the return types of
aur declaration of __cxa_get_globals and the original in cxxabi.h.

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

.travis.yml

@@ -1,4 +1,4 @@
-# Copyright 2016, 2017 Peter Dimov
+# Copyright 2016-2018 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)
 
@@ -119,6 +119,16 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
+    - os: linux
+      compiler: g++-8
+      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
     - os: linux
       compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
@@ -200,6 +210,29 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-trusty-6.0
 
+    - os: linux
+      compiler: clang++-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+
+    - os: linux
+      compiler: clang++-6.0
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+
     - os: linux
       compiler: clang++-libc++
       env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
@@ -208,22 +241,42 @@ matrix:
           packages:
             - libc++-dev
 
+    - os: linux
+      compiler: clang++-libc++
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
     - os: osx
       compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
 
+    - os: linux
+      compiler: g++
+      env: CMAKE_SUBDIR_TEST=1
+      script:
+      - cd libs/core/test/cmake_subdir_test && mkdir __build__ && cd __build__
+      - cmake ..
+      - cmake --build .
+      - cmake --build . --target check
+
 install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - BOOST_BRANCH=develop
+  - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
   - cd ..
   - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
   - cd boost-root
+  - git submodule init libs/headers
   - git submodule init libs/assert
   - git submodule init libs/config
   - git submodule init libs/predef
   - git submodule init libs/static_assert
   - git submodule init libs/type_traits
   - git submodule init tools/build
-  - git submodule update
+  - git submodule init tools/boost_install
+  - git submodule update --jobs 4
   - cp -r $TRAVIS_BUILD_DIR/* libs/core
   - ./bootstrap.sh
   - ./b2 headers
@@ -231,7 +284,8 @@ install:
 script:
   - |-
     echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 -j 3 libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD
+  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
+  - ./b2 -j $BUILD_JOBS libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
 
 notifications:
   email:

CMakeLists.txt

@@ -0,0 +1,21 @@
+# Copyright 2018 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
+
+# Partial (add_subdirectory only) and experimental CMake support
+# Subject to change; please do not rely on the contents of this file yet
+
+cmake_minimum_required(VERSION 3.5)
+
+project(BoostCore LANGUAGES CXX)
+
+add_library(boost_core INTERFACE)
+add_library(Boost::core ALIAS boost_core)
+
+target_include_directories(boost_core INTERFACE include)
+
+target_link_libraries(boost_core
+    INTERFACE
+        Boost::assert
+        Boost::config
+)

README.md

@@ -1,7 +1,7 @@
 Boost.Core
 ==========
 
-Boost.Core, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), is a collection of core utilities used by other Boost libraries.
+Boost.Core, part of collection of the [Boost C++ Libraries](https://github.com/boostorg), is a collection of core utilities used by other Boost libraries.
 The criteria for inclusion is that the utility component be:
 
 * simple,
@@ -23,10 +23,10 @@ Master   | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=maste
 
 ### More information
 
-* [Documentation](http://boost.org/libs/core)
+* [Documentation](https://boost.org/libs/core)
 * [Report bugs](https://svn.boost.org/trac/boost/newticket?component=core;version=Boost%20Release%20Branch). Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
-* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
 
 ### License
 
-Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
+Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).

appveyor.yml

@@ -17,21 +17,6 @@ environment:
     - 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 2013
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11
-
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-14.0
 
@@ -39,19 +24,46 @@ environment:
       TOOLSET: msvc-14.1
       CXXSTD: 14,17
 
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      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
+      ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
 install:
   - set BOOST_BRANCH=develop
   - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
   - cd ..
   - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost-root
   - cd boost-root
+  - git submodule init libs/headers
   - git submodule init libs/assert
   - git submodule init libs/config
   - git submodule init libs/predef
   - git submodule init libs/static_assert
   - git submodule init libs/type_traits
   - git submodule init tools/build
-  - git submodule update
+  - git submodule init tools/boost_install
+  - git submodule update --jobs 4
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core
   - cmd /c bootstrap
   - b2 headers
@@ -61,4 +73,4 @@ build: off
 test_script:
   - PATH=%ADDPATH%%PATH%
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j 3 libs/core/test toolset=%TOOLSET% %CXXSTD%
+  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD%

doc/.gitignore

@@ -0,0 +1,3 @@
+/html/
+/pdf/
+ref_reference.xml

doc/Jamfile.v2

@@ -1,5 +1,5 @@
-# Copyright (c) 2014 Glen Joseph Fernandes
-# glenfe at live dot com
+# Copyright 2014 Glen Joseph Fernandes
+# (glenjofe@gmail.com)
 #
 # Distributed under the Boost Software License,
 # Version 1.0. (See accompanying file LICENSE_1_0.txt

doc/core.qbk

@@ -1,10 +1,10 @@
 [/
-  Copyright (c) 2014 Glen Joseph Fernandes
-  glenfe at live dot com
+Copyright 2014 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://boost.org/LICENSE_1_0.txt)
+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)
 ]
 
 [library Boost.Core
@@ -52,7 +52,9 @@ criteria for inclusion is that the utility component be:
 [include noncopyable.qbk]
 [include null_deleter.qbk]
 [include pointer_traits.qbk]
+[include quick_exit.qbk]
 [include ref.qbk]
 [include scoped_enum.qbk]
 [include swap.qbk]
 [include typeinfo.qbk]
+[include uncaught_exceptions.qbk]

doc/empty_value.qbk

@@ -85,14 +85,16 @@ struct empty_init_t { };
 template<class T, unsigned Index = 0, bool Empty = ``/see below/``>
 class empty_value {
 public:
+    typedef T type;
+
     empty_value() = default;
 
     template<class... Args>
     explicit empty_value(empty_init_t, Args&&... args);
 
-    const T& get() const;
+    const T& get() const noexcept;
 
-    T& get();
+    T& get() noexcept;
 };
 
 } /* boost */
@@ -107,6 +109,12 @@ public:
 
 [endsect]
 
+[section Member types]
+
+[variablelist [[`type`][The template parameter `T`]]]
+
+[endsect]
+
 [section Constructors]
 
 [variablelist
@@ -119,8 +127,8 @@ public:
 [section Member functions]
 
 [variablelist
-[[`const T& get() const;`][Returns the value]]
-[[`T& get();`][Returns the value]]]
+[[`const T& get() const noexcept;`][Returns the value]]
+[[`T& get() noexcept;`][Returns the value]]]
 
 [endsect]
 

doc/quick_exit.qbk

@@ -0,0 +1,40 @@
+[/
+  Copyright 2018 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
+]
+
+[section:quick_exit quick_exit]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/quick_exit.hpp>]
+
+The header `<boost/core/quick_exit.hpp>` defines the function
+`void boost::quick_exit(int code)`. It calls the standard C++11 function
+[@https://en.cppreference.com/w/cpp/utility/program/quick_exit
+ `std::quick_exit(code)`], if that is available, and otherwise exits the
+ process via [@https://en.cppreference.com/w/cpp/utility/program/_Exit
+ `std::_Exit(code)`] or equivalent.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+    [[noreturn]] void quick_exit(int code) noexcept;
+}
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/uncaught_exceptions.qbk

@@ -0,0 +1,52 @@
+[/
+ / Copyright (c) 2018 Andrey Semashev
+ /
+ / 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)
+ /]
+
+[section:uncaught_exceptions uncaught_exceptions]
+
+[simplesect Authors]
+
+* Andrey Semashev
+
+[endsimplesect]
+
+[section Header <boost/core/uncaught_exceptions.hpp>]
+
+The header `<boost/core/uncaught_exceptions.hpp>` defines the `boost::core::uncaught_exceptions` function,
+which is a more portable implementation of the same named function introduced in C++17. The function
+returns the number of the currently pending exceptions. When that function returns a value greater than 0,
+throwing an exception from a destructor can terminate the program.
+
+Unfortunately, the function cannot be implemented on every pre-C++17 compiler, although the most commonly
+used compilers are supported. When the compiler does not provide the necessary functionality,
+`boost::core::uncaught_exceptions` returns a non-zero value if at least one exception is pending (i.e. not
+necessarily the number of pending exceptions), and `BOOST_CORE_UNCAUGHT_EXCEPTIONS_EMULATED` macro
+is defined.
+
+[section Example]
+``
+class my_class
+{
+private:
+    const unsigned int m_exception_count;
+
+public:
+    my_class() : m_exception_count(boost::core::uncaught_exceptions())
+    {
+    }
+
+    ~my_class() noexcept(false)
+    {
+        if (m_exception_count == boost::core::uncaught_exceptions())
+            do_something_potentially_throwing();
+    }
+};
+``
+[endsect]
+
+[endsect]
+
+[endsect]

include/boost/core/empty_value.hpp

@@ -40,31 +40,36 @@ struct use_empty_value_base {
 
 struct empty_init_t { };
 
-template<class T, unsigned N = 0, bool E = use_empty_value_base<T>::value>
+namespace empty_ {
+
+template<class T, unsigned N = 0,
+    bool E = boost::use_empty_value_base<T>::value>
 class empty_value {
 public:
+    typedef T type;
+
 #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
     empty_value() = default;
 #else
     empty_value() { }
 #endif
 
-    empty_value(empty_init_t)
+    empty_value(boost::empty_init_t)
         : value_() { }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     template<class... Args>
-    explicit empty_value(empty_init_t, Args&&... args)
+    explicit empty_value(boost::empty_init_t, Args&&... args)
         : value_(std::forward<Args>(args)...) { }
 #else
     template<class U>
-    empty_value(empty_init_t, U&& value)
+    empty_value(boost::empty_init_t, U&& value)
         : value_(std::forward<U>(value)) { }
 #endif
 #else
     template<class U>
-    empty_value(empty_init_t, const U& value)
+    empty_value(boost::empty_init_t, const U& value)
         : value_(value) { }
 #endif
 
@@ -85,28 +90,30 @@ template<class T, unsigned N>
 class empty_value<T, N, true>
     : T {
 public:
+    typedef T type;
+
 #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
     empty_value() = default;
 #else
     empty_value() { }
 #endif
 
-    empty_value(empty_init_t)
+    empty_value(boost::empty_init_t)
         : T() { }
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     template<class... Args>
-    explicit empty_value(empty_init_t, Args&&... args)
+    explicit empty_value(boost::empty_init_t, Args&&... args)
         : T(std::forward<Args>(args)...) { }
 #else
     template<class U>
-    empty_value(empty_init_t, U&& value)
+    empty_value(boost::empty_init_t, U&& value)
         : T(std::forward<U>(value)) { }
 #endif
 #else
     template<class U>
-    empty_value(empty_init_t, const U& value)
+    empty_value(boost::empty_init_t, const U& value)
         : T(value) { }
 #endif
 
@@ -120,6 +127,10 @@ public:
 };
 #endif
 
+} /* empty_ */
+
+using empty_::empty_value;
+
 } /* boost */
 
 #endif

include/boost/core/lightweight_test.hpp

@@ -47,7 +47,7 @@ public:
     test_result()
         : report_(false)
         , errors_(0) {
-#if defined(_MSC_VER)
+#if defined(_MSC_VER) && (_MSC_VER > 1310)
         ::_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 #endif
     }
@@ -55,14 +55,7 @@ public:
     ~test_result() {
         if (!report_) {
             BOOST_LIGHTWEIGHT_TEST_OSTREAM << "main() should return report_errors()" << std::endl;
-
-#if defined(_MSC_VER)
-            ::_exit( 3 );
-#elif defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
             std::abort();
-#else
-            ::_Exit( 3 );
-#endif
         }
     }
 
@@ -429,6 +422,7 @@ inline int report_errors()
          (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
       }                                                        \
       catch(EXCEP const&) {                                    \
+         ::boost::detail::test_results();                      \
       }                                                        \
       catch(...) {                                             \
          ::boost::detail::throw_failed_impl                    \

include/boost/core/quick_exit.hpp

@@ -0,0 +1,59 @@
+#ifndef BOOST_CORE_QUICK_EXIT_HPP_INCLUDED
+#define BOOST_CORE_QUICK_EXIT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  boost/core/quick_exit.hpp
+//
+//  Copyright 2018 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/config.hpp>
+#include <cstdlib>
+
+#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+
+extern "C" _CRTIMP __cdecl __MINGW_NOTHROW  void _exit (int) __MINGW_ATTRIB_NORETURN;
+
+#endif
+
+#if defined(__CYGWIN__) && __cplusplus < 201103L
+
+extern "C" _Noreturn void quick_exit(int);
+
+#endif
+
+namespace boost
+{
+
+BOOST_NORETURN void quick_exit( int code ) BOOST_NOEXCEPT
+{
+#if defined(_MSC_VER) && _MSC_VER < 1900
+
+    ::_exit( code );
+
+#elif defined(__MINGW32__)
+
+    ::_exit( code );
+
+#elif defined(__APPLE__)
+
+    ::_Exit( code );
+
+#else
+
+    ::quick_exit( code );
+
+#endif
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_QUICK_EXIT_HPP_INCLUDED

include/boost/core/ref.hpp

@@ -19,7 +19,8 @@
 //  Copyright (C) 2002 David Abrahams
 //
 //  Copyright (C) 2014 Glen Joseph Fernandes
-//  glenfe at live dot com
+//  (glenjofe@gmail.com)
+//
 //  Copyright (C) 2014 Agustin Berge
 //
 // Distributed under the Boost Software License, Version 1.0. (See

include/boost/core/swap.hpp

@@ -21,13 +21,19 @@
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
 
+#include <boost/core/enable_if.hpp>
+#include <boost/config.hpp>
 #include <utility> //for std::swap (C++11)
 #include <algorithm> //for std::swap (C++98)
 #include <cstddef> //for std::size_t
-#include <boost/config.hpp>
 
 namespace boost_swap_impl
 {
+  // we can't use type_traits here
+
+  template<class T> struct is_const { enum _vt { value = 0 }; };
+  template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
+
   template<class T>
   BOOST_GPU_ENABLED
   void swap_impl(T& left, T& right)
@@ -51,7 +57,8 @@ namespace boost
 {
   template<class T1, class T2>
   BOOST_GPU_ENABLED
-  void swap(T1& left, T2& right)
+  typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
+  swap(T1& left, T2& right)
   {
     ::boost_swap_impl::swap_impl(left, right);
   }

include/boost/core/typeinfo.hpp

@@ -21,6 +21,7 @@
 
 #include <boost/current_function.hpp>
 #include <functional>
+#include <cstring>
 
 namespace boost
 {
@@ -36,26 +37,43 @@ private:
     typeinfo& operator=( typeinfo const& );
 
     char const * name_;
+    void (*lib_id_)();
 
 public:
 
-    explicit typeinfo( char const * name ): name_( name )
+    typeinfo( char const * name, void (*lib_id)() ): name_( name ), lib_id_( lib_id )
     {
     }
 
     bool operator==( typeinfo const& rhs ) const
     {
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+
+        return lib_id_ == rhs.lib_id_? this == &rhs: std::strcmp( name_, rhs.name_ ) == 0;
+
+#else
+
         return this == &rhs;
+
+#endif
     }
 
     bool operator!=( typeinfo const& rhs ) const
     {
-        return this != &rhs;
+        return !( *this == rhs );
     }
 
     bool before( typeinfo const& rhs ) const
     {
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+
+        return lib_id_ == rhs.lib_id_? std::less< typeinfo const* >()( this, &rhs ): std::strcmp( name_, rhs.name_ ) < 0;
+
+#else
+
         return std::less< typeinfo const* >()( this, &rhs );
+
+#endif
     }
 
     char const* name() const
@@ -74,7 +92,7 @@ inline char const * demangled_name( core::typeinfo const & ti )
 namespace detail
 {
 
-template<class T> struct core_typeid_
+template<class T> struct BOOST_SYMBOL_VISIBLE core_typeid_
 {
     static boost::core::typeinfo ti_;
 
@@ -84,13 +102,11 @@ template<class T> struct core_typeid_
     }
 };
 
-#if defined(__SUNPRO_CC)
-// see #4199, the Sun Studio compiler gets confused about static initialization 
-// constructor arguments. But an assignment works just fine. 
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
-#else
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
-#endif
+BOOST_SYMBOL_VISIBLE inline void core_typeid_lib_id()
+{
+}
+
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_( core_typeid_< T >::name(), &core_typeid_lib_id );
 
 template<class T> struct core_typeid_< T & >: core_typeid_< T >
 {

include/boost/core/uncaught_exceptions.hpp

@@ -0,0 +1,111 @@
+/*
+ *             Copyright Andrey Semashev 2018.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          https://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   uncaught_exceptions.hpp
+ * \author Andrey Semashev
+ * \date   2018-11-10
+ *
+ * \brief  This header provides an `uncaught_exception` function implementation, which was introduced in C++17.
+ *
+ * The code in this file is based on the implementation by Evgeny Panasyuk:
+ *
+ * https://github.com/panaseleus/stack_unwinding/blob/master/boost/exception/uncaught_exception_count.hpp
+ */
+
+#ifndef BOOST_CORE_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED_
+#define BOOST_CORE_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED_
+
+#include <exception>
+#include <boost/config.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+// Visual Studio 14 supports N4152 std::uncaught_exceptions()
+#if (defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411) || \
+    (defined(_MSC_VER) && _MSC_VER >= 1900)
+#define BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
+#endif
+
+#if !defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS)
+
+// cxxabi.h availability macro
+#if defined(__has_include) && (!defined(BOOST_GCC) || (__GNUC__ >= 5))
+#   if __has_include(<cxxabi.h>)
+#       define BOOST_CORE_HAS_CXXABI_H
+#   endif
+#elif defined(__GLIBCXX__) || defined(__GLIBCPP__)
+#   define BOOST_CORE_HAS_CXXABI_H
+#endif
+
+#if defined(BOOST_CORE_HAS_CXXABI_H)
+// MinGW GCC 4.4 seem to not work the same way the newer GCC versions do. As a result, __cxa_get_globals based implementation will always return 0.
+// Just disable it for now and fall back to std::uncaught_exception().
+#if !defined(__MINGW32__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)))
+#define BOOST_CORE_HAS_CXA_GET_GLOBALS
+#include <cxxabi.h>
+// Only GCC 4.7 declares __cxa_get_globals() in cxxabi.h, older compilers do not expose this function but it's there
+#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407
+namespace __cxxabiv1 {
+struct __cxa_eh_globals;
+extern "C" __cxa_eh_globals* __cxa_get_globals() BOOST_NOEXCEPT_OR_NOTHROW __attribute__((__const__));
+} // namespace __cxxabiv1
+#endif // defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407
+#endif
+#endif // defined(BOOST_CORE_HAS_CXXABI_H)
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+#define BOOST_CORE_HAS_GETPTD
+namespace boost {
+namespace core {
+namespace detail {
+extern "C" void* _getptd();
+} // namespace detail
+} // namespace core
+} // namespace boost
+#endif // defined(_MSC_VER) && _MSC_VER >= 1400
+
+#endif // !defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS)
+
+#if !defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS) && !defined(BOOST_CORE_HAS_CXA_GET_GLOBALS) && !defined(BOOST_CORE_HAS_GETPTD)
+//! This macro is defined when `uncaught_exceptions` is not guaranteed to return values greater than 1 if multiple exceptions are pending
+#define BOOST_CORE_UNCAUGHT_EXCEPTIONS_EMULATED
+#endif
+
+namespace boost {
+
+namespace core {
+
+//! Returns the number of currently pending exceptions
+inline unsigned int uncaught_exceptions() BOOST_NOEXCEPT
+{
+#if defined(BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS)
+    // C++17 implementation
+    return static_cast< unsigned int >(std::uncaught_exceptions());
+#elif defined(BOOST_CORE_HAS_CXA_GET_GLOBALS)
+    // Tested on {clang 3.2,GCC 3.5.6,GCC 4.1.2,GCC 4.4.6,GCC 4.4.7}x{x32,x64}
+    return *(reinterpret_cast< const unsigned int* >(reinterpret_cast< const char* >(::abi::__cxa_get_globals()) + sizeof(void*))); // __cxa_eh_globals::uncaughtExceptions, x32 offset - 0x4, x64 - 0x8
+#elif defined(BOOST_CORE_HAS_GETPTD)
+    // MSVC specific. Tested on {MSVC2005SP1,MSVC2008SP1,MSVC2010SP1,MSVC2012}x{x32,x64}.
+    return *(reinterpret_cast< const unsigned int* >(static_cast< const char* >(boost::core::detail::_getptd()) + (sizeof(void*) == 8 ? 0x100 : 0x90))); // _tiddata::_ProcessingThrow, x32 offset - 0x90, x64 - 0x100
+#else
+    // Portable C++03 implementation. Does not allow to detect multiple nested exceptions.
+    return static_cast< unsigned int >(std::uncaught_exception());
+#endif
+}
+
+} // namespace core
+
+} // namespace boost
+
+#undef BOOST_CORE_HAS_CXXABI_H
+#undef BOOST_CORE_HAS_CXA_GET_GLOBALS
+#undef BOOST_CORE_HAS_UNCAUGHT_EXCEPTIONS
+#undef BOOST_CORE_HAS_GETPTD
+
+#endif // BOOST_CORE_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED_

meta/libraries.json

@@ -9,7 +9,7 @@
     ],
     "maintainers": [
         "Peter Dimov <pdimov -at- pdimov.com>",
-        "Glen Fernandes <glenfe -at- live.com>",
+        "Glen Fernandes <glenjofe -at- gmail.com>",
         "Andrey Semashev <andrey.semashev -at- gmail.com>"
     ],
     "description": "A collection of simple core utilities with minimal dependencies.",

test/Jamfile.v2

@@ -127,5 +127,19 @@ run exchange_move_test.cpp ;
 run empty_value_test.cpp ;
 run empty_value_size_test.cpp ;
 
+run quick_exit_test.cpp ;
+run-fail quick_exit_fail.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 uncaught_exceptions.cpp : : : <exception-handling>on ;
+run uncaught_exceptions_np.cpp : : : <exception-handling>on ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/cmake_subdir_test/CMakeLists.txt

@@ -0,0 +1,19 @@
+# Copyright 2018, 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
+
+cmake_minimum_required(VERSION 3.5)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+add_subdirectory(../.. boostorg/core)
+add_subdirectory(../../../assert boostorg/assert)
+add_subdirectory(../../../config boostorg/config)
+
+add_executable(quick ../quick.cpp)
+target_link_libraries(quick Boost::core)
+
+enable_testing()
+add_test(quick quick)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

test/lib_typeid.cpp

@@ -0,0 +1,17 @@
+
+// Copyright 2018 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/core/typeinfo.hpp>
+#include <boost/config.hpp>
+
+#if defined(LIB_TYPEID_DYN_LINK)
+# define EXPORT BOOST_SYMBOL_EXPORT
+#else
+# define EXPORT
+#endif
+
+EXPORT boost::core::typeinfo const & get_typeid_int()
+{
+    return BOOST_CORE_TYPEID( int );
+}

test/quick_exit_fail.cpp

@@ -0,0 +1,17 @@
+
+// Test for quick_exit.hpp
+//
+// Copyright 2018 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/quick_exit.hpp>
+
+int main()
+{
+    boost::quick_exit( 1 );
+    return 0;
+}

test/quick_exit_test.cpp

@@ -0,0 +1,17 @@
+
+// Test for quick_exit.hpp
+//
+// Copyright 2018 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/quick_exit.hpp>
+
+int main()
+{
+    boost::quick_exit( 0 );
+    return 1;
+}

test/swap/Jamfile.v2

@@ -16,6 +16,9 @@ local compile_tests =
     mixed_headers_2.cpp
     ;
 
+local compile_fail_tests =
+    const_wrapper_fail.cpp ;
+
 local run_tests =
     primitive.cpp
     specialized_in_boost.cpp
@@ -49,6 +52,12 @@ rule test_all
         all_rules += [ compile $(file) : : "swap-$(test_name)" ] ;
     }
 
+    for file in $(compile_fail_tests)
+    {
+        local test_name = [ MATCH "([^.]*).cpp$" : $(file) ] ;
+        all_rules += [ compile-fail $(file) : : "swap-$(test_name)" ] ;
+    }
+
     for file in $(run_tests)
     {
         local test_name = [ MATCH "([^.]*).cpp$" : $(file) ] ;

test/swap/const_wrapper_fail.cpp

@@ -0,0 +1,28 @@
+// Copyright 2018 Andrzej Krzemieński
+// Copyright 2018 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/core/swap.hpp>
+
+namespace boost
+{
+  
+template<class T> struct Wrapper
+{
+    T value;
+};
+
+template<class T> inline void swap( Wrapper<T> & w, Wrapper<T> & v )
+{
+    boost::swap( w, v );
+}
+  
+} // namespace boost
+ 
+int main()
+{
+    boost::Wrapper<int> const w = { 2 };
+    boost::Wrapper<int> const v = { 3 };
+
+    swap( w, v );
+}

test/test_lib_typeid.cpp

@@ -0,0 +1,26 @@
+
+// Copyright 2018 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/core/typeinfo.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+boost::core::typeinfo const & get_typeid_int();
+
+int main()
+{
+    boost::core::typeinfo const & ti = BOOST_CORE_TYPEID( int );
+    boost::core::typeinfo const & tf = BOOST_CORE_TYPEID( float );
+
+    boost::core::typeinfo const & ti2 = get_typeid_int();
+
+    BOOST_TEST( ti2 == ti );
+    BOOST_TEST( ti2 != tf );
+
+    BOOST_TEST( !ti2.before( ti ) );
+    BOOST_TEST( !ti.before( ti2 ) );
+
+    BOOST_TEST( ti2.before( tf ) != tf.before( ti2 ) );
+
+    return boost::report_errors();
+}

test/uncaught_exceptions.cpp

@@ -0,0 +1,55 @@
+/*
+ *             Copyright Andrey Semashev 2018.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          https://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   uncaught_exceptions.cpp
+ * \author Andrey Semashev
+ * \date   2018-11-10
+ *
+ * \brief  This file contains tests for the uncaught_exceptions function.
+ *
+ * This file only contains the very basic checks of functionality that can be portably achieved
+ * through C++03 std::uncaught_exception.
+ */
+
+#include <boost/core/uncaught_exceptions.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct my_exception {};
+
+class exception_watcher
+{
+    unsigned int& m_count;
+
+public:
+    explicit exception_watcher(unsigned int& count) : m_count(count) {}
+    ~exception_watcher() { m_count = boost::core::uncaught_exceptions(); }
+};
+
+// Tests for uncaught_exceptions when used in a destructor while an exception propagates
+void test_in_destructor()
+{
+    const unsigned int root_count = boost::core::uncaught_exceptions();
+
+    unsigned int level1_count = root_count;
+    try
+    {
+        exception_watcher watcher(level1_count);
+        throw my_exception();
+    }
+    catch (...)
+    {
+    }
+
+    BOOST_TEST_NE(root_count, level1_count);
+}
+
+int main()
+{
+    test_in_destructor();
+
+    return boost::report_errors();
+}

test/uncaught_exceptions_np.cpp

@@ -0,0 +1,90 @@
+/*
+ *             Copyright Andrey Semashev 2018.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          https://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   uncaught_exceptions_np.cpp
+ * \author Andrey Semashev
+ * \date   2018-11-10
+ *
+ * \brief  This file contains tests for the uncaught_exceptions function.
+ *
+ * This file contains checks that are compiler specific and not quite portable or require C++17.
+ */
+
+#include <boost/core/uncaught_exceptions.hpp>
+
+#if !defined(BOOST_CORE_UNCAUGHT_EXCEPTIONS_EMULATED)
+
+#include <boost/core/lightweight_test.hpp>
+
+struct my_exception1 {};
+struct my_exception2 {};
+
+class exception_watcher2
+{
+    unsigned int& m_count;
+
+public:
+    explicit exception_watcher2(unsigned int& count) : m_count(count) {}
+    ~exception_watcher2() { m_count = boost::core::uncaught_exceptions(); }
+};
+
+class exception_watcher1
+{
+    unsigned int& m_count1;
+    unsigned int& m_count2;
+
+public:
+    exception_watcher1(unsigned int& count1, unsigned int& count2) : m_count1(count1), m_count2(count2) {}
+    ~exception_watcher1()
+    {
+        m_count1 = boost::core::uncaught_exceptions();
+        try
+        {
+            exception_watcher2 watcher2(m_count2);
+            throw my_exception2();
+        }
+        catch (...)
+        {
+        }
+    }
+};
+
+// Tests for uncaught_exceptions when used in nested destructors while an exception propagates
+void test_in_nested_destructors()
+{
+    const unsigned int root_count = boost::core::uncaught_exceptions();
+
+    unsigned int level1_count = root_count, level2_count = root_count;
+    try
+    {
+        exception_watcher1 watcher1(level1_count, level2_count);
+        throw my_exception1();
+    }
+    catch (...)
+    {
+    }
+
+    BOOST_TEST_NE(root_count, level1_count);
+    BOOST_TEST_NE(root_count, level2_count);
+    BOOST_TEST_NE(level1_count, level2_count);
+}
+
+int main()
+{
+    test_in_nested_destructors();
+
+    return boost::report_errors();
+}
+
+#else
+
+int main()
+{
+    return 0;
+}
+
+#endif