fix failing tests

tested on my own machine for Clang/OSX, gcc on ubuntu and on mingw

.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,79 @@ language: cpp
 
 sudo: false
 
-os:
-  - linux
-  - osx
-
 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: clang++
+      env: TOOLSET=clang
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang
 
 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
 
 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)

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/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/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/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;
@@ -115,17 +119,28 @@ private:
         // use a wrapper so that types T with protected constructors
         // can be used
         class singleton_wrapper : public T {};
-        static singleton_wrapper t;
+
+        // Use a heap-allocated instance to work around static variable
+        // destruction order issues: this inner singleton_wrapper<>
+        // instance may be destructed before the singleton<> instance.
+        // Using a 'dumb' static variable lets us precisely choose the
+        // time destructor is invoked.
+        static singleton_wrapper *t = 0;
+
         // 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);
+
+        if (!t)
+            t = new singleton_wrapper;
+        return static_cast<T &>(*t);
     }
     static bool & get_is_destroyed(){
         static bool is_destroyed;
@@ -147,6 +162,9 @@ public:
         get_is_destroyed() = false;
     }
     BOOST_DLLEXPORT ~singleton() {
+        if (!get_is_destroyed()) {
+            delete &(get_instance());
+        }
         get_is_destroyed() = true;
     }
 };

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
         );
     }

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,12 @@ 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
 
 BOOST_SYMBOL_VISIBLE library_version_type
 BOOST_ARCHIVE_VERSION(){
-    return library_version_type(15);
+    return library_version_type(16);
 }
 
 } // 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,6 +9,7 @@
 project libs/serialization/test
     : id serialization_test
     : requirements <source>/boost/filesystem
+    : requirements <source>/boost/system
     ;
 
 # import rules for testing conditional on config file variables
@@ -28,34 +29,21 @@ 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 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
+	polymorphic_base.cpp 
         ../build//boost_serialization
     : 
+        <link>shared:<define>BOOST_SERIALIZATION_DYN_LINK=1 
     ;
 
 test-suite "serialization" :
@@ -133,13 +121,16 @@ 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 +138,9 @@ 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_codecvt_null ]
         
-        #[ test-bsl-run test_z ]
+        # [ test-bsl-run test_z ]
 
         # should fail compilation
         [ compile-fail test_not_serializable.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_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_z.cpp

@@ -555,7 +555,8 @@ int main()
     assert(base64 == output);
     return 0;
 }
-#else
+#elif 0
+
 #include <memory>
 #include <sstream>
 
@@ -597,4 +598,23 @@ int main()
 
 	return 0;
 }
+
+#else
+#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;
+}
 #endif