Release 1.46.1

[SVN r69890]

doc/html/index.html

@@ -37,7 +37,7 @@ can be deduced from their types.</p>
 </tbody>
 </table>
 <!-- @jam_prefix.append('''
-project test : requirements <include>. <implicit-dependency>/boost//headers ;''') -->
+project test : requirements <include>. <source>/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://www.open-std.org/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://anubis.dkuug.dk/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://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>
+<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>
 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">8</span></tt></td>
+<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>
 </tbody>
 </table>

doc/index.rst

@@ -30,7 +30,7 @@ __ ../../../../index.htm
   can be deduced from their types.
 
 .. @jam_prefix.append('''
-        project test : requirements <include>. <implicit-dependency>/boost//headers ;''')
+        project test : requirements <include>. <source>/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://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#225
+__ http://anubis.dkuug.dk/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://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm
+.. _`forwarding problem`: http://std.dkuug.dk/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: ``8``
+:Default Value: ``5``
 
 Tutorial
 ========

include/boost/parameter/aux_/arg_list.hpp

@@ -78,11 +78,15 @@ 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(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+    || (BOOST_WORKAROUND(__GNUC__, < 3)) \
+    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
     // The overload set technique doesn't work with these older
     // compilers, so they need some explicit handholding.
@@ -146,6 +150,11 @@ 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;
@@ -218,17 +227,25 @@ struct arg_list : Next
         };
     };
 
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#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
     // 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(Next::has_key((key_type*)0)) == sizeof(no_tag)
+        sizeof(BOOST_PARAMETER_CALL_HAS_KEY(Next,key_type)) == sizeof(no_tag)
       , duplicate_keyword, (key_type)
     );
 
+# undef BOOST_PARAMETER_CALL_HAS_KEY
 #endif
     //
     // Begin implementation of indexing operators for looking up
@@ -249,7 +266,9 @@ struct arg_list : Next
         return arg.value ? arg.value.get() : arg.value.construct(d.value);
     }
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+    || BOOST_WORKAROUND(__GNUC__, < 3) \
+    || 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
@@ -388,6 +407,10 @@ 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,7 +7,8 @@
 
 # include <boost/detail/workaround.hpp>
 
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #  include <boost/type_traits/add_reference.hpp>
 #  include <boost/type_traits/remove_const.hpp>
 # endif
@@ -16,7 +17,8 @@ namespace boost { namespace parameter { namespace aux {
 
 struct use_default_tag {};
 
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
 #  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) value
 
@@ -38,11 +40,11 @@ struct use_default_tag {};
 //   X(something, *(predicate))
 //   X(something, (int))
 
-template <class T, class Args>
+template <class T>
 struct cast;
 
-template <class Args>
-struct cast<void*, Args>
+template <>
+struct cast<void*>
 {
     static use_default_tag execute(use_default_tag)
     {
@@ -71,39 +73,27 @@ struct cast<void*, Args>
 
 typedef void* voidstar;
 
-template <class T, class Args>
-struct cast<voidstar(T), Args>
-  : cast<void*, Args>
+template <class T>
+struct cast<voidstar(T)>
+  : cast<void*>
 {
 };
 
 #else
 
-template <class T, class Args>
-struct cast<void*(T), Args>
-  : cast<void*, Args>
+template <class T>
+struct cast<void*(T)>
+  : cast<void*>
 {
 };
 
 #endif
 
-// 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
+template <class T>
+struct cast<void(T)>
 {
-    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<type0>::type 
+        typename boost::remove_const<T>::type 
     >::type reference;
 
     static use_default_tag execute(use_default_tag)
@@ -116,7 +106,7 @@ struct cast<void(T), Args>
         return use_default_tag();
     }
 
-    static type0 execute(type0 value)
+    static T execute(T value)
     {
         return value;
     }
@@ -128,9 +118,9 @@ struct cast<void(T), Args>
     }
 };
 
-#  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) \
+#  define BOOST_PARAMETER_FUNCTION_CAST(value, predicate) \
+    boost::parameter::aux::cast<void predicate>::remove_const( \
+        boost::parameter::aux::cast<void predicate>::execute(value) \
     )
 
 # endif

include/boost/parameter/aux_/parenthesized_type.hpp

@@ -18,12 +18,96 @@ 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,7 +7,8 @@
 
 # include <boost/detail/workaround.hpp>
 
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) \
+  && !BOOST_WORKAROUND(__GNUC__, < 3)
 #  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& ) const
+    reference operator[](default_<key_type,Default> const& x) const
     {
         return value;
     }
 
     template <class F>
-    reference operator[](lazy_default<key_type,F> const& ) const
+    reference operator[](lazy_default<key_type,F> const& x) const
     {
         return value;
     }

include/boost/parameter/aux_/unwrap_cv_reference.hpp

@@ -44,6 +44,12 @@ 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,13 +11,18 @@
 # 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(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template <class Parameters, class Keyword, class Default>
 struct binding0
 {
@@ -35,9 +40,14 @@ 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(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     typedef typename mpl::eval_if<
         mpl::is_placeholder<Parameters>
       , mpl::identity<int>
@@ -56,8 +66,24 @@ struct binding
     ));
 # 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 8
+# define BOOST_PARAMETER_MAX_ARITY 5
 #endif
 
 #endif // BOOST_PARAMETER_CONFIG_050403_HPP

include/boost/parameter/keyword.hpp

@@ -52,6 +52,7 @@ 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
@@ -59,10 +60,15 @@ 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_);
     }
