X-Git-Url: https://git.donarmstrong.com/?p=rsem.git;a=blobdiff_plain;f=boost%2Ftypeof%2Fmsvc%2Ftypeof_impl.hpp;fp=boost%2Ftypeof%2Fmsvc%2Ftypeof_impl.hpp;h=74ebc7073830661caa784caccb14d85944db9c2c;hp=0000000000000000000000000000000000000000;hb=2d71eb92104693ca9baa5a2e1c23eeca776d8fd3;hpb=da57529b92adbb7ae74a89861cb39fb35ac7c62d

diff --git a/boost/typeof/msvc/typeof_impl.hpp b/boost/typeof/msvc/typeof_impl.hpp
new file mode 100644
index 0000000..74ebc70
--- /dev/null
+++ b/boost/typeof/msvc/typeof_impl.hpp
@@ -0,0 +1,283 @@
+
+// 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
+// EAN: preprocess this block out on advice of Peder Holt
+// to eliminate errors in type_traits/common_type.hpp
+# if 0 //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