Swiftdiff options
| author | Remko Tronçon <git@el-tramo.be> | 2010-04-11 18:19:17 (GMT) |
|---|---|---|
| committer | Remko Tronçon <git@el-tramo.be> | 2010-04-11 19:20:07 (GMT) |
| commit | 857e44c156a1dbefcb49bb5792c4384cebd8762a (patch) | |
| tree | 11947fb81ad9c502627f1b2bb8f090fb8d53c107 /3rdParty/Boost/src/boost/exception | |
| parent | 77d4eb7588e113beaa03f3347523b26adefdeb06 (diff) | |
| download | swift-contrib-857e44c156a1dbefcb49bb5792c4384cebd8762a.zip swift-contrib-857e44c156a1dbefcb49bb5792c4384cebd8762a.tar.bz2 | |
Updated Boost to 1.42.
Diffstat (limited to '3rdParty/Boost/src/boost/exception')
13 files changed, 1533 insertions, 35 deletions
diff --git a/3rdParty/Boost/src/boost/exception/current_exception_cast.hpp b/3rdParty/Boost/src/boost/exception/current_exception_cast.hpp new file mode 100644 index 0000000..af2f153 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/current_exception_cast.hpp @@ -0,0 +1,43 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_7E83C166200811DE885E826156D89593 +#define UUID_7E83C166200811DE885E826156D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +namespace +boost + { + template <class E> + inline + E * + current_exception_cast() + { + try + { + throw; + } + catch( + E & e ) + { + return &e; + } + catch( + ...) + { + return 0; + } + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/detail/attribute_noreturn.hpp b/3rdParty/Boost/src/boost/exception/detail/attribute_noreturn.hpp new file mode 100644 index 0000000..f6a0b59 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/detail/attribute_noreturn.hpp @@ -0,0 +1,17 @@ +//Copyright (c) 2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_61531AB0680611DEADD5846855D89593 +#define UUID_61531AB0680611DEADD5846855D89593 + +#if defined(_MSC_VER) +#define BOOST_ATTRIBUTE_NORETURN __declspec(noreturn) +#elif defined(__GNUC__) +#define BOOST_ATTRIBUTE_NORETURN __attribute__((noreturn)) +#else +#define BOOST_ATTRIBUTE_NORETURN +#endif + +#endif diff --git a/3rdParty/Boost/src/boost/exception/detail/error_info_impl.hpp b/3rdParty/Boost/src/boost/exception/detail/error_info_impl.hpp new file mode 100644 index 0000000..32113b1 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/detail/error_info_impl.hpp @@ -0,0 +1,75 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_CE6983AC753411DDA764247956D89593 +#define UUID_CE6983AC753411DDA764247956D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <string> + +namespace +boost + { + namespace + exception_detail + { + class + error_info_base + { + public: + + virtual char const * tag_typeid_name() const = 0; + virtual std::string value_as_string() const = 0; + + protected: + + ~error_info_base() throw() + { + } + }; + } + + template <class Tag,class T> + class + error_info: + public exception_detail::error_info_base + { + public: + + typedef T value_type; + + error_info( value_type const & value ); + ~error_info() throw(); + + value_type const & + value() const + { + return value_; + } + + value_type & + value() + { + return value_; + } + + private: + + char const * tag_typeid_name() const; + std::string value_as_string() const; + + value_type value_; + }; + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/detail/exception_ptr.hpp b/3rdParty/Boost/src/boost/exception/detail/exception_ptr.hpp new file mode 100644 index 0000000..78db17c --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/detail/exception_ptr.hpp @@ -0,0 +1,490 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_618474C2DE1511DEB74A388C56D89593 +#define UUID_618474C2DE1511DEB74A388C56D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/config.hpp> +#ifdef BOOST_NO_EXCEPTIONS +#error This header requires exception handling to be enabled. +#endif +#include <boost/exception/exception.hpp> +#include <boost/exception/info.hpp> +#include <boost/exception/diagnostic_information.hpp> +#include <boost/exception/detail/type_info.hpp> +#include <boost/shared_ptr.hpp> +#include <stdexcept> +#include <new> +#include <ios> + +namespace +boost + { +#ifndef BOOST_NO_RTTI + typedef error_info<struct tag_original_exception_type,std::type_info const *> original_exception_type; + + inline + std::string + to_string( original_exception_type const & x ) + { + return x.value()->name(); + } +#endif + + class exception_ptr; + exception_ptr current_exception(); + void rethrow_exception( exception_ptr const & ); + + class + exception_ptr + { + typedef bool exception_ptr::*unspecified_bool_type; + friend exception_ptr current_exception(); + friend void rethrow_exception( exception_ptr const & ); + + shared_ptr<exception_detail::clone_base const> c_; + bool bad_alloc_; + + struct + bad_alloc_tag + { + }; + + explicit + exception_ptr( bad_alloc_tag ): + bad_alloc_(true) + { + } + + explicit + exception_ptr( shared_ptr<exception_detail::clone_base const> const & c ): + c_(c), + bad_alloc_(false) + { + BOOST_ASSERT(c); + } + + void + rethrow() const + { + BOOST_ASSERT(*this); + if( bad_alloc_ ) + throw enable_current_exception(std::bad_alloc()); + else + c_->rethrow(); + } + + bool + empty() const + { + return !bad_alloc_ && !c_; + } + + public: + + exception_ptr(): + bad_alloc_(false) + { + } + + ~exception_ptr() throw() + { + } + + operator unspecified_bool_type() const + { + return empty() ? 0 : &exception_ptr::bad_alloc_; + } + + friend + bool + operator==( exception_ptr const & a, exception_ptr const & b ) + { + return a.c_==b.c_ && a.bad_alloc_==b.bad_alloc_; + } + + friend + bool + operator!=( exception_ptr const & a, exception_ptr const & b ) + { + return !(a==b); + } + }; + + class + unknown_exception: + public exception, + public std::exception, + public exception_detail::clone_base + { + public: + + unknown_exception() + { + } + + explicit + unknown_exception( std::exception const & e ) + { + add_original_type(e); + } + + explicit + unknown_exception( boost::exception const & e ): + boost::exception(e) + { + add_original_type(e); + } + + ~unknown_exception() throw() + { + } + + private: + + exception_detail::clone_base const * + clone() const + { + return new unknown_exception(*this); + } + + void + rethrow() const + { + throw*this; + } + + template <class E> + void + add_original_type( E const & e ) + { +#ifndef BOOST_NO_RTTI + (*this) << original_exception_type(&typeid(e)); +#endif + } + }; + + namespace + exception_detail + { + template <class T> + class + current_exception_std_exception_wrapper: + public T, + public boost::exception, + public clone_base + { + public: + + explicit + current_exception_std_exception_wrapper( T const & e1 ): + T(e1) + { + add_original_type(e1); + } + + current_exception_std_exception_wrapper( T const & e1, boost::exception const & e2 ): + T(e1), + boost::exception(e2) + { + add_original_type(e1); + } + + ~current_exception_std_exception_wrapper() throw() + { + } + + private: + + clone_base const * + clone() const + { + return new current_exception_std_exception_wrapper(*this); + } + + void + rethrow() const + { + throw *this; + } + + template <class E> + void + add_original_type( E const & e ) + { +#ifndef BOOST_NO_RTTI + (*this) << original_exception_type(&typeid(e)); +#endif + } + }; + +#ifdef BOOST_NO_RTTI + template <class T> + exception const * + get_boost_exception( T const * ) + { + try + { + throw; + } + catch( + exception & x ) + { + return &x; + } + catch(...) + { + return 0; + } + } +#else + template <class T> + exception const * + get_boost_exception( T const * x ) + { + return dynamic_cast<exception const *>(x); + } +#endif + + template <class T> + inline + shared_ptr<clone_base const> + current_exception_std_exception( T const & e1 ) + { + if( boost::exception const * e2 = get_boost_exception(&e1) ) + return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1,*e2)); + else + return shared_ptr<current_exception_std_exception_wrapper<T> const>(new current_exception_std_exception_wrapper<T>(e1)); + } + + inline + shared_ptr<clone_base const> + current_exception_unknown_exception() + { + return shared_ptr<unknown_exception const>(new unknown_exception()); + } + + inline + shared_ptr<clone_base const> + current_exception_unknown_boost_exception( boost::exception const & e ) + { + return shared_ptr<unknown_exception const>(new unknown_exception(e)); + } + + inline + shared_ptr<clone_base const> + current_exception_unknown_std_exception( std::exception const & e ) + { + if( boost::exception const * be = get_boost_exception(&e) ) + return current_exception_unknown_boost_exception(*be); + else + return shared_ptr<unknown_exception const>(new unknown_exception(e)); + } + + inline + shared_ptr<clone_base const> + current_exception_impl() + { + try + { + throw; + } + catch( + exception_detail::clone_base & e ) + { + return shared_ptr<exception_detail::clone_base const>(e.clone()); + } + catch( + std::domain_error & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::invalid_argument & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::length_error & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::out_of_range & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::logic_error & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::range_error & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::overflow_error & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::underflow_error & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::ios_base::failure & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::runtime_error & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::bad_alloc & e ) + { + return exception_detail::current_exception_std_exception(e); + } +#ifndef BOOST_NO_TYPEID + catch( + std::bad_cast & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::bad_typeid & e ) + { + return exception_detail::current_exception_std_exception(e); + } +#endif + catch( + std::bad_exception & e ) + { + return exception_detail::current_exception_std_exception(e); + } + catch( + std::exception & e ) + { + return exception_detail::current_exception_unknown_std_exception(e); + } + catch( + boost::exception & e ) + { + return exception_detail::current_exception_unknown_boost_exception(e); + } + catch( + ... ) + { + return exception_detail::current_exception_unknown_exception(); + } + } + } + + inline + exception_ptr + current_exception() + { + try + { + return exception_ptr(exception_detail::current_exception_impl()); + } + catch( + std::bad_alloc & ) + { + } + catch( + ... ) + { + try + { + return exception_ptr(exception_detail::current_exception_std_exception(std::bad_exception())); + } + catch( + std::bad_alloc & ) + { + } + catch( + ... ) + { + BOOST_ASSERT(0); + } + } + return exception_ptr(exception_ptr::bad_alloc_tag()); + } + + template <class T> + inline + exception_ptr + copy_exception( T const & e ) + { + try + { + throw enable_current_exception(e); + } + catch( + ... ) + { + return current_exception(); + } + } + + inline + void + rethrow_exception( exception_ptr const & p ) + { + p.rethrow(); + } + + inline + std::string + diagnostic_information( exception_ptr const & p ) + { + if( p ) + try + { + rethrow_exception(p); + } + catch( + ... ) + { + return current_exception_diagnostic_information(); + } + return "<empty>"; + } + + inline + std::string + to_string( exception_ptr const & p ) + { + std::string s='\n'+diagnostic_information(p); + std::string padding(" "); + std::string r; + bool f=false; + for( std::string::const_iterator i=s.begin(),e=s.end(); i!=e; ++i ) + { + if( f ) + r+=padding; + char c=*i; + r+=c; + f=(c=='\n'); + } + return r; + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/detail/is_output_streamable.hpp b/3rdParty/Boost/src/boost/exception/detail/is_output_streamable.hpp new file mode 100644 index 0000000..5eb1695 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/detail/is_output_streamable.hpp @@ -0,0 +1,47 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_898984B4076411DD973EDFA055D89593 +#define UUID_898984B4076411DD973EDFA055D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <ostream> + +namespace +boost + { + namespace + to_string_detail + { + template <class T,class CharT,class Traits> + char operator<<( std::basic_ostream<CharT,Traits> &, T const & ); + + template <class T,class CharT,class Traits> + struct + is_output_streamable_impl + { + static std::basic_ostream<CharT,Traits> & f(); + static T const & g(); + enum e { value=1!=(sizeof(f()<<g())) }; + }; + } + + template <class T, class CharT=char, class Traits=std::char_traits<CharT> > + struct + is_output_streamable + { + enum e { value=to_string_detail::is_output_streamable_impl<T,CharT,Traits>::value }; + }; + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/detail/object_hex_dump.hpp b/3rdParty/Boost/src/boost/exception/detail/object_hex_dump.hpp new file mode 100644 index 0000000..ccf1bac --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/detail/object_hex_dump.hpp @@ -0,0 +1,50 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_6F463AC838DF11DDA3E6909F56D89593 +#define UUID_6F463AC838DF11DDA3E6909F56D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/exception/detail/type_info.hpp> +#include <iomanip> +#include <ios> +#include <string> +#include <sstream> +#include <cstdlib> + +namespace +boost + { + namespace + exception_detail + { + template <class T> + inline + std::string + object_hex_dump( T const & x, std::size_t max_size=16 ) + { + std::ostringstream s; + s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: "; + std::size_t n=sizeof(T)>max_size?max_size:sizeof(T); + s.fill('0'); + s.width(2); + unsigned char const * b=reinterpret_cast<unsigned char const *>(&x); + s << std::setw(2) << std::hex << (unsigned int)*b; + for( unsigned char const * e=b+n; ++b!=e; ) + s << " " << std::setw(2) << std::hex << (unsigned int)*b; + return s.str(); + } + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/detail/type_info.hpp b/3rdParty/Boost/src/boost/exception/detail/type_info.hpp new file mode 100644 index 0000000..60709a1 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/detail/type_info.hpp @@ -0,0 +1,79 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_C3E1741C754311DDB2834CCA55D89593 +#define UUID_C3E1741C754311DDB2834CCA55D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/detail/sp_typeinfo.hpp> +#include <boost/current_function.hpp> +#include <boost/config.hpp> + +namespace +boost + { + template <class T> + inline + char const * + tag_type_name() + { +#ifdef BOOST_NO_TYPEID + return BOOST_CURRENT_FUNCTION; +#else + return typeid(T*).name(); +#endif + } + + template <class T> + inline + char const * + type_name() + { +#ifdef BOOST_NO_TYPEID + return BOOST_CURRENT_FUNCTION; +#else + return typeid(T).name(); +#endif + } + + namespace + exception_detail + { + struct + type_info_ + { + detail::sp_typeinfo const & type_; + + explicit + type_info_( detail::sp_typeinfo const & type ): + type_(type) + { + } + + friend + bool + operator<( type_info_ const & a, type_info_ const & b ) + { + return 0!=(a.type_.before(b.type_)); + } + }; + } + } + +#define BOOST_EXCEPTION_STATIC_TYPEID(T) ::boost::exception_detail::type_info_(BOOST_SP_TYPEID(T)) + +#ifndef BOOST_NO_RTTI +#define BOOST_EXCEPTION_DYNAMIC_TYPEID(x) ::boost::exception_detail::type_info_(typeid(x)) +#endif + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/diagnostic_information.hpp b/3rdParty/Boost/src/boost/exception/diagnostic_information.hpp new file mode 100644 index 0000000..632a5a3 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/diagnostic_information.hpp @@ -0,0 +1,182 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_0552D49838DD11DD90146B8956D89593 +#define UUID_0552D49838DD11DD90146B8956D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/config.hpp> +#include <boost/exception/get_error_info.hpp> +#include <boost/utility/enable_if.hpp> +#include <boost/config.hpp> +#include <exception> +#include <sstream> +#include <string> + +#ifndef BOOST_NO_EXCEPTIONS +#include <boost/exception/current_exception_cast.hpp> +namespace +boost + { + namespace + exception_detail + { + std::string diagnostic_information_impl( boost::exception const *, std::exception const *, bool ); + } + + inline + std::string + current_exception_diagnostic_information() + { + boost::exception const * be=current_exception_cast<boost::exception const>(); + std::exception const * se=current_exception_cast<std::exception const>(); + if( be || se ) + return exception_detail::diagnostic_information_impl(be,se,true); + else + return "No diagnostic information available."; + } + } +#endif + +namespace +boost + { + namespace + exception_detail + { + inline + exception const * + get_boost_exception( exception const * e ) + { + return e; + } + + inline + exception const * + get_boost_exception( ... ) + { + return 0; + } + + inline + std::exception const * + get_std_exception( std::exception const * e ) + { + return e; + } + + inline + std::exception const * + get_std_exception( ... ) + { + return 0; + } + + inline + char const * + get_diagnostic_information( exception const & x, char const * header ) + { + if( error_info_container * c=x.data_.get() ) +#ifndef BOOST_NO_EXCEPTIONS + try + { +#endif + return c->diagnostic_information(header); +#ifndef BOOST_NO_EXCEPTIONS + } + catch(...) + { + } +#endif + return 0; + } + + inline + std::string + diagnostic_information_impl( boost::exception const * be, std::exception const * se, bool with_what ) + { + if( !be && !se ) + return "Unknown exception."; +#ifndef BOOST_NO_RTTI + if( !be ) + be=dynamic_cast<boost::exception const *>(se); + if( !se ) + se=dynamic_cast<std::exception const *>(be); +#endif + char const * wh=0; + if( with_what && se ) + { + wh=se->what(); + if( be && exception_detail::get_diagnostic_information(*be,0)==wh ) + return wh; + } + std::ostringstream tmp; + if( be ) + { + if( char const * const * f=get_error_info<throw_file>(*be) ) + { + tmp << *f; + if( int const * l=get_error_info<throw_line>(*be) ) + tmp << '(' << *l << "): "; + } + tmp << "Throw in function "; + if( char const * const * fn=get_error_info<throw_function>(*be) ) + tmp << *fn; + else + tmp << "(unknown)"; + tmp << '\n'; + } +#ifndef BOOST_NO_RTTI + tmp << std::string("Dynamic exception type: ") << + (be?BOOST_EXCEPTION_DYNAMIC_TYPEID(*be):BOOST_EXCEPTION_DYNAMIC_TYPEID(*se)).type_.name() << '\n'; +#endif + if( with_what && se ) + tmp << "std::exception::what: " << wh << '\n'; + if( be ) + if( char const * s=exception_detail::get_diagnostic_information(*be,tmp.str().c_str()) ) + if( *s ) + return s; + return tmp.str(); + } + } + + template <class T> + std::string + diagnostic_information( T const & e ) + { + return exception_detail::diagnostic_information_impl(exception_detail::get_boost_exception(&e),exception_detail::get_std_exception(&e),true); + } + + inline + char const * + diagnostic_information_what( exception const & e ) throw() + { + char const * w=0; +#ifndef BOOST_NO_EXCEPTIONS + try + { +#endif + (void) exception_detail::diagnostic_information_impl(&e,0,false); + return exception_detail::get_diagnostic_information(e,0); +#ifndef BOOST_NO_EXCEPTIONS + } + catch( + ... ) + { + } +#endif + return w; + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/exception.hpp b/3rdParty/Boost/src/boost/exception/exception.hpp index 6df93ac..79b2739 100644 --- a/3rdParty/Boost/src/boost/exception/exception.hpp +++ b/3rdParty/Boost/src/boost/exception/exception.hpp @@ -5,6 +5,12 @@ #ifndef UUID_274DA366004E11DCB1DDFE2E56D89593 #define UUID_274DA366004E11DCB1DDFE2E56D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif namespace boost @@ -80,13 +86,13 @@ boost template <class Tag,class T> class error_info; - typedef error_info<struct tag_throw_function,char const *> throw_function; - typedef error_info<struct tag_throw_file,char const *> throw_file; - typedef error_info<struct tag_throw_line,int> throw_line; + typedef error_info<struct throw_function_,char const *> throw_function; + typedef error_info<struct throw_file_,char const *> throw_file; + typedef error_info<struct throw_line_,int> throw_line; template <> class - error_info<tag_throw_function,char const *> + error_info<throw_function_,char const *> { public: typedef char const * value_type; @@ -100,7 +106,7 @@ boost template <> class - error_info<tag_throw_file,char const *> + error_info<throw_file_,char const *> { public: typedef char const * value_type; @@ -114,7 +120,7 @@ boost template <> class - error_info<tag_throw_line,int> + error_info<throw_line_,int> { public: typedef int value_type; @@ -129,6 +135,15 @@ boost template <class E,class Tag,class T> E const & operator<<( E const &, error_info<Tag,T> const & ); + template <class E> + E const & operator<<( E const &, throw_function const & ); + + template <class E> + E const & operator<<( E const &, throw_file const & ); + + template <class E> + E const & operator<<( E const &, throw_line const & ); + class exception; template <class> @@ -143,15 +158,14 @@ boost struct error_info_container { - virtual char const * diagnostic_information() const = 0; - virtual shared_ptr<error_info_base const> get( type_info_ const & ) const = 0; - virtual void set( shared_ptr<error_info_base const> const &, type_info_ const & ) = 0; + virtual char const * diagnostic_information( char const * ) const = 0; + virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0; + virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0; virtual void add_ref() const = 0; virtual void release() const = 0; protected: - virtual ~error_info_container() throw() { } @@ -169,7 +183,7 @@ boost template <> struct get_info<throw_line>; - char const * get_diagnostic_information( exception const & ); + char const * get_diagnostic_information( exception const &, char const * ); } class @@ -202,36 +216,21 @@ boost #endif ; +#if defined(__MWERKS__) && __MWERKS__<=0x3207 + public: +#else private: template <class E> - friend - E const & - operator<<( E const & x, throw_function const & y ) - { - x.throw_function_=y.v_; - return x; - } + friend E const & operator<<( E const &, throw_function const & ); template <class E> - friend - E const & - operator<<( E const & x, throw_file const & y ) - { - x.throw_file_=y.v_; - return x; - } + friend E const & operator<<( E const &, throw_file const & ); template <class E> - friend - E const & - operator<<( E const & x, throw_line const & y ) - { - x.throw_line_=y.v_; - return x; - } + friend E const & operator<<( E const &, throw_line const & ); - friend char const * exception_detail::get_diagnostic_information( exception const & ); + friend char const * exception_detail::get_diagnostic_information( exception const &, char const * ); template <class E,class Tag,class T> friend E const & operator<<( E const &, error_info<Tag,T> const & ); @@ -241,7 +240,7 @@ boost friend struct exception_detail::get_info<throw_function>; friend struct exception_detail::get_info<throw_file>; friend struct exception_detail::get_info<throw_line>; - +#endif mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_; mutable char const * throw_function_; mutable char const * throw_file_; @@ -254,6 +253,30 @@ boost { } + template <class E> + E const & + operator<<( E const & x, throw_function const & y ) + { + x.throw_function_=y.v_; + return x; + } + + template <class E> + E const & + operator<<( E const & x, throw_file const & y ) + { + x.throw_file_=y.v_; + return x; + } + + template <class E> + E const & + operator<<( E const & x, throw_line const & y ) + { + x.throw_line_=y.v_; + return x; + } + //////////////////////////////////////////////////////////////////////// namespace @@ -303,7 +326,7 @@ boost struct enable_error_info_return_type { - typedef typename enable_error_info_helper<T,sizeof(dispatch((T*)0))>::type type; + typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch((T*)0))>::type type; }; } @@ -393,4 +416,7 @@ boost } } +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif #endif diff --git a/3rdParty/Boost/src/boost/exception/get_error_info.hpp b/3rdParty/Boost/src/boost/exception/get_error_info.hpp new file mode 100644 index 0000000..046f05a --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/get_error_info.hpp @@ -0,0 +1,130 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_1A590226753311DD9E4CCF6156D89593 +#define UUID_1A590226753311DD9E4CCF6156D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/exception/exception.hpp> +#include <boost/exception/detail/error_info_impl.hpp> +#include <boost/exception/detail/type_info.hpp> +#include <boost/shared_ptr.hpp> + +namespace +boost + { + namespace + exception_detail + { + template <class ErrorInfo> + struct + get_info + { + static + typename ErrorInfo::value_type * + get( exception const & x ) + { + if( exception_detail::error_info_container * c=x.data_.get() ) + if( shared_ptr<exception_detail::error_info_base> eib = c->get(BOOST_EXCEPTION_STATIC_TYPEID(ErrorInfo)) ) + { +#ifndef BOOST_NO_RTTI + BOOST_ASSERT( 0!=dynamic_cast<ErrorInfo *>(eib.get()) ); +#endif + ErrorInfo * w = static_cast<ErrorInfo *>(eib.get()); + return &w->value(); + } + return 0; + } + }; + + template <> + struct + get_info<throw_function> + { + static + char const * * + get( exception const & x ) + { + return x.throw_function_ ? &x.throw_function_ : 0; + } + }; + + template <> + struct + get_info<throw_file> + { + static + char const * * + get( exception const & x ) + { + return x.throw_file_ ? &x.throw_file_ : 0; + } + }; + + template <> + struct + get_info<throw_line> + { + static + int * + get( exception const & x ) + { + return x.throw_line_!=-1 ? &x.throw_line_ : 0; + } + }; + + template <class T,class R> + struct + get_error_info_return_type + { + typedef R * type; + }; + + template <class T,class R> + struct + get_error_info_return_type<T const,R> + { + typedef R const * type; + }; + } + +#ifdef BOOST_NO_RTTI + template <class ErrorInfo> + inline + typename ErrorInfo::value_type const * + get_error_info( boost::exception const & x ) + { + return exception_detail::get_info<ErrorInfo>::get(x); + } + template <class ErrorInfo> + inline + typename ErrorInfo::value_type * + get_error_info( boost::exception & x ) + { + return exception_detail::get_info<ErrorInfo>::get(x); + } +#else + template <class ErrorInfo,class E> + inline + typename exception_detail::get_error_info_return_type<E,typename ErrorInfo::value_type>::type + get_error_info( E & some_exception ) + { + if( exception const * x = dynamic_cast<exception const *>(&some_exception) ) + return exception_detail::get_info<ErrorInfo>::get(*x); + else + return 0; + } +#endif + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/info.hpp b/3rdParty/Boost/src/boost/exception/info.hpp new file mode 100644 index 0000000..cbbc2c0 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/info.hpp @@ -0,0 +1,167 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_8D22C4CA9CC811DCAA9133D256D89593 +#define UUID_8D22C4CA9CC811DCAA9133D256D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/exception/exception.hpp> +#include <boost/exception/to_string_stub.hpp> +#include <boost/exception/detail/error_info_impl.hpp> +#include <boost/shared_ptr.hpp> +#include <boost/config.hpp> +#include <map> + +namespace +boost + { + template <class Tag,class T> + inline + typename enable_if<has_to_string<T>,std::string>::type + to_string( error_info<Tag,T> const & x ) + { + return to_string(x.value()); + } + + template <class Tag,class T> + inline + error_info<Tag,T>:: + error_info( value_type const & value ): + value_(value) + { + } + + template <class Tag,class T> + inline + error_info<Tag,T>:: + ~error_info() throw() + { + } + + template <class Tag,class T> + inline + char const * + error_info<Tag,T>:: + tag_typeid_name() const + { + return tag_type_name<Tag>(); + } + + template <class Tag,class T> + inline + std::string + error_info<Tag,T>:: + value_as_string() const + { + return to_string_stub(*this); + } + + namespace + exception_detail + { + class + error_info_container_impl: + public error_info_container + { + public: + + error_info_container_impl(): + count_(0) + { + } + + ~error_info_container_impl() throw() + { + } + + void + set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ ) + { + BOOST_ASSERT(x); + info_[typeid_] = x; + diagnostic_info_str_.clear(); + } + + shared_ptr<error_info_base> + get( type_info_ const & ti ) const + { + error_info_map::const_iterator i=info_.find(ti); + if( info_.end()!=i ) + { + shared_ptr<error_info_base> const & p = i->second; +#ifndef BOOST_NO_RTTI + BOOST_ASSERT( BOOST_EXCEPTION_DYNAMIC_TYPEID(*p).type_==ti.type_ ); +#endif + return p; + } + return shared_ptr<error_info_base>(); + } + + char const * + diagnostic_information( char const * header ) const + { + if( header ) + { + BOOST_ASSERT(*header!=0); + std::ostringstream tmp; + tmp << header; + for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i ) + { + shared_ptr<error_info_base const> const & x = i->second; + tmp << '[' << x->tag_typeid_name() << "] = " << x->value_as_string() << '\n'; + } + tmp.str().swap(diagnostic_info_str_); + } + return diagnostic_info_str_.c_str(); + } + + private: + + friend class boost::exception; + + typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map; + error_info_map info_; + mutable std::string diagnostic_info_str_; + mutable int count_; + + void + add_ref() const + { + ++count_; + } + + void + release() const + { + if( !--count_ ) + delete this; + } + }; + } + + template <class E,class Tag,class T> + inline + E const & + operator<<( E const & x, error_info<Tag,T> const & v ) + { + typedef error_info<Tag,T> error_info_tag_t; + shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) ); + exception_detail::error_info_container * c=x.data_.get(); + if( !c ) + x.data_.adopt(c=new exception_detail::error_info_container_impl); + c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t)); + return x; + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/to_string.hpp b/3rdParty/Boost/src/boost/exception/to_string.hpp new file mode 100644 index 0000000..59bf83d --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/to_string.hpp @@ -0,0 +1,83 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_7E48761AD92811DC9011477D56D89593 +#define UUID_7E48761AD92811DC9011477D56D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/utility/enable_if.hpp> +#include <boost/exception/detail/is_output_streamable.hpp> +#include <sstream> + +namespace +boost + { + namespace + to_string_detail + { + template <class T> + typename disable_if<is_output_streamable<T>,char>::type to_string( T const & ); + + template <class,bool IsOutputStreamable> + struct has_to_string_impl; + + template <class T> + struct + has_to_string_impl<T,true> + { + enum e { value=1 }; + }; + + template <class T> + struct + has_to_string_impl<T,false> + { + static T const & f(); + enum e { value=1!=sizeof(to_string(f())) }; + }; + } + + template <class T> + inline + typename enable_if<is_output_streamable<T>,std::string>::type + to_string( T const & x ) + { + std::ostringstream out; + out << x; + return out.str(); + } + + template <class T> + struct + has_to_string + { + enum e { value=to_string_detail::has_to_string_impl<T,is_output_streamable<T>::value>::value }; + }; + + template <class T,class U> + inline + std::string + to_string( std::pair<T,U> const & x ) + { + return std::string("(") + to_string(x.first) + ',' + to_string(x.second) + ')'; + } + + inline + std::string + to_string( std::exception const & x ) + { + return x.what(); + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif diff --git a/3rdParty/Boost/src/boost/exception/to_string_stub.hpp b/3rdParty/Boost/src/boost/exception/to_string_stub.hpp new file mode 100644 index 0000000..e41d369 --- /dev/null +++ b/3rdParty/Boost/src/boost/exception/to_string_stub.hpp @@ -0,0 +1,109 @@ +//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. + +//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) + +#ifndef UUID_E788439ED9F011DCB181F25B55D89593 +#define UUID_E788439ED9F011DCB181F25B55D89593 +#if defined(__GNUC__) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma GCC system_header +#endif +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(push,1) +#endif + +#include <boost/exception/to_string.hpp> +#include <boost/exception/detail/object_hex_dump.hpp> +#include <boost/assert.hpp> + +namespace +boost + { + namespace + exception_detail + { + template <bool ToStringAvailable> + struct + to_string_dispatcher + { + template <class T,class Stub> + static + std::string + convert( T const & x, Stub ) + { + return to_string(x); + } + }; + + template <> + struct + to_string_dispatcher<false> + { + template <class T,class Stub> + static + std::string + convert( T const & x, Stub s ) + { + return s(x); + } + + template <class T> + static + std::string + convert( T const & x, std::string s ) + { + return s; + } + + template <class T> + static + std::string + convert( T const & x, char const * s ) + { + BOOST_ASSERT(s!=0); + return s; + } + }; + + namespace + to_string_dispatch + { + template <class T,class Stub> + inline + std::string + dispatch( T const & x, Stub s ) + { + return to_string_dispatcher<has_to_string<T>::value>::convert(x,s); + } + } + + template <class T> + inline + std::string + string_stub_dump( T const & x ) + { + return "[ " + exception_detail::object_hex_dump(x) + " ]"; + } + } + + template <class T> + inline + std::string + to_string_stub( T const & x ) + { + return exception_detail::to_string_dispatch::dispatch(x,&exception_detail::string_stub_dump<T>); + } + + template <class T,class Stub> + inline + std::string + to_string_stub( T const & x, Stub s ) + { + return exception_detail::to_string_dispatch::dispatch(x,s); + } + } + +#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS) +#pragma warning(pop) +#endif +#endif |