Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/archive/impl')
13 files changed, 75 insertions, 66 deletions
diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp index 8ea39f7..b8e7f45 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iarchive.ipp @@ -1,129 +1,133 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_iarchive.ipp: // (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) // See http://www.boost.org for updates, documentation, and revision history. #include <string> #include <boost/assert.hpp> #include <algorithm> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; using ::strlen; using ::size_t; } #endif #include <boost/detail/workaround.hpp> #include <boost/detail/endian.hpp> #include <boost/archive/basic_binary_iarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of binary_binary_archive template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_iarchive<Archive>::load_override(class_name_type & t, int){ std::string cn; cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE); load_override(cn, 0); if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_class_name) ); std::memcpy(t, cn.data(), cn.size()); // borland tweak t.t[cn.size()] = '\0'; } template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_iarchive<Archive>::init(){ // read signature in an archive version independent manner std::string file_signature; + + #if 0 // commented out since it interfers with derivation try { std::size_t l; this->This()->load(l); if(l == std::strlen(BOOST_ARCHIVE_SIGNATURE())) { // borland de-allocator fixup #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101)) if(NULL != file_signature.data()) #endif file_signature.resize(l); // note breaking a rule here - could be a problem on some platform if(0 < l) this->This()->load_binary(&(*file_signature.begin()), l); } } catch(archive_exception const &) { // catch stream_error archive exceptions // will cause invalid_signature archive exception to be thrown below file_signature = ""; } + #else + // https://svn.boost.org/trac/boost/ticket/7301 + * this->This() >> file_signature; + #endif + if(file_signature != BOOST_ARCHIVE_SIGNATURE()) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_signature) ); // make sure the version of the reading archive library can // support the format of the archive being read library_version_type input_library_version; //* this->This() >> input_library_version; { int v = 0; v = this->This()->m_sb.sbumpc(); #if defined(BOOST_LITTLE_ENDIAN) if(v < 6){ ; } else if(v < 7){ // version 6 - next byte should be zero this->This()->m_sb.sbumpc(); } else if(v < 8){ int x1; // version 7 = might be followed by zero or some other byte x1 = this->This()->m_sb.sgetc(); // it's =a zero, push it back if(0 == x1) this->This()->m_sb.sbumpc(); } else{ // version 8+ followed by a zero this->This()->m_sb.sbumpc(); } #elif defined(BOOST_BIG_ENDIAN) if(v == 0) v = this->This()->m_sb.sbumpc(); #endif input_library_version = static_cast<library_version_type>(v); } #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) this->set_library_version(input_library_version); #else - #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200) - detail:: - #endif - basic_iarchive::set_library_version(input_library_version); + detail::basic_iarchive::set_library_version(input_library_version); #endif if(BOOST_ARCHIVE_VERSION() < input_library_version) boost::serialization::throw_exception( archive_exception(archive_exception::unsupported_version) ); } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp index e0f5c2e..9e2340e 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_iprimitive.ipp @@ -1,65 +1,66 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_iprimitive.ipp: // (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) // See http://www.boost.org for updates, documentation, and revision history. #include <boost/assert.hpp> #include <cstddef> // size_t, NULL #include <cstring> // memcpy #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; using ::memcpy; } // namespace std #endif #include <boost/detail/workaround.hpp> // fixup for RogueWave #include <boost/serialization/throw_exception.hpp> #include <boost/scoped_ptr.hpp> #include <boost/archive/archive_exception.hpp> #include <boost/archive/codecvt_null.hpp> #include <boost/archive/add_facet.hpp> +#include <boost/archive/basic_binary_iprimitive.hpp> namespace boost { namespace archive { ////////////////////////////////////////////////////////////////////// // implementation of basic_binary_iprimitive template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_iprimitive<Archive, Elem, Tr>::init() { // Detect attempts to pass native binary archives across // incompatible platforms. This is not fool proof but its // better than nothing. unsigned char size; this->This()->load(size); if(sizeof(int) != size) boost::serialization::throw_exception( archive_exception( archive_exception::incompatible_native_format, "size of int" ) ); this->This()->load(size); if(sizeof(long) != size) boost::serialization::throw_exception( archive_exception( archive_exception::incompatible_native_format, "size of long" ) ); this->This()->load(size); if(sizeof(float) != size) boost::serialization::throw_exception( archive_exception( diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp index dec2cd7..467fd6f 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oarchive.ipp @@ -1,46 +1,46 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_oarchive.ipp: // (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) // See http://www.boost.org for updates, documentation, and revision history. #include <string> #include <boost/assert.hpp> #include <algorithm> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif #include <boost/archive/basic_binary_oarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of binary_binary_oarchive template<class Archive> #if !defined(__BORLANDC__) BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) #else void #endif basic_binary_oarchive<Archive>::init(){ // write signature in an archive version independent manner const std::string file_signature(BOOST_ARCHIVE_SIGNATURE()); * this->This() << file_signature; // write library version const library_version_type v(BOOST_ARCHIVE_VERSION()); * this->This() << v; } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp index 02b5ffa..509decb 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_binary_oprimitive.ipp @@ -1,68 +1,69 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_binary_oprimitive.ipp: // (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) // See http://www.boost.org for updates, documentation, and revision history. #include <ostream> #include <cstddef> // NULL #include <cstring> #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__) namespace std{ using ::strlen; } // namespace std #endif #ifndef BOOST_NO_CWCHAR #include <cwchar> #ifdef BOOST_NO_STDC_NAMESPACE namespace std{ using ::wcslen; } #endif #endif #include <boost/detail/workaround.hpp> #include <boost/archive/add_facet.hpp> #include <boost/archive/codecvt_null.hpp> +#include <boost/archive/basic_binary_oprimitive.hpp> namespace boost { namespace archive { ////////////////////////////////////////////////////////////////////// // implementation of basic_binary_oprimitive template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_oprimitive<Archive, Elem, Tr>::init() { // record native sizes of fundamental types // this is to permit detection of attempts to pass // native binary archives accross incompatible machines. // This is not foolproof but its better than nothing. this->This()->save(static_cast<unsigned char>(sizeof(int))); this->This()->save(static_cast<unsigned char>(sizeof(long))); this->This()->save(static_cast<unsigned char>(sizeof(float))); this->This()->save(static_cast<unsigned char>(sizeof(double))); // for checking endianness this->This()->save(int(1)); } template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s) { std::size_t l = std::strlen(s); this->This()->save(l); save_binary(s, l); } template<class Archive, class Elem, class Tr> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s) diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp index 0a246b7..8d364f9 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_iarchive.ipp @@ -1,79 +1,76 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_iarchive.ipp: // (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) // See http://www.boost.org for updates, documentation, and revision history. #include <string> #include <algorithm> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif #include <boost/detail/workaround.hpp> #include <boost/serialization/string.hpp> #include <boost/archive/basic_text_iarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of text_text_archive template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_iarchive<Archive>::load_override(class_name_type & t, int){ std::string cn; cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE); load_override(cn, 0); if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_class_name) ); std::memcpy(t, cn.data(), cn.size()); // borland tweak t.t[cn.size()] = '\0'; } template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_iarchive<Archive>::init(void){ // read signature in an archive version independent manner std::string file_signature; * this->This() >> file_signature; if(file_signature != BOOST_ARCHIVE_SIGNATURE()) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_signature) ); // make sure the version of the reading archive library can // support the format of the archive being read library_version_type input_library_version; * this->This() >> input_library_version; #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205)) this->set_library_version(input_library_version); #else - #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200) - detail:: - #endif - basic_iarchive::set_library_version(input_library_version); + detail::basic_iarchive::set_library_version(input_library_version); #endif // extra little .t is to get around borland quirk if(BOOST_ARCHIVE_VERSION() < input_library_version) boost::serialization::throw_exception( archive_exception(archive_exception::unsupported_version) ); } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp index ad6a6d5..d0da284 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_iprimitive.ipp @@ -1,154 +1,152 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_iprimitive.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. #include <cstddef> // size_t #include <cstddef> // NULL #include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::size_t; } // namespace std #endif #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/basic_text_iprimitive.hpp> #include <boost/archive/codecvt_null.hpp> #include <boost/archive/add_facet.hpp> #include <boost/archive/iterators/remove_whitespace.hpp> #include <boost/archive/iterators/istream_iterator.hpp> #include <boost/archive/iterators/binary_from_base64.hpp> #include <boost/archive/iterators/transform_width.hpp> -namespace boost { +namespace boost { namespace archive { -namespace { +namespace detail { template<class CharType> bool is_whitespace(CharType c); template<> bool is_whitespace(char t){ return 0 != std::isspace(t); } #ifndef BOOST_NO_CWCHAR template<> bool is_whitespace(wchar_t t){ return 0 != std::iswspace(t); } #endif -} +} // detail // translate base64 text into binary and copy into buffer // until buffer is full. template<class IStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_iprimitive<IStream>::load_binary( void *address, std::size_t count ){ - typedef BOOST_DEDUCED_TYPENAME IStream::char_type CharType; + typedef typename IStream::char_type CharType; if(0 == count) return; BOOST_ASSERT( static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) > (count + sizeof(CharType) - 1)/sizeof(CharType) ); if(is.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::input_stream_error) ); // convert from base64 to binary - typedef BOOST_DEDUCED_TYPENAME + typedef typename iterators::transform_width< iterators::binary_from_base64< iterators::remove_whitespace< iterators::istream_iterator<CharType> > ,CharType > ,8 ,6 ,CharType > binary; - - binary ti_begin = binary( + + binary i = binary( BOOST_MAKE_PFTO_WRAPPER( iterators::istream_iterator<CharType>(is) ) ); - + char * caddr = static_cast<char *>(address); // take care that we don't increment anymore than necessary - while(--count > 0){ - *caddr++ = static_cast<char>(*ti_begin); - ++ti_begin; + while(count-- > 0){ + *caddr++ = static_cast<char>(*i++); } - *caddr++ = static_cast<char>(*ti_begin); - - iterators::istream_iterator<CharType> i; + + // skip over any excess input for(;;){ - BOOST_DEDUCED_TYPENAME IStream::int_type r; + typename IStream::int_type r; r = is.get(); if(is.eof()) break; - if(is_whitespace(static_cast<CharType>(r))) + if(detail::is_whitespace(static_cast<CharType>(r))) break; } } - + template<class IStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_iprimitive<IStream>::basic_text_iprimitive( IStream &is_, bool no_codecvt ) : #ifndef BOOST_NO_STD_LOCALE is(is_), flags_saver(is_), precision_saver(is_), archive_locale(NULL), locale_saver(* is_.rdbuf()) { if(! no_codecvt){ archive_locale.reset( add_facet( std::locale::classic(), - new codecvt_null<BOOST_DEDUCED_TYPENAME IStream::char_type> + new codecvt_null<typename IStream::char_type> ) ); is.imbue(* archive_locale); } is >> std::noboolalpha; } #else is(is_), flags_saver(is_), precision_saver(is_) {} #endif template<class IStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_iprimitive<IStream>::~basic_text_iprimitive(){ is.sync(); } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp index 34e6995..4170c97 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_oarchive.ipp @@ -1,49 +1,49 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_oarchive.ipp: // (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) // See http://www.boost.org for updates, documentation, and revision history. #include <string> #include <boost/assert.hpp> #include <cstring> -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } #endif #include <boost/archive/basic_text_oarchive.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation of basic_text_oarchive template<class Archive> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_oarchive<Archive>::newtoken() { switch(delimiter){ default: BOOST_ASSERT(false); break; case eol: this->This()->put('\n'); delimiter = space; break; case space: this->This()->put(' '); break; case none: delimiter = space; break; } } diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp b/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp index cacab61..33ab4a8 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_text_oprimitive.ipp @@ -1,114 +1,115 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_text_oprimitive.ipp: // (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) // See http://www.boost.org for updates, documentation, and revision history. #include <cstddef> // NULL +#include <algorithm> // std::copy #include <boost/serialization/pfto.hpp> #include <boost/archive/basic_text_oprimitive.hpp> #include <boost/archive/codecvt_null.hpp> #include <boost/archive/add_facet.hpp> #include <boost/archive/iterators/base64_from_binary.hpp> #include <boost/archive/iterators/insert_linebreaks.hpp> #include <boost/archive/iterators/transform_width.hpp> #include <boost/archive/iterators/ostream_iterator.hpp> namespace boost { namespace archive { // translate to base64 and copy in to buffer. template<class OStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) basic_text_oprimitive<OStream>::save_binary( const void *address, std::size_t count ){ - typedef BOOST_DEDUCED_TYPENAME OStream::char_type CharType; + typedef typename OStream::char_type CharType; if(0 == count) return; if(os.fail()) boost::serialization::throw_exception( archive_exception(archive_exception::output_stream_error) ); os.put('\n'); typedef boost::archive::iterators::insert_linebreaks< boost::archive::iterators::base64_from_binary< boost::archive::iterators::transform_width< const char *, 6, 8 > > - ,72 + ,76 ,const char // cwpro8 needs this > base64_text; boost::archive::iterators::ostream_iterator<CharType> oi(os); std::copy( base64_text(BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address))), base64_text( BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address) + count) ), oi ); std::size_t tail = count % 3; if(tail > 0){ *oi++ = '='; if(tail < 2) *oi = '='; } } template<class OStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_oprimitive<OStream>::basic_text_oprimitive( OStream & os_, bool no_codecvt ) : #ifndef BOOST_NO_STD_LOCALE os(os_), flags_saver(os_), precision_saver(os_), archive_locale(NULL), locale_saver(* os_.rdbuf()) { if(! no_codecvt){ archive_locale.reset( add_facet( std::locale::classic(), - new codecvt_null<BOOST_DEDUCED_TYPENAME OStream::char_type> + new codecvt_null<typename OStream::char_type> ) ); os.imbue(* archive_locale); } os << std::noboolalpha; } #else os(os_), flags_saver(os_), precision_saver(os_) {} #endif template<class OStream> BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_text_oprimitive<OStream>::~basic_text_oprimitive(){ os << std::endl; } } //namespace boost } //namespace archive diff --git a/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp b/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp index 807ed07..66ca1f0 100644 --- a/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp +++ b/3rdParty/Boost/src/boost/archive/impl/basic_xml_grammar.hpp @@ -1,92 +1,87 @@ #ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP #define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP // MS compatible compilers support #pragma once -#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#if defined(_MSC_VER) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // basic_xml_grammar.hpp // (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) // See http://www.boost.org for updates, documentation, and revision history. // this module is derived from simplexml.cpp - an example shipped as part of // the spirit parser. This example contains the following notice: /*============================================================================= simplexml.cpp Spirit V1.3 URL: http://spirit.sourceforge.net/ Copyright (c) 2001, Daniel C. Nuffer This software is provided 'as-is', without any express or implied warranty. In no event will the copyright holder be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. =============================================================================*/ #include <string> #include <boost/config.hpp> #include <boost/detail/workaround.hpp> -// supress noise -#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) -# pragma warning (disable : 4786) // too long name, harmless warning -#endif - #include <boost/spirit/include/classic_rule.hpp> #include <boost/spirit/include/classic_chset.hpp> #include <boost/archive/basic_archive.hpp> #include <boost/serialization/tracking.hpp> #include <boost/serialization/version.hpp> namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // XML grammar parsing template<class CharType> class basic_xml_grammar { public: // The following is not necessary according to DR45, but at least // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise. struct return_values; friend struct return_values; private: typedef BOOST_DEDUCED_TYPENAME std::basic_istream<CharType> IStream; typedef BOOST_DEDUCED_TYPENAME std::basic_string<CharType> StringType; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chset<CharType> chset_t; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::chlit<CharType> chlit_t; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::scanner< BOOST_DEDUCED_TYPENAME std::basic_string<CharType>::iterator > scanner_t; typedef BOOST_DEDUCED_TYPENAME boost::spirit::classic::rule<scanner_t> rule_t; // Start grammar definition rule_t Reference, Eq, STag, diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp index c7cbc7f..dc62eed 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_iarchive_impl.ipp @@ -66,73 +66,73 @@ xml_iarchive_impl<Archive>::load(std::wstring &ws){ ws.resize(0); const char * start = s.data(); const char * end = start + s.size(); while(start < end){ wchar_t wc; int resultx = std::mbtowc(&wc, start, end - start); if(0 < resultx){ start += resultx; ws += wc; continue; } boost::serialization::throw_exception( iterators::dataflow_exception( iterators::dataflow_exception::invalid_conversion ) ); } } #endif // BOOST_NO_STD_WSTRING #ifndef BOOST_NO_INTRINSIC_WCHAR_T template<class Archive> BOOST_ARCHIVE_DECL(void) xml_iarchive_impl<Archive>::load(wchar_t * ws){ std::string s; bool result = gimpl->parse_string(is, s); if(! result) boost::serialization::throw_exception( xml_archive_exception(xml_archive_exception::xml_archive_parsing_error) ); const char * start = s.data(); const char * end = start + s.size(); while(start < end){ wchar_t wc; - int result = std::mbtowc(&wc, start, end - start); - if(0 < result){ - start += result; + int length = std::mbtowc(&wc, start, end - start); + if(0 < length){ + start += length; *ws++ = wc; continue; } boost::serialization::throw_exception( iterators::dataflow_exception( iterators::dataflow_exception::invalid_conversion ) ); } *ws = L'\0'; } #endif // BOOST_NO_INTRINSIC_WCHAR_T #endif // BOOST_NO_CWCHAR template<class Archive> BOOST_ARCHIVE_DECL(void) xml_iarchive_impl<Archive>::load(std::string &s){ bool result = gimpl->parse_string(is, s); if(! result) boost::serialization::throw_exception( xml_archive_exception(xml_archive_exception::xml_archive_parsing_error) ); } template<class Archive> BOOST_ARCHIVE_DECL(void) xml_iarchive_impl<Archive>::load(char * s){ std::string tstring; bool result = gimpl->parse_string(is, tstring); if(! result) boost::serialization::throw_exception( xml_archive_exception(xml_archive_exception::xml_archive_parsing_error) ); std::memcpy(s, tstring.data(), tstring.size()); diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp index 8ab954f..ab1a217 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_oarchive_impl.ipp @@ -1,46 +1,46 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // xml_oarchive_impl.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include <ostream> #include <iomanip> -#include <algorithm> +#include <algorithm> // std::copy #include <string> #include <cstring> // strlen #include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::strlen; } // namespace std #endif #include <boost/archive/iterators/xml_escape.hpp> #include <boost/archive/iterators/ostream_iterator.hpp> #ifndef BOOST_NO_CWCHAR #include <boost/archive/wcslen.hpp> #include <boost/archive/iterators/mb_from_wchar.hpp> #endif namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implemenations of functions specific to char archives // wide char stuff used by char archives #ifndef BOOST_NO_CWCHAR // copy chars to output escaping to xml and translating wide chars to mb chars template<class InputIterator> void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){ typedef boost::archive::iterators::mb_from_wchar< boost::archive::iterators::xml_escape<InputIterator> > translator; std::copy( translator(BOOST_MAKE_PFTO_WRAPPER(begin)), translator(BOOST_MAKE_PFTO_WRAPPER(end)), diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp index 9dde66c..a4665ad 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_wiarchive_impl.ipp @@ -1,74 +1,79 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 -// xml_wiprimitive.cpp: +// xml_wiarchive_impl.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. -#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME - #include <cstring> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::memcpy; } //std #endif #include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings #ifndef BOOST_NO_STD_WSTREAMBUF #include <boost/assert.hpp> -#include <algorithm> +#include <algorithm> // std::copy #include <boost/detail/workaround.hpp> // Dinkumware and RogueWave #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) #include <boost/archive/dinkumware.hpp> #endif #include <boost/io/ios_state.hpp> #include <boost/detail/no_exceptions_support.hpp> #include <boost/serialization/pfto.hpp> #include <boost/serialization/string.hpp> #include <boost/archive/add_facet.hpp> -#include <boost/archive/xml_archive_exception.hpp> -#include <boost/archive/detail/utf8_codecvt_facet.hpp> +#ifndef BOOST_NO_CXX11_HDR_CODECVT + #include <codecvt> + namespace boost { namespace archive { namespace detail { + typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet; + } } } +#else + #include <boost/archive/detail/utf8_codecvt_facet.hpp> +#endif +#include <boost/archive/xml_archive_exception.hpp> #include <boost/archive/iterators/mb_from_wchar.hpp> #include <boost/archive/basic_xml_archive.hpp> #include <boost/archive/xml_wiarchive.hpp> #include "basic_xml_grammar.hpp" namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implemenations of functions specific to wide char archives namespace { // anonymous void copy_to_ptr(char * s, const std::wstring & ws){ std::copy( iterators::mb_from_wchar<std::wstring::const_iterator>( BOOST_MAKE_PFTO_WRAPPER(ws.begin()) ), iterators::mb_from_wchar<std::wstring::const_iterator>( BOOST_MAKE_PFTO_WRAPPER(ws.end()) ), s ); s[ws.size()] = 0; } } // anonymous template<class Archive> BOOST_WARCHIVE_DECL(void) xml_wiarchive_impl<Archive>::load(std::string & s){ std::wstring ws; bool result = gimpl->parse_string(is, ws); @@ -135,71 +140,71 @@ template<class Archive> BOOST_WARCHIVE_DECL(void) xml_wiarchive_impl<Archive>::load_override(class_name_type & t, int){ const std::wstring & ws = gimpl->rv.class_name; if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1) boost::serialization::throw_exception( archive_exception(archive_exception::invalid_class_name) ); copy_to_ptr(t, ws); } template<class Archive> BOOST_WARCHIVE_DECL(void) xml_wiarchive_impl<Archive>::init(){ gimpl->init(is); this->set_library_version( library_version_type(gimpl->rv.version) ); } template<class Archive> BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_wiarchive_impl<Archive>::xml_wiarchive_impl( std::wistream &is_, unsigned int flags ) : basic_text_iprimitive<std::wistream>( is_, true // don't change the codecvt - use the one below ), basic_xml_iarchive<Archive>(flags), gimpl(new xml_wgrammar()) { if(0 == (flags & no_codecvt)){ archive_locale.reset( add_facet( - std::locale::classic(), + is_.getloc(), new boost::archive::detail::utf8_codecvt_facet ) ); is.imbue(* archive_locale); } if(0 == (flags & no_header)){ BOOST_TRY{ this->init(); } BOOST_CATCH(...){ delete gimpl; #ifndef BOOST_NO_EXCEPTIONS throw; // re-throw #endif } BOOST_CATCH_END } } template<class Archive> BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){ if(0 == (this->get_flags() & no_header)){ BOOST_TRY{ gimpl->windup(is); } BOOST_CATCH(...){} BOOST_CATCH_END } delete gimpl; } } // namespace archive } // namespace boost diff --git a/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp b/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp index 3bf42bd..6092a91 100644 --- a/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp +++ b/3rdParty/Boost/src/boost/archive/impl/xml_woarchive_impl.ipp @@ -1,77 +1,83 @@ /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // xml_woarchive_impl.ipp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include <boost/config.hpp> #ifndef BOOST_NO_STD_WSTREAMBUF #include <ostream> #include <string> -#include <algorithm> +#include <algorithm> // std::copy #include <locale> -#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings - // for BOOST_DEDUCED_TYPENAME #include <cstring> // strlen #include <cstdlib> // mbtowc #include <cwchar> // wcslen +#include <boost/config.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std{ using ::strlen; #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T) using ::mbtowc; using ::wcslen; #endif } // namespace std #endif #include <boost/serialization/throw_exception.hpp> #include <boost/serialization/pfto.hpp> #include <boost/archive/iterators/xml_escape.hpp> #include <boost/archive/iterators/wchar_from_mb.hpp> #include <boost/archive/iterators/ostream_iterator.hpp> #include <boost/archive/iterators/dataflow_exception.hpp> #include <boost/archive/add_facet.hpp> -#include <boost/archive/detail/utf8_codecvt_facet.hpp> +#ifndef BOOST_NO_CXX11_HDR_CODECVT + #include <codecvt> + namespace boost { namespace archive { namespace detail { + typedef std::codecvt_utf8<wchar_t> utf8_codecvt_facet; + } } } +#else + #include <boost/archive/detail/utf8_codecvt_facet.hpp> +#endif namespace boost { namespace archive { /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implemenations of functions specific to wide char archives // copy chars to output escaping to xml and widening characters as we go template<class InputIterator> void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){ typedef iterators::wchar_from_mb< iterators::xml_escape<InputIterator> > xmbtows; std::copy( xmbtows(BOOST_MAKE_PFTO_WRAPPER(begin)), xmbtows(BOOST_MAKE_PFTO_WRAPPER(end)), boost::archive::iterators::ostream_iterator<wchar_t>(os) ); } template<class Archive> BOOST_WARCHIVE_DECL(void) xml_woarchive_impl<Archive>::save(const std::string & s){ // note: we don't use s.begin() and s.end() because dinkumware // doesn't have string::value_type defined. So use a wrapper // around these values to implement the definitions. const char * begin = s.data(); const char * end = begin + s.size(); save_iterator(os, begin, end); } #ifndef BOOST_NO_STD_WSTRING template<class Archive> BOOST_WARCHIVE_DECL(void) xml_woarchive_impl<Archive>::save(const std::wstring & ws){ @@ -96,65 +102,66 @@ template<class Archive> BOOST_WARCHIVE_DECL(void) xml_woarchive_impl<Archive>::save(const char * s){ save_iterator(os, s, s + std::strlen(s)); } #ifndef BOOST_NO_INTRINSIC_WCHAR_T 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(BOOST_MAKE_PFTO_WRAPPER(ws)), xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws + std::wcslen(ws))), boost::archive::iterators::ostream_iterator<wchar_t>(os) ); } #endif template<class Archive> BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY()) xml_woarchive_impl<Archive>::xml_woarchive_impl( std::wostream & os_, unsigned int flags ) : basic_text_oprimitive<std::wostream>( os_, true // don't change the codecvt - use the one below ), basic_xml_oarchive<Archive>(flags) { // Standard behavior is that imbue can be called // a) before output is invoked or // b) after flush has been called. This prevents one-to-many // transforms (such as one to many transforms from getting - // mixed up. Unfortunately, STLPort doesn't respect b) above - // so the restoration of the original archive locale done by - // the locale_saver doesn't get processed, - // before the current one is destroyed. - // so the codecvt doesn't get replaced with the orginal - // so closing the stream invokes codecvt::do_unshift - // so it crashes because the corresponding locale that contained - // the codecvt isn't around any more. - // we can hack around this by using a static codecvt that never - // gets destroyed. + // mixed up. if(0 == (flags & no_codecvt)){ boost::archive::detail::utf8_codecvt_facet *pfacet; #if defined(__SGI_STL_PORT) - static boost::archive::detail::utf8_codecvt_facet + // Unfortunately, STLPort doesn't respect b) above + // so the restoration of the original archive locale done by + // the locale_saver doesn't get processed, + // before the current one is destroyed. + // so the codecvt doesn't get replaced with the orginal + // so closing the stream invokes codecvt::do_unshift + // so it crashes because the corresponding locale that contained + // the codecvt isn't around any more. + // we can hack around this by using a static codecvt that never + // gets destroyed. + static boost::archive::detail::utf8_codecvt_facet facet(static_cast<size_t>(1)); pfacet = & facet; #else pfacet = new boost::archive::detail::utf8_codecvt_facet; #endif - archive_locale.reset(add_facet(std::locale::classic(), pfacet)); + archive_locale.reset(add_facet(os_.getloc(), pfacet)); os.imbue(* archive_locale); } if(0 == (flags & no_header)) this->init(); } } // namespace archive } // namespace boost #endif //BOOST_NO_STD_WSTREAMBUF |