Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r86119 - in trunk/boost/parameter: . aux_
From: steveire_at_[hidden]
Date: 2013-10-01 04:48:50


Author: skelly
Date: 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013)
New Revision: 86119
URL: http://svn.boost.org/trac/boost/changeset/86119

Log:
Parameter: Remove obsolete MSVC version checks.

Text files modified:
   trunk/boost/parameter/aux_/arg_list.hpp | 27 +--------
   trunk/boost/parameter/aux_/parenthesized_type.hpp | 84 ------------------------------
   trunk/boost/parameter/aux_/unwrap_cv_reference.hpp | 6 --
   trunk/boost/parameter/binding.hpp | 30 ----------
   trunk/boost/parameter/keyword.hpp | 30 ----------
   trunk/boost/parameter/name.hpp | 19 +-----
   trunk/boost/parameter/preprocessor.hpp | 111 +--------------------------------------
   trunk/boost/parameter/value_type.hpp | 30 ----------
   8 files changed, 17 insertions(+), 320 deletions(-)

Modified: trunk/boost/parameter/aux_/arg_list.hpp
==============================================================================
--- trunk/boost/parameter/aux_/arg_list.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/aux_/arg_list.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -78,14 +78,11 @@
         };
     };
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     // Terminator for has_key, indicating that the keyword is unique
     template <class KW>
     static no_tag has_key(KW*);
-#endif
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
     // The overload set technique doesn't work with these older
     // compilers, so they need some explicit handholding.
@@ -149,11 +146,6 @@
     typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-template<class KW>
-no_tag operator*(empty_arg_list, KW*);
-#endif
-
 // Forward declaration for arg_list::operator,
 template <class KW, class T>
 struct tagged_argument;
@@ -227,24 +219,16 @@
     };
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
- friend yes_tag operator*(arg_list, key_type*);
-# define BOOST_PARAMETER_CALL_HAS_KEY(next, key) (*(next*)0 * (key*)0)
-# else
     // Overload for key_type, so the assert below will fire if the
     // same keyword is used again
     static yes_tag has_key(key_type*);
     using Next::has_key;
 
-# define BOOST_PARAMETER_CALL_HAS_KEY(next, key) next::has_key((key*)0)
-# endif
-
     BOOST_MPL_ASSERT_MSG(
- sizeof(BOOST_PARAMETER_CALL_HAS_KEY(Next,key_type)) == sizeof(no_tag)
+ sizeof(Next::has_key((key_type*)0)) == sizeof(no_tag)
       , duplicate_keyword, (key_type)
     );
 
-# undef BOOST_PARAMETER_CALL_HAS_KEY
 #endif
     //
     // Begin implementation of indexing operators for looking up
@@ -265,8 +249,7 @@
         return arg.value ? arg.value.get() : arg.value.construct(d.value);
     }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     // These older compilers don't support the overload set creation
     // idiom well, so we need to do all the return type calculation
     // for the compiler and dispatch through an outer function template
@@ -405,10 +388,6 @@
     typedef arg_list_tag tag; // For dispatching to sequence intrinsics
 };
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) // ETI workaround
-template <> struct arg_list<int,int> {};
-#endif
-
 // MPL sequence support
 template <class ArgumentPack>
 struct arg_list_iterator

Modified: trunk/boost/parameter/aux_/parenthesized_type.hpp
==============================================================================
--- trunk/boost/parameter/aux_/parenthesized_type.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/aux_/parenthesized_type.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -18,96 +18,12 @@
 template <class UnaryFunctionPointer>
 struct unaryfunptr_arg_type;
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-
 template <class Arg>
 struct unaryfunptr_arg_type<void(*)(Arg)>
 {
     typedef Arg type;
 };
 
-# else
-
-// Use the "native typeof" bugfeatures of older versions of MSVC to
-// accomplish what we'd normally do with partial specialization. This
-// capability was discovered by Igor Chesnokov.
-
-# if BOOST_WORKAROUND(BOOST_MSVC, != 1300)
-
-// This version applies to VC6.5 and VC7.1 (except that we can just
-// use partial specialization for the latter in this case).
-
-// This gets used as a base class.
-template<typename Address>
-struct msvc_type_memory
-{
- // A nullary metafunction that will yield the Value type "stored"
- // at this Address.
- struct storage;
-};
-
-template<typename Value, typename Address>
-struct msvc_store_type : msvc_type_memory<Address>
-{
- // VC++ somehow lets us define the base's nested storage
- // metafunction here, where we have the Value type we'd like to
- // "store" in it. Later we can come back to the base class and
- // extract the "stored type."
- typedef msvc_type_memory<Address> location;
- struct location::storage
- {
- typedef Value type;
- };
-};
-
-# else
-
-// This slightly more complicated version of the same thing is
-// required for msvc-7.0
-template<typename Address>
-struct msvc_type_memory
-{
- template<bool>
- struct storage_impl;
-
- typedef storage_impl<true> storage;
-};
-
-template<typename Value, typename Address>
-struct msvc_store_type : msvc_type_memory<Address>
-{
- // Rather than supplying a definition for the base class' nested
- // class, we specialize the base class' nested template
- template<>
- struct storage_impl<true>
- {
- typedef Value type;
- };
-};
-
-# endif
-
-// Function template argument deduction does many of the same things
-// as type matching during partial specialization, so we call a
-// function template to "store" T into the type memory addressed by
-// void(*)(T).
-template <class T>
-msvc_store_type<T,void(*)(T)>
-msvc_store_argument_type(void(*)(T));
-
-template <class FunctionPointer>
-struct unaryfunptr_arg_type
-{
- // We don't want the function to be evaluated, just instantiated,
- // so protect it inside of sizeof.
- enum { dummy = sizeof(msvc_store_argument_type((FunctionPointer)0)) };
-
- // Now pull the type out of the instantiated base class
- typedef typename msvc_type_memory<FunctionPointer>::storage::type type;
-};
-
-# endif
-
 template <>
 struct unaryfunptr_arg_type<void(*)(void)>
 {

Modified: trunk/boost/parameter/aux_/unwrap_cv_reference.hpp
==============================================================================
--- trunk/boost/parameter/aux_/unwrap_cv_reference.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/aux_/unwrap_cv_reference.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -44,12 +44,6 @@
     value> type;
 };
 
-#if BOOST_WORKAROUND(MSVC, == 1200)
-template <>
-struct is_cv_reference_wrapper<int>
- : mpl::false_ {};
-#endif
-
 // Needed for unwrap_cv_reference below. T might be const, so
 // eval_if might fail because of deriving from T const on EDG.
 template <class T>

Modified: trunk/boost/parameter/binding.hpp
==============================================================================
--- trunk/boost/parameter/binding.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/binding.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -11,18 +11,13 @@
 # include <boost/parameter/aux_/void.hpp>
 # include <boost/type_traits/is_same.hpp>
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# include <boost/mpl/eval_if.hpp>
-# endif
-
 namespace boost { namespace parameter {
 
 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword. If no such
 // parameter has been specified, returns Default
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template <class Parameters, class Keyword, class Default>
 struct binding0
 {
@@ -40,14 +35,9 @@
 # endif
 
 template <class Parameters, class Keyword, class Default = void_>
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 struct binding
-# else
-struct binding_eti
-# endif
 {
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     typedef typename mpl::eval_if<
         mpl::is_placeholder<Parameters>
       , mpl::identity<int>
@@ -66,24 +56,8 @@
     ));
 # endif
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
-# endif
-};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-template <class Parameters, class Keyword, class Default = void_>
-struct binding
-{
- typedef typename mpl::eval_if<
- is_same<Parameters, int>
- , mpl::identity<int>
- , binding_eti<Parameters, Keyword, Default>
- >::type type;
-
     BOOST_MPL_AUX_LAMBDA_SUPPORT(3,binding,(Parameters,Keyword,Default))
 };
-# endif
 
 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword. If no such

Modified: trunk/boost/parameter/keyword.hpp
==============================================================================
--- trunk/boost/parameter/keyword.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/keyword.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -52,7 +52,6 @@
         return aux::lazy_default<Tag, Default>(default_);
     }
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) // avoid partial ordering bugs
     template <class T>
     typename aux::tag<Tag, T const>::type const
     operator=(T const& x) const
@@ -60,15 +59,10 @@
         typedef typename aux::tag<Tag, T const>::type result;
         return result(x);
     }
-#endif
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) // avoid partial ordering bugs
     template <class Default>
     aux::default_<Tag, const Default>
     operator|(const Default& default_) const
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
- volatile
-#endif
     {
         return aux::default_<Tag, const Default>(default_);
     }
@@ -76,13 +70,9 @@
     template <class Default>
     aux::lazy_default<Tag, Default>
     operator||(Default const& default_) const
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
- volatile
-#endif
     {
         return aux::lazy_default<Tag, Default>(default_);
     }
-#endif
 
  public: // Insurance against ODR violations
     
