fix a unused variable warning

These evaded scripting.

[SVN r86249]

doc/html/index.html

@@ -37,7 +37,7 @@ can be deduced from their types.</p>
 </tbody>
 </table>
 <!-- @jam_prefix.append('''
-project test : requirements <include>. <source>/boost//headers ;''') -->
+project test : requirements <include>. <implicit-dependency>/boost//headers ;''') -->
 <!-- @example.prepend('''
 #include <boost/parameter.hpp>
 
@@ -727,7 +727,7 @@ worse—think of the kinds of errors you get from your STL
 implementation when you make a mistake).<a class="footnote-reference" href="#conceptcpp" id="id7"><sup>4</sup></a></li>
 <li>The problems with exposing such permissive function template
 signatures have been the subject of much discussion, especially
-in the presence of <a class="reference external" href="http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#225">unqualified calls</a>.  If all we want is to
+in the presence of <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225">unqualified calls</a>.  If all we want is to
 avoid unintentional argument-dependent lookup (ADL), we can
 isolate <tt class="docutils literal"><span class="pre">depth_first_search</span></tt> in a namespace containing no
 types<a class="footnote-reference" href="#using" id="id8"><sup>6</sup></a>, but suppose we <em>want</em> it to found via ADL?</li>
@@ -1601,7 +1601,7 @@ using boost::mpl::_;''') -->
 int main()
 {}''') -->
 <!-- @test('run', howmany='all') -->
-<p>Note that because of the <a class="reference external" href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">forwarding problem</a>, <tt class="docutils literal"><span class="pre">parameter::parameters::operator()</span></tt>
+<p>Note that because of the <a class="reference external" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">forwarding problem</a>, <tt class="docutils literal"><span class="pre">parameter::parameters::operator()</span></tt>
 can't accept non-const rvalues.</p>
 </div>
 <div class="section" id="extracting-parameter-types">

doc/html/reference.html

@@ -1094,7 +1094,7 @@ already <tt class="docutils literal"><span class="pre">#defined</span></tt>.</p>
 <col class="field-name" />
 <col class="field-body" />
 <tbody valign="top">
-<tr class="field"><th class="field-name">Default Value:</th><td class="field-body"><tt class="docutils literal"><span class="pre">5</span></tt></td>
+<tr class="field"><th class="field-name">Default Value:</th><td class="field-body"><tt class="docutils literal"><span class="pre">8</span></tt></td>
 </tr>
 </tbody>
 </table>

doc/index.rst

@@ -30,7 +30,7 @@ __ ../../../../index.htm
   can be deduced from their types.
 
 .. @jam_prefix.append('''
