passenger 6.0.19 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/type_index.hpp

@@ -1,265 +0,0 @@
-//
-// Copyright 2012-2022 Antony Polukhin.
-//
-// 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_TYPE_INDEX_HPP
-#define BOOST_TYPE_INDEX_HPP
-
-/// \file boost/type_index.hpp
-/// \brief Includes minimal set of headers required to use the Boost.TypeIndex library.
-///
-/// By inclusion of this file most optimal type index classes will be included and used 
-/// as a boost::typeindex::type_index and boost::typeindex::type_info.
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-# pragma once
-#endif
-
-#if defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
-#   include BOOST_TYPE_INDEX_USER_TYPEINDEX
-#   ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#       pragma detect_mismatch( "boost__type_index__abi", "user defined type_index class is used: " BOOST_STRINGIZE(BOOST_TYPE_INDEX_USER_TYPEINDEX))
-#   endif
-#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
-#   include <boost/type_index/stl_type_index.hpp>
-#   if defined(BOOST_NO_RTTI) || defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)
-#       include <boost/type_index/detail/stl_register_class.hpp>
-#       ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#           pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - typeid() is used only for templates")
-#       endif
-#   else
-#       ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#           pragma detect_mismatch( "boost__type_index__abi", "RTTI is used")
-#       endif
-#   endif
-#else
-#   include <boost/type_index/ctti_type_index.hpp>
-#   include <boost/type_index/detail/ctti_register_class.hpp>
-#   ifdef BOOST_HAS_PRAGMA_DETECT_MISMATCH
-#       pragma detect_mismatch( "boost__type_index__abi", "RTTI is off - using CTTI")
-#   endif
-#endif
-
-#ifndef BOOST_TYPE_INDEX_REGISTER_CLASS
-#define BOOST_TYPE_INDEX_REGISTER_CLASS
-#endif
-
-namespace boost { namespace typeindex {
-
-#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-
-/// \def BOOST_TYPE_INDEX_FUNCTION_SIGNATURE
-/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is used by boost::typeindex::ctti_type_index class to
-/// deduce the name of a type. If your compiler is not recognized
-/// by the TypeIndex library and you wish to work with boost::typeindex::ctti_type_index, you may
-/// define this macro by yourself.
-///
-/// BOOST_TYPE_INDEX_FUNCTION_SIGNATURE must be defined to a compiler specific macro
-/// that outputs the \b whole function signature \b including \b template \b parameters.
-///
-/// If your compiler is not recognised and BOOST_TYPE_INDEX_FUNCTION_SIGNATURE is not defined,
-/// then a compile-time error will arise at any attempt to use boost::typeindex::ctti_type_index classes.
-///
-/// See BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS and BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
-/// for an information of how to tune the implementation to make a nice pretty_name() output.
-#define BOOST_TYPE_INDEX_FUNCTION_SIGNATURE BOOST_CURRENT_FUNCTION
-
-/// \def BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING
-/// This is a helper macro for making correct pretty_names() with RTTI off.
-///
-/// BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING macro may be defined to
-/// '(begin_skip, end_skip, runtime_skip, runtime_skip_until)' with parameters for adding a
-/// support for compilers, that by default are not recognized by TypeIndex library.
-///
-/// \b Example:
-///
-/// Imagine the situation when
-/// \code boost::typeindex::ctti_type_index::type_id<int>().pretty_name() \endcode
-/// returns the following string:
-/// \code "static const char *boost::detail::ctti<int>::n() [T = int]" \endcode
-/// and \code boost::typeindex::ctti_type_index::type_id<short>().pretty_name() \endcode returns the following:
-/// \code "static const char *boost::detail::ctti<short>::n() [T = short]" \endcode
-///
-/// As we may see first 39 characters are "static const char *boost::detail::ctti<" and they do not depend on
-/// the type T. After first 39 characters we have a human readable type name which is duplicated at the end
-/// of a string. String always ends on ']', which consumes 1 character.
-///
-/// Now if we define `BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING` to
-/// `(39, 1, false, "")` we'll be getting \code "int>::n() [T = int" \endcode
-/// for `boost::typeindex::ctti_type_index::type_id<int>().pretty_name()` and \code "short>::n() [T = short" \endcode
-/// for `boost::typeindex::ctti_type_index::type_id<short>().pretty_name()`.
-///
-/// Now we need to take additional care of the characters that go before the last mention of our type. We'll
-/// do that by telling the macro that we need to cut off everything that goes before the "T = " including the "T = "
-/// itself:
-///
-/// \code (39, 1, true, "T = ") \endcode
-///
-/// In case of GCC or Clang command line we need to add the following line while compiling all the sources:
-///
-/// \code
-/// -DBOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING='(39, 1, true, "T = ")'
-/// \endcode
-/// \param begin_skip How many characters must be skipped at the beginning of the type holding string.
-/// Must be a compile time constant.
-/// \param end_skip How many characters must be skipped at the end of the type holding string.
-/// Must be a compile time constant.
-/// \param runtime_skip Do we need additional checks at runtime to cut off the more characters.
-/// Must be `true` or `false`.
-/// \param runtime_skip_until Skip all the characters before the following string (including the string itself).
-/// Must be a compile time array of characters.
-///
-/// See [RTTI emulation limitations](boost_typeindex/rtti_emulation_limitations.html) for more info.
-#define BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING (0, 0, false, "")
-
-
-    /// Depending on a compiler flags, optimal implementation of type_index will be used 
-    /// as a default boost::typeindex::type_index.
-    ///
-    /// Could be a boost::typeindex::stl_type_index, boost::typeindex::ctti_type_index or 
-    /// user defined type_index class.
-    ///
-    /// \b See boost::typeindex::type_index_facade for a full description of type_index functions.
-    typedef platform_specific type_index;
-#elif defined(BOOST_TYPE_INDEX_USER_TYPEINDEX)
-    // Nothing to do
-#elif (!defined(BOOST_NO_RTTI) && !defined(BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY)) || defined(BOOST_MSVC)
-    typedef boost::typeindex::stl_type_index type_index;
-#else 
-    typedef boost::typeindex::ctti_type_index type_index;
-#endif
-
-/// Depending on a compiler flags, optimal implementation of type_info will be used 
-/// as a default boost::typeindex::type_info.
-///
-/// Could be a std::type_info, boost::typeindex::detail::ctti_data or 
-/// some user defined class.
-///
-/// type_info \b is \b not copyable or default constructible. It is \b not assignable too!
-typedef type_index::type_info_t type_info;
-
-#if defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-
-/// \def BOOST_TYPE_INDEX_USER_TYPEINDEX
-/// BOOST_TYPE_INDEX_USER_TYPEINDEX can be defined to the path to header file
-/// with user provided implementation of type_index.
-///
-/// See [Making a custom type_index](boost_typeindex/making_a_custom_type_index.html) section
-/// of documentation for usage example.
-#define BOOST_TYPE_INDEX_USER_TYPEINDEX <full/absolute/path/to/header/with/type_index.hpp>
-
-
-/// \def BOOST_TYPE_INDEX_REGISTER_CLASS
-/// BOOST_TYPE_INDEX_REGISTER_CLASS is used to help to emulate RTTI.
-/// Put this macro into the public section of polymorphic class to allow runtime type detection.
-///
-/// Depending on the typeid() availability this macro will expand to nothing or to virtual helper function
-/// `virtual const type_info& boost_type_info_type_id_runtime_() const noexcept`.
-///
-/// \b Example:
-/// \code
-/// class A {
-/// public:
-///     BOOST_TYPE_INDEX_REGISTER_CLASS
-///     virtual ~A(){}
-/// };
-///
-/// struct B: public A {
-///     BOOST_TYPE_INDEX_REGISTER_CLASS
-/// };
-///
-/// struct C: public B {
-///     BOOST_TYPE_INDEX_REGISTER_CLASS
-/// };
-///
-/// ...
-///
-/// C c1;
-/// A* pc1 = &c1;
-/// assert(boost::typeindex::type_id<C>() == boost::typeindex::type_id_runtime(*pc1));
-/// \endcode
-#define BOOST_TYPE_INDEX_REGISTER_CLASS nothing-or-some-virtual-functions
-
-/// \def BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
-/// BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY is a helper macro that must be defined if mixing
-/// RTTI on/off modules. See
-/// [Mixing sources with RTTI on and RTTI off](boost_typeindex/mixing_sources_with_rtti_on_and_.html)
-/// section of documentation for more info.
-#define BOOST_TYPE_INDEX_FORCE_NO_RTTI_COMPATIBILITY
-
-#endif // defined(BOOST_TYPE_INDEX_DOXYGEN_INVOKED)
-
-
-/// Function to get boost::typeindex::type_index for a type T.
-/// Removes const, volatile && and & modifiers from T.
-///
-/// \b Example:
-/// \code
-/// type_index ti = type_id<int&>();
-/// std::cout << ti.pretty_name();  // Outputs 'int'
-/// \endcode
-///
-/// \tparam T Type for which type_index must be created.
-/// \throw Nothing.
-/// \return boost::typeindex::type_index with information about the specified type T.
-template <class T>
-inline type_index type_id() BOOST_NOEXCEPT {
-    return type_index::type_id<T>();
-}
-
-/// Function for constructing boost::typeindex::type_index instance for type T. 
-/// Does not remove const, volatile, & and && modifiers from T.
-///
-/// If T has no const, volatile, & and && modifiers, then returns exactly 
-/// the same result as in case of calling `type_id<T>()`.
-///
-/// \b Example:
-/// \code
-/// type_index ti = type_id_with_cvr<int&>();
-/// std::cout << ti.pretty_name();  // Outputs 'int&'
-/// \endcode
-///
-/// \tparam T Type for which type_index must be created.
-/// \throw Nothing.
-/// \return boost::typeindex::type_index with information about the specified type T.
-template <class T>
-inline type_index type_id_with_cvr() BOOST_NOEXCEPT {
-    return type_index::type_id_with_cvr<T>();
-}
-
-/// Function that works exactly like C++ typeid(rtti_val) call, but returns boost::type_index.
-///
-/// Returns runtime information about specified type.
-///
-/// \b Requirements: RTTI available or Base and Derived classes must be marked with BOOST_TYPE_INDEX_REGISTER_CLASS.
-///
-/// \b Example:
-/// \code
-/// struct Base { virtual ~Base(){} };
-/// struct Derived: public Base  {};
-/// ...
-/// Derived d;
-/// Base& b = d;
-/// type_index ti = type_id_runtime(b);
-/// std::cout << ti.pretty_name();  // Outputs 'Derived'
-/// \endcode
-///
-/// \param runtime_val Variable which runtime type must be returned.
-/// \throw Nothing.
-/// \return boost::typeindex::type_index with information about the specified variable.
-template <class T>
-inline type_index type_id_runtime(const T& runtime_val) BOOST_NOEXCEPT {
-    return type_index::type_id_runtime(runtime_val);
-}
-
-}} // namespace boost::typeindex
-
-
-
-#endif // BOOST_TYPE_INDEX_HPP
-

