diff options
author | Remko Tronçon <git@el-tramo.be> | 2010-03-28 15:46:49 (GMT) |
---|---|---|
committer | Remko Tronçon <git@el-tramo.be> | 2010-03-28 15:46:49 (GMT) |
commit | f53a1ef582494458301b97bf6e546be52d7ff7e8 (patch) | |
tree | 7571b5cbcbd8a8f1dd1c966c9045b6cb69f0e295 /3rdParty/Boost/src/boost/typeof/msvc | |
parent | 638345680d72ca6acaf123f2c8c1c391f696e371 (diff) | |
download | swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.zip swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.tar.bz2 |
Moving submodule contents back.
Diffstat (limited to '3rdParty/Boost/src/boost/typeof/msvc')
-rw-r--r-- | 3rdParty/Boost/src/boost/typeof/msvc/typeof_impl.hpp | 281 |
1 files changed, 281 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/typeof/msvc/typeof_impl.hpp b/3rdParty/Boost/src/boost/typeof/msvc/typeof_impl.hpp new file mode 100644 index 0000000..2f58c18 --- /dev/null +++ b/3rdParty/Boost/src/boost/typeof/msvc/typeof_impl.hpp @@ -0,0 +1,281 @@ + +// Copyright (C) 2005 Igor Chesnokov, mailto:ichesnokov@gmail.com (VC 6.5,VC 7.1 + counter code) +// Copyright (C) 2005-2007 Peder Holt (VC 7.0 + framework) +// Copyright (C) 2006 Steven Watanabe (VC 8.0) + +// 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/detail/workaround.hpp> +# include <boost/mpl/int.hpp> +# include <boost/type_traits/is_function.hpp> +# include <boost/utility/enable_if.hpp> + +# if BOOST_WORKAROUND(BOOST_MSVC,>=1310) +# include <typeinfo> +# endif + +namespace boost +{ + namespace type_of + { + + //Compile time constant code +# if BOOST_WORKAROUND(BOOST_MSVC,>=1300) && defined(_MSC_EXTENSIONS) + template<int N> struct the_counter; + + template<typename T,int N = 5/*for similarity*/> + struct encode_counter + { + __if_exists(the_counter<N + 256>) + { + BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 257>::count)); + } + __if_not_exists(the_counter<N + 256>) + { + __if_exists(the_counter<N + 64>) + { + BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 65>::count)); + } + __if_not_exists(the_counter<N + 64>) + { + __if_exists(the_counter<N + 16>) + { + BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 17>::count)); + } + __if_not_exists(the_counter<N + 16>) + { + __if_exists(the_counter<N + 4>) + { + BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 5>::count)); + } + __if_not_exists(the_counter<N + 4>) + { + __if_exists(the_counter<N>) + { + BOOST_STATIC_CONSTANT(unsigned,count=(encode_counter<T,N + 1>::count)); + } + __if_not_exists(the_counter<N>) + { + BOOST_STATIC_CONSTANT(unsigned,count=N); + typedef the_counter<N> type; + } + } + } + } + } + }; + +# define BOOST_TYPEOF_INDEX(T) (encode_counter<T>::count) +# define BOOST_TYPEOF_NEXT_INDEX(next) +# else + template<int N> struct encode_counter : encode_counter<N - 1> {}; + template<> struct encode_counter<0> {}; + + //Need to default to a larger value than 4, as due to MSVC's ETI errors. (sizeof(int)==4) + char (*encode_index(...))[5]; + +# define BOOST_TYPEOF_INDEX(T) (sizeof(*boost::type_of::encode_index((boost::type_of::encode_counter<1005>*)0))) +# define BOOST_TYPEOF_NEXT_INDEX(next) friend char (*encode_index(encode_counter<next>*))[next]; +# endif + + //Typeof code + +# if BOOST_WORKAROUND(BOOST_MSVC,==1300) + template<typename ID> + struct msvc_extract_type + { + template<bool> + struct id2type_impl; + + typedef id2type_impl<true> id2type; + }; + + template<typename T, typename ID> + struct msvc_register_type : msvc_extract_type<ID> + { + template<> + struct id2type_impl<true> //VC7.0 specific bugfeature + { + typedef T type; + }; + }; +#elif BOOST_WORKAROUND(BOOST_MSVC,>=1400) + struct msvc_extract_type_default_param {}; + + template<typename ID, typename T = msvc_extract_type_default_param> + struct msvc_extract_type; + + template<typename ID> + struct msvc_extract_type<ID, msvc_extract_type_default_param> { + template<bool> + struct id2type_impl; + + typedef id2type_impl<true> id2type; + }; + + template<typename ID, typename T> + struct msvc_extract_type : msvc_extract_type<ID,msvc_extract_type_default_param> + { + template<> + struct id2type_impl<true> //VC8.0 specific bugfeature + { + typedef T type; + }; + template<bool> + struct id2type_impl; + + typedef id2type_impl<true> id2type; + }; + + template<typename T, typename ID> + struct msvc_register_type : msvc_extract_type<ID, T> + { + }; +# else + 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 + { + typedef T type; + }; + }; +# endif +# if BOOST_WORKAROUND(BOOST_MSVC,==1310) + template<const std::type_info& ref_type_info> + struct msvc_typeid_wrapper { + typedef typename msvc_extract_type<msvc_typeid_wrapper>::id2type id2type; + typedef typename id2type::type wrapped_type; + typedef typename wrapped_type::type type; + }; + //This class is used for registering the type T. encode_type<T> is mapped against typeid(encode_type<T>). + //msvc_typeid_wrapper<typeid(encode_type<T>)> will now have a type typedef that equals encode_type<T>. + template<typename T> + struct encode_type + { + typedef encode_type<T> input_type; + //Invoke registration of encode_type<T>. typeid(encode_type<T>) is now mapped to encode_type<T>. Do not use registered_type for anything. + //The reason for registering encode_type<T> rather than T, is that VC handles typeid(function reference) poorly. By adding another + //level of indirection, we solve this problem. + typedef typename msvc_register_type<input_type,msvc_typeid_wrapper<typeid(input_type)> >::id2type registered_type; + typedef T type; + }; + + template<typename T> typename disable_if< + typename is_function<T>::type, + typename encode_type<T>::input_type>::type encode_start(T const&); + + template<typename T> typename enable_if< + typename is_function<T>::type, + typename encode_type<T>::input_type>::type encode_start(T&); + + template<typename Organizer, typename T> + msvc_register_type<T,Organizer> typeof_register_type(const T&); + + +# define BOOST_TYPEOF(expr) \ + boost::type_of::msvc_typeid_wrapper<typeid(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 {\ + enum {_typeof_register_value=sizeof(typeid(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 {\ + enum {_typeof_register_value=sizeof(typeid(boost::type_of::typeof_register_type<name>(expr)))};\ + typedef boost::type_of::msvc_extract_type<name>::id2type id2type;\ + typedef id2type::type type;\ +}; + +# else + template<int ID> + struct msvc_typeid_wrapper { + typedef typename msvc_extract_type<mpl::int_<ID> >::id2type id2type; + typedef typename id2type::type type; + }; + //Workaround for ETI-bug for VC6 and VC7 + template<> + struct msvc_typeid_wrapper<1> { + typedef msvc_typeid_wrapper<1> type; + }; + //Workaround for ETI-bug for VC7.1 + template<> + struct msvc_typeid_wrapper<4> { + typedef msvc_typeid_wrapper<4> 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,mpl::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]; + }; +# if BOOST_WORKAROUND(BOOST_MSVC,>=1310) + template<typename T> typename disable_if< + typename is_function<T>::type, + typename sizer<T>::type>::type encode_start(T const&); + + template<typename T> typename enable_if< + typename is_function<T>::type, + typename sizer<T>::type>::type encode_start(T&); +# else + template<typename T> + typename sizer<T>::type encode_start(T const&); +# endif + 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 + } +} + +#endif//BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED |