correct msvc version number

Export base class.
Ignore windows warning that base class isn't exported.

.travis.yml

@@ -1,4 +1,4 @@
-# Copyright 2016 Peter Dimov
+# Copyright 2016, 2017 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)
 
@@ -6,66 +6,100 @@ language: cpp
 
 sudo: false
 
-os:
-  - linux
-  - osx
+cache:
+  ccache: true
 
 branches:
   only:
     - master
     - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc-5
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc-6
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc-7
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc-7 LINK=static
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang LINK=static
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang LINK=static
 
 install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
   - cd ..
-  - git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
   - cd boost-root
-  - git submodule init libs/align
-  - git submodule init libs/array
-  - git submodule init libs/assert
-  - git submodule init libs/bind
-  - git submodule init libs/compatibility
-  - git submodule init libs/concept_check
-  - git submodule init libs/config
-  - git submodule init libs/container
-  - git submodule init libs/core
-  - git submodule init libs/detail
-  - git submodule init libs/filesystem
-  - git submodule init libs/function
-  - git submodule init libs/functional
-  - git submodule init libs/integer
-  - git submodule init libs/intrusive
-  - git submodule init libs/io
-  - git submodule init libs/iterator
-  - git submodule init libs/lexical_cast
-  - git submodule init libs/math
-  - git submodule init libs/move
-  - git submodule init libs/mpl
-  - git submodule init libs/numeric/conversion
-  - git submodule init libs/optional
-  - git submodule init libs/predef
-  - git submodule init libs/preprocessor
-  - git submodule init libs/range
-  - git submodule init libs/smart_ptr
-  - git submodule init libs/spirit
-  - git submodule init libs/static_assert
-  - git submodule init libs/system
-  - git submodule init libs/throw_exception
-  - git submodule init libs/tuple
-  - git submodule init libs/type_index
-  - git submodule init libs/type_traits
-  - git submodule init libs/unordered
-  - git submodule init libs/utility
-  - git submodule init libs/variant
-  - git submodule init tools/build
-  - git submodule update --depth 1
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
   - cp -r $TRAVIS_BUILD_DIR/* libs/serialization
+  - python tools/boostdep/depinst/depinst.py serialization
   - ./bootstrap.sh
   - ./b2 headers
 
 script:
-  - TOOLSET=gcc,clang
-  - if [ $TRAVIS_OS_NAME == osx ]; then TOOLSET=clang; fi
-  - ./b2 libs/serialization/test toolset=$TOOLSET
+  - ./b2 -j 3 libs/serialization/test toolset=$TOOLSET link=${LINK:-shared}
 
 notifications:
   email:

CMake/CMakeLists.txt

@@ -166,7 +166,6 @@ add_library(serialization ${LINK_TYPE}
   ../src/extended_type_info.cpp
   ../src/polymorphic_iarchive.cpp
   ../src/polymorphic_oarchive.cpp
-  ../src/singleton.cpp
   ../src/stl_port.cpp
   ../src/text_iarchive.cpp
   ../src/text_oarchive.cpp
@@ -252,7 +251,8 @@ endfunction(polymorphic_archive_test)
 
 enable_testing()
 
-# serialization(test_dll_exported dll_polymorphic_derived2_lib)
+serialization_test(test_dll_exported polymorphic_derived2 polymorphic_base)
+
 # serialization(test_dll_simple dll_a_lib)
 # compile test_dll_plugin.cpp
 # Running the following test requires that the test know the directory 
@@ -266,6 +266,7 @@ serialization_test(test_mult_archive_types)
 serialization_test(test_iterators)
 serialization_test(test_iterators_base64)
 serialization_test(test_inclusion)
+serialization_test(test_inclusion2)
 serialization_test(test_smart_cast)
 serialization_test(test_codecvt_null ../src/codecvt_null)
 serialization_test(test_strong_typedef)

appveyor.yml

@@ -12,6 +12,17 @@ branches:
     - develop
 #    - master
 
+environment:
+  matrix:
+    - BUILD_TOOLSET: gcc
+      BUILD_LINK: static
+    - BUILD_TOOLSET: gcc
+      BUILD_LINK: shared
+    - BUILD_TOOLSET: msvc-14.0
+      BUILD_LINK: static
+    - BUILD_TOOLSET: msvc-14.0
+      BUILD_LINK: shared
+
 install:
   - cd ..
   - git clone -b %APPVEYOR_REPO_BRANCH%  https://github.com/boostorg/boost.git boost-root
@@ -24,6 +35,7 @@ install:
   - git submodule init libs/concept_check
   - git submodule init libs/config
   - git submodule init libs/container
+  - git submodule init libs/container_hash
   - git submodule init libs/core
   - git submodule init libs/detail
   - git submodule init libs/filesystem
@@ -53,6 +65,7 @@ install:
   - git submodule init libs/unordered
   - git submodule init libs/utility
   - git submodule init libs/variant
+  - git submodule init libs/winapi
   - git submodule init tools/build
   - git submodule update
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\serialization
@@ -64,4 +77,4 @@ build: off
 
 test_script:
   - cd libs/serialization/test
-  - b2 toolset=gcc link=static,shared
+  - b2 -j2 toolset=%BUILD_TOOLSET% link=%BUILD_LINK%

build/Jamfile.v2

@@ -82,8 +82,7 @@ SOURCES =
     xml_archive_exception
     codecvt_null
     utf8_codecvt_facet
-    singleton
-;
+ ;
     
 WSOURCES = 
     basic_text_wiprimitive

include/boost/archive/basic_archive.hpp

@@ -151,7 +151,10 @@ private:
 public:
     object_id_type(): t(0) {};
     // note: presumes that size_t >= unsigned int.
-    explicit object_id_type(const std::size_t & t_) : t(t_){
+    // use explicit cast to silence useless warning
+    explicit object_id_type(const std::size_t & t_) : t(static_cast<base_type>(t_)){
+        // make quadriple sure that we haven't lost any real integer
+        // precision
         BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
     }
     object_id_type(const object_id_type & t_) : 

include/boost/archive/codecvt_null.hpp

@@ -63,10 +63,10 @@ public:
 };
 
 template<>
-class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
+class BOOST_WARCHIVE_DECL codecvt_null<wchar_t> :
     public std::codecvt<wchar_t, char, std::mbstate_t>
 {
-    virtual BOOST_WARCHIVE_DECL std::codecvt_base::result
+    virtual std::codecvt_base::result
     do_out(
         std::mbstate_t & state,
         const wchar_t * first1,
@@ -76,7 +76,7 @@ class BOOST_SYMBOL_VISIBLE codecvt_null<wchar_t> :
         char * last2,
         char * & next2
     ) const;
-    virtual BOOST_WARCHIVE_DECL std::codecvt_base::result
+    virtual std::codecvt_base::result
     do_in(
         std::mbstate_t & state,
         const char * first1,
@@ -96,7 +96,7 @@ public:
     explicit codecvt_null(std::size_t no_locale_manage = 0) :
         std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
     {}
-    virtual ~codecvt_null(){};
+    //virtual ~codecvt_null(){};
 };
 
 } // namespace archive

include/boost/archive/detail/common_iarchive.hpp

@@ -35,11 +35,12 @@ class extended_type_info;
 
 // note: referred to as Curiously Recurring Template Patter (CRTP)
 template<class Archive>
-class BOOST_SYMBOL_VISIBLE common_iarchive : 
+class BOOST_SYMBOL_VISIBLE common_iarchive :
     public basic_iarchive,
     public interface_iarchive<Archive>
 {
     friend class interface_iarchive<Archive>;
+    friend class basic_iarchive;
 private:
     virtual void vload(version_type & t){
         * this->This() >> t; 

include/boost/archive/detail/common_oarchive.hpp

@@ -38,6 +38,7 @@ class BOOST_SYMBOL_VISIBLE common_oarchive :
     public interface_oarchive<Archive>
 {
     friend class interface_oarchive<Archive>;
+    friend class basic_oarchive;
 private:
     virtual void vsave(const version_type t){
         * this->This() << t;

include/boost/archive/detail/iserializer.hpp

@@ -57,11 +57,10 @@ namespace std{
 
 #include <boost/serialization/assume_abstract.hpp>
 
-#if BOOST_WORKAROUND(__IBMCPP__, < 1210)          \
-|| (                                              \
-    defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590) \
-)                                                 
-        #define DONT_USE_HAS_NEW_OPERATOR 1
+#if !defined(BOOST_MSVC) && \
+    (BOOST_WORKAROUND(__IBMCPP__, < 1210) || \
+    defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x590))
+    #define DONT_USE_HAS_NEW_OPERATOR 1
 #else
     #define DONT_USE_HAS_NEW_OPERATOR 0
 #endif
@@ -90,6 +89,8 @@ namespace std{
 #include <boost/archive/detail/archive_serializer_map.hpp>
 #include <boost/archive/detail/check.hpp>
 
+#include <boost/core/addressof.hpp>
+
 namespace boost {
 
 namespace serialization {
@@ -234,7 +235,7 @@ struct heap_allocation {
                 // that the class might have class specific new with NO
                 // class specific delete at all.  Patches (compatible with
                 // C++03) welcome!
-                delete t;
+                (operator delete)(t);
             }
         };
         struct doesnt_have_new_operator {
@@ -243,7 +244,7 @@ struct heap_allocation {
             }
             static void invoke_delete(T * t) {
                 // Note: I'm reliance upon automatic conversion from T * to void * here
-                delete t;
+                (operator delete)(t);
             }
         };
         static T * invoke_new() {
@@ -406,7 +407,7 @@ struct load_non_pointer_type {
     struct load_standard {
         template<class T>
         static void invoke(Archive &ar, const T & t){
-            void * x = & const_cast<T &>(t);
+            void * x = boost::addressof(const_cast<T &>(t));
             ar.load_object(
                 x, 
                 boost::serialization::singleton<
@@ -484,7 +485,7 @@ struct load_pointer_type {
     };
 
     template<class T>
-    static const basic_pointer_iserializer * register_type(Archive &ar, const T & /*t*/){
+    static const basic_pointer_iserializer * register_type(Archive &ar, const T* const /*t*/){
         // there should never be any need to load an abstract polymorphic 
         // class pointer.  Inhibiting code generation for this
         // permits abstract base classes to be used - note: exception
@@ -523,7 +524,7 @@ struct load_pointer_type {
     }
 
     template<class T>
-    static void check_load(T & /* t */){
+    static void check_load(T * const /* t */){
         check_pointer_level< T >();
         check_pointer_tracking< T >();
     }
@@ -537,8 +538,8 @@ struct load_pointer_type {
 
     template<class Tptr>
     static void invoke(Archive & ar, Tptr & t){
-        check_load(*t);
-        const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
+        check_load(t);
+        const basic_pointer_iserializer * bpis_ptr = register_type(ar, t);
         const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
             // note major hack here !!!
             // I tried every way to convert Tptr &t (where Tptr might

include/boost/archive/detail/oserializer.hpp

@@ -26,6 +26,7 @@
 #include <cstddef> // NULL
 
 #include <boost/config.hpp>
+
 #include <boost/static_assert.hpp>
 #include <boost/detail/workaround.hpp>
 
@@ -68,6 +69,8 @@
 #include <boost/archive/detail/archive_serializer_map.hpp>
 #include <boost/archive/detail/check.hpp>
 
+#include <boost/core/addressof.hpp>
+
 namespace boost {
 
 namespace serialization {
@@ -253,7 +256,7 @@ struct save_non_pointer_type {
         template<class T>
         static void invoke(Archive &ar, const T & t){
             ar.save_object(
-                & t, 
+                boost::addressof(t),
                 boost::serialization::singleton<
                     oserializer<Archive, T>
                 >::get_const_instance()
@@ -261,6 +264,8 @@ struct save_non_pointer_type {
         }
     };
 
+
+
     // adds class information to the archive. This includes
     // serialization level and class version
     struct save_conditional {

include/boost/archive/detail/utf8_codecvt_facet.hpp

@@ -13,27 +13,17 @@
 #error "wide char i/o not supported on this platform"
 #endif
 
-// std::codecvt_utf8 doesn't seem to work for any versions of msvc
+// use boost's utf8 codecvt facet
+#include <boost/archive/detail/decl.hpp>
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+     namespace boost { namespace archive { namespace detail {
+#define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
+#define BOOST_UTF8_END_NAMESPACE }}}
 
-#if defined(_MSC_VER) || defined(BOOST_NO_CXX11_HDR_CODECVT)
-    // use boost's utf8 codecvt facet
-    #include <boost/archive/detail/decl.hpp>
-    #define BOOST_UTF8_BEGIN_NAMESPACE \
-         namespace boost { namespace archive { namespace detail {
-    #define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
-    #define BOOST_UTF8_END_NAMESPACE }}}
+#include <boost/detail/utf8_codecvt_facet.hpp>
 
-    #include <boost/detail/utf8_codecvt_facet.hpp>
-
-    #undef BOOST_UTF8_END_NAMESPACE
-    #undef BOOST_UTF8_DECL
-    #undef BOOST_UTF8_BEGIN_NAMESPACE
-#else
-    // use the standard vendor supplied facet
-    #include <codecvt>
-    namespace boost { namespace archive { namespace detail {
-        typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet;
-    } } }
-#endif
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL
+#undef BOOST_UTF8_BEGIN_NAMESPACE
 
 #endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP

include/boost/archive/impl/xml_wiarchive_impl.ipp

@@ -161,13 +161,13 @@ xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
     gimpl(new xml_wgrammar())
 {
     if(0 == (flags & no_codecvt)){
-        std::locale l = std::locale(
+        archive_locale = std::locale(
             is_.getloc(),
             new boost::archive::detail::utf8_codecvt_facet
         );
         // libstdc++ crashes without this
         is_.sync();
-        is_.imbue(l);
+        is_.imbue(archive_locale);
     }
     if(0 == (flags & no_header))
         init();

include/boost/archive/impl/xml_woarchive_impl.ipp

@@ -103,7 +103,6 @@ xml_woarchive_impl<Archive>::save(const char * s){
 template<class Archive>
 BOOST_WARCHIVE_DECL void
 xml_woarchive_impl<Archive>::save(const wchar_t * ws){
-    os << ws;
     typedef iterators::xml_escape<const wchar_t *> xmbtows;
     std::copy(
         xmbtows(ws),
@@ -126,12 +125,12 @@ xml_woarchive_impl<Archive>::xml_woarchive_impl(
     basic_xml_oarchive<Archive>(flags)
 {
     if(0 == (flags & no_codecvt)){
-        std::locale l = std::locale(
+        archive_locale = std::locale(
             os_.getloc(),
             new boost::archive::detail::utf8_codecvt_facet
         );
         os_.flush();
-        os_.imbue(l);
+        os_.imbue(archive_locale);
     }
     if(0 == (flags & no_header))
         this->init();
@@ -143,7 +142,7 @@ xml_woarchive_impl<Archive>::~xml_woarchive_impl(){
     if(std::uncaught_exception())
         return;
     if(0 == (this->get_flags() & no_header)){
-        save(L"</boost_serialization>\n");
+        os << L"</boost_serialization>";
     }
 }
 

include/boost/archive/iterators/xml_unescape.hpp

@@ -16,6 +16,8 @@
 
 //  See http://www.boost.org for updates, documentation, and revision history.
 
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
 #include <boost/assert.hpp>
 
 #include <boost/serialization/throw_exception.hpp>
@@ -42,11 +44,11 @@ class xml_unescape
         return unescape<xml_unescape<Base>, Base>::dereference();
     }
 public:
-    // workaround msvc 7.1 ICU crash
-    #if defined(BOOST_MSVC)
+    // msvc versions prior to 14.0 crash with and ICE 
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1900)
         typedef int value_type;
     #else
-        typedef typename this_t::value_type value_type;
+        typedef typename super_t::value_type value_type;
     #endif
 
     void drain_residue(const char *literal);

include/boost/archive/text_oarchive.hpp

@@ -65,10 +65,10 @@ protected:
         basic_text_oprimitive<std::ostream>::save(t);
     }
     void save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     void save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     BOOST_ARCHIVE_DECL void 
     save(const char * t);

include/boost/archive/text_woarchive.hpp

@@ -78,10 +78,10 @@ protected:
         basic_text_oprimitive<std::wostream>::save(t);
     }
     void save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     void save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     BOOST_WARCHIVE_DECL void
     save(const char * t);

include/boost/archive/xml_oarchive.hpp

@@ -65,11 +65,11 @@ protected:
     }
     void 
     save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     void 
     save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     BOOST_ARCHIVE_DECL void 
     save(const char * t);

include/boost/archive/xml_wiarchive.hpp

@@ -62,6 +62,7 @@ protected:
     friend class basic_xml_iarchive<Archive>;
     friend class load_access;
 #endif
+    std::locale archive_locale;
     boost::scoped_ptr<xml_wgrammar> gimpl;
     std::wistream & get_is(){
         return is;

include/boost/archive/xml_woarchive.hpp

@@ -74,11 +74,11 @@ protected:
     }
     void
     save(const version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     void 
     save(const boost::serialization::item_version_type & t){
-        save(static_cast<const unsigned int>(t));
+        save(static_cast<unsigned int>(t));
     }
     BOOST_WARCHIVE_DECL void
     save(const char * t);

include/boost/serialization/boost_array.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_SERIALIZATION_ARRAY_HPP
-#define BOOST_SERIALIZATION_ARRAY_HPP
+#ifndef BOOST_SERIALIZATION_BOOST_ARRAY_HPP
+#define BOOST_SERIALIZATION_BOOST_ARRAY_HPP
 
 // (C) Copyright 2005 Matthias Troyer and Dave Abrahams
 // Use, modification and distribution is subject to the Boost Software
@@ -30,4 +30,4 @@ void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int /* version
 } } // end namespace boost::serialization
 
 
-#endif //BOOST_SERIALIZATION_ARRAY_HPP
+#endif //BOOST_SERIALIZATION_BOOST_ARRAY_HPP

include/boost/serialization/collections_save_imp.hpp

@@ -19,6 +19,7 @@
 // helper function templates for serialization of collections
 
 #include <boost/config.hpp>
+#include <boost/core/addressof.hpp>
 #include <boost/serialization/nvp.hpp>
 #include <boost/serialization/serialization.hpp>
 #include <boost/serialization/version.hpp>
@@ -60,7 +61,7 @@ inline void save_collection(
         // note borland emits a no-op without the explicit namespace
         boost::serialization::save_construct_data_adl(
             ar, 
-            &(*it), 
+            boost::addressof(*it),
             item_version
         );
         ar << boost::serialization::make_nvp("item", *it++);

include/boost/serialization/nvp.hpp

@@ -28,6 +28,8 @@
 #include <boost/serialization/traits.hpp>
 #include <boost/serialization/wrapper.hpp>
 
+#include <boost/core/addressof.hpp>
+
 namespace boost {
 namespace serialization {
 
@@ -43,7 +45,7 @@ struct nvp :
 public:
     explicit nvp(const char * name_, T & t) :
         // note: added _ to suppress useless gcc warning
-        std::pair<const char *, T *>(name_, & t)
+        std::pair<const char *, T *>(name_, boost::addressof(t))
     {}
 
     const char * name() const {

include/boost/serialization/set.hpp

@@ -57,7 +57,8 @@ inline void load_set_collection(Archive & ar, Container &s)
         ar >> boost::serialization::make_nvp("item", t.reference());
         typename Container::iterator result =
             s.insert(hint, boost::move(t.reference()));
-        ar.reset_object_address(& (* result), & t.reference());
+        const type * new_address = & (* result);
+        ar.reset_object_address(new_address, & t.reference());
         hint = result;
     }
 }

include/boost/serialization/singleton.hpp

@@ -91,7 +91,11 @@ class BOOST_SYMBOL_VISIBLE singleton_module :
     public boost::noncopyable
 {
 private:
-    BOOST_DLLEXPORT static bool & get_lock() BOOST_USED;
+    BOOST_DLLEXPORT static bool & get_lock() BOOST_USED {
+        static bool lock = false;
+        return lock;
+    }
+
 public:
     BOOST_DLLEXPORT static void lock(){
         get_lock() = true;
@@ -116,15 +120,18 @@ private:
         // can be used
         class singleton_wrapper : public T {};
         static singleton_wrapper t;
+
         // refer to instance, causing it to be instantiated (and
         // initialized at startup on working compilers)
         BOOST_ASSERT(! is_destroyed());
+
         // note that the following is absolutely essential.
         // commenting out this statement will cause compilers to fail to
         // construct the instance at pre-execution time.  This would prevent
         // our usage/implementation of "locking" and introduce uncertainty into
         // the sequence of object initializaition.
         use(& m_instance);
+
         return static_cast<T &>(t);
     }
     static bool & get_is_destroyed(){

include/boost/serialization/valarray.hpp

@@ -18,6 +18,7 @@
 
 #include <valarray>
 #include <boost/config.hpp>
+#include <boost/core/addressof.hpp>
 
 #include <boost/serialization/collections_save_imp.hpp>
 #include <boost/serialization/collections_load_imp.hpp>
@@ -47,7 +48,7 @@ void save( Archive & ar, const STD::valarray<U> &t, const unsigned int /*file_ve
     if (t.size()){
         // explict template arguments to pass intel C++ compiler
         ar << serialization::make_array<const U, collection_size_type>(
-            static_cast<const U *>(&t[0]),
+            static_cast<const U *>( boost::addressof(t[0]) ),
             count
         );
     }
@@ -62,7 +63,7 @@ void load( Archive & ar, STD::valarray<U> &t,  const unsigned int /*file_version
     if (t.size()){
         // explict template arguments to pass intel C++ compiler
         ar >> serialization::make_array<U, collection_size_type>(
-            static_cast<U *>(&t[0]),
+            static_cast<U *>( boost::addressof(t[0]) ),
             count
         );
     }

include/boost/serialization/variant.hpp

@@ -43,8 +43,8 @@ namespace boost {
 namespace serialization {
 
 template<class Archive>
-struct variant_save_visitor : 
-    boost::static_visitor<> 
+struct variant_save_visitor :
+    boost::static_visitor<>
 {
     variant_save_visitor(Archive& ar) :
         m_ar(ar)
@@ -100,7 +100,8 @@ struct variant_impl {
                 head_type value;
                 ar >> BOOST_SERIALIZATION_NVP(value);
                 v = value;
-                ar.reset_object_address(& boost::get<head_type>(v), & value);
+                head_type * new_address = & boost::get<head_type>(v);
+                ar.reset_object_address(new_address, & value);
                 return;
             }
             typedef typename mpl::pop_front<S>::type type;
@@ -155,4 +156,23 @@ inline void serialize(
 } // namespace serialization
 } // namespace boost
 
+//template<typename T0_, BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)>
+
+#include <boost/serialization/tracking.hpp>
+
+namespace boost {
+    namespace serialization {
+        
+template<BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+struct tracking_level<
+    variant<BOOST_VARIANT_ENUM_PARAMS(T)>
+>{
+    typedef mpl::integral_c_tag tag;
+    typedef mpl::int_< ::boost::serialization::track_always> type;
+    BOOST_STATIC_CONSTANT(int, value = type::value);
+};
+
+} // namespace serialization
+} // namespace boost
+
 #endif //BOOST_SERIALIZATION_VARIANT_HPP

include/boost/serialization/void_cast.hpp

@@ -181,13 +181,14 @@ void_caster_primitive<Derived, Base>::void_caster_primitive() :
     void_caster( 
         & type_info_implementation<Derived>::type::get_const_instance(), 
         & type_info_implementation<Base>::type::get_const_instance(),
-        // note:I wanted to displace from 0 here, but at least one compiler
-        // treated 0 by not shifting it at all.
+        /* note about displacement:
+         * displace 0: at least one compiler treated 0 by not shifting it at all
+         * displace by small value (8): caused ICE on certain mingw gcc versions */
         reinterpret_cast<std::ptrdiff_t>(
             static_cast<Derived *>(
-                reinterpret_cast<Base *>(8)
+                reinterpret_cast<Base *>(1 << 20)
             )
-        ) - 8
+        ) - (1 << 20)
     )
 {
     recursive_register();

src/archive_exception.cpp

@@ -77,6 +77,14 @@ archive_exception::archive_exception(
         break;
     case input_stream_error:
         length = append(length, "input stream error");
+        if(NULL != e1){
+            length = append(length, "-");
+            length = append(length, e1);
+        }
+        if(NULL != e2){
+            length = append(length, "-");
+            length = append(length, e2);
+        }
         break;
     case invalid_class_name:
         length = append(length, "class name too long");
@@ -105,6 +113,14 @@ archive_exception::archive_exception(
         break;
     case output_stream_error:
         length = append(length, "output stream error");
+        if(NULL != e1){
+            length = append(length, "-");
+            length = append(length, e1);
+        }
+        if(NULL != e2){
+            length = append(length, "-");
+            length = append(length, e2);
+        }
         break;
     default:
         BOOST_ASSERT(false);

src/basic_archive.cpp

@@ -77,10 +77,13 @@ BOOST_ARCHIVE_SIGNATURE(){
 // 13- simplified visibility, removed Borland, removed pfto
 // 14- improved visibility, refactor map/set
 // 15- corrections to optional and collection loading
+// 16- eliminated dependency on <codecvt> which is buggy in some libraries
+//     and now officially deprecated in the standard
+// 17- Boost 1.68 August 2018
 
 BOOST_SYMBOL_VISIBLE library_version_type
 BOOST_ARCHIVE_VERSION(){
-    return library_version_type(15);
+    return library_version_type(17);
 }
 
 } // namespace archive

src/basic_oarchive.cpp

@@ -106,8 +106,9 @@ class basic_oarchive_impl {
             m_class_id(class_id),
             m_initialized(false)
         {}
-        cobject_type(const basic_oserializer & bos)
-            : m_bos_ptr(& bos)
+        cobject_type(const basic_oserializer & bos) :
+            m_bos_ptr(& bos),
+            m_initialized(false)
         {}
         cobject_type(
             const cobject_type & rhs

src/basic_xml_grammar.ipp

@@ -21,6 +21,9 @@
 #  pragma warning(disable : 4244 4511 4512)
 #endif
 
+#include <cerrno>   // errno
+#include <cstring>  // strerror(errno)
+
 // spirit stuff
 #include <boost/spirit/include/classic_operators.hpp>
 #include <boost/spirit/include/classic_actions.hpp>
@@ -31,7 +34,6 @@
 #endif
 
 // for head_iterator test
-//#include <boost/bind.hpp> 
 #include <boost/function.hpp>
 
 #include <boost/io/ios_state.hpp>
@@ -188,8 +190,14 @@ bool basic_xml_grammar<CharType>::my_parse(
     for(;;){
         CharType result;
         is.get(result);
-        if(is.fail())
-            return false;
+        if(is.fail()){
+            boost::serialization::throw_exception(
+                boost::archive::archive_exception(
+                    archive_exception::input_stream_error,
+                    std::strerror(errno)
+                )
+            );
+        }
         if(is.eof())
             return false;
         arg += result;

src/codecvt_null.cpp

@@ -18,7 +18,7 @@
 namespace boost {
 namespace archive {
 
-BOOST_WARCHIVE_DECL std::codecvt_base::result
+std::codecvt_base::result
 codecvt_null<wchar_t>::do_out(
     std::mbstate_t & /*state*/,
     const wchar_t * first1, 
@@ -46,7 +46,7 @@ codecvt_null<wchar_t>::do_out(
     return std::codecvt_base::ok;
 }
 
-BOOST_WARCHIVE_DECL std::codecvt_base::result
+std::codecvt_base::result
 codecvt_null<wchar_t>::do_in(
     std::mbstate_t & /*state*/,
     const char * first1, 

src/extended_type_info_typeid.cpp

@@ -98,17 +98,15 @@ extended_type_info_typeid_0::type_unregister()
         BOOST_ASSERT(! singleton<tkmap>::is_destroyed());
         if(! singleton<tkmap>::is_destroyed()){
             tkmap & x = singleton<tkmap>::get_mutable_instance();
-            tkmap::iterator start = x.lower_bound(this);
-            tkmap::iterator end = x.upper_bound(this);
-            BOOST_ASSERT(start != end);
 
-            // remove entry in map which corresponds to this type
-            do{
-            if(this == *start)
-                x.erase(start++);
-            else
-                ++start;
-            }while(start != end);
+            // remove all entries in map which corresponds to this type
+            // make sure that we don't use any invalidated iterators
+            for(;;){
+                const tkmap::iterator & it = x.find(this);
+                if(it == x.end())
+                    break;
+                x.erase(it);
+            };
         }
     }
     m_ti = NULL;

src/singleton.cpp

@@ -1,26 +0,0 @@
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// singleton.cpp
-//
-// Copyright (c) 201 5 Robert Ramey, Indiana University (garcia@osl.iu.edu)
-// Use, modification and distribution is subject to 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)
-//
-
-// it marks our code with proper attributes as being exported when
-// we're compiling it while marking it import when just the headers
-// is being included.
-#define BOOST_SERIALIZATION_SOURCE
-#include <boost/serialization/config.hpp>
-#include <boost/serialization/singleton.hpp>
-
-namespace boost { 
-namespace serialization { 
-
-BOOST_SERIALIZATION_DECL bool & singleton_module::get_lock(){
-    static bool lock = false;
-    return lock;
-}
-
-} // namespace serialization
-} // namespace boost

src/utf8_codecvt_facet.cpp

@@ -9,18 +9,14 @@
 #error "wide char i/o not supported on this platform"
 #endif
 
-// std::codecvt_utf8 doesn't seem to work for any versions of msvc
-#if defined(_MSC_VER) \
-||  defined( BOOST_NO_CXX11_HDR_CODECVT )
-    // include boost implementation of utf8 codecvt facet
-    # define BOOST_ARCHIVE_SOURCE
-    #include <boost/archive/detail/decl.hpp>
-    #define BOOST_UTF8_BEGIN_NAMESPACE \
-         namespace boost { namespace archive { namespace detail {
-    #define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
-    #define BOOST_UTF8_END_NAMESPACE }}}
-    #include <boost/detail/utf8_codecvt_facet.ipp>
-    #undef BOOST_UTF8_END_NAMESPACE
-    #undef BOOST_UTF8_DECL
-    #undef BOOST_UTF8_BEGIN_NAMESPACE
-#endif
+// include boost implementation of utf8 codecvt facet
+# define BOOST_ARCHIVE_SOURCE
+#include <boost/archive/detail/decl.hpp>
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+     namespace boost { namespace archive { namespace detail {
+#define BOOST_UTF8_DECL BOOST_ARCHIVE_DECL
+#define BOOST_UTF8_END_NAMESPACE }}}
+#include <boost/detail/utf8_codecvt_facet.ipp>
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL
+#undef BOOST_UTF8_BEGIN_NAMESPACE

test/A.cpp

@@ -48,7 +48,7 @@ void accumulate(std::size_t & s, const T & t){
         s += *tptr++;
     }
 }
-
+A_DLL_DECL
 A::operator std::size_t () const {
     std::size_t retval = 0;
     accumulate(retval, b);
@@ -78,6 +78,7 @@ A::operator std::size_t () const {
 #pragma warning(disable : 4244) // Disable possible loss of data warning
 #endif
 
+A_DLL_DECL
 A::A() :
     b(true),
     #ifndef BOOST_NO_INT64_T
@@ -111,8 +112,8 @@ A::A() :
 #pragma warning(pop) // Restore warnings to previous state.
 #endif 
 
-bool A::operator==(const A &rhs) const
-{
+A_DLL_DECL bool
+A::operator==(const A &rhs) const {
     if(b != rhs.b)
         return false;
     if(l != rhs.l)
@@ -160,13 +161,13 @@ bool A::operator==(const A &rhs) const
     return true;
 }
 
-bool A::operator!=(const A &rhs) const
-{
+A_DLL_DECL bool
+A::operator!=(const A &rhs) const {
     return ! (*this == rhs);
 }
 
-bool A::operator<(const A &rhs) const
-{
+A_DLL_DECL bool
+A::operator<(const A &rhs) const {
     if(b != rhs.b)
         return b < rhs.b;
     #ifndef BOOST_NO_INT64_T

test/A.hpp

@@ -32,13 +32,17 @@ namespace std{
 #include <boost/serialization/access.hpp>
 #include <boost/serialization/string.hpp>
 
-#if defined(A_IMPORT)
-    #define A_DLL_DECL BOOST_SYMBOL_IMPORT
-    #pragma message("A imported")
-#elif defined(A_EXPORT)
-    #define A_DLL_DECL BOOST_SYMBOL_EXPORT
-    #pragma message ("A exported")
-#else
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #if defined(A_IMPORT)
+        #define A_DLL_DECL BOOST_SYMBOL_IMPORT
+        #pragma message("A imported")
+    #elif defined(A_EXPORT)
+        #define A_DLL_DECL BOOST_SYMBOL_EXPORT
+        #pragma message ("A exported")
+    #endif
+#endif
+
+#ifndef A_DLL_DECL
     #define A_DLL_DECL
 #endif
 

test/A.ipp

@@ -57,4 +57,4 @@ void A::serialize(
     #ifndef BOOST_NO_STD_WSTRING
     ar & BOOST_SERIALIZATION_NVP(z);
     #endif
-}
+};

test/Jamfile.v2

@@ -9,13 +9,13 @@
 project libs/serialization/test
     : id serialization_test
     : requirements <source>/boost/filesystem
+    : requirements <source>/boost/system
     ;
 
 # import rules for testing conditional on config file variables
 import ../../config/checks/config : requires ;
 
 # import rules from the boost serialization test
-# import ../util/test : test-bsl-run-no-lib ;
 import ../util/test :
     run-template
     run-invoke
@@ -28,34 +28,28 @@ import ../util/test :
 ;
 
 BOOST_ARCHIVE_LIST = [ modules.peek : BOOST_ARCHIVE_LIST ] ;
-
-lib dll_a_lib 
+    
+lib a
     : 
         dll_a.cpp
         ../build//boost_serialization
     : 
+        <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1 
+    ;
+lib polymorphic_base
+    :
+        polymorphic_base.cpp 
+        ../build//boost_serialization
+    : 
+        <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1 
     ;
 
-lib dll_base_lib 
-    : 
-        dll_base.cpp
-        ../build//boost_serialization
-    : 
-    ;
-    
-lib dll_derived2_lib
+lib polymorphic_derived2
     :
-        dll_derived2.cpp 
-        dll_base_lib
-        ../build//boost_serialization
-    : 
-    ;
-
-lib dll_polymorphic_derived2_lib
-    :
-        polymorphic_derived2.cpp 
+        polymorphic_derived2.cpp
         ../build//boost_serialization
     : 
+        <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1 
     ;
 
 test-suite "serialization" :
@@ -133,13 +127,18 @@ test-suite "serialization" :
 
 if ! $(BOOST_ARCHIVE_LIST) {
     test-suite "serialization2" : 
-        [ test-bsl-run-no-lib test_inclusion ]
-        [ test-bsl-run test_dll_exported : : dll_polymorphic_derived2_lib ]
-        [ test-bsl-run test_dll_simple : : dll_a_lib ]
-        [ compile test_dll_plugin.cpp ]
-        # Running the following test requires that the test know the directory 
-        # in which the dll is stored. I don't know how to extract this from bjam
-        # [ test-bsl-run test_dll_plugin : : dll_polymorphic_derived2_lib ]
+        [ test-bsl-run test_inclusion ]
+        [ test-bsl-run test_inclusion2 ]
+        # boost build has the feature that the building if libraries vs dll is automatic
+        # in that dependent libraries are built the same way - shared/static - that
+        # the application is.  On some platforms (e.g windows) this is required to avoid
+        # problems of linking incompatible versions of the runtime library.  So
+        # we suppress tests of our dlls when using static libraries
+        [ test-bsl-run test_dll_exported : : polymorphic_derived2 : <link>static:<build>no ]
+
+        # [ test-bsl-run test_dll_plugin : : polymorphic_derived2 : <link>static:<build>no <target-os>linux:<linkflags>-ldl ]
+
+        [ test-bsl-run test_dll_simple   : : a : ]
         [ test-bsl-run test_private_ctor ]
         [ test-bsl-run test_reset_object_address : A ]
         [ test-bsl-run test_void_cast ]
@@ -147,13 +146,10 @@ if ! $(BOOST_ARCHIVE_LIST) {
         [ test-bsl-run test_iterators ]
         [ test-bsl-run test_iterators_base64 ]
         [ test-bsl-run test_smart_cast ]
-        [ test-bsl-run test_codecvt_null 
-            : ../src/codecvt_null
-            :
-            : [ requires std_wstreambuf ]
-        ]
-        
-        #[ test-bsl-run test_z ]
+        [ test-bsl-run test_codecvt_null ]
+        [ test-bsl-run test_singleton ]
+
+        # [ test-bsl-run test_z ]
 
         # should fail compilation
         [ compile-fail test_not_serializable.cpp ]
@@ -171,6 +167,7 @@ if ! $(BOOST_ARCHIVE_LIST) {
         [ compile test_const_save_warn1.cpp ]
         [ compile test_const_save_warn2.cpp ]
         [ compile test_const_save_warn3.cpp ]
+
         # note - library unable to detect these errors for now
         #[ compile test_const_save_warn1_nvp.cpp ]
         #[ compile test_const_save_warn2_nvp.cpp ]

test/dll_a.cpp

@@ -26,8 +26,7 @@ A_DLL_DECL void A::serialize(
     const unsigned int /* file_version */
 );
 template
-A_DLL_DECL
-void A::serialize(
+A_DLL_DECL void A::serialize(
     boost::archive::text_iarchive &ar,
     const unsigned int /* file_version */
 );
@@ -38,14 +37,12 @@ void A::serialize(
 #include <boost/archive/polymorphic_iarchive.hpp>
 
 template
-A_DLL_DECL
-void A::serialize(
+A_DLL_DECL void A::serialize(
     boost::archive::polymorphic_oarchive &ar,
     const unsigned int /* file_version */
 );
 template
-A_DLL_DECL
-void A::serialize(
+A_DLL_DECL void A::serialize(
     boost::archive::polymorphic_iarchive &ar,
     const unsigned int /* file_version */
 );

test/polymorphic_base.cpp

@@ -10,6 +10,8 @@
 
 #include <boost/serialization/export.hpp>
 
+#define POLYMORPHIC_BASE_EXPORT
+
 #include "polymorphic_base.hpp"
 
 BOOST_CLASS_EXPORT_IMPLEMENT(polymorphic_base)

test/polymorphic_base.hpp

@@ -24,7 +24,21 @@
 #include <boost/serialization/type_info_implementation.hpp>
 #include <boost/serialization/extended_type_info_no_rtti.hpp>
 
-class BOOST_SYMBOL_VISIBLE polymorphic_base
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #if defined(POLYMORPHIC_BASE_IMPORT)
+        #define POLYMORPHIC_BASE_DLL_DECL BOOST_SYMBOL_IMPORT
+        #pragma message ("polymorphic_base imported")
+    #elif defined(POLYMORPHIC_BASE_EXPORT)
+        #define POLYMORPHIC_BASE_DLL_DECL BOOST_SYMBOL_EXPORT
+        #pragma message ("polymorphic_base exported")
+    #endif
+#endif
+
+#ifndef POLYMORPHIC_BASE_DLL_DECL
+    #define POLYMORPHIC_BASE_DLL_DECL
+#endif
+
+class POLYMORPHIC_BASE_DLL_DECL polymorphic_base
 {
     friend class boost::serialization::access;
     template<class Archive>
@@ -45,9 +59,10 @@ BOOST_SERIALIZATION_ASSUME_ABSTRACT(polymorphic_base)
 // the no_rtti system requires this !!!
 BOOST_CLASS_EXPORT_KEY(polymorphic_base)
 
+
 BOOST_CLASS_TYPE_INFO(
     polymorphic_base,
-    boost::serialization::extended_type_info_no_rtti<polymorphic_base>
+    extended_type_info_no_rtti<polymorphic_base>
 )
 
 #endif // POLYMORPHIC_BASE_HPP

test/polymorphic_derived2.cpp

@@ -12,29 +12,22 @@
 #include <boost/serialization/extended_type_info_no_rtti.hpp>
 #include <boost/serialization/export.hpp>
 
+#define POLYMORPHIC_BASE_EXPORT
+#include "polymorphic_base.hpp"
+
 #define POLYMORPHIC_DERIVED2_EXPORT
 #include "polymorphic_derived2.hpp"
 
-template<class Archive>
-void polymorphic_derived2::serialize(
-    Archive &ar, 
-    const unsigned int /* file_version */
-){
-    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base);
-}
-
 // instantiate code for text archives
 #include <boost/archive/text_oarchive.hpp>
 #include <boost/archive/text_iarchive.hpp>
 
 template
-POLYMORPHIC_DERIVED2_DLL_DECL
 void polymorphic_derived2::serialize(
     boost::archive::text_oarchive & ar,
     const unsigned int version
 );
 template
-POLYMORPHIC_DERIVED2_DLL_DECL
 void polymorphic_derived2::serialize(
     boost::archive::text_iarchive & ar,
     const unsigned int version
@@ -45,13 +38,11 @@ void polymorphic_derived2::serialize(
 #include <boost/archive/polymorphic_oarchive.hpp>
 
 template
-POLYMORPHIC_DERIVED2_DLL_DECL
 void polymorphic_derived2::serialize(
     boost::archive::polymorphic_oarchive & ar,
     const unsigned int version
 );
 template
-POLYMORPHIC_DERIVED2_DLL_DECL
 void polymorphic_derived2::serialize(
     boost::archive::polymorphic_iarchive & ar,
     const unsigned int version

test/polymorphic_derived2.hpp

@@ -1,5 +1,5 @@
-#ifndef POLYMORPHIC_DERIVED2_HPP
-#define POLYMORPHIC_DERIVED2_HPP
+#ifndef BOOST_SERIALIZATION_TEST_POLYMORPHIC_DERIVED2_HPP
+#define BOOST_SERIALIZATION_TEST_POLYMORPHIC_DERIVED2_HPP
 
 // MS compatible compilers support #pragma once
 #if defined(_MSC_VER)
@@ -24,18 +24,22 @@
 #include <boost/serialization/type_info_implementation.hpp>
 #include <boost/serialization/extended_type_info_typeid.hpp>
 
-#include "polymorphic_base.hpp"
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+    #if defined(POLYMORPHIC_DERIVED2_IMPORT)
+        #define POLYMORPHIC_DERIVED2_DLL_DECL BOOST_SYMBOL_IMPORT
+        #pragma message ("polymorphic_derived2 imported")
+    #elif defined(POLYMORPHIC_DERIVED2_EXPORT)
+        #define POLYMORPHIC_DERIVED2_DLL_DECL BOOST_SYMBOL_EXPORT
+        #pragma message ("polymorphic_derived2 exported")
+    #endif
+#endif
 
-#if defined(POLYMORPHIC_DERIVED2_IMPORT)
-    #define POLYMORPHIC_DERIVED2_DLL_DECL BOOST_SYMBOL_IMPORT
-    #pragma message ("polymorphic_derived2 imported")
-#elif defined(POLYMORPHIC_DERIVED2_EXPORT)
-    #define POLYMORPHIC_DERIVED2_DLL_DECL BOOST_SYMBOL_EXPORT
-    #pragma message ("polymorphic_derived2 exported")
-#else
+#ifndef POLYMORPHIC_DERIVED2_DLL_DECL
     #define POLYMORPHIC_DERIVED2_DLL_DECL
 #endif
 
+#include "polymorphic_base.hpp"
+
 class POLYMORPHIC_DERIVED2_DLL_DECL polymorphic_derived2 :
     public polymorphic_base
 {
@@ -44,10 +48,15 @@ class POLYMORPHIC_DERIVED2_DLL_DECL polymorphic_derived2 :
     void serialize(
         Archive &ar, 
         const unsigned int /* file_version */
-    );
+    ){
+        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base);
+    }
     virtual const char * get_key() const {
         return "polymorphic_derived2";
     }
+public:
+    polymorphic_derived2(){}
+    ~polymorphic_derived2(){}
 };
 
 // we use this because we want to assign a key to this type
@@ -63,5 +72,5 @@ BOOST_CLASS_TYPE_INFO(
     boost::serialization::extended_type_info_typeid<polymorphic_derived2>
 )
 
-#endif // POLYMORPHIC_DERIVED2_HPP
+#endif // BOOST_SERIALIZATION_TEST_POLYMORPHIC_DERIVED2_HPP
 

test/test_cyclic_ptrs.cpp

@@ -143,6 +143,7 @@ int test2(){
         ia >> BOOST_SERIALIZATION_NVP(j2);
     }
     BOOST_CHECK(*j1 == *j2);
+    delete j1;
     BOOST_CHECK(j2 == j2->j);
     std::remove(testfile);
     return EXIT_SUCCESS;

test/test_derived_class_ptr.cpp

@@ -44,6 +44,7 @@ int test_main( int /* argc */, char* /* argv */[] )
     }
     BOOST_CHECK(tb != tb1);
     BOOST_CHECK(*tb == *tb1);
+    delete tb;
     std::remove(testfile);
     return EXIT_SUCCESS;
 }

test/test_diamond.cpp

@@ -198,6 +198,7 @@ test_main( int /* argc */, char* /* argv */[] )
     BOOST_CHECK(1 == save_count);
     BOOST_CHECK(1 == load_count);
     BOOST_CHECK(*bp2 == *bp);
+    delete bp;
     std::remove(testfile);
 
     return EXIT_SUCCESS;

test/test_dll_exported.cpp

@@ -61,7 +61,8 @@ public:
     virtual ~polymorphic_derived1(){}
 };
 
-BOOST_CLASS_EXPORT(polymorphic_derived1)
+BOOST_CLASS_EXPORT_KEY(polymorphic_derived1)
+BOOST_CLASS_EXPORT_IMPLEMENT(polymorphic_derived1)
 
 // MWerks users can do this to make their code work
 BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(polymorphic_base, polymorphic_derived1)
@@ -85,8 +86,9 @@ void save_exported(const char *testfile)
     oa << BOOST_SERIALIZATION_NVP(rb2);
     oa << BOOST_SERIALIZATION_NVP(rd21);
 
-    delete rb1;
+    delete rd21;
     delete rb2;
+    delete rb1;
 }
 
 // save exported polymorphic class
@@ -128,9 +130,9 @@ void load_exported(const char *testfile)
             ::type::get_const_instance().get_derived_extended_type_info(*rd21),
         "restored pointer d2 not of correct type"
     );
-    delete rb1;
-    delete rb2;
     delete rd21;
+    delete rb2;
+    delete rb1;
 }
 
 int

test/test_dll_plugin.cpp

@@ -165,10 +165,10 @@ test_main( int /* argc */, char* /* argv */[] )
     BOOST_REQUIRE(NULL != testfile);
 
     HINSTANCE hDLL;               // Handle to DLL
-    hDLL = LoadLibrary(_T("plugin_polymorphic_derived2.dll"));
+    hDLL = LoadLibrary(_T("polymorphic_derived2.dll"));
     BOOST_CHECK_MESSAGE(
         (0 != hDLL), 
-        "Failed to find/load plugin_polymorphic_derived2"
+        "Failed to find/load polymorphic_derived2"
     );
     if(0 == hDLL)
         return EXIT_FAILURE;
@@ -192,8 +192,9 @@ test_main( int /* argc */, char* /* argv */[] )
     BOOST_REQUIRE(NULL != testfile);
 
     void * hDLL;               // Handle to DLL
-    hDLL = dlopen("plugin_polymorphic_derived2.so", RTLD_NOW | RTLD_GLOBAL);
+    hDLL = dlopen("polymorphic_derived2.so", RTLD_NOW | RTLD_GLOBAL);
     BOOST_CHECK_MESSAGE((0 != hDLL), "Failed to find/load plugin_polymorphic_derived2" );
+    BOOST_CHECK_MESSAGE((0 != hDLL), dlerror() );
     if(0 == hDLL)
         return EXIT_FAILURE;
 

test/test_exported.cpp

@@ -56,21 +56,13 @@ BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(polymorphic_base, polymorphic_derive
 // MWerks users can do this to make their code work
 BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(polymorphic_base, polymorphic_derived2)
 
-template<class Archive>
-void polymorphic_derived2::serialize(
-    Archive &ar, 
-    const unsigned int /* file_version */
-){
-    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base);
-}
-
 BOOST_CLASS_EXPORT_IMPLEMENT(polymorphic_derived2)
 
-template BOOST_SYMBOL_EXPORT void polymorphic_derived2::serialize(
+template void polymorphic_derived2::serialize(
     test_oarchive & ar,
     const unsigned int version
 );
-template BOOST_SYMBOL_EXPORT void polymorphic_derived2::serialize(
+template void polymorphic_derived2::serialize(
     test_iarchive & ar,
     const unsigned int version
 );

test/test_inclusion.cpp

@@ -19,6 +19,7 @@
 #include <boost/serialization/traits.hpp>
 #include <boost/serialization/type_info_implementation.hpp>
 #include <boost/serialization/version.hpp> 
+#include <boost/serialization/singleton.hpp>
 
 struct foo
 {

test/test_inclusion2.cpp

@@ -0,0 +1,25 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// test_const.cpp
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// Use, modification and distribution is subject to 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/archive/binary_iarchive.hpp>
+#include <boost/serialization/vector.hpp>
+#include <sstream>
+#include <vector>
+
+void f()
+{
+  std::stringstream iss;
+  boost::archive::binary_iarchive ar(iss);
+  std::vector<int> out;
+  ar >> out;
+}
+
+int
+main(int /*argc*/, char * /*argv*/[]){
+  return 0;
+}

test/test_interrupts.cpp

@@ -77,10 +77,10 @@ int test_out(){
 
 struct test_dummy_in {
     template<class Archive>
-    void save(Archive & ar, const unsigned int /*version*/) const {
+    void save(Archive & /* ar */, const unsigned int /*version*/) const {
     }
     template<class Archive>
-    void load(Archive & ar, const unsigned int /*version*/){
+    void load(Archive & /* ar */, const unsigned int /*version*/){
         throw boost::archive::archive_exception(
             boost::archive::archive_exception::other_exception
         );

test/test_mult_archive_types.cpp

@@ -117,5 +117,8 @@ int test_main(int /* argc */, char * /* argv */[])
     // Try to save and load pointers to Bs, to an xml archive
     test_save_and_load<xml_oarchive, xml_iarchive>(b, b1);
 
+    delete a;
+    delete b;
+
     return EXIT_SUCCESS;
 }

test/test_no_rtti.cpp

@@ -41,14 +41,6 @@ namespace std{
 #include "polymorphic_derived1.hpp"
 #include "polymorphic_derived2.hpp"
 
-template<class Archive>
-void polymorphic_derived2::serialize(
-    Archive &ar, 
-    const unsigned int /* file_version */
-){
-    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(polymorphic_base);
-}
-
 template void polymorphic_derived2::serialize(
     test_oarchive & ar,
     const unsigned int version

test/test_set.cpp

@@ -49,19 +49,27 @@ test_set(){
     std::set<A> aset;
     aset.insert(A());
     aset.insert(A());
+    const A * a_ptr = & * aset.begin();
     {   
         test_ostream os(testfile, TEST_STREAM_FLAGS);
         test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
         oa << boost::serialization::make_nvp("aset", aset);
+        // serialize a pointer into the set
+        oa << boost::serialization::make_nvp("a_ptr", a_ptr);
     }
     std::set<A> aset1;
+    A * a_ptr1;
     {
         test_istream is(testfile, TEST_STREAM_FLAGS);
         test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
         ia >> boost::serialization::make_nvp("aset", aset1);
+        // deserialize a pointer into the set
+        ia >> boost::serialization::make_nvp("a_ptr1", a_ptr1);
     }
-    BOOST_CHECK(aset == aset1);
-    std::remove(testfile);    
+    BOOST_CHECK_EQUAL(aset, aset1);
+    BOOST_CHECK_EQUAL(*a_ptr1, * aset1.begin());
+    BOOST_CHECK_EQUAL(a_ptr1, & * aset1.begin());
+    std::remove(testfile);
 }
 
 void
@@ -72,18 +80,26 @@ test_multiset(){
     std::multiset<A> amultiset;
     amultiset.insert(A());
     amultiset.insert(A());
-    {   
+    const A * a_ptr = & * amultiset.begin();
+    {
         test_ostream os(testfile, TEST_STREAM_FLAGS);
         test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
         oa << boost::serialization::make_nvp("amultiset", amultiset);
+        // serialize a pointer into the set
+        oa << boost::serialization::make_nvp("a_ptr", a_ptr);
     }
     std::multiset<A> amultiset1;
+    A * a_ptr1;
     {
         test_istream is(testfile, TEST_STREAM_FLAGS);
         test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
         ia >> boost::serialization::make_nvp("amultiset", amultiset1);
+        // deserialize a pointer into the set
+        ia >> boost::serialization::make_nvp("a_ptr1", a_ptr1);
     }
     BOOST_CHECK(amultiset == amultiset1);
+    BOOST_CHECK_EQUAL(*a_ptr1, * amultiset1.begin());
+    BOOST_CHECK_EQUAL(a_ptr1, & * amultiset1.begin());
     std::remove(testfile);
 }
 

test/test_simple_class_ptr.cpp

@@ -45,6 +45,7 @@ int test_main( int /* argc */, char* /* argv */[] )
     }
     BOOST_CHECK(ta != ta1);
     BOOST_CHECK(*ta == *ta1);
+    delete ta;
     std::remove(testfile);
     return EXIT_SUCCESS;
 }

test/test_singleton.cpp

@@ -1,35 +1,74 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-// test_singleton.cpp: test implementation of run-time casting of void pointers
+// test_singleton.cpp
 
-// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
+// (C) Copyright 2018 Robert Ramey - http://www.rrsd.com . 
 // Use, modification and distribution is subject to 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)
-// <gennadiy.rozental@tfn.com>
 
-#include "test_tools.hpp"
+// should pass compilation and execution
+
+#include <iostream>
 #include <boost/serialization/singleton.hpp>
 
-class x {
+#include "test_tools.hpp"
+
+static int i = 0;
+
+struct A {
+    int m_id;
+    A() : m_id(++i) {}
+    ~A(){
+        // verify that objects are destroyed in sequence reverse of construction
+        if(i-- != m_id) std::terminate();
+    }
 };
 
-void
-test1(const x & x1, const x & x2){
-    BOOST_CHECK(& x1 == & x2);
+struct B {
+    int m_id;
+    B() : m_id(++i) {}
+    ~B(){
+        // verify that objects are destroyed in sequence reverse of construction
+        if(i-- != m_id) std::terminate();
+    }
+};
+
+struct C {
+    int m_id;
+    C() : m_id(++i) {}
+    ~C(){
+        // verify that objects are destroyed in sequence reverse of construction
+        if(i-- != m_id) std::terminate();
+    }
+};
+
+struct D {
+    int m_id;
+    D(){
+        // verify that only one object is indeed created
+        const C & c = boost::serialization::singleton<C>::get_const_instance();
+        const C & c1 = boost::serialization::singleton<C>::get_const_instance();
+        BOOST_CHECK_EQUAL(&c, &c1);
+
+        // verify that objects are created in sequence of definition
+        BOOST_CHECK_EQUAL(c.m_id, 1);
+        const B & b = boost::serialization::singleton<B>::get_const_instance();
+        BOOST_CHECK_EQUAL(b.m_id, 2);
+        const A & a = boost::serialization::singleton<A>::get_const_instance();
+        BOOST_CHECK_EQUAL(a.m_id, 3);
+        std::cout << a.m_id << b.m_id << c.m_id << '\n';
+
+        m_id = ++i;
+    }
+    ~D(){
+        // verify that objects are destroyed in sequence reverse of construction
+        if(i-- != m_id) std::terminate();
+    }
+};
+
+int test_main(int, char *[]){
+    return 0;
 }
 
-int
-test_main( int /* argc */, char* /* argv */[] )
-{
-    const x & x1 = boost::serialization::singleton<x>::get_const_instance();
-    const x & x2 = boost::serialization::singleton<x>::get_const_instance();
-
-    BOOST_CHECK(& x1 == & x2);
-
-    test1(
-        boost::serialization::singleton<x>::get_const_instance(),
-        boost::serialization::singleton<x>::get_const_instance()
-    );
-
-    return EXIT_SUCCESS;
-}
+// note: not a singleton
+D d;

test/test_variant.cpp

@@ -19,7 +19,7 @@
 #include <cstdio> // remove
 #include <fstream>
 #include <boost/config.hpp>
-#include <boost/math/special_functions/next.hpp>
+#include <boost/math/special_functions/next.hpp> // float_distance
 #if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std{ 
     using ::remove;
@@ -145,25 +145,155 @@ void do_bad_read()
     #endif
 }
 
+struct H {
+    int i;
+};
+
+namespace boost {
+namespace serialization {
+        
+template<class Archive>
+void serialize(Archive &ar, H & h, const unsigned int /*file_version*/){
+    ar & boost::serialization::make_nvp("h", h.i);
+}
+
+} // namespace serialization
+} // namespace boost
+
+inline bool operator==(H const & lhs, H const & rhs) {
+    return lhs.i == rhs.i;
+}
+
+inline bool operator!=(H const & lhs, H const & rhs) {
+    return !(lhs == rhs);
+}
+
+inline bool operator<(H const & lhs, H const & rhs) {
+    return lhs.i < rhs.i;
+}
+
+inline std::size_t hash_value(H const & val) {
+    return val.i;
+}
+
+void test_pointer(){
+    const char * testfile = boost::archive::tmpnam(NULL);
+    BOOST_REQUIRE(testfile != NULL);
+    typedef boost::variant<H, int> variant_t;
+    H const h = {5};
+    variant_t v(h);
+    {
+        test_ostream os(testfile, TEST_STREAM_FLAGS);
+        test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
+        oa << boost::serialization::make_nvp("written", v);
+        const H * h_ptr = & boost::strict_get<H const &>(v);
+        oa << boost::serialization::make_nvp("written", h_ptr);
+    }
+    variant_t v2;
+    {
+        test_istream is(testfile, TEST_STREAM_FLAGS);
+        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
+        ia >> boost::serialization::make_nvp("written", v2);
+        H * h2_ptr;
+        ia >> boost::serialization::make_nvp("written", h2_ptr);
+        BOOST_CHECK_EQUAL(h, boost::strict_get<H const>(v2));
+        BOOST_CHECK_EQUAL(h2_ptr, & boost::strict_get<H const &>(v2));
+    }
+    BOOST_CHECK_EQUAL(v, v2);
+}
+
+#include <boost/serialization/map.hpp>
+#include <boost/serialization/set.hpp>
+
+// test a pointer to an object contained into a variant that is an
+// element of a set
+void test_variant_set()
+{
+    const char * testfile = boost::archive::tmpnam(NULL);
+    BOOST_REQUIRE(testfile != NULL);
+    typedef boost::variant<H, int> variant_t;
+    typedef std::set<variant_t> uset_t;
+    uset_t set;
+    {
+        test_ostream os(testfile, TEST_STREAM_FLAGS);
+        test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
+        H const h = {5};
+        variant_t v(h);
+        set.insert(v);
+        oa << boost::serialization::make_nvp("written", set);
+        H const * const h_ptr = boost::strict_get<H const>(&(*set.begin()));
+        oa << boost::serialization::make_nvp("written", h_ptr);
+    }
+    uset_t set2;
+    {
+        test_istream is(testfile, TEST_STREAM_FLAGS);
+        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
+        ia >> boost::serialization::make_nvp("written", set2);
+        H * h_ptr;
+        ia >> boost::serialization::make_nvp("written", h_ptr);
+        const H * h_ptr2 = & boost::strict_get<H const>(*set2.begin());
+        BOOST_CHECK_EQUAL(h_ptr, h_ptr2);
+    }
+    BOOST_CHECK_EQUAL(set, set2);
+}
+
+// test a pointer to an object contained into a variant that is an
+// element of a map
+void test_variant_map()
+{
+    const char * testfile = boost::archive::tmpnam(NULL);
+    BOOST_REQUIRE(testfile != NULL);
+    typedef boost::variant<H, int> variant_t;
+    typedef std::map<int, variant_t> map_t;
+    map_t map;
+    {
+        test_ostream os(testfile, TEST_STREAM_FLAGS);
+        test_oarchive oa(os, TEST_ARCHIVE_FLAGS);
+        H const h = {5};
+        variant_t v(h);
+        map[0] = v;
+        BOOST_ASSERT(1 == map.size());
+        oa << boost::serialization::make_nvp("written", map);
+        H const * const h_ptr = boost::strict_get<H const>(&map[0]);
+        BOOST_CHECK_EQUAL(h_ptr, boost::strict_get<H const>(&map[0]));
+        oa << boost::serialization::make_nvp("written", h_ptr);
+    }
+    map_t map2;
+    {
+        test_istream is(testfile, TEST_STREAM_FLAGS);
+        test_iarchive ia(is, TEST_ARCHIVE_FLAGS);
+        ia >> boost::serialization::make_nvp("written", map2);
+        BOOST_ASSERT(1 == map2.size());
+        H * h_ptr;
+        ia >> boost::serialization::make_nvp("written", h_ptr);
+        H const * const h_ptr2 = boost::strict_get<H const>(&map2[0]);
+        BOOST_CHECK_EQUAL(h_ptr, h_ptr2);
+    }
+    BOOST_CHECK_EQUAL(map, map2);
+}
+
 int test_main( int /* argc */, char* /* argv */[] )
 {
-   {
-      boost::variant<bool, int, float, double, A, std::string> v;
-      v = false;
-      test_type(v);
-      v = 1;
-      test_type(v);
-      v = (float) 2.3;
-      test_type(v);
-      v = (double) 6.4;
-      test_type(v);
-      v = std::string("we can't stop here, this is Bat Country");
-      test_type(v);
-      v = A();
-      test_type(v);
-   }
-   do_bad_read();
-   return EXIT_SUCCESS;
+    {
+        boost::variant<bool, int, float, double, A, std::string> v;
+        v = false;
+        test_type(v);
+        v = 1;
+        test_type(v);
+        v = (float) 2.3;
+        test_type(v);
+        v = (double) 6.4;
+        test_type(v);
+        v = std::string("we can't stop here, this is Bat Country");
+        test_type(v);
+        v = A();
+        test_type(v);
+    }
+    test_pointer();
+    test_variant_set();
+    test_variant_map();
+    do_bad_read();
+    return EXIT_SUCCESS;
 }
 
 // EOF

test/test_z.cpp

@@ -555,7 +555,8 @@ int main()
     assert(base64 == output);
     return 0;
 }
-#else
+#elif 0
+
 #include <memory>
 #include <sstream>
 
@@ -597,4 +598,24 @@ int main()
 
 	return 0;
 }
+
+#elif 0
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/serialization/vector.hpp>
+#include <sstream>
+#include <vector>
+
+void f()
+{
+  std::stringstream iss;
+  boost::archive::binary_iarchive ar(iss);
+  std::vector<int> out;
+  ar >> out;
+}
+
 #endif
+
+int main(int argc, char* argv[])
+{
+  return 0;
+}

util/test.jam

@@ -10,6 +10,9 @@
 # boost test, as well as the performance test and comprehensive
 # tests.
 
+# import rules for testing conditional on config file variables
+import ../../config/checks/config : requires ;
+
 BOOST_ARCHIVE_LIST = [ modules.peek : BOOST_ARCHIVE_LIST ] ;
 
 # these are used to shorten testing while in development.  It permits
@@ -26,12 +29,13 @@ if ! $(BOOST_ARCHIVE_LIST) {
     BOOST_SERIALIZATION_TEST = true ;
 }
 
-rule run-template ( test-name : sources * : requirements * ) {
+rule run-template ( test-name : sources * : files * : requirements * ) {
     return [
         run
             $(sources)
         : # command
-        : # input files
+        : #input files
+            $(files)
         : # requirements
             # toolset warnings
             <toolset>borland:<cxxflags>"-w-8080 -w-8071 -w-8057 -w-8062 -w-8008 -w-0018 -w-8066"
@@ -49,7 +53,6 @@ rule run-template ( test-name : sources * : requirements * ) {
             <toolset>clang:<variant>debug:<cxxflags>"-fsanitize=memory"
             # toolset optimizations
             <toolset>gcc:<cxxflags>"-ftemplate-depth-255"
-            <toolset>qcc:<cxxflags>"-ftemplate-depth-255"
             <toolset>clang:<cxxflags>"-ftemplate-depth-255"
             <toolset>darwin:<cxxflags>"-ftemplate-depth-255"
             <toolset>msvc:<cxxflags>"-Gy"
@@ -74,7 +77,7 @@ rule dependency-save-test ( test )
 }
 
 # each of the following tests is run with each type of archive
-rule run-invoke ( test-name : sources * : requirements * )
+rule run-invoke ( test-name : sources * : files * : requirements * )
 {
     local save-test = [ dependency-save-test $(test-name) ] ;
 
@@ -84,6 +87,7 @@ rule run-invoke ( test-name : sources * : requirements * )
         : # sources
             $(sources)
             ../build//boost_serialization
+        : # input files
         : # requirements
             $(requirements)
             <define>BOOST_LIB_DIAGNOSTIC=1
@@ -93,7 +97,7 @@ rule run-invoke ( test-name : sources * : requirements * )
 }
 
 # each of the following tests is run with each type of archive
-rule run-winvoke ( test-name : sources * : requirements * )
+rule run-winvoke ( test-name : sources * : files * : requirements * )
 {
     local save-test = [ dependency-save-test $(test-name) ] ;
 
@@ -104,13 +108,14 @@ rule run-winvoke ( test-name : sources * : requirements * )
             $(sources)
             ../build//boost_serialization
             ../build//boost_wserialization
+        : # input files
         : # requirements
             $(requirements)
             <define>BOOST_LIB_DIAGNOSTIC=1
             # both stlport and msvc6 define iswspace
             <toolset>msvc,<stdlib>stlport:<linkflags>"-force:multiple"
             <dependency>$(save-test)
-            <dependency>../../config/test/all//BOOST_NO_STD_WSTREAMBUF
+            [ requires std_wstreambuf ]
     ] ;
     return $(tests) ;
 }
@@ -123,7 +128,8 @@ rule test-bsl-run-no-lib  ( test-name : sources * : requirements * )
         run-template $(test-name)
         : # sources
             $(test-name).cpp $(sources).cpp
-        :
+        : # input files
+        : # requirements
             $(requirements)
     ] ;
     return $(tests) ;
@@ -137,7 +143,8 @@ rule test-bsl-run ( test-name : sources * : libs * : requirements * )
         run-invoke $(test-name) 
         : # sources
             $(test-name).cpp $(sources).cpp $(libs)
-        :
+        : # input files
+        : # requirements
             $(requirements)
     ] ;
     return $(tests) ;
@@ -149,18 +156,20 @@ rule test-bsl-run_archive ( test-name : archive-name : sources * : libs * : requ
     case "*_warchive" :
         tests +=  [
             run-winvoke $(test-name)_$(archive-name)
-            : 
+            : # sources
                 $(sources).cpp $(libs)
-            :
+            : # input files
+            : # requirements
                 <define>BOOST_ARCHIVE_TEST=$(archive-name).hpp
                 $(requirements)
         ] ;
     case "*" :
         tests +=  [
             run-invoke $(test-name)_$(archive-name)
-            : 
+            : # sources
                 $(sources).cpp $(libs)
-            : 
+            : # input files
+            : # requirements
                 <define>BOOST_ARCHIVE_TEST=$(archive-name).hpp
                 $(requirements)
         ] ;