data/src/cxx_supportlib/vendor-modified/boost/typeof/dmc/typeof_impl.hpp

@@ -1,100 +0,0 @@
-// Copyright (C) 2007 Peder Holt
-
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
-# define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
-
-# include <boost/config.hpp>
-# include <boost/config/workaround.hpp>
-# include <boost/typeof/constant.hpp>
-
-namespace boost
-{
-    namespace type_of
-    {
-
-        template<int N> struct encode_counter : encode_counter<N - 1> {};
-        template<> struct encode_counter<0> {};
-
-        char (*encode_index(...))[1];
-
-# define BOOST_TYPEOF_INDEX(T) (sizeof(*boost::type_of::encode_index((boost::type_of::encode_counter<1000>*)0)))
-# define BOOST_TYPEOF_NEXT_INDEX(next) friend char (*encode_index(encode_counter<next>*))[next];
-
-
-        //Typeof code
-
-        template<typename ID>
-        struct msvc_extract_type
-        {
-            struct id2type;
-        };
-
-        template<typename T, typename ID>
-        struct msvc_register_type : msvc_extract_type<ID>
-        {
-            typedef msvc_extract_type<ID> base_type;
-            struct base_type::id2type // This uses nice VC6.5 and VC7.1 bugfeature, also works for Digital Mars
-            {
-                typedef T type;
-            };
-        };
-
-
-        template<int ID>
-        struct msvc_typeid_wrapper {
-            typedef typename msvc_extract_type<constant<int,ID> >::id2type id2type;
-            typedef typename id2type::type type;
-        };
-
-        //Tie it all together
-        template<typename T>
-        struct encode_type
-        {
-            //Get the next available compile time constants index
-            BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
-            //Instantiate the template
-            typedef typename msvc_register_type<T,constant<int,value> >::id2type type;
-            //Set the next compile time constants index
-            BOOST_STATIC_CONSTANT(unsigned,next=value+1);
-            //Increment the compile time constant (only needed when extensions are not active
-            BOOST_TYPEOF_NEXT_INDEX(next);
-        };
-
-        template<class T>
-        struct sizer
-        {
-            typedef char(*type)[encode_type<T>::value];
-        };
-
-        template<typename T>
-            typename sizer<T>::type encode_start(T const&);
-
-        template<typename Organizer, typename T>
-        msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);
-
-# define BOOST_TYPEOF(expr) \
-    boost::type_of::msvc_typeid_wrapper<sizeof(*boost::type_of::encode_start(expr))>::type
-
-# define BOOST_TYPEOF_TPL(expr) typename BOOST_TYPEOF(expr)
-
-# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
-    struct name {\
-        BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr)));\
-        typedef typename boost::type_of::msvc_extract_type<name>::id2type id2type;\
-        typedef typename id2type::type type;\
-    };
-
-# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
-    struct name {\
-        BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr)));\
-        typedef boost::type_of::msvc_extract_type<name>::id2type id2type;\
-        typedef id2type::type type;\
-    };
-
-    }
-}
-
-#endif//BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/encode_decode.hpp

