CCF_100/suyu-mirror
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu synced 2025-09-07 23:06:33 -05:00
Code Issues Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Crimson-Hawk
2024-03-05 16:42:40 +08:00
commit f1e4595ebf
39576 changed files with 7006612 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
externals/vcpkg/packages/boost-exception_x64-windows/BUILD_INFO vendored Executable file
View File

@@ -0,0 +1,2 @@
CRTLinkage: dynamic
LibraryLinkage: dynamic

8
externals/vcpkg/packages/boost-exception_x64-windows/CONTROL vendored Executable file
View File

@@ -0,0 +1,8 @@
Package: boost-exception
Version: 1.79.0
Depends: boost-assert, boost-build, boost-config, boost-core, boost-modular-build-helper, boost-smart-ptr, boost-throw-exception, boost-tuple, boost-type-traits, boost-vcpkg-helpers, vcpkg-cmake
Architecture: x64-windows
Multi-Arch: same
Abi: 85c64552480492927af1bfcf8855c2846a3911ea0a33c44aa60d53731d787b0e
Description: Boost exception module
Type: Port

BIN
externals/vcpkg/packages/boost-exception_x64-windows/debug/lib/boost_exception-vc140-mt-gd.lib vendored Executable file
View File

Binary file not shown.

27
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/all.hpp vendored Executable file
View File

@@ -0,0 +1,27 @@
//Copyright (c) 2006-2008 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 BOOST_EXCEPTION_316FDA946C0D11DEA9CBAE5255D89593
#define BOOST_EXCEPTION_316FDA946C0D11DEA9CBAE5255D89593
#include <boost/config.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include <boost/exception/error_info.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/get_error_info.hpp>
#include <boost/exception/info.hpp>
#include <boost/exception/info_tuple.hpp>
#include <boost/exception/errinfo_api_function.hpp>
#include <boost/exception/errinfo_at_line.hpp>
#include <boost/exception/errinfo_errno.hpp>
#include <boost/exception/errinfo_file_handle.hpp>
#include <boost/exception/errinfo_file_name.hpp>
#include <boost/exception/errinfo_file_open_mode.hpp>
#include <boost/exception/errinfo_type_info_name.hpp>
#ifndef BOOST_NO_EXCEPTIONS
#include <boost/exception/errinfo_nested_exception.hpp>
#include <boost/exception_ptr.hpp>
#endif
#endif

49
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/current_exception_cast.hpp vendored Executable file
View File

@@ -0,0 +1,49 @@
//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 BOOST_EXCEPTION_7E83C166200811DE885E826156D89593
#define BOOST_EXCEPTION_7E83C166200811DE885E826156D89593
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#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

62
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/detail/clone_current_exception.hpp vendored Executable file
View File