@@ -70,9 +76,13 @@ 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
     
@@ -99,6 +109,24 @@ 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                                         \
     {                                                               \
@@ -116,6 +144,8 @@ 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,6 +16,7 @@
 # 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>
@@ -26,7 +27,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>
@@ -45,7 +46,7 @@ namespace boost { namespace mpl {
 template <class T>
 struct lambda<
     T
-  , typename boost::enable_if<
+  , typename enable_if<
         parameter::aux::is_name_tag<T>, parameter::aux::lambda_tag
     >::type
 >
@@ -74,6 +75,19 @@ 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                                         \
     {                                                               \
@@ -93,11 +107,7 @@ struct lambda<
           > _1;                                                     \
       };                                                            \
     }                                                               \
-    namespace                                                       \
-    {                                                               \
-       ::boost::parameter::keyword<tag_namespace::tag> const& name  \
-       = ::boost::parameter::keyword<tag_namespace::tag>::instance; \
-    }
+    BOOST_PARAMETER_NAME_OBJECT(tag_namespace::tag, name)
 
 # define BOOST_PARAMETER_COMPLEX_NAME_TUPLE1(tag,namespace)         \
     (tag, namespace), ~

include/boost/parameter/preprocessor.hpp

@@ -37,6 +37,10 @@
 # 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))
@@ -98,6 +102,41 @@ 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 <
@@ -119,6 +158,7 @@ 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)
@@ -131,9 +171,11 @@ T const& as_lvalue(T const& value, int)
 {
     return value;
 }
+# endif
 
 
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 
 template <class Predicate, class T, class Args>
 struct apply_predicate
@@ -460,7 +502,13 @@ struct funptr_predicate<void**>
 #  define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \
     required<boost::parameter::deduced<tag>
 
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# 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
 
 #  define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
     BOOST_PP_COMMA_IF(i) \
@@ -473,9 +521,24 @@ struct funptr_predicate<void**>
         ) \
     ) \
       , typename boost::parameter::aux::unwrap_predicate< \
-            void BOOST_PARAMETER_FN_ARG_PRED(elem) \
+            BOOST_PARAMETER_PREDICATE_TYPE(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) \
@@ -520,6 +583,21 @@ 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>                                   \
@@ -623,7 +701,6 @@ struct funptr_predicate<void**>
             ) \
         ] \
       , BOOST_PARAMETER_FN_ARG_PRED(arg) \
-      , Args \
     )
 
 # define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \
@@ -651,7 +728,6 @@ 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_) \
@@ -767,7 +843,6 @@ 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
@@ -818,7 +893,7 @@ struct funptr_predicate<void**>
     BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
     ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
         ResultType(*)() \
-      , Args const& \
+      , Args const& args \
       , int \
         BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
             BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
@@ -837,7 +912,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);                   \
@@ -943,6 +1018,18 @@ 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 \
@@ -967,7 +1054,7 @@ struct funptr_predicate<void**>
           , n \
         ) \
     ) \
-      : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
+      : BOOST_PARAMETER_PARENTHESIZED_BASE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
             BOOST_PP_CAT(constructor_parameters, __LINE__)()( \
                 BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
             ) \
@@ -1058,7 +1145,18 @@ 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,13 +12,18 @@
 # 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(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 template <class Parameters, class Keyword, class Default>
 struct value_type0
 {
@@ -36,9 +41,14 @@ 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(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+  || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
     typedef typename mpl::eval_if<
         mpl::is_placeholder<Parameters>
       , mpl::identity<int>
@@ -57,8 +67,24 @@ struct value_type
     ));
 # 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

@@ -1,17 +0,0 @@
-{
-    "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>"
-    ]
-}