@@ -1,58 +0,0 @@
-// Copyright (C) 2004 Arkadiy Vertleyb
-
-// 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)
-
-// boostinspect:nounnamed
-
-#ifndef BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
-#define BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
-
-#ifndef BOOST_TYPEOF_SUPPRESS_UNNAMED_NAMESPACE
-
-#   define BOOST_TYPEOF_BEGIN_ENCODE_NS namespace { namespace boost_typeof {
-#   define BOOST_TYPEOF_END_ENCODE_NS }}
-#   define BOOST_TYPEOF_ENCODE_NS_QUALIFIER boost_typeof
-
-#else
-
-#   define BOOST_TYPEOF_BEGIN_ENCODE_NS namespace boost { namespace type_of {
-#   define BOOST_TYPEOF_END_ENCODE_NS }}
-#   define BOOST_TYPEOF_ENCODE_NS_QUALIFIER boost::type_of
-
-#   define BOOST_TYPEOF_TEXT "unnamed namespace is off"
-#   include <boost/typeof/message.hpp>
-
-#endif
-
-BOOST_TYPEOF_BEGIN_ENCODE_NS
-
-template<class V, class Type_Not_Registered_With_Typeof_System>
-struct encode_type_impl;
-
-template<class T, class Iter>
-struct decode_type_impl
-{
-    typedef int type;  // MSVC ETI workaround
-};
-
-template<class T>
-struct decode_nested_template_helper_impl;
-
-BOOST_TYPEOF_END_ENCODE_NS
-
-namespace boost { namespace type_of {
-
-    template<class V, class T>
-    struct encode_type : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::encode_type_impl<V, T>
-    {};
-
-    template<class Iter>
-    struct decode_type : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::decode_type_impl<
-        typename Iter::type,
-        typename Iter::next
-    >
-    {};
-}}
-
-#endif//BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/encode_decode_params.hpp