@@ -109,24 +99,6 @@
 // reference in an anonymous namespace to a singleton instance of that
 // type.
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
-# define BOOST_PARAMETER_KEYWORD(tag_namespace,name) \
- namespace tag_namespace \
- { \
- struct name \
- { \
- static char const* keyword_name() \
- { \
- return #name; \
- } \
- }; \
- } \
- static ::boost::parameter::keyword<tag_namespace::name> const& name \
- = ::boost::parameter::keyword<tag_namespace::name>::instance;
-
-#else
-
 #define BOOST_PARAMETER_KEYWORD(tag_namespace,name) \
     namespace tag_namespace \
     { \
@@ -144,8 +116,6 @@
        = ::boost::parameter::keyword<tag_namespace::name>::instance;\
     }
 
-#endif
-
 }} // namespace boost::parameter
 
 #endif // KEYWORD_050328_HPP

Modified: trunk/boost/parameter/name.hpp
==============================================================================
--- trunk/boost/parameter/name.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/name.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -75,19 +75,6 @@
 # define BOOST_PARAMETER_IS_BINARY(x) BOOST_PP_IS_BINARY(x)
 # endif
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# define BOOST_PARAMETER_NAME_OBJECT(tag, name) \
- static ::boost::parameter::keyword<tag> const& name \
- = ::boost::parameter::keyword<tag>::instance;
-# else
-# define BOOST_PARAMETER_NAME_OBJECT(tag, name) \
- namespace \
- { \
- ::boost::parameter::keyword<tag> const& name \
- = ::boost::parameter::keyword<tag>::instance; \
- }
-# endif
-
 # define BOOST_PARAMETER_BASIC_NAME(tag_namespace, tag, name) \
     namespace tag_namespace \
     { \
@@ -107,7 +94,11 @@
> _1; \
       }; \
     } \
- BOOST_PARAMETER_NAME_OBJECT(tag_namespace::tag, name)
+ namespace \
+ { \
+ ::boost::parameter::keyword<tag_namespace::tag> const& name \
+ = ::boost::parameter::keyword<tag_namespace::tag>::instance; \
+ }
 
 # define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(tag,namespace) \
     (tag, namespace), ~

Modified: trunk/boost/parameter/preprocessor.hpp
==============================================================================
--- trunk/boost/parameter/preprocessor.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/preprocessor.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -37,10 +37,6 @@
 # include <boost/mpl/always.hpp>
 # include <boost/mpl/apply_wrap.hpp>
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-# include <boost/type.hpp>
-# endif
-
 namespace boost { namespace parameter { namespace aux {
 
 # if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
@@ -102,41 +98,6 @@
 {};
 # endif
 
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-
-// Function template argument deduction does many of the same things
-// as type matching during partial specialization, so we call a
-// function template to "store" T into the type memory addressed by
-// void(*)(T).
-template <class T>
-msvc_store_type<T,void*(*)(void**(T))>
-msvc_store_predicate_type(void*(*)(void**(T)));
-
-template <class T>
-msvc_store_type<boost::is_convertible<mpl::_,T>,void*(*)(void*(T))>
-msvc_store_predicate_type(void*(*)(void*(T)));
-
-template <class FunctionType>
-struct unwrap_predicate
-{
- static FunctionType f;
-
- // We don't want the function to be evaluated, just instantiated,
- // so protect it inside of sizeof.
- enum { dummy = sizeof(msvc_store_predicate_type(f)) };
-
- // Now pull the type out of the instantiated base class
- typedef typename msvc_type_memory<FunctionType>::storage::type type;
-};
-
-template <>
-struct unwrap_predicate<void*(*)(void**)>
-{
- typedef mpl::always<mpl::true_> type;
-};
-
-# endif
-
 # undef false_
 
 template <
@@ -158,7 +119,6 @@
     typedef typename mpl::first<result>::type type;
 };
 
-# if 1 //BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 // Works around VC6 problem where it won't accept rvalues.
 template <class T>
 T& as_lvalue(T& value, long)
@@ -171,11 +131,9 @@
 {
     return value;
 }
-# endif
 
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
 template <class Predicate, class T, class Args>
 struct apply_predicate
@@ -502,13 +460,7 @@
 # define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \
     required<boost::parameter::deduced<tag>
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-# define BOOST_PARAMETER_PREDICATE_TYPE(p) void*(*) (void* p)
-# else
-# define BOOST_PARAMETER_PREDICATE_TYPE(p) void p
-# endif
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
 # define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
     BOOST_PP_COMMA_IF(i) \
@@ -521,24 +473,9 @@
         ) \
     ) \
       , typename boost::parameter::aux::unwrap_predicate< \