-        project test : requirements <include>. <source>/boost//headers ;''')
+        project test : requirements <include>. <implicit-dependency>/boost//headers ;''')
 
 .. @example.prepend('''
    #include <boost/parameter.hpp>
@@ -783,7 +783,7 @@ signatures.
    isolate ``depth_first_search`` in a namespace containing no
    types [#using]_, but suppose we *want* it to found via ADL?
 
-__ http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#225
+__ http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225
 
 It's usually a good idea to prevent functions from being considered
 for overload resolution when the passed argument types aren't
@@ -1767,7 +1767,7 @@ its function call operator:
 Note that because of the `forwarding problem`_, ``parameter::parameters::operator()``
 can't accept non-const rvalues.
 
-.. _`forwarding problem`: http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm
+.. _`forwarding problem`: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm
 
 Extracting Parameter Types
 ==========================

doc/reference.rst

@@ -970,7 +970,7 @@ already ``#defined``.
 
 __ ../../../../boost/parameter/config.hpp
 
-:Default Value: ``5``
+:Default Value: ``8``
 
 Tutorial
 ========

include/boost/parameter/aux_/arg_list.hpp

@@ -78,15 +78,11 @@ struct empty_arg_list
         };
     };
 
-#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(__GNUC__, < 3)) \
-    || 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.
@@ -150,11 +146,6 @@ struct empty_arg_list
     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,25 +218,17 @@ struct arg_list : Next
         };
     };
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && !BOOST_WORKAROUND(__GNUC__, == 2)
-# 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
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     // 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
@@ -266,9 +249,7 @@ struct arg_list : Next
         return arg.value ? arg.value.get() : arg.value.construct(d.value);
     }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
-    || BOOST_WORKAROUND(__GNUC__, < 3) \
-    || 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
@@ -407,10 +388,6 @@ struct arg_list : Next
     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

include/boost/parameter/aux_/cast.hpp

@@ -7,8 +7,7 @@
 
 # include <boost/detail/workaround.hpp>
 
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
-  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #  include <boost/type_traits/add_reference.hpp>
 #  include <boost/type_traits/remove_const.hpp>
 # endif
@@ -17,8 +16,7 @@ namespace boost { namespace parameter { namespace aux {
 
 struct use_default_tag {};
 
-# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
-  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
 #  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) value
 
@@ -40,11 +38,11 @@ struct use_default_tag {};
 //   X(something, *(predicate))
 //   X(something, (int))
 
-template <class T>
+template <class T, class Args>
 struct cast;
 
-template <>
-struct cast<void*>
+template <class Args>
+struct cast<void*, Args>
 {
     static use_default_tag execute(use_default_tag)
     {
@@ -73,27 +71,39 @@ struct cast<void*>
 
 typedef void* voidstar;
 
-template <class T>
-struct cast<voidstar(T)>
-  : cast<void*>
+template <class T, class Args>
+struct cast<voidstar(T), Args>
+  : cast<void*, Args>
 {
 };
 
 #else
 
-template <class T>
-struct cast<void*(T)>
-  : cast<void*>
+template <class T, class Args>
+struct cast<void*(T), Args>
+  : cast<void*, Args>
 {
 };
 
 #endif
 
-template <class T>
-struct cast<void(T)>
+// This is a hack used in cast<> to turn the user supplied type,
+// which may or may not be a placeholder expression into one, so
+// that it will be properly evaluated by mpl::apply.
+template <class T, class Dummy = mpl::_1>
+struct as_placeholder_expr
 {
+    typedef T type;
+};
+
+template <class T, class Args>
+struct cast<void(T), Args>
+{
+    typedef typename mpl::apply2<
+        as_placeholder_expr<T>, Args, Args>::type type0;
+
     typedef typename boost::add_reference<
-        typename boost::remove_const<T>::type 
+        typename boost::remove_const<type0>::type 
     >::type reference;
 
     static use_default_tag execute(use_default_tag)
@@ -106,7 +116,7 @@ struct cast<void(T)>
         return use_default_tag();
     }
 
-    static T execute(T value)
+    static type0 execute(type0 value)
     {
         return value;
     }
@@ -118,9 +128,9 @@ struct cast<void(T)>
     }
 };
 
-#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) \
-    boost::parameter::aux::cast<void predicate>::remove_const( \
-        boost::parameter::aux::cast<void predicate>::execute(value) \
+#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate, args) \
+    boost::parameter::aux::cast<void predicate, args>::remove_const( \
+        boost::parameter::aux::cast<void predicate, args>::execute(value) \
     )
 
 # endif

include/boost/parameter/aux_/parenthesized_type.hpp

@@ -18,96 +18,12 @@ namespace boost { namespace parameter { namespace aux {
 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)>
 {

include/boost/parameter/aux_/set.hpp

@@ -7,8 +7,7 @@
 
 # include <boost/detail/workaround.hpp>
 
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
-  && !BOOST_WORKAROUND(__GNUC__, < 3)
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #  include <boost/mpl/insert.hpp>
 #  include <boost/mpl/set/set0.hpp>
 #  include <boost/mpl/has_key.hpp>

include/boost/parameter/aux_/tagged_argument.hpp

@@ -120,13 +120,13 @@ struct tagged_argument : tagged_argument_base
     }
 # else
     template <class Default>
-    reference operator[](default_<key_type,Default> const& x) const
+    reference operator[](default_<key_type,Default> const& ) const
     {
         return value;
     }
 
     template <class F>
-    reference operator[](lazy_default<key_type,F> const& x) const
+    reference operator[](lazy_default<key_type,F> const& ) const
     {
         return value;
     }

include/boost/parameter/aux_/unwrap_cv_reference.hpp

@@ -44,12 +44,6 @@ struct is_cv_reference_wrapper
     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>

include/boost/parameter/binding.hpp

@@ -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 @@ struct binding0
 # 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 @@ struct binding_eti
     ));
 # 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

include/boost/parameter/config.hpp

@@ -7,7 +7,7 @@
 #define BOOST_PARAMETER_CONFIG_050403_HPP
 
 #ifndef BOOST_PARAMETER_MAX_ARITY
-# define BOOST_PARAMETER_MAX_ARITY 5
+# define BOOST_PARAMETER_MAX_ARITY 8
 #endif
 
 #endif // BOOST_PARAMETER_CONFIG_050403_HPP

include/boost/parameter/keyword.hpp

@@ -52,7 +52,6 @@ struct keyword
         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 @@ struct keyword
         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 @@ struct keyword
     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 @@ keyword<Tag> const keyword<Tag>::instance = {};
 // 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 @@ keyword<Tag> const keyword<Tag>::instance = {};
        = ::boost::parameter::keyword<tag_namespace::name>::instance;\
     }
 
-#endif
-
 }} // namespace boost::parameter
 
 #endif // KEYWORD_050328_HPP

include/boost/parameter/name.hpp

@@ -16,7 +16,6 @@
 # include <boost/mpl/placeholders.hpp>
 
 # if !defined(BOOST_NO_SFINAE) \
-  && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
   && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
 
 #  include <boost/utility/enable_if.hpp>
@@ -27,7 +26,7 @@ namespace boost { namespace parameter { namespace aux {
 // Tag type passed to MPL lambda.
 struct lambda_tag;
 
-struct name_tag_base 
+struct name_tag_base
 {};
 
 template <class Tag>
@@ -46,7 +45,7 @@ namespace boost { namespace mpl {
 template <class T>
 struct lambda<
     T
-  , typename enable_if<
+  , typename boost::enable_if<
         parameter::aux::is_name_tag<T>, parameter::aux::lambda_tag
     >::type
 >
@@ -75,19 +74,6 @@ struct lambda<
 #  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 +93,11 @@ struct lambda<
           > _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), ~

include/boost/parameter/preprocessor.hpp

@@ -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 @@ struct match
 {};
 # 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 @@ struct argument_pack
     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 @@ T const& as_lvalue(T const& value, int)
 {
     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 @@ struct funptr_predicate<void**>
 #  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 @@ struct funptr_predicate<void**>
         ) \
     ) \
       , 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 @@ struct funptr_predicate<void**>
         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>                                   \
@@ -701,6 +623,7 @@ struct funptr_predicate<void**>
             ) \
         ] \
       , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+      , Args \
     )
 
 # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \
@@ -728,6 +651,7 @@ struct funptr_predicate<void**>
     BOOST_PARAMETER_FUNCTION_CAST( \
         boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \
       , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+      , Args \
     )
 
 # define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_) \
@@ -843,6 +767,7 @@ struct funptr_predicate<void**>
               boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \
           ] \
         , BOOST_PARAMETER_FN_ARG_PRED(arg) \
+        , Args \
       )
 
 // Generates the function template that recives a ArgumentPack, and then
@@ -893,7 +818,7 @@ struct funptr_predicate<void**>
     BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
     ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
         ResultType(*)() \
-      , Args const& args \
+      , Args const& \
       , int \
         BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
             BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
@@ -912,7 +837,7 @@ struct funptr_predicate<void**>
 
 // 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);                   \
@@ -1018,18 +943,6 @@ struct funptr_predicate<void**>
     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 \
@@ -1054,7 +967,7 @@ struct funptr_predicate<void**>
           , 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) \
             ) \
@@ -1145,18 +1058,7 @@ struct funptr_predicate<void**>
       , (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( \

include/boost/parameter/value_type.hpp

@@ -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 @@ struct value_type0
 # 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 @@ struct value_type_eti
     ));
 # 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

meta/libraries.json

@@ -0,0 +1,17 @@
+{
+    "key": "parameter",
+    "name": "Parameter",
+    "authors": [
+        "David Abrahams",
+        "Daniel Wallin"
+    ],
+    "description": "Boost.Parameter Library - Write functions that accept arguments by name.",
+    "category": [
+        "Emulation",
+        "Programming"
+    ],
+    "maintainers": [
+        "David Abrahams <dave -at- boost-consulting.com>",
+        "Daniel Wallin <daniel -at- boostpro.com>"
+    ]
+}