@@ -1,34 +0,0 @@
-// Copyright (C) 2005 Arkadiy Vertleyb
-// 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_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
-#define BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
-
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-
-// Assumes iter0 contains initial iterator
-
-#define BOOST_TYPEOF_DECODE_PARAM(z, n, text)   \
-    typedef boost::type_of::decode_type<iter##n> decode##n;     \
-    typedef typename decode##n::type p##n;      \
-    typedef typename decode##n::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
-
-#define BOOST_TYPEOF_DECODE_PARAMS(n)\
-    BOOST_PP_REPEAT(n, BOOST_TYPEOF_DECODE_PARAM, ~)
-
-// The P0, P1, ... PN are encoded and added to V 
-
-#define BOOST_TYPEOF_ENCODE_PARAMS_BEGIN(z, n, text)\
-    typename boost::type_of::encode_type<
-
-#define BOOST_TYPEOF_ENCODE_PARAMS_END(z, n, text)\
-    , BOOST_PP_CAT(P, n)>::type
-
-#define BOOST_TYPEOF_ENCODE_PARAMS(n, ID)                   \
-    BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_BEGIN, ~) \
-    typename boost::type_of::push_back<V, boost::type_of::constant<std::size_t,ID> >::type      \
-    BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_END, ~)
-
-#endif//BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/int_encoding.hpp

@@ -1,118 +0,0 @@
-// Copyright (C) 2004 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
-#define BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
-
-#include <boost/config.hpp>
-#include <boost/typeof/constant.hpp>
-#include <cstddef> // for std::size_t
-
-namespace boost { namespace type_of {
-
-    template<class T> struct get_unsigned
-    {
-        typedef T type;
-    };
-    template<> struct get_unsigned<signed char>
-    {
-        typedef unsigned char type;
-    };
-    template<> struct get_unsigned<char>
-    {
-        typedef unsigned char type;
-    };
-    template<> struct get_unsigned<short>
-    {
-        typedef unsigned short type;
-    };
-    template<> struct get_unsigned<int>
-    {
-        typedef unsigned int type;
-    };
-    template<> struct get_unsigned<long>
-    {
-        typedef unsigned long type;
-    };
-
-    //////////////////////////
-
-    template<std::size_t n, bool Overflow>
-    struct pack
-    {
-        BOOST_STATIC_CONSTANT(std::size_t , value=((n + 1) * 2 + (Overflow ? 1 : 0)));
-    };
-
-    template<std::size_t m>
-    struct unpack
-    {
-        BOOST_STATIC_CONSTANT(std::size_t, value = (m / 2) - 1);
-        BOOST_STATIC_CONSTANT(std::size_t, overflow = (m % 2 == 1));
-    };
-
-    ////////////////////////////////
-
-    template<class V, std::size_t n, bool overflow = (n >= 0x3fffffff)>
-    struct encode_size_t : push_back<
-        V,
-        boost::type_of::constant<std::size_t,pack<n, false>::value>
-    >
-    {};
-
-    template<class V, std::size_t n>
-    struct encode_size_t<V, n, true> : push_back<typename push_back<
-        V,
-        boost::type_of::constant<std::size_t,pack<n % 0x3ffffffe, true>::value> >::type,
-        boost::type_of::constant<std::size_t,n / 0x3ffffffe>
-    >
-    {};
-
-    template<class V, class T, T n>
-    struct encode_integral : encode_size_t< V, (typename get_unsigned<T>::type)n,(((typename get_unsigned<T>::type)n)>=0x3fffffff) >
-    {};
-
-    template<class V, bool b>
-    struct encode_integral<V, bool, b> : encode_size_t< V, b?1:0, false>
-    {};
-    ///////////////////////////
-
-    template<std::size_t n, class Iter, bool overflow>
-    struct decode_size_t;
-
-    template<std::size_t n, class Iter>
-    struct decode_size_t<n, Iter, false>
-    {
-        BOOST_STATIC_CONSTANT(std::size_t,value = n);
-        typedef Iter iter;
-    };
-
-    template<std::size_t n, class Iter>
-    struct decode_size_t<n, Iter, true>
-    {
-        BOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);
-
-        BOOST_STATIC_CONSTANT(std::size_t,value = (std::size_t)m * 0x3ffffffe + n);
-        typedef typename Iter::next iter;
-    };
-
-    template<class T, class Iter>
-    struct decode_integral
-    {
-        typedef decode_integral<T,Iter> self_t;
-        BOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);
-
-        BOOST_STATIC_CONSTANT(std::size_t,n = unpack<m>::value);
-
-        BOOST_STATIC_CONSTANT(std::size_t,overflow = unpack<m>::overflow);
-
-        typedef typename Iter::next nextpos;
-
-        static const T value = (T)(std::size_t)decode_size_t<n, nextpos, overflow>::value;
-
-        typedef typename decode_size_t<self_t::n, nextpos, self_t::overflow>::iter iter;
-    };
-
-}}//namespace
-
-#endif//BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/integral_template_param.hpp

@@ -1,80 +0,0 @@
-// Copyright (C) 2005 Arkadiy Vertleyb
-// 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_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
-#define BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED
-
-#define BOOST_TYPEOF_unsigned (unsigned)
-#define BOOST_TYPEOF_signed (signed)
-
-#define char_BOOST_TYPEOF (char)
-#define short_BOOST_TYPEOF (short)
-#define int_BOOST_TYPEOF (int)
-#define long_BOOST_TYPEOF (long)
-
-#define BOOST_TYPEOF_char_BOOST_TYPEOF (char)
-#define BOOST_TYPEOF_short_BOOST_TYPEOF (short)
-#define BOOST_TYPEOF_int_BOOST_TYPEOF (int)
-#define BOOST_TYPEOF_long_BOOST_TYPEOF (long)
-#define BOOST_TYPEOF_bool_BOOST_TYPEOF (bool)
-#define BOOST_TYPEOF_unsigned_BOOST_TYPEOF (unsigned)
-#define BOOST_TYPEOF_size_t_BOOST_TYPEOF (size_t)
-
-#define BOOST_TYPEOF_MAKE_OBJ_char          BOOST_TYPEOF_INTEGRAL_PARAM(char)
-#define BOOST_TYPEOF_MAKE_OBJ_short         BOOST_TYPEOF_INTEGRAL_PARAM(short)
-#define BOOST_TYPEOF_MAKE_OBJ_int           BOOST_TYPEOF_INTEGRAL_PARAM(int)
-#define BOOST_TYPEOF_MAKE_OBJ_long          BOOST_TYPEOF_INTEGRAL_PARAM(long)
-#define BOOST_TYPEOF_MAKE_OBJ_bool          BOOST_TYPEOF_INTEGRAL_PARAM(bool)
-#define BOOST_TYPEOF_MAKE_OBJ_unsigned      BOOST_TYPEOF_INTEGRAL_PARAM(unsigned)
-#define BOOST_TYPEOF_MAKE_OBJ_size_t        BOOST_TYPEOF_INTEGRAL_PARAM(size_t)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedchar  BOOST_TYPEOF_INTEGRAL_PARAM(unsigned char)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedshort BOOST_TYPEOF_INTEGRAL_PARAM(unsigned short)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedint   BOOST_TYPEOF_INTEGRAL_PARAM(unsigned int)
-#define BOOST_TYPEOF_MAKE_OBJ_unsignedlong  BOOST_TYPEOF_INTEGRAL_PARAM(unsigned long)
-#define BOOST_TYPEOF_MAKE_OBJ_signedchar    BOOST_TYPEOF_INTEGRAL_PARAM(signed char)
-#define BOOST_TYPEOF_MAKE_OBJ_signedshort   BOOST_TYPEOF_INTEGRAL_PARAM(signed short)
-#define BOOST_TYPEOF_MAKE_OBJ_signedint     BOOST_TYPEOF_INTEGRAL_PARAM(signed int)
-#define BOOST_TYPEOF_MAKE_OBJ_signedlong    BOOST_TYPEOF_INTEGRAL_PARAM(signed long)
-#define BOOST_TYPEOF_MAKE_OBJ_integral(x)   BOOST_TYPEOF_INTEGRAL_PARAM(x)
-
-#define BOOST_TYPEOF_INTEGRAL(X) integral(X) BOOST_TYPEOF_EAT
-#define BOOST_TYPEOF_EAT_BOOST_TYPEOF
-#define BOOST_TYPEOF_integral(X) (integral(X))
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM(Type)\
-    (INTEGRAL_PARAM)\
-    (Type)
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)\
-    BOOST_PP_SEQ_ELEM(1, Param)
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_EXPANDTYPE(Param)\
-    BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
-
-// INTEGRAL_PARAM "virtual functions" implementation
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_ENCODE(This, n)\
-    typedef typename boost::type_of::encode_integral<\
-        BOOST_PP_CAT(V, n),\
-        BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This),\
-        BOOST_PP_CAT(P, n)\
-    >::type BOOST_PP_CAT(V, BOOST_PP_INC(n)); 
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_DECODE(This, n)\
-    typedef boost::type_of::decode_integral<BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This), BOOST_PP_CAT(iter, n)> BOOST_PP_CAT(d, n);\
-    static const BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(This) BOOST_PP_CAT(P, n) = BOOST_PP_CAT(d, n)::value;\
-    typedef typename BOOST_PP_CAT(d, n)::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER(Param)\
-    (BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param))0
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_DECLARATION_TYPE(Param)\
-    BOOST_TYPEOF_INTEGRAL_PARAM_GETTYPE(Param)
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_PLACEHOLDER_TYPES(Param, n)\
-    BOOST_PP_CAT(T,n)
-
-#define BOOST_TYPEOF_INTEGRAL_PARAM_ISTEMPLATE 0
-
-#endif//BOOST_TYPEOF_INTEGRAL_TEMPLATE_PARAM_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/typeof/message.hpp

@@ -1,8 +0,0 @@
-// Copyright (C) 2005 Arkadiy Vertleyb
-// Use, modification and distribution is subject to the Boost Software
-// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)
-
-#if defined(_MSC_VER) && defined BOOST_TYPEOF_MESSAGES
-#    pragma message(BOOST_TYPEOF_TEXT)
-#endif
-#undef BOOST_TYPEOF_TEXT