@@ -0,0 +1,62 @@
//Copyright (c) 2006-2013 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 BOOST_EXCEPTION_81522C0EB56511DFAB613DB0DFD72085
#define BOOST_EXCEPTION_81522C0EB56511DFAB613DB0DFD72085
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
#ifdef BOOST_NO_EXCEPTIONS
# error This header requires exception handling to be enabled.
#endif
namespace
boost
{
namespace
exception_detail
{
class clone_base;
#ifdef BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR
int clone_current_exception_non_intrusive( clone_base const * & cloned );
#endif
namespace
clone_current_exception_result
{
int const success=0;
int const bad_alloc=1;
int const bad_exception=2;
int const not_supported=3;
}
inline
int
clone_current_exception( clone_base const * & cloned )
{
#ifdef BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR
return clone_current_exception_non_intrusive(cloned);
#else
return clone_current_exception_result::not_supported;
#endif
}
}
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
#endif

107
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/detail/error_info_impl.hpp vendored Executable file
View File

@@ -0,0 +1,107 @@
//Copyright (c) 2006-2010 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 BOOST_EXCEPTION_CE6983AC753411DDA764247956D89593
#define BOOST_EXCEPTION_CE6983AC753411DDA764247956D89593
#include <boost/config.hpp>
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
#include <boost/type_traits/is_nothrow_move_constructible.hpp>
#endif
#include <utility>
#include <string>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
namespace
boost
{
namespace
exception_detail
{
class
error_info_base
{
public:
virtual std::string name_value_string() const = 0;
virtual error_info_base * clone() const = 0;
virtual
~error_info_base() BOOST_NOEXCEPT_OR_NOTHROW
{
}
};
}
template <class Tag,class T>
class
error_info:
public exception_detail::error_info_base
{
exception_detail::error_info_base *
clone() const
{
return new error_info<Tag,T>(*this);
}
public:
typedef T value_type;
error_info( value_type const & v ):
v_(v)
{
}
#if (__GNUC__*100+__GNUC_MINOR__!=406) //workaround for g++ bug
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
error_info( error_info const & x ):
v_(x.v_)
{
}
error_info( T && v ) BOOST_NOEXCEPT_IF(boost::is_nothrow_move_constructible<T>::value):
v_(std::move(v))
{
}
error_info( error_info && x ) BOOST_NOEXCEPT_IF(boost::is_nothrow_move_constructible<T>::value):
v_(std::move(x.v_))
{
}
#endif
#endif
~error_info() BOOST_NOEXCEPT_OR_NOTHROW
{
}
value_type const &
value() const
{
return v_;
}
value_type &
value()
{
return v_;
}
private:
error_info & operator=( error_info const & );
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
error_info & operator=( error_info && x );
#endif
std::string name_value_string() const;
value_type v_;
};
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
#endif

603
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/detail/exception_ptr.hpp vendored Executable file
View File

@@ -0,0 +1,603 @@
//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.
//Copyright (c) 2019 Dario Menendez, Banco Santander
//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 BOOST_EXCEPTION_618474C2DE1511DEB74A388C56D89593
#define BOOST_EXCEPTION_618474C2DE1511DEB74A388C56D89593
#include <boost/config.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/info.hpp>
#include <boost/exception/diagnostic_information.hpp>
#ifndef BOOST_NO_EXCEPTIONS
# include <boost/exception/detail/clone_current_exception.hpp>
#endif
#include <boost/exception/detail/type_info.hpp>
#ifndef BOOST_NO_RTTI
#include <boost/core/demangle.hpp>
#endif
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <stdexcept>
#include <new>
#include <ios>
#include <stdlib.h>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
namespace
boost
{
namespace
exception_detail
{
#ifndef BOOST_NO_CXX11_HDR_EXCEPTION
struct
std_exception_ptr_wrapper:
std::exception
{
std::exception_ptr p;
explicit std_exception_ptr_wrapper( std::exception_ptr const & ptr ) BOOST_NOEXCEPT:
p(ptr)
{
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
explicit std_exception_ptr_wrapper( std::exception_ptr && ptr ) BOOST_NOEXCEPT:
p(static_cast<std::exception_ptr &&>(ptr))
{
}
#endif
};
shared_ptr<exception_detail::clone_base const>
inline
wrap_exception_ptr( std::exception_ptr const & e )
{
exception_detail::clone_base const & base =
boost::enable_current_exception(std_exception_ptr_wrapper(std::current_exception()));
return shared_ptr<exception_detail::clone_base const>(base.clone());
}
#endif
}
class exception_ptr;
namespace exception_detail { void rethrow_exception_( exception_ptr const & ); }
class
exception_ptr
{
typedef boost::shared_ptr<exception_detail::clone_base const> impl;
impl ptr_;
friend void exception_detail::rethrow_exception_( exception_ptr const & );
typedef exception_detail::clone_base const * (impl::*unspecified_bool_type)() const;
public:
exception_ptr()
{
}
#ifndef BOOST_NO_CXX11_HDR_EXCEPTION
exception_ptr( std::exception_ptr const & e ):
ptr_(exception_detail::wrap_exception_ptr(e))
{
}
#endif
explicit
exception_ptr( impl const & ptr ):
ptr_(ptr)
{
}
bool
operator==( exception_ptr const & other ) const
{
return ptr_==other.ptr_;
}
bool
operator!=( exception_ptr const & other ) const
{
return ptr_!=other.ptr_;
}
operator unspecified_bool_type() const
{
return ptr_?&impl::get:0;
}
};
template <class E>
inline
exception_ptr
copy_exception( E const & e )
{
E cp = e;
exception_detail::copy_boost_exception(&cp, &e);
return exception_ptr(boost::make_shared<wrapexcept<E> >(cp));
}
template <class T>
inline
exception_ptr
make_exception_ptr( T const & e )
{
return boost::copy_exception(e);
}
#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 core::demangle(x.value()->name());
}
#endif
#ifndef BOOST_NO_EXCEPTIONS
namespace
exception_detail
{
struct
bad_alloc_:
boost::exception,
std::bad_alloc
{
~bad_alloc_() BOOST_NOEXCEPT_OR_NOTHROW { }
};
struct
bad_exception_:
boost::exception,
std::bad_exception
{
~bad_exception_() BOOST_NOEXCEPT_OR_NOTHROW { }
};
template <class Exception>
exception_ptr
get_static_exception_object()
{
Exception ba;
exception_detail::clone_impl<Exception> c(ba);
#ifndef BOOST_EXCEPTION_DISABLE
c <<
throw_function(BOOST_CURRENT_FUNCTION) <<
throw_file(__FILE__) <<
throw_line(__LINE__);
#endif
static exception_ptr ep(shared_ptr<exception_detail::clone_base const>(new exception_detail::clone_impl<Exception>(c)));
return ep;
}
template <class Exception>
struct
exception_ptr_static_exception_object
{
static exception_ptr const e;
};
template <class Exception>
exception_ptr const
exception_ptr_static_exception_object<Exception>::
e = get_static_exception_object<Exception>();
}
#if defined(__GNUC__)
# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
# pragma GCC visibility push (default)
# endif
#endif
class
unknown_exception:
public boost::exception,
public std::exception
{
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() BOOST_NOEXCEPT_OR_NOTHROW
{
}
private:
template <class E>
void
add_original_type( E const & e )
{
#ifndef BOOST_NO_RTTI
(*this) << original_exception_type(&typeid(e));
#endif
}
};
#if defined(__GNUC__)
# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
# pragma GCC visibility pop
# endif
#endif
namespace
exception_detail
{
template <class T>
class
current_exception_std_exception_wrapper:
public T,
public boost::exception
{
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() BOOST_NOEXCEPT_OR_NOTHROW
{
}
private:
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>
boost::exception const *
get_boost_exception( T const * )
{
try
{
throw;
}
catch(
boost::exception & x )
{
return &x;
}
catch(...)
{
return 0;
}
}
#else
template <class T>
boost::exception const *
get_boost_exception( T const * x )
{
return dynamic_cast<boost::exception const *>(x);
}
#endif
template <class T>
inline
exception_ptr
current_exception_std_exception( T const & e1 )
{
if( boost::exception const * e2 = get_boost_exception(&e1) )
return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1,*e2));
else
return boost::copy_exception(current_exception_std_exception_wrapper<T>(e1));
}
inline
exception_ptr
current_exception_unknown_exception()
{
return boost::copy_exception(unknown_exception());
}
inline
exception_ptr
current_exception_unknown_boost_exception( boost::exception const & e )
{
return boost::copy_exception(unknown_exception(e));
}
inline
exception_ptr
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 boost::copy_exception(unknown_exception(e));
}
inline
exception_ptr
current_exception_impl()
{
exception_detail::clone_base const * e=0;
switch(
exception_detail::clone_current_exception(e) )
{
case exception_detail::clone_current_exception_result::
success:
{
BOOST_ASSERT(e!=0);
return exception_ptr(shared_ptr<exception_detail::clone_base const>(e));
}
case exception_detail::clone_current_exception_result::
bad_alloc:
{
BOOST_ASSERT(!e);
return exception_detail::exception_ptr_static_exception_object<bad_alloc_>::e;
}
case exception_detail::clone_current_exception_result::
bad_exception:
{
BOOST_ASSERT(!e);
return exception_detail::exception_ptr_static_exception_object<bad_exception_>::e;
}
default:
BOOST_ASSERT(0);
case exception_detail::clone_current_exception_result::
not_supported:
{
BOOST_ASSERT(!e);
try
{
throw;
}
catch(
exception_detail::clone_base & e )
{
return exception_ptr(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);
}
#ifdef BOOST_NO_CXX11_HDR_EXCEPTION
// this case can be handled losslesly with std::current_exception() (see below)
catch(
std::exception & e )
{
return exception_detail::current_exception_unknown_std_exception(e);
}
#endif
catch(
boost::exception & e )
{
return exception_detail::current_exception_unknown_boost_exception(e);
}
catch(
... )
{
#ifndef BOOST_NO_CXX11_HDR_EXCEPTION
try
{
return exception_ptr(std::current_exception());
}
catch(
...)
{
return exception_detail::current_exception_unknown_exception();
}
#else
return exception_detail::current_exception_unknown_exception();
#endif
}
}
}
}
}
inline
exception_ptr
current_exception()
{
exception_ptr ret;
try
{
ret=exception_detail::current_exception_impl();
}
catch(
std::bad_alloc & )
{
ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_alloc_>::e;
}
catch(
... )
{
ret=exception_detail::exception_ptr_static_exception_object<exception_detail::bad_exception_>::e;
}
BOOST_ASSERT(ret);
return ret;
}
#endif // ifndef BOOST_NO_EXCEPTIONS
namespace
exception_detail
{
inline
void
rethrow_exception_( exception_ptr const & p )
{
BOOST_ASSERT(p);
#if defined( BOOST_NO_CXX11_HDR_EXCEPTION ) || defined( BOOST_NO_EXCEPTIONS )
p.ptr_->rethrow();
#else
try
{
p.ptr_->rethrow();
}
catch(
std_exception_ptr_wrapper const & wrp)
{
// if an std::exception_ptr was wrapped above then rethrow it
std::rethrow_exception(wrp.p);
}
#endif
}
}
BOOST_NORETURN
inline
void
rethrow_exception( exception_ptr const & p )
{
exception_detail::rethrow_exception_(p);
BOOST_ASSERT(0);
#if defined(UNDER_CE)
// some CE platforms don't define ::abort()
exit(-1);
#else
abort();
#endif
}
inline
std::string
diagnostic_information( exception_ptr const & p, bool verbose=true )
{
if( p )
#ifdef BOOST_NO_EXCEPTIONS
return "<unavailable> due to BOOST_NO_EXCEPTIONS";
#else
try
{
rethrow_exception(p);
}
catch(
... )
{
return current_exception_diagnostic_information(verbose);
}
#endif
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

66
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/detail/is_output_streamable.hpp vendored Executable file
View File

@@ -0,0 +1,66 @@
//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 BOOST_EXCEPTION_898984B4076411DD973EDFA055D89593
#define BOOST_EXCEPTION_898984B4076411DD973EDFA055D89593
#include <ostream>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
namespace
boost
{
namespace
to_string_detail
{
struct
partial_ordering_helper1
{
template <class CharT,class Traits>
partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
};
struct
partial_ordering_helper2
{
template <class T>
partial_ordering_helper2( T const & );
};
char operator<<( partial_ordering_helper1, partial_ordering_helper2 );
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

56
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/detail/object_hex_dump.hpp vendored Executable file
View File

@@ -0,0 +1,56 @@
//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 BOOST_EXCEPTION_6F463AC838DF11DDA3E6909F56D89593
#define BOOST_EXCEPTION_6F463AC838DF11DDA3E6909F56D89593
#include <boost/exception/detail/type_info.hpp>
#include <iomanip>
#include <ios>
#include <string>
#include <sstream>
#include <cstdlib>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
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

17
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/detail/shared_ptr.hpp vendored Executable file
View File

@@ -0,0 +1,17 @@
//Copyright (c) 2006-2008 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 BOOST_EXCEPTION_837060E885AF11E68DA91D15E31AC075
#define BOOST_EXCEPTION_837060E885AF11E68DA91D15E31AC075
#ifdef BOOST_EXCEPTION_MINI_BOOST
#include <memory>
namespace boost { namespace exception_detail { using std::shared_ptr; } }
#else
#include <boost/shared_ptr.hpp>
namespace boost { namespace exception_detail { using boost::shared_ptr; } }
#endif
#endif

88
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/detail/type_info.hpp vendored Executable file
View File

@@ -0,0 +1,88 @@
//Copyright (c) 2006-2010 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 BOOST_EXCEPTION_C3E1741C754311DDB2834CCA55D89593
#define BOOST_EXCEPTION_C3E1741C754311DDB2834CCA55D89593
#include <boost/config.hpp>
#include <boost/core/typeinfo.hpp>
#include <boost/core/demangle.hpp>
#include <boost/current_function.hpp>
#include <string>
#include <string.h>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
namespace
boost
{
template <class T>
inline
std::string
tag_type_name()
{
#ifdef BOOST_NO_TYPEID
return BOOST_CURRENT_FUNCTION;
#else
return core::demangle(typeid(T*).name());
#endif
}
template <class T>
inline
std::string
type_name()
{
#ifdef BOOST_NO_TYPEID
return BOOST_CURRENT_FUNCTION;
#else
return core::demangle(typeid(T).name());
#endif
}
namespace
exception_detail
{
struct
type_info_
{
core::typeinfo const * type_;
explicit
type_info_( core::typeinfo const & type ):
type_(&type)
{
}
friend
bool
operator<( type_info_ const & a, type_info_ const & b )
{
return a.type_!=b.type_ && strcmp(a.type_->name(), b.type_->name()) < 0;
}
};
}
}
#define BOOST_EXCEPTION_STATIC_TYPEID(T) ::boost::exception_detail::type_info_(BOOST_CORE_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

213
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/diagnostic_information.hpp vendored Executable file
View File

@@ -0,0 +1,213 @@
//Copyright (c) 2006-2010 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 BOOST_EXCEPTION_0552D49838DD11DD90146B8956D89593
#define BOOST_EXCEPTION_0552D49838DD11DD90146B8956D89593
#include <boost/config.hpp>
#include <boost/exception/get_error_info.hpp>
#include <boost/exception/info.hpp>
#include <boost/utility/enable_if.hpp>
#ifndef BOOST_NO_RTTI
#include <boost/core/demangle.hpp>
#endif
#include <exception>
#include <sstream>
#include <string>
#ifndef BOOST_NO_EXCEPTIONS
#include <boost/exception/current_exception_cast.hpp>
#endif
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
#ifndef BOOST_NO_EXCEPTIONS
namespace
boost
{
namespace
exception_detail
{
std::string diagnostic_information_impl( boost::exception const *, std::exception const *, bool, bool );
}
inline
std::string
current_exception_diagnostic_information( bool verbose=true)
{
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,verbose);
#if defined(__GLIBCXX__) && __cplusplus >= 201103L && !defined(BOOST_NO_RTTI)
else if (auto* p=std::current_exception().__cxa_exception_type())
return "Dynamic exception type: "+boost::core::demangle(p->name());
#endif
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 )
{
#ifndef BOOST_NO_EXCEPTIONS
try
{
#endif
error_info_container * c=x.data_.get();
if( !c )
x.data_.adopt(c=new exception_detail::error_info_container_impl);
char const * di=c->diagnostic_information(header);
BOOST_ASSERT(di!=0);
return di;
#ifndef BOOST_NO_EXCEPTIONS
}
catch(...)
{
return 0;
}
#endif
}
inline
std::string
diagnostic_information_impl( boost::exception const * be, std::exception const * se, bool with_what, bool verbose )
{
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 && verbose )
{
char const * const * f=get_error_info<throw_file>(*be);
int const * l=get_error_info<throw_line>(*be);
char const * const * fn=get_error_info<throw_function>(*be);
if( !f && !l && !fn )
tmp << "Throw location unknown (consider using BOOST_THROW_EXCEPTION)\n";
else
{
if( f )
{
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
if ( verbose )
tmp << std::string("Dynamic exception type: ") <<
core::demangle((be?(BOOST_EXCEPTION_DYNAMIC_TYPEID(*be)):(BOOST_EXCEPTION_DYNAMIC_TYPEID(*se))).type_->name()) << '\n';
#endif
if( with_what && se && verbose )
tmp << "std::exception::what: " << (wh ? wh : "(null)") << '\n';
if( be )
if( char const * s=exception_detail::get_diagnostic_information(*be,tmp.str().c_str()) )
if( *s )
return std::string(s);
return tmp.str();
}
}
template <class T>
std::string
diagnostic_information( T const & e, bool verbose=true )
{
return exception_detail::diagnostic_information_impl(exception_detail::get_boost_exception(&e),exception_detail::get_std_exception(&e),true,verbose);
}
inline
char const *
diagnostic_information_what( exception const & e, bool verbose=true ) BOOST_NOEXCEPT_OR_NOTHROW
{
char const * w=0;
#ifndef BOOST_NO_EXCEPTIONS
try
{
#endif
(void) exception_detail::diagnostic_information_impl(&e,0,false,verbose);
if( char const * di=exception_detail::get_diagnostic_information(e,0) )
return di;
else
return "Failed to produce boost::diagnostic_information_what()";
#ifndef BOOST_NO_EXCEPTIONS
}
catch(
... )
{
}
#endif
return w;
}
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
#endif

11
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/enable_current_exception.hpp vendored Executable file
View File

@@ -0,0 +1,11 @@
//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 BOOST_EXCEPTION_851700A4F7CF11E6B2EE06DD14915323
#define BOOST_EXCEPTION_851700A4F7CF11E6B2EE06DD14915323
#include <boost/exception/exception.hpp>
#endif

11
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/enable_error_info.hpp vendored Executable file
View File

@@ -0,0 +1,11 @@
//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 BOOST_EXCEPTION_A0F7404AF7CF11E6908227DD14915323
#define BOOST_EXCEPTION_A0F7404AF7CF11E6908227DD14915323
#include <boost/exception/exception.hpp>
#endif

22
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_api_function.hpp vendored Executable file
View File

@@ -0,0 +1,22 @@
//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 BOOST_EXCEPTION_DDFBB4546C1211DEA4659E9055D89593
#define BOOST_EXCEPTION_DDFBB4546C1211DEA4659E9055D89593
#include <boost/exception/error_info.hpp>
namespace
boost
{
//Usage hint:
//if( api_function(....)!=0 )
// BOOST_THROW_EXCEPTION(
// failure() <<
// errinfo_api_function("api_function") );
typedef error_info<struct errinfo_api_function_,char const *> errinfo_api_function;
}
#endif

18
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_at_line.hpp vendored Executable file
View File

@@ -0,0 +1,18 @@
//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 BOOST_EXCEPTION_E7255CE26C1211DE85800C9155D89593
#define BOOST_EXCEPTION_E7255CE26C1211DE85800C9155D89593
namespace
boost
{
template <class Tag,class T> class error_info;
//Use with parsing errors exceptions, for example in a XML file parser.
typedef error_info<struct errinfo_at_line_,int> errinfo_at_line;
}
#endif

51
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_errno.hpp vendored Executable file
View File

@@ -0,0 +1,51 @@
//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 BOOST_EXCEPTION_F0EE17BE6C1211DE87FF459155D89593
#define BOOST_EXCEPTION_F0EE17BE6C1211DE87FF459155D89593
#include <boost/exception/info.hpp>
#include <errno.h>
#include <string.h>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#pragma warning(disable:4996)
#endif
#endif
namespace
boost
{
typedef error_info<struct errinfo_errno_,int> errinfo_errno;
//Usage hint:
//if( c_function(....)!=0 )
// BOOST_THROW_EXCEPTION(
// failure() <<
// errinfo_errno(errno) <<
// errinfo_api_function("c_function") );
inline
std::string
to_string( errinfo_errno const & e )
{
std::ostringstream tmp;
int v=e.value();
tmp << '[' << error_info_name(e) << "] = " << v << ", \"" << strerror(v) << "\"\n";
return tmp.str();
}
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
#endif

20
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_file_handle.hpp vendored Executable file
View File

@@ -0,0 +1,20 @@
//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 BOOST_EXCEPTION_F79E6EE26C1211DEB26E929155D89593
#define BOOST_EXCEPTION_F79E6EE26C1211DEB26E929155D89593
#include <stdio.h>
namespace
boost
{
template <class> class weak_ptr;
template <class Tag,class T> class error_info;
typedef error_info<struct errinfo_file_handle_,weak_ptr<FILE> > errinfo_file_handle;
}
#endif

26
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_file_name.hpp vendored Executable file
View File

@@ -0,0 +1,26 @@
//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 BOOST_EXCEPTION_FEE5120A6C1211DE94E8BC9155D89593
#define BOOST_EXCEPTION_FEE5120A6C1211DE94E8BC9155D89593
#include <string>
namespace
boost
{
template <class Tag,class T> class error_info;
//Usage hint:
//FILE * f=fopen(name,mode);
//if( !f )
// BOOST_THROW_EXCEPTION(
// file_open_error() <<
// errinfo_file_name(name) <<
// errinfo_file_open_mode(mode) );
typedef error_info<struct errinfo_file_name_,std::string> errinfo_file_name;
}
#endif

26
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_file_open_mode.hpp vendored Executable file
View File

@@ -0,0 +1,26 @@
//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 BOOST_EXCEPTION_056F1F266C1311DE8E74299255D89593
#define BOOST_EXCEPTION_056F1F266C1311DE8E74299255D89593
#include <string>
namespace
boost
{
template <class Tag,class T> class error_info;
//Usage hint:
//FILE * f=fopen(name,mode);
//if( !f )
// BOOST_THROW_EXCEPTION(
// file_open_error() <<
// errinfo_file_name(name) <<
// errinfo_file_open_mode(mode) );
typedef error_info<struct errinfo_file_open_mode_,std::string> errinfo_file_open_mode;
}
#endif

18
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_nested_exception.hpp vendored Executable file
View File

@@ -0,0 +1,18 @@
//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 BOOST_EXCEPTION_45CC9A82B77511DEB330FC4956D89593
#define BOOST_EXCEPTION_45CC9A82B77511DEB330FC4956D89593
namespace
boost
{
namespace exception_detail { class clone_base; }
template <class Tag,class T> class error_info;
class exception_ptr;
typedef error_info<struct errinfo_nested_exception_,exception_ptr> errinfo_nested_exception;
}
#endif

23
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/errinfo_type_info_name.hpp vendored Executable file
View File

@@ -0,0 +1,23 @@
//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 BOOST_EXCEPTION_0E11109E6C1311DEB7EA649255D89593
#define BOOST_EXCEPTION_0E11109E6C1311DEB7EA649255D89593
#include <string>
namespace
boost
{
template <class Tag,class T> class error_info;
//Usage hint:
//BOOST_THROW_EXCEPTION(
// bad_type() <<
// errinfo_type_info_name(typeid(x).name()) );
typedef error_info<struct errinfo_type_info_name_,std::string> errinfo_type_info_name;
}
#endif

9
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/error_info.hpp vendored Executable file
View File

@@ -0,0 +1,9 @@
//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 BOOST_EXCEPTION_EE7ECCA0433B11E1923E37064924019B
#define BOOST_EXCEPTION_EE7ECCA0433B11E1923E37064924019B
namespace boost { template <class Tag,class T> class error_info; }
#endif

138
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/get_error_info.hpp vendored Executable file
View File

@@ -0,0 +1,138 @@
//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 BOOST_EXCEPTION_1A590226753311DD9E4CCF6156D89593
#define BOOST_EXCEPTION_1A590226753311DD9E4CCF6156D89593
#include <boost/config.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/detail/error_info_impl.hpp>
#include <boost/exception/detail/type_info.hpp>
#include <boost/exception/detail/shared_ptr.hpp>
#include <boost/assert.hpp>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
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

279
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/info.hpp vendored Executable file
View File

@@ -0,0 +1,279 @@
//Copyright (c) 2006-2010 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 BOOST_EXCEPTION_8D22C4CA9CC811DCAA9133D256D89593
#define BOOST_EXCEPTION_8D22C4CA9CC811DCAA9133D256D89593
#include <boost/config.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/to_string_stub.hpp>
#include <boost/exception/detail/error_info_impl.hpp>
#include <boost/exception/detail/shared_ptr.hpp>
#include <map>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
namespace
boost
{
template <class Tag,class T>
inline
std::string
error_info_name( error_info<Tag,T> const & )
{
return tag_type_name<Tag>();
}
template <class Tag,class T>
inline
std::string
to_string( error_info<Tag,T> const & x )
{
return '[' + error_info_name(x) + "] = " + to_string_stub(x.value()) + '\n';
}
template <class Tag,class T>
inline
std::string
error_info<Tag,T>::
name_value_string() const
{
return to_string_stub(*this);
}
namespace
exception_detail
{
class
error_info_container_impl BOOST_FINAL:
public error_info_container
{
public:
error_info_container_impl():
count_(0)
{
}
~error_info_container_impl() BOOST_NOEXCEPT_OR_NOTHROW
{
}
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;
return p;
}
return shared_ptr<error_info_base>();
}
char const *
diagnostic_information( char const * header ) const
{
if( header )
{
std::ostringstream tmp;
tmp << header;
for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
{
error_info_base const & x = *i->second;
tmp << x.name_value_string();
}
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_;
error_info_container_impl( error_info_container_impl const & );
error_info_container_impl & operator=( error_info_container const & );
void
add_ref() const
{
++count_;
}
bool
release() const
{
if( --count_ )
return false;
else
{
delete this;
return true;
}
}
refcount_ptr<error_info_container>
clone() const
{
refcount_ptr<error_info_container> p;
error_info_container_impl * c=new error_info_container_impl;
p.adopt(c);
for( error_info_map::const_iterator i=info_.begin(),e=info_.end(); i!=e; ++i )
{
shared_ptr<error_info_base> cp(i->second->clone());
c->info_.insert(std::make_pair(i->first,cp));
}
return p;
}
};
template <class E,class Tag,class T>
inline
E const &
set_info( 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;
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class E,class Tag,class T>
E const & set_info( E const &, error_info<Tag,T> && );
template <class T>
struct set_info_rv;
template <class Tag,class T>
struct
set_info_rv<error_info<Tag,T> >
{
template <class E,class Tag1,class T1>
friend E const & set_info( E const &, error_info<Tag1,T1> && );
template <class E>
static
E const &
set( E const & x, error_info<Tag,T> && v )
{
typedef error_info<Tag,T> error_info_tag_t;
shared_ptr<error_info_tag_t> p( new error_info_tag_t(std::move(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;
}
};
template <>
struct
set_info_rv<throw_function>
{
template <class E,class Tag1,class T1>
friend E const & set_info( E const &, error_info<Tag1,T1> && );
template <class E>
static
E const &
set( E const & x, throw_function && y )
{
x.throw_function_=y.v_;
return x;
}
};
template <>
struct
set_info_rv<throw_file>
{
template <class E,class Tag1,class T1>
friend E const & set_info( E const &, error_info<Tag1,T1> && );
template <class E>
static
E const &
set( E const & x, throw_file && y )
{
x.throw_file_=y.v_;
return x;
}
};
template <>
struct
set_info_rv<throw_line>
{
template <class E,class Tag1,class T1>
friend E const & set_info( E const &, error_info<Tag1,T1> && );
template <class E>
static
E const &
set( E const & x, throw_line && y )
{
x.throw_line_=y.v_;
return x;
}
};
template <class E,class Tag,class T>
inline
E const &
set_info( E const & x, error_info<Tag,T> && v )
{
return set_info_rv<error_info<Tag,T> >::template set<E>(x,std::move(v));
}
#endif
template <class T>
struct
derives_boost_exception
{
enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
};
}
template <class E,class Tag,class T>
inline
typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
operator<<( E const & x, error_info<Tag,T> const & v )
{
return exception_detail::set_info(x,v);
}
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <class E,class Tag,class T>
inline
typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
operator<<( E const & x, error_info<Tag,T> && v )
{
return exception_detail::set_info(x,std::move(v));
}
#endif
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
#endif

106
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/info_tuple.hpp vendored Executable file
View File

@@ -0,0 +1,106 @@
//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 BOOST_EXCEPTION_63EE924290FB11DC87BB856555D89593
#define BOOST_EXCEPTION_63EE924290FB11DC87BB856555D89593
#include <boost/exception/info.hpp>
#include <boost/tuple/tuple.hpp>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
namespace
boost
{
template <
class E >
inline
E const &
operator<<(
E const & x,
tuple< > const & v )
{
return x;
}
template <
class E,
class Tag1,class T1 >
inline
E const &
operator<<(
E const & x,
tuple<
error_info<Tag1,T1> > const & v )
{
return x << v.template get<0>();
}
template <
class E,
class Tag1,class T1,
class Tag2,class T2 >
inline
E const &
operator<<(
E const & x,
tuple<
error_info<Tag1,T1>,
error_info<Tag2,T2> > const & v )
{
return x << v.template get<0>() << v.template get<1>();
}
template <
class E,
class Tag1,class T1,
class Tag2,class T2,
class Tag3,class T3 >
inline
E const &
operator<<(
E const & x,
tuple<
error_info<Tag1,T1>,
error_info<Tag2,T2>,
error_info<Tag3,T3> > const & v )
{
return x << v.template get<0>() << v.template get<1>() << v.template get<2>();
}
template <
class E,
class Tag1,class T1,
class Tag2,class T2,
class Tag3,class T3,
class Tag4,class T4 >
inline
E const &
operator<<(
E const & x,
tuple<
error_info<Tag1,T1>,
error_info<Tag2,T2>,
error_info<Tag3,T3>,
error_info<Tag4,T4> > const & v )
{
return x << v.template get<0>() << v.template get<1>() << v.template get<2>() << v.template get<3>();
}
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
#endif

94
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/to_string.hpp vendored Executable file
View File

@@ -0,0 +1,94 @@
//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 BOOST_EXCEPTION_7E48761AD92811DC9011477D56D89593
#define BOOST_EXCEPTION_7E48761AD92811DC9011477D56D89593
#include <boost/utility/enable_if.hpp>
#include <boost/exception/detail/is_output_streamable.hpp>
#include <sstream>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
namespace
boost
{
template <class T,class U>
std::string to_string( std::pair<T,U> const & );
std::string to_string( std::exception const & );
namespace
to_string_detail
{
template <class T>
typename disable_if<is_output_streamable<T>,char>::type to_string( T const & );
using boost::to_string;
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

123
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception/to_string_stub.hpp vendored Executable file
View File

@@ -0,0 +1,123 @@
//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 BOOST_EXCEPTION_E788439ED9F011DCB181F25B55D89593
#define BOOST_EXCEPTION_E788439ED9F011DCB181F25B55D89593
#include <boost/exception/to_string.hpp>
#include <boost/exception/detail/object_hex_dump.hpp>
#include <boost/assert.hpp>
#ifndef BOOST_EXCEPTION_ENABLE_WARNINGS
#if __GNUC__*100+__GNUC_MINOR__>301
#pragma GCC system_header
#endif
#ifdef __clang__
#pragma clang system_header
#endif
#ifdef _MSC_VER
#pragma warning(push,1)
#endif
#endif
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);
}
template <class T,class U,class Stub>
inline
std::string
to_string_stub( std::pair<T,U> const & x, Stub s )
{
return std::string("(") + to_string_stub(x.first,s) + ',' + to_string_stub(x.second,s) + ')';
}
}
#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
#pragma warning(pop)
#endif
#endif

11
externals/vcpkg/packages/boost-exception_x64-windows/include/boost/exception_ptr.hpp vendored Executable file
View File

@@ -0,0 +1,11 @@
//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 BOOST_EXCEPTION_FA5836A2CADA11DC8CD47C8555D89593
#define BOOST_EXCEPTION_FA5836A2CADA11DC8CD47C8555D89593
#include <boost/exception/detail/exception_ptr.hpp>
#endif

BIN
externals/vcpkg/packages/boost-exception_x64-windows/lib/boost_exception-vc140-mt.lib vendored Executable file
View File

Binary file not shown.

23
externals/vcpkg/packages/boost-exception_x64-windows/share/boost-exception/copyright vendored Executable file
View File

@@ -0,0 +1,23 @@
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

4
externals/vcpkg/packages/boost-exception_x64-windows/share/boost-exception/usage vendored Executable file
View File

@@ -0,0 +1,4 @@
The package boost is compatible with built-in CMake targets:
find_package(Boost REQUIRED [COMPONENTS <libs>...])
target_link_libraries(main PRIVATE Boost::boost Boost::<lib1> Boost::<lib2> ...)

115
externals/vcpkg/packages/boost-exception_x64-windows/share/boost-exception/vcpkg.spdx.json vendored Executable file
View File

@@ -0,0 +1,115 @@
{
"$schema": "https://raw.githubusercontent.com/spdx/spdx-spec/v2.2.1/schemas/spdx-schema.json",
"spdxVersion": "SPDX-2.2",
"dataLicense": "CC0-1.0",
"SPDXID": "SPDXRef-DOCUMENT",
"documentNamespace": "https://spdx.org/spdxdocs/boost-exception-x64-windows-1.79.0-7ed81d15-bb9c-432f-839c-62c5e0f45f9f",
"name": "boost-exception:x64-windows@1.79.0 85c64552480492927af1bfcf8855c2846a3911ea0a33c44aa60d53731d787b0e",
"creationInfo": {
"creators": [
"Tool: vcpkg-9268e366206712e38102b28dbd1617697a99ff2e"
],
"created": "2022-07-23T08:23:12Z"
},
"relationships": [
{
"spdxElementId": "SPDXRef-port",
"relationshipType": "GENERATES",
"relatedSpdxElement": "SPDXRef-binary"
},
{
"spdxElementId": "SPDXRef-port",
"relationshipType": "CONTAINS",
"relatedSpdxElement": "SPDXRef-file-0"
},
{
"spdxElementId": "SPDXRef-port",
"relationshipType": "CONTAINS",
"relatedSpdxElement": "SPDXRef-file-1"
},
{
"spdxElementId": "SPDXRef-binary",
"relationshipType": "GENERATED_FROM",
"relatedSpdxElement": "SPDXRef-port"
},
{
"spdxElementId": "SPDXRef-file-0",
"relationshipType": "CONTAINED_BY",
"relatedSpdxElement": "SPDXRef-port"
},
{
"spdxElementId": "SPDXRef-file-1",
"relationshipType": "CONTAINED_BY",
"relatedSpdxElement": "SPDXRef-port"
},
{
"spdxElementId": "SPDXRef-file-1",
"relationshipType": "DEPENDENCY_MANIFEST_OF",
"relatedSpdxElement": "SPDXRef-port"
}
],
"packages": [
{
"name": "boost-exception",
"SPDXID": "SPDXRef-port",
"versionInfo": "1.79.0",
"downloadLocation": "NOASSERTION",
"homepage": "https://github.com/boostorg/exception",
"licenseConcluded": "BSL-1.0",
"licenseDeclared": "NOASSERTION",
"copyrightText": "NOASSERTION",
"description": "Boost exception module",
"comment": "This is the port (recipe) consumed by vcpkg."
},
{
"name": "boost-exception:x64-windows",
"SPDXID": "SPDXRef-binary",
"versionInfo": "85c64552480492927af1bfcf8855c2846a3911ea0a33c44aa60d53731d787b0e",
"downloadLocation": "NONE",
"licenseConcluded": "BSL-1.0",
"licenseDeclared": "NOASSERTION",
"copyrightText": "NOASSERTION",
"comment": "This is a binary package built by vcpkg."
},
{
"SPDXID": "SPDXRef-resource-1",
"name": "boostorg/exception",
"downloadLocation": "git+https://github.com/boostorg/exception@boost-1.79.0",
"licenseConcluded": "NOASSERTION",
"licenseDeclared": "NOASSERTION",
"copyrightText": "NOASSERTION",
"checksums": [
{
"algorithm": "SHA512",
"checksumValue": "a43b5b296f5af17ca447dd8ca5d89abbddf37969fef858f2d5966f57b336f5620b7e77ac5c99fe796d4440d66ecd376564c00b7936a5393a67045cbf148d520e"
}
]
}
],
"files": [
{
"fileName": "./portfile.cmake",
"SPDXID": "SPDXRef-file-0",
"checksums": [
{
"algorithm": "SHA256",
"checksumValue": "ef5efec2542963a9b6251ed29af22b0f72ca3c008e59c5da412cec559e09fed0"
}
],
"licenseConcluded": "NOASSERTION",
"copyrightText": "NOASSERTION"
},
{
"fileName": "./vcpkg.json",
"SPDXID": "SPDXRef-file-1",
"checksums": [
{
"algorithm": "SHA256",
"checksumValue": "5ad07be1fb1dcc01ba9c2f52b3b19d0f24d70cb5179801c1b13271926e2ac998"
}
],
"licenseConcluded": "NOASSERTION",
"copyrightText": "NOASSERTION"
}
]
}

22
externals/vcpkg/packages/boost-exception_x64-windows/share/boost-exception/vcpkg_abi_info.txt vendored Executable file
View File

@@ -0,0 +1,22 @@
boost-assert a50eed453b8be6c8932fb3d5f8feaf194a2ebeaed7982db4e36e3ba17f3ec107
boost-build ae2e04240d11929b681e289a0f6dd881454523061c007bfce13fdb89700330de
boost-config 797535e8975ed7cf5bbe11d9f7fe26caa5da8fe819888564758d82a21109fade
boost-core 498aea0b6b68bcfe1ec683e76c2f0d32477dfe9ba958f518980ff806b6faba90
boost-modular-build-helper 2a88f7e0b19495c5c387221437d68f0488f9ef0237f86b578a8560ce6e7192c2
boost-smart-ptr 38f44cf21554a20b78483abc4409c3edd633b78cc519fcf48803a1fe6b53316f
boost-throw-exception 4bb4a0182f0f071c3c1ffd9cbd82fbc3bc7db4a35346f930bbe504e7e3a94e0a
boost-tuple e6f7c6d1656fd8c39b8b9f32445599b1c69838c1cfeb99fca22a7bdab0d68eb7
boost-type-traits 74f62124585467fbb6c4fa16015164d11e1a079d6bdb70ec1c3fe7cf65b9a594
boost-vcpkg-helpers c81c7b003df356a1a120a7c0c2f5a2ac95f3c33b006a2a5b4c02dcf0c9f3deaa
cmake 3.23.2
features core
portfile.cmake ef5efec2542963a9b6251ed29af22b0f72ca3c008e59c5da412cec559e09fed0
ports.cmake 366c60b768113102408b32ac1d7c7b48ef7d30a477af2a220ecc222d9ffa3166
post_build_checks 2
powershell 7.2.5
triplet x64-windows
triplet_abi 4556164a2cd3dd6f4742101eabb46def7e71b6e5856faa88e5d005aac12a803c-c0600b35e024ce0485ed253ef5419f3686f7257cfb58cb6a24febcb600fc4b4c-27ebd443f77a6c449168adfa6ce8def60cf46e88
vcpkg-cmake 8a68341d77ea3fc25cc1a56db9e8d3a5f3cc851fed64c21e39dd6d26f8d28428
vcpkg.json 5ad07be1fb1dcc01ba9c2f52b3b19d0f24d70cb5179801c1b13271926e2ac998
vcpkg_from_git 0aab20e34e84d52ba4763f009e539bfa8f418c41c918c8cf700156f1a8551a10
vcpkg_from_github b743742296a114ea1b18ae99672e02f142c4eb2bef7f57d36c038bedbfb0502f