- BOOST_PARAMETER_PREDICATE_TYPE(BOOST_PARAMETER_FN_ARG_PRED(elem)) \
+ void BOOST_PARAMETER_FN_ARG_PRED(elem) \
>::type \
>
-# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
- BOOST_PP_COMMA_IF(i) \
- boost::parameter::BOOST_PP_CAT( \
- BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \
- , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \
- )( \
- tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \
- BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \
- ) \
- ) \
- , boost::parameter::aux::funptr_predicate< \
- void* BOOST_PARAMETER_FN_ARG_PRED(elem) \
- > \
- >
 # elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 # define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
     BOOST_PP_COMMA_IF(i) \
@@ -583,21 +520,6 @@
         typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type; \
     };
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-
-# define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \
- BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \
- template <> \
- struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<int> \
- { typedef int type; };
-
-# else
-
-# define BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \
- BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)
-
-# endif
-
 // Defines implementation function
 # define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) \
     template <class Args> \
@@ -915,7 +837,7 @@
 
 // Defines the result metafunction and the parameters specialization.
 # define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args) \
- BOOST_PARAMETER_FUNCTION_RESULT(result, name, args) \
+ BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args) \
                                                                             \
           BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args) \
           BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name); \
@@ -1021,18 +943,6 @@
     BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i)
 /**/
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-
-// Older MSVC can't do what's necessary to handle commas in base names; just
-// use a typedef instead if you have a base name that contains commas.
-# define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PP_SEQ_HEAD(x)
-
-# else
-
-# define BOOST_PARAMETER_PARENTHESIZED_BASE(x) BOOST_PARAMETER_PARENTHESIZED_TYPE(x)
-
-# endif
-
 # define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem) \
     BOOST_PP_IF( \
         n \
@@ -1057,7 +967,7 @@
           , n \
         ) \
     ) \
- : BOOST_PARAMETER_PARENTHESIZED_BASE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
+ : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
             BOOST_PP_CAT(constructor_parameters, __LINE__)()( \
                 BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
             ) \
@@ -1148,18 +1058,7 @@
       , (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \
       , (const ParameterArgumentType ## i) \
     ))
-// MSVC6.5 lets us bind rvalues to T&.
-# elif BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
- (BOOST_PP_IF( \
- BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
- BOOST_PARAMETER_FN_ARG_NAME(elem) \
- ) \
- , (ParameterArgumentType ## i) \
- , (const ParameterArgumentType ## i) \
- ))
 // No partial ordering. This feature doesn't work.
-// This is exactly the same as for VC6.5, but we might change it later.
 # else
 # define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
     (BOOST_PP_IF( \

Modified: trunk/boost/parameter/value_type.hpp
==============================================================================
--- trunk/boost/parameter/value_type.hpp Tue Oct 1 04:48:23 2013 (r86118)
+++ trunk/boost/parameter/value_type.hpp 2013-10-01 04:48:50 EDT (Tue, 01 Oct 2013) (r86119)
@@ -12,18 +12,13 @@
 # include <boost/parameter/aux_/void.hpp>
 # include <boost/type_traits/is_same.hpp>
 
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-# include <boost/mpl/eval_if.hpp>
-# endif
-
 namespace boost { namespace parameter {
 
 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword. If no such
 // parameter has been specified, returns Default
 
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template <class Parameters, class Keyword, class Default>
 struct value_type0
 {
@@ -41,14 +36,9 @@
 # endif
 
 template <class Parameters, class Keyword, class Default = void_>
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 struct value_type
-# else
-struct value_type_eti
-# endif
 {
-# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
- || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     typedef typename mpl::eval_if<
         mpl::is_placeholder<Parameters>
       , mpl::identity<int>
@@ -67,24 +57,8 @@
     ));
 # endif
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
- BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
-# endif
-};
-
-# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-template <class Parameters, class Keyword, class Default = void_>
-struct value_type
-{
- typedef typename mpl::eval_if<
- is_same<Parameters, int>
- , mpl::identity<int>
- , value_type_eti<Parameters, Keyword, Default>
- >::type type;
-
     BOOST_MPL_AUX_LAMBDA_SUPPORT(3,value_type,(Parameters,Keyword,Default))
 };
-# endif
 
 // A metafunction that, given an argument pack, returns the type of
 // the parameter identified by the given keyword. If no such


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk