Fix link to Python bindings

Use glob instead of path.glob, as it's relative to the Jamfile
Update the parameter_python submodule, as we still keep the Python tests here
2026-01-19 16:32:13 +00:00 · 2018-10-16 06:40:55 +03:00 · 2018-10-16 06:26:47 +03:00 · 2018-10-15 00:29:51 +03:00 · 2018-10-15 00:27:41 +03:00 · 2018-10-15 00:26:55 +03:00
92 changed files with 281 additions and 2975 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,136 @@
+# Copyright 2016 Edward Diener
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libstdc++-5-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - git submodule update --init libs/parameter_python
+  - cp -r $TRAVIS_BUILD_DIR/* libs/parameter
+  - python tools/boostdep/depinst/depinst.py parameter
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 --verbose-test libs/config/test//config_info toolset=$TOOLSET cxxstd=$CXXSTD || true
+  - ./b2 -j3 libs/parameter/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -0,0 +1,37 @@
+# Copyright 2017 Edward Diener
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0,msvc-14.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+
+install:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - git submodule update --init libs/parameter_python
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\parameter
+  - python tools/boostdep/depinst/depinst.py parameter
+  - bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - b2 libs/parameter/test toolset=%TOOLSET%
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -1,12 +1,12 @@
 # Copyright David Abrahams 2006. Distributed under the Boost
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
 import docutils ;

-import path ;
-sources = [ path.glob . : *.rst ] ;
+sources = [ glob *.rst ] ;
 bases = $(sources:S=) ;
-  
+
 # This is a path relative to the html/ subdirectory where the
 # generated output will eventually be moved.
 stylesheet = "--stylesheet=rst.css" ;
@@ -22,3 +22,9 @@ for local b in $(bases)

 alias htmls : $(bases) ;
 stage html : $(bases) ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : html ;
+explicit boostrelease ;
--- a/doc/html/index.html
+++ b/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">depth_first_search</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>
@@ -1632,7 +1632,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">
--- a/doc/html/python.html
+++ b/doc/html/python.html
@@ -1,788 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.7: http://docutils.sourceforge.net/" />
-<title>The Boost Parameter Library Python Binding Documentation</title>
-<meta name="authors" content="David Abrahams  Daniel Wallin" />
-<meta name="organization" content="BoostPro Computing" />
-<meta name="date" content="2009-01-29" />
-<meta name="copyright" content="Copyright David Abrahams, Daniel Wallin 2005-2009. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)" />
-<link rel="stylesheet" href="rst.css" type="text/css" />
-</head>
-<body>
-<div class="document" id="the-boost-parameter-library-python-binding-documentation">
-<h1 class="title">The Boost Parameter Library Python Binding Documentation</h1>
-<table class="docinfo" frame="void" rules="none">
-<col class="docinfo-name" />
-<col class="docinfo-content" />
-<tbody valign="top">
-<tr><th class="docinfo-name">Authors:</th>
-<td>David Abrahams
-<br />Daniel Wallin</td></tr>
-<tr><th class="docinfo-name">Contact:</th>
-<td><a class="first reference external" href="mailto:dave&#64;boost-consulting.com">dave&#64;boost-consulting.com</a>, <a class="last reference external" href="mailto:daniel&#64;boostpro.com">daniel&#64;boostpro.com</a></td></tr>
-<tr><th class="docinfo-name">Organization:</th>
-<td><a class="first last reference external" href="http://www.boostpro.com">BoostPro Computing</a></td></tr>
-<tr><th class="docinfo-name">Date:</th>
-<td>2009-01-29</td></tr>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Copyright David Abrahams, Daniel Wallin
-2005-2009. Distributed under the Boost Software License,
-Version 1.0. (See accompanying file LICENSE_1_0.txt
-or copy at <a class="reference external" href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</td></tr>
-</tbody>
-</table>
-<div class="abstract topic">
-<p class="topic-title first">Abstract</p>
-<p>Makes it possible to bind Boost.Parameter-enabled
-functions, operators and constructors to Python.</p>
-</div>
-<p><a class="reference external" href="../../../../index.htm"><img alt="Boost" src="../../../../boost.png" /></a></p>
-<div class="contents topic" id="contents">
-<p class="topic-title first">Contents</p>
-<ul class="simple">
-<li><a class="reference internal" href="#introduction" id="id7">Introduction</a></li>
-<li><a class="reference internal" href="#tutorial" id="id8">Tutorial</a></li>
-<li><a class="reference internal" href="#concept-parameterspec" id="id9">concept <span class="concept">ParameterSpec</span></a></li>
-<li><a class="reference internal" href="#special-keywords" id="id10"><em>special</em> keywords</a></li>
-<li><a class="reference internal" href="#class-template-init" id="id11">class template <tt class="docutils literal">init</tt></a></li>
-<li><a class="reference internal" href="#class-template-call" id="id12">class template <tt class="docutils literal">call</tt></a></li>
-<li><a class="reference internal" href="#class-template-function" id="id13">class template <tt class="docutils literal">function</tt></a></li>
-<li><a class="reference internal" href="#function-template-def" id="id14">function template <tt class="docutils literal">def</tt></a></li>
-<li><a class="reference internal" href="#portability" id="id15">Portability</a></li>
-</ul>
-</div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id7">Introduction</a></h1>
-<p><tt class="docutils literal">boost/parameter/python.hpp</tt> introduces a group of <a class="reference external" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal">def_visitors</tt></a> that can
-be used to easily expose Boost.Parameter-enabled member functions to Python with
-Boost.Python. It also provides a function template <tt class="docutils literal">def()</tt> that can be used
-to expose Boost.Parameter-enabled free functions.</p>
-<p>When binding a Boost.Parameter enabled function, the keyword tags
-must be specified.  Additionally, because Boost.Parameter enabled
-functions are templates, the desired function signature must be
-specified.</p>
-<!-- The keyword tags are specified as an `MPL Sequence`_, using the
-pointer qualifications described in |ParameterSpec|_ below.  The
-signature is also specifid as an `MPL sequence`_ of parameter
-types. Additionally, ``boost::parameter::python::function`` and
-``boost::parameter::python::def`` requires a class with forwarding
-overloads. We will take a closer look at how this is done in the
-tutorial section below. -->
-<p>The keyword tags and associated argument types are specified as an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL
-Sequence</a>, using the function type syntax described in <a class="reference internal" href="#concept-parameterspec"><span class="concept">ParameterSpec</span></a>
-below. Additionally, <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> and
-<tt class="docutils literal"><span class="pre">boost::parameter::python::def</span></tt> requires a class with forwarding overloads.
-We will take a closer look at how this is done in the tutorial section below.</p>
-<!-- The last two sentences are terribly vague.  Which namespace is -->
-<!-- ``function`` in?  Isn't the return type always needed?  What -->
-<!-- else are we going to do other than pass these sequences to -->
-<!-- function? -->
-</div>
-<div class="section" id="tutorial">
-<h1><a class="toc-backref" href="#id8">Tutorial</a></h1>
-<p>In this section we will outline the steps needed to bind a simple
-Boost.Parameter-enabled member function to Python. Knowledge of the
-Boost.Parameter <a class="reference external" href="index.html">macros</a> are required to understand this section.</p>
-<p>The class and member function we are interested in binding looks
-like this:</p>
-<pre class="literal-block">
-#include &lt;boost/parameter/keyword.hpp&gt;
-#include &lt;boost/parameter/preprocessor.hpp&gt;
-#include &lt;boost/parameter/python.hpp&gt;
-#include &lt;boost/python.hpp&gt;
-
-// First the keywords
-BOOST_PARAMETER_KEYWORD(tag, title)
-BOOST_PARAMETER_KEYWORD(tag, width)
-BOOST_PARAMETER_KEYWORD(tag, height)
-
-class window
-{
-public:
-    BOOST_PARAMETER_MEMBER_FUNCTION(
-      (void), open, tag,
-      (required (title, (std::string)))
-      (optional (width, (unsigned), 400)
-                (height, (unsigned), 400))
-    )
-    {
-        <em>… function implementation …</em>
-    }
-};
-</pre>
-<!-- @example.prepend('#include <cassert>') -->
-<!-- @example.replace_emphasis('''
-assert(title == "foo");
-assert(height == 20);
-assert(width == 400);
-''') -->
-<p>It defines a set of overloaded member functions called <tt class="docutils literal">open</tt> with one
-required parameter and two optional ones. To bind this member function to
-Python we use the binding utility <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt>.
-<tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> is a <a class="reference external" href="../../../python/doc/v2/def_visitor.html"><tt class="docutils literal">def_visitor</tt></a> that we'll instantiate
-and pass to <tt class="docutils literal"><span class="pre">boost::python::class_::def()</span></tt>.</p>
-<p>To use <tt class="docutils literal"><span class="pre">boost::parameter::python::function</span></tt> we first need to define
-a class with forwarding overloads. This is needed because <tt class="docutils literal"><span class="pre">window::open()</span></tt>
-is a function template, so we can't refer to it in any other way.</p>
-<pre class="literal-block">
-struct open_fwd
-{
-    template &lt;class A0, class A1, class A2&gt;
-    void operator()(
-        boost::type&lt;void&gt;, window&amp; self
-      , A0 const&amp; a0, A1 const&amp; a1, A2 const&amp; a2
-    )
-    {
-        self.open(a0, a1, a2);
-    }
-};
-</pre>
-<p>The first parameter, <tt class="docutils literal"><span class="pre">boost::type&lt;void&gt;</span></tt>, tells the forwarding overload
-what the return type should be. In this case we know that it's always void
-but in some cases, when we are exporting several specializations of a
-Boost.Parameter-enabled template, we need to use that parameter to
-deduce the return type.</p>
-<p><tt class="docutils literal"><span class="pre">window::open()</span></tt> takes a total of 3 parameters, so the forwarding function
-needs to take three parameters as well.</p>
-<div class="note">
-<p class="first admonition-title">Note</p>
-<p class="last">We only need one overload in the forwarding class, despite the
-fact that there are two optional parameters. There are special
-circumstances when several overload are needed; see
-<a class="reference internal" href="#special-keywords">special keywords</a>.</p>
-</div>
-<p>Next we'll define the module and export the class:</p>
-<pre class="literal-block">
-BOOST_PYTHON_MODULE(my_module)
-{
-    using namespace boost::python;
-    namespace py = boost::parameter::python;
-    namespace mpl = boost::mpl;
-
-    class_&lt;window&gt;(&quot;window&quot;)
-        .def(
-            &quot;open&quot;, py::function&lt;
-                open_fwd
-              , mpl::vector&lt;
-                    void
-                  , tag::title(std::string)
-                  , tag::width*(unsigned)
-                  , tag::height*(unsigned)
-                &gt;
-            &gt;()
-        );
-}
-</pre>
-<!-- @jam_prefix.append('import python ;') -->
-<!-- @jam_prefix.append('stage . : my_module /boost/python//boost_python ;') -->
-<!-- @my_module = build(
-    output = 'my_module'
-  , target_rule = 'python-extension'
-  , input = '/boost/python//boost_python'
-  , howmany = 'all'
-) -->
-<!-- @del jam_prefix[:] -->
-<p><tt class="docutils literal"><span class="pre">py::function</span></tt> is passed two parameters. The first one is the class with
-forwarding overloads that we defined earlier. The second one is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL
-Sequence</a> with the keyword tag types and argument types for the function
-specified as function types. The pointer syntax used in <tt class="docutils literal"><span class="pre">tag::width*</span></tt> and
-<tt class="docutils literal"><span class="pre">tag::height*</span></tt> means that the parameter is optional. The first element of
-the <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> is the return type of the function, in this case <tt class="docutils literal">void</tt>,
-which is passed as the first argument to <tt class="docutils literal">operator()</tt> in the forwarding
-class.</p>
-<!-- The
-pointer syntax means that the parameter is optional, so in this case
-``width`` and ``height`` are optional parameters. The third parameter
-is an `MPL Sequence`_ with the desired function signature. The return type comes first, and
-then the parameter types:
-
-.. parsed-literal::
-
-    mpl::vector<void,        std::string, unsigned, unsigned>
-                *return type*  *title*        *width*     *height*
-
-.. @ignore() -->
-<p>That's it! This class can now be used in Python with the expected syntax:</p>
-<pre class="literal-block">
-&gt;&gt;&gt; w = my_module.window()
-&gt;&gt;&gt; w.open(title = &quot;foo&quot;, height = 20)
-</pre>
-<!-- @example.prepend('import my_module') -->
-<!-- @run_python(module_path = my_module) -->
-<!-- Sorry to say this at such a late date, but this syntax really -->
-<!-- strikes me as cumbersome.  Couldn't we do something like:
-
- class_<window>("window")
-       .def(
-           "open",
-           (void (*)(
-               tag::title(std::string),
-               tag::width*(unsigned),
-               tag::height*(unsigned))
-           )0
-       );
-
-or at least:
-
-   class_<window>("window")
-       .def(
-           "open",
-           mpl::vector<
-               void,
-               tag::title(std::string),
-               tag::width*(unsigned),
-               tag::height*(unsigned)
-           >()
-       );
-
-assuming, that is, that we will have to repeat the tags (yes,
-users of broken compilers will have to give us function pointer
-types instead). -->
-</div>
-<hr class="docutils" />
-<div class="section" id="concept-parameterspec">
-<h1><a class="toc-backref" href="#id9">concept <span class="concept">ParameterSpec</span></a></h1>
-<p>A <span class="concept">ParameterSpec</span> is a function type <tt class="docutils literal">K(T)</tt> that describes both the keyword tag,
-<tt class="docutils literal">K</tt>, and the argument type, <tt class="docutils literal">T</tt>, for a parameter.</p>
-<p><tt class="docutils literal">K</tt> is either:</p>
-<ul class="simple">
-<li>A <em>required</em> keyword of the form <tt class="docutils literal">Tag</tt></li>
-<li><strong>or</strong>, an <em>optional</em> keyword of the form <tt class="docutils literal">Tag*</tt></li>
-<li><strong>or</strong>, a <em>special</em> keyword of the form <tt class="docutils literal">Tag**</tt></li>
-</ul>
-<p>where <tt class="docutils literal">Tag</tt> is a keyword tag type, as used in a specialization
-of <a class="reference external" href="../../../parameter/doc/html/reference.html#keyword"><tt class="docutils literal"><span class="pre">boost::parameter::keyword</span></tt></a>.</p>
-<p>The <strong>arity range</strong> for an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL Sequence</a> of <span class="concept">ParameterSpec</span>'s is
-defined as the closed range:</p>
-<pre class="literal-block">
-[ mpl::size&lt;S&gt; - number of <em>special</em> keyword tags in <tt class="docutils literal">S</tt>, mpl::size&lt;S&gt; ]
-</pre>
-<p>For example, the <strong>arity range</strong> of <tt class="docutils literal"><span class="pre">mpl::vector2&lt;x(int),y(int)&gt;</span></tt> is <tt class="docutils literal">[2,2]</tt>,
-the <strong>arity range</strong> of <tt class="docutils literal"><span class="pre">mpl::vector2&lt;x(int),y*(int)&gt;</span></tt> is <tt class="docutils literal">[2,2]</tt> and the
-<strong>arity range</strong> of <tt class="docutils literal"><span class="pre">mpl::vector2&lt;x(int),y**(int)&gt;</span></tt> is <tt class="docutils literal">[1,2]</tt>.</p>
-</div>
-<div class="section" id="special-keywords">
-<h1><a class="toc-backref" href="#id10"><em>special</em> keywords</a></h1>
-<p>Sometimes it is desirable to have a default value for a parameter that differ
-in type from the parameter. This technique is useful for doing simple tag-dispatching
-based on the presence of a parameter. For example:</p>
-<!-- An example_ of this is given in the Boost.Parameter
-docs. The example uses a different technique, but could also have been written like this: -->
-<pre class="literal-block">
-namespace core
-{
-  template &lt;class ArgumentPack&gt;
-  void dfs_dispatch(ArgumentPack const&amp; args, mpl::false_)
-  {
-      <em>…compute and use default color map…</em>
-  }
-
-  template &lt;class ArgumentPack, class ColorMap&gt;
-  void dfs_dispatch(ArgumentPack const&amp; args, ColorMap colormap)
-  {
-      <em>…use colormap…</em>
-  }
-}
-
-template &lt;class ArgumentPack&gt;
-void depth_first_search(ArgumentPack const&amp; args)
-{
-    core::dfs_dispatch(args, args[color | mpl::false_()]);
-}
-</pre>
-<!-- @example.prepend('''
-#include <boost/parameter/keyword.hpp>
-#include <boost/parameter/parameters.hpp>
-#include <boost/mpl/bool.hpp>
-#include <cassert>
-
-BOOST_PARAMETER_KEYWORD(tag, color);
-
-typedef boost::parameter::parameters<tag::color> params;
-
-namespace mpl = boost::mpl;
-''') -->
-<!-- @example.replace_emphasis('''
-assert(args[color | 1] == 1);
-''') -->
-<!-- @example.replace_emphasis('''
-assert(args[color | 1] == 0);
-''') -->
-<!-- @example.append('''
-int main()
-{
-    depth_first_search(params()());
-    depth_first_search(params()(color = 0));
-}''') -->
-<!-- @build() -->
-<!-- .. _example: index.html#dispatching-based-on-the-presence-of-a-default -->
-<p>In the above example the type of the default for <tt class="docutils literal">color</tt> is <tt class="docutils literal"><span class="pre">mpl::false_</span></tt>, a
-type that is distinct from any color map that the user might supply.</p>
-<p>When binding the case outlined above, the default type for <tt class="docutils literal">color</tt> will not
-be convertible to the parameter type. Therefore we need to tag the <tt class="docutils literal">color</tt>
-keyword as a <em>special</em> keyword. This is done by specifying the tag as
-<tt class="docutils literal"><span class="pre">tag::color**</span></tt> when binding the function (see <a class="reference internal" href="#concept-parameterspec">concept ParameterSpec</a> for
-more details on the tagging). By doing this we tell the binding functions that
-it needs to generate two overloads, one with the <tt class="docutils literal">color</tt> parameter present
-and one without. Had there been two <em>special</em> keywords, four overloads would
-need to be generated. The number of generated overloads is equal to 2<sup>N</sup>, where <tt class="docutils literal">N</tt> is the number of <em>special</em> keywords.</p>
-</div>
-<hr class="docutils" />
-<div class="section" id="class-template-init">
-<h1><a class="toc-backref" href="#id11">class template <tt class="docutils literal">init</tt></a></h1>
-<p>Defines a named parameter enabled constructor.</p>
-<pre class="literal-block">
-template &lt;class ParameterSpecs&gt;
-struct init : python::def_visitor&lt;init&lt;ParameterSpecs&gt; &gt;
-{
-    template &lt;class Class&gt;
-    void def(Class&amp; class_);
-
-    template &lt;class CallPolicies&gt;
-    <em>def_visitor</em> operator[](CallPolicies const&amp; policies) const;
-};
-</pre>
-<!-- @ignore() -->
-<div class="section" id="init-requirements">
-<h2><tt class="docutils literal">init</tt> requirements</h2>
-<ul>
-<li><p class="first"><tt class="docutils literal">ParameterSpecs</tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element is a
-model of <span class="concept">ParameterSpec</span>.</p>
-</li>
-<li><p class="first">For every <tt class="docutils literal">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity
-range</strong> of <tt class="docutils literal">ParameterSpecs</tt>, <tt class="docutils literal">Class</tt> must support these
-expressions:</p>
-<table border="1" class="docutils">
-<colgroup>
-<col width="30%" />
-<col width="17%" />
-<col width="53%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th class="head"><p class="first last">Expression</p>
-</th>
-<th class="head"><p class="first last">Return type</p>
-</th>
-<th class="head"><p class="first last">Requirements</p>
-</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><p class="first last"><tt class="docutils literal">Class(a0, …, aN)</tt></p>
-</td>
-<td><p class="first last">-</p>
-</td>
-<td><p class="first last"><tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt> are tagged arguments.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</li>
-</ul>
-</div>
-<div class="section" id="template-class-callpolicies-operator-callpolicies-const">
-<h2><tt class="docutils literal">template &lt;class CallPolicies&gt; <span class="pre">operator[](CallPolicies</span> const&amp;)</tt></h2>
-<p>Returns a <tt class="docutils literal">def_visitor</tt> equivalent to <tt class="docutils literal">*this</tt>, except that it
-uses CallPolicies when creating the binding.</p>
-</div>
-<div class="section" id="example">
-<h2>Example</h2>
-<pre class="literal-block">
-#include &lt;boost/parameter/keyword.hpp&gt;
-#include &lt;boost/parameter/preprocessor.hpp&gt;
-#include &lt;boost/parameter/python.hpp&gt;
-#include &lt;boost/python.hpp&gt;
-#include &lt;boost/mpl/vector.hpp&gt;
-
-BOOST_PARAMETER_KEYWORD(tag, x)
-BOOST_PARAMETER_KEYWORD(tag, y)
-
-struct base
-{
-    template &lt;class ArgumentPack&gt;
-    base(ArgumentPack const&amp; args)
-    {
-        <em>… use args …</em>
-    }
-};
-
-class X : base
-{
-public:
-    BOOST_PARAMETER_CONSTRUCTOR(X, (base), tag,
-        (required (x, *))
-        (optional (y, *))
-    )
-};
-
-BOOST_PYTHON_MODULE(<em>module name</em>)
-{
-    using namespace boost::python;
-    namespace py = boost::parameter::python;
-    namespace mpl = boost::mpl;
-
-    class_&lt;X&gt;(&quot;X&quot;, no_init)
-        .def(
-            py::init&lt;
-                mpl::vector&lt;tag::x(int), tag::y*(int)&gt;
-            &gt;()
-        );
-}
-</pre>
-<!-- @example.replace_emphasis('''
-assert(args[x] == 0);
-assert(args[y | 1] == 1);
-''') -->
-<!-- @example.replace_emphasis('my_module') -->
-<!-- @jam_prefix.append('import python ;') -->
-<!-- @jam_prefix.append('stage . : my_module /boost/python//boost_python ;') -->
-<!-- @my_module = build(
-    output = 'my_module'
-  , target_rule = 'python-extension'
-  , input = '/boost/python//boost_python'
-) -->
-</div>
-</div>
-<hr class="docutils" />
-<div class="section" id="class-template-call">
-<h1><a class="toc-backref" href="#id12">class template <tt class="docutils literal">call</tt></a></h1>
-<p>Defines a <tt class="docutils literal">__call__</tt> operator, mapped to <tt class="docutils literal">operator()</tt> in C++.</p>
-<pre class="literal-block">
-template &lt;class ParameterSpecs&gt;
-struct call : python::def_visitor&lt;call&lt;ParameterSpecs&gt; &gt;
-{
-    template &lt;class Class&gt;
-    void def(Class&amp; class_);
-
-    template &lt;class CallPolicies&gt;
-    <em>def_visitor</em> operator[](CallPolicies const&amp; policies) const;
-};
-</pre>
-<!-- @ignore() -->
-<div class="section" id="call-requirements">
-<h2><tt class="docutils literal">call</tt> requirements</h2>
-<ul>
-<li><p class="first"><tt class="docutils literal">ParameterSpecs</tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
-except the first models <span class="concept">ParameterSpec</span>. The first element
-is the result type of <tt class="docutils literal"><span class="pre">c(…)</span></tt>.</p>
-</li>
-<li><p class="first"><tt class="docutils literal">Class</tt> must support these expressions, where <tt class="docutils literal">c</tt> is an
-instance of <tt class="docutils literal">Class</tt>:</p>
-<table border="1" class="docutils">
-<colgroup>
-<col width="24%" />
-<col width="26%" />
-<col width="50%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th class="head"><p class="first last">Expression</p>
-</th>
-<th class="head"><p class="first last">Return type</p>
-</th>
-<th class="head"><p class="first last">Requirements</p>
-</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><p class="first last"><tt class="docutils literal">c(a0, …, aN)</tt></p>
-</td>
-<td><p class="first last">Convertible to <tt class="docutils literal">R</tt></p>
-</td>
-<td><p class="first last"><tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt> are tagged arguments.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<p>For every <tt class="docutils literal">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity range</strong> of <tt class="docutils literal">ParameterSpecs</tt>.</p>
-</li>
-</ul>
-</div>
-<div class="section" id="id3">
-<h2><tt class="docutils literal">template &lt;class CallPolicies&gt; <span class="pre">operator[](CallPolicies</span> const&amp;)</tt></h2>
-<p>Returns a <tt class="docutils literal">def_visitor</tt> equivalent to <tt class="docutils literal">*this</tt>, except that it
-uses CallPolicies when creating the binding.</p>
-</div>
-<div class="section" id="id4">
-<h2>Example</h2>
-<pre class="literal-block">
-#include &lt;boost/parameter/keyword.hpp&gt;
-#include &lt;boost/parameter/preprocessor.hpp&gt;
-#include &lt;boost/parameter/python.hpp&gt;
-#include &lt;boost/python.hpp&gt;
-#include &lt;boost/mpl/vector.hpp&gt;
-
-BOOST_PARAMETER_KEYWORD(tag, x)
-BOOST_PARAMETER_KEYWORD(tag, y)
-
-namespace parameter = boost::parameter;
-
-typedef parameter::parameters&lt;
-    parameter::required&lt;tag::x&gt;
-  , parameter::optional&lt;tag::y&gt;
-&gt; call_parameters;
-
-class X
-{
-public:
-    template &lt;class ArgumentPack&gt;
-    int call_impl(ArgumentPack const&amp; args)
-    {
-        <em>… use args …</em>
-    }
-
-    template &lt;class A0&gt;
-    int operator()(A0 const&amp; a0)
-    {
-        return call_impl(call_parameters()(a0));
-    }
-
-    template &lt;class A0, class A1&gt;
-    int operator()(A0 const&amp; a0, A1 const&amp; a1)
-    {
-        return call_impl(call_parameters()(a0,a1));
-    }
-};
-
-BOOST_PYTHON_MODULE(<em>module name</em>)
-{
-    using namespace boost::python;
-    namespace py = parameter::python;
-    namespace mpl = boost::mpl;
-
-    class_&lt;X&gt;(&quot;X&quot;)
-        .def(
-            py::call&lt;
-                mpl::vector&lt;int, tag::x(int), tag::y*(int)&gt;
-            &gt;()
-        );
-}
-</pre>
-<!-- @example.replace_emphasis('''
-assert(args[x] == 0);
-assert(args[y | 1] == 1);
-return 0;
-''') -->
-<!-- @example.replace_emphasis('my_module') -->
-<!-- @my_module = build(
-    output = 'my_module'
-  , target_rule = 'python-extension'
-  , input = '/boost/python//boost_python'
-) -->
-</div>
-</div>
-<hr class="docutils" />
-<div class="section" id="class-template-function">
-<h1><a class="toc-backref" href="#id13">class template <tt class="docutils literal">function</tt></a></h1>
-<p>Defines a named parameter enabled member function.</p>
-<pre class="literal-block">
-template &lt;class Fwd, class ParameterSpecs&gt;
-struct function : python::def_visitor&lt;function&lt;Fwd, ParameterSpecs&gt; &gt;
-{
-    template &lt;class Class, class Options&gt;
-    void def(Class&amp; class_, char const* name, Options const&amp; options);
-};
-</pre>
-<!-- @ignore() -->
-<div class="section" id="function-requirements">
-<h2><tt class="docutils literal">function</tt> requirements</h2>
-<ul>
-<li><p class="first"><tt class="docutils literal">ParameterSpecs</tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
-except the first models <span class="concept">ParameterSpec</span>. The first element
-is the result type of <tt class="docutils literal"><span class="pre">c.f(…)</span></tt>, where <tt class="docutils literal">f</tt> is the member
-function.</p>
-</li>
-<li><p class="first">An instance of <tt class="docutils literal">Fwd</tt> must support this expression:</p>
-<table border="1" class="docutils">
-<colgroup>
-<col width="39%" />
-<col width="18%" />
-<col width="43%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th class="head"><p class="first last">Expression</p>
-</th>
-<th class="head"><p class="first last">Return type</p>
-</th>
-<th class="head"><p class="first last">Requirements</p>
-</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><p class="first last"><tt class="docutils literal"><span class="pre">fwd(boost::type&lt;R&gt;(),</span> self, a0, …, aN)</tt></p>
-</td>
-<td><p class="first last">Convertible to <tt class="docutils literal">R</tt></p>
-</td>
-<td><p class="first last"><tt class="docutils literal">self</tt> is a reference to the object on which
-the function should be invoked. <tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt>
-are tagged arguments.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<p>For every <tt class="docutils literal">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity range</strong> of <tt class="docutils literal">ParameterSpecs</tt>.</p>
-</li>
-</ul>
-</div>
-<div class="section" id="id5">
-<h2>Example</h2>
-<p>This example exports a member function <tt class="docutils literal">f(int x, int y = …)</tt> to Python. The
-sequence of <span class="concept">ParameterSpec</span>'s <tt class="docutils literal"><span class="pre">mpl::vector2&lt;tag::x(int),</span> <span class="pre">tag::y*(int)&gt;</span></tt> has
-an <strong>arity range</strong> of [2,2], so we only need one forwarding overload.</p>
-<pre class="literal-block">
-#include &lt;boost/parameter/keyword.hpp&gt;
-#include &lt;boost/parameter/preprocessor.hpp&gt;
-#include &lt;boost/parameter/python.hpp&gt;
-#include &lt;boost/python.hpp&gt;
-#include &lt;boost/mpl/vector.hpp&gt;
-
-BOOST_PARAMETER_KEYWORD(tag, x)
-BOOST_PARAMETER_KEYWORD(tag, y)
-
-class X
-{
-public:
-    BOOST_PARAMETER_MEMBER_FUNCTION((void), f, tag,
-        (required (x, *))
-        (optional (y, *, 1))
-    )
-    {
-        <em>…</em>
-    }
-};
-
-struct f_fwd
-{
-    template &lt;class A0, class A1&gt;
-    void operator()(boost::type&lt;void&gt;, X&amp; self, A0 const&amp; a0, A1 const&amp; a1)
-    {
-        self.f(a0, a1);
-    }
-};
-
-BOOST_PYTHON_MODULE(<em>module name</em>)
-{
-    using namespace boost::python;
-    namespace py = boost::parameter::python;
-    namespace mpl = boost::mpl;
-
-    class_&lt;X&gt;(&quot;X&quot;)
-        .def(&quot;f&quot;,
-            py::function&lt;
-                f_fwd
-              , mpl::vector&lt;void, tag::x(int), tag::y*(int)&gt;
-            &gt;()
-        );
-}
-</pre>
-<!-- @example.replace_emphasis('''
-assert(x == 0);
-assert(y == 1);
-''') -->
-<!-- @example.replace_emphasis('my_module') -->
-<!-- @my_module = build(
-    output = 'my_module'
-  , target_rule = 'python-extension'
-  , input = '/boost/python//boost_python'
-) -->
-</div>
-</div>
-<hr class="docutils" />
-<div class="section" id="function-template-def">
-<h1><a class="toc-backref" href="#id14">function template <tt class="docutils literal">def</tt></a></h1>
-<p>Defines a named parameter enabled free function in the current Python scope.</p>
-<pre class="literal-block">
-template &lt;class Fwd, class ParameterSpecs&gt;
-void def(char const* name);
-</pre>
-<!-- @ignore() -->
-<div class="section" id="def-requirements">
-<h2><tt class="docutils literal">def</tt> requirements</h2>
-<ul>
-<li><p class="first"><tt class="docutils literal">ParameterSpecs</tt> is an <a class="reference external" href="../../../mpl/doc/refmanual/sequences.html">MPL sequence</a> where each element
-except the first models <span class="concept">ParameterSpec</span>. The first element
-is the result type of <tt class="docutils literal"><span class="pre">f(…)</span></tt>, where <tt class="docutils literal">f</tt> is the function.</p>
-</li>
-<li><p class="first">An instance of <tt class="docutils literal">Fwd</tt> must support this expression:</p>
-<table border="1" class="docutils">
-<colgroup>
-<col width="39%" />
-<col width="21%" />
-<col width="40%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th class="head"><p class="first last">Expression</p>
-</th>
-<th class="head"><p class="first last">Return type</p>
-</th>
-<th class="head"><p class="first last">Requirements</p>
-</th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><p class="first last"><tt class="docutils literal"><span class="pre">fwd(boost::type&lt;R&gt;(),</span> a0, …, aN)</tt></p>
-</td>
-<td><p class="first last">Convertible to <tt class="docutils literal">R</tt></p>
-</td>
-<td><p class="first last"><tt class="docutils literal">a0</tt>…<tt class="docutils literal">aN</tt> are tagged arguments.</p>
-</td>
-</tr>
-</tbody>
-</table>
-<p>For every <tt class="docutils literal">N</tt> in <tt class="docutils literal">[U,V]</tt>, where <tt class="docutils literal">[U,V]</tt> is the <strong>arity range</strong> of <tt class="docutils literal">ParameterSpecs</tt>.</p>
-</li>
-</ul>
-</div>
-<div class="section" id="id6">
-<h2>Example</h2>
-<p>This example exports a function <tt class="docutils literal">f(int x, int y = …)</tt> to Python. The
-sequence of <span class="concept">ParameterSpec</span>'s <tt class="docutils literal"><span class="pre">mpl::vector2&lt;tag::x(int),</span> <span class="pre">tag::y*(int)&gt;</span></tt> has
-an <strong>arity range</strong> of [2,2], so we only need one forwarding overload.</p>
-<pre class="literal-block">
-BOOST_PARAMETER_FUNCTION((void), f, tag,
-    (required (x, *))
-    (optional (y, *, 1))
-)
-{
-    <em>…</em>
-}
-
-struct f_fwd
-{
-    template &lt;class A0, class A1&gt;
-    void operator()(boost::type&lt;void&gt;, A0 const&amp; a0, A1 const&amp; a1)
-    {
-        f(a0, a1);
-    }
-};
-
-BOOST_PYTHON_MODULE(…)
-{
-    def&lt;
-        f_fwd
-      , mpl::vector&lt;
-            void, tag::x(int), tag::y*(int)
-        &gt;
-    &gt;(&quot;f&quot;);
-}
-</pre>
-<!-- @ignore() -->
-<!-- again, the undefined ``fwd`` identifier. -->
-</div>
-</div>
-<div class="section" id="portability">
-<h1><a class="toc-backref" href="#id15">Portability</a></h1>
-<p>The Boost.Parameter Python binding library requires <em>partial template
-specialization</em>.</p>
-</div>
-</div>
-<div class="footer">
-<hr class="footer" />
-Generated on: 2011-11-08 21:40 UTC.
-Generated by <a class="reference external" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference external" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
-
-</div>
-</body>
-</html>
--- a/doc/html/rst.css
+++ b/doc/html/rst.css
--- a/doc/html/vellipsis.gif
+++ b/doc/html/vellipsis.gif
--- a/doc/index.rst
+++ b/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
@@ -1800,7 +1800,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
 ==========================
@@ -2285,7 +2285,7 @@ enclosing namespace without qualification::
 Follow `this link`__ for documentation on how to expose
 Boost.Parameter-enabled functions to Python with `Boost.Python`_.

-__ python.html
+__ ../../../parameter_python/doc/html/index.html

 ===========
 Reference
--- a/doc/python.rst
+++ b/doc/python.rst
@@ -1,778 +0,0 @@
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- The Boost Parameter Library Python Binding Documentation 
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-:Authors:       David Abrahams, Daniel Wallin
-:Contact:       dave@boost-consulting.com, daniel@boostpro.com
-:organization:  `BoostPro Computing`_
-:date:          $Date$
-
-:copyright:     Copyright David Abrahams, Daniel Wallin
-                2005-2009. Distributed under the Boost Software License,
-                Version 1.0. (See accompanying file LICENSE_1_0.txt
-                or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-:abstract:      Makes it possible to bind Boost.Parameter-enabled
-                functions, operators and constructors to Python.
-
-|(logo)|__
-
-.. |(logo)| image:: ../../../../boost.png
-   :alt: Boost
-
-__ ../../../../index.htm
-
-.. _`BoostPro Computing`: http://www.boostpro.com
-
-
-.. role:: class
-    :class: class
-
-.. role:: concept
-    :class: concept
-
-.. role:: function
-    :class: function
-
-.. |ParameterSpec| replace:: :concept:`ParameterSpec`
-
-.. contents::
-    :depth: 1
-
-Introduction
------------
-
-``boost/parameter/python.hpp`` introduces a group of |def_visitors|_ that can
-be used to easily expose Boost.Parameter-enabled member functions to Python with 
-Boost.Python. It also provides a function template ``def()`` that can be used
-to expose Boost.Parameter-enabled free functions.
-
-.. |def_visitor| replace:: ``def_visitor``
-.. |def_visitors| replace:: ``def_visitors``
-
-.. _def_visitor: def_visitors_
-.. _def_visitors: ../../../python/doc/v2/def_visitor.html
-
-When binding a Boost.Parameter enabled function, the keyword tags
-must be specified.  Additionally, because Boost.Parameter enabled
-functions are templates, the desired function signature must be
-specified.
-
-..  The keyword tags are specified as an `MPL Sequence`_, using the
-    pointer qualifications described in |ParameterSpec|_ below.  The
-    signature is also specifid as an `MPL sequence`_ of parameter
-    types. Additionally, ``boost::parameter::python::function`` and
-    ``boost::parameter::python::def`` requires a class with forwarding
-    overloads. We will take a closer look at how this is done in the
-    tutorial section below.
-
-The keyword tags and associated argument types are specified as an `MPL
-Sequence`_, using the function type syntax described in |ParameterSpec|_
-below. Additionally, ``boost::parameter::python::function`` and
-``boost::parameter::python::def`` requires a class with forwarding overloads.
-We will take a closer look at how this is done in the tutorial section below.
-
-.. The last two sentences are terribly vague.  Which namespace is
-.. ``function`` in?  Isn't the return type always needed?  What
-.. else are we going to do other than pass these sequences to
-.. function?
-
-.. _`MPL Sequence`: ../../../mpl/doc/refmanual/sequences.html
-.. _parameterspec: `concept ParameterSpec`_
-
-Tutorial
--------
-
-In this section we will outline the steps needed to bind a simple
-Boost.Parameter-enabled member function to Python. Knowledge of the
-Boost.Parameter macros_ are required to understand this section.
-
-.. _macros: index.html
-
-The class and member function we are interested in binding looks
-like this:
-
-.. parsed-literal::
-
-  #include <boost/parameter/keyword.hpp>
-  #include <boost/parameter/preprocessor.hpp>
-  #include <boost/parameter/python.hpp>
-  #include <boost/python.hpp>
-
-  // First the keywords
-  BOOST_PARAMETER_KEYWORD(tag, title)
-  BOOST_PARAMETER_KEYWORD(tag, width)
-  BOOST_PARAMETER_KEYWORD(tag, height)
-
-  class window
-  {
-  public:
-      BOOST_PARAMETER_MEMBER_FUNCTION(
-        (void), open, tag,
-        (required (title, (std::string)))
-        (optional (width, (unsigned), 400)
-                  (height, (unsigned), 400))
-      )
-      {
-          *… function implementation …*
-      }
-  };
-
-.. @example.prepend('#include <cassert>')
-.. @example.replace_emphasis('''
-   assert(title == "foo");
-   assert(height == 20);
-   assert(width == 400);
-   ''')
-
-It defines a set of overloaded member functions called ``open`` with one
-required parameter and two optional ones. To bind this member function to
-Python we use the binding utility ``boost::parameter::python::function``.
-``boost::parameter::python::function`` is a |def_visitor|_ that we'll instantiate
-and pass to ``boost::python::class_::def()``.
-
-To use ``boost::parameter::python::function`` we first need to define
-a class with forwarding overloads. This is needed because ``window::open()``
-is a function template, so we can't refer to it in any other way. 
-
-::
-
-  struct open_fwd
-  {
-      template <class A0, class A1, class A2>
-      void operator()(
-          boost::type<void>, window& self
-        , A0 const& a0, A1 const& a1, A2 const& a2
-      )
-      {
-          self.open(a0, a1, a2);
-      }
-  };
-
-The first parameter, ``boost::type<void>``, tells the forwarding overload
-what the return type should be. In this case we know that it's always void
-but in some cases, when we are exporting several specializations of a
-Boost.Parameter-enabled template, we need to use that parameter to
-deduce the return type.
-
-``window::open()`` takes a total of 3 parameters, so the forwarding function
-needs to take three parameters as well.
-
-.. Note::
-
-    We only need one overload in the forwarding class, despite the
-    fact that there are two optional parameters. There are special
-    circumstances when several overload are needed; see 
-    `special keywords`_.
-
-Next we'll define the module and export the class:
-
-::
-
-  BOOST_PYTHON_MODULE(my_module)
-  {
-      using namespace boost::python;
-      namespace py = boost::parameter::python;
-      namespace mpl = boost::mpl;
-
-      class_<window>("window")
-          .def(
-              "open", py::function<
-                  open_fwd
-                , mpl::vector<
-                      void
-                    , tag::title(std::string)
-                    , tag::width*(unsigned)
-                    , tag::height*(unsigned)
-                  >
-              >()
-          );
-  }
-
-.. @jam_prefix.append('import python ;')
-.. @jam_prefix.append('stage . : my_module /boost/python//boost_python ;')
-.. @my_module = build(
-        output = 'my_module'
-      , target_rule = 'python-extension'
-      , input = '/boost/python//boost_python'
-      , howmany = 'all'
-    )
-
-.. @del jam_prefix[:]
-
-``py::function`` is passed two parameters. The first one is the class with
-forwarding overloads that we defined earlier. The second one is an `MPL
-Sequence`_ with the keyword tag types and argument types for the function
-specified as function types. The pointer syntax used in ``tag::width*`` and
-``tag::height*`` means that the parameter is optional. The first element of
-the `MPL Sequence`_ is the return type of the function, in this case ``void``,
-which is passed as the first argument to ``operator()`` in the forwarding
-class.
-
-..  The
-    pointer syntax means that the parameter is optional, so in this case
-    ``width`` and ``height`` are optional parameters. The third parameter
-    is an `MPL Sequence`_ with the desired function signature. The return type comes first, and
-    then the parameter types:
-
-    .. parsed-literal::
-
-        mpl::vector<void,        std::string, unsigned, unsigned>
-                    *return type*  *title*        *width*     *height*
-
-    .. @ignore()
-
-That's it! This class can now be used in Python with the expected syntax::
-
-    >>> w = my_module.window()
-    >>> w.open(title = "foo", height = 20)
-
-.. @example.prepend('import my_module')
-.. @run_python(module_path = my_module)
-
-.. Sorry to say this at such a late date, but this syntax really
-.. strikes me as cumbersome.  Couldn't we do something like:
-
-    class_<window>("window")
-          .def(
-              "open", 
-              (void (*)( 
-                  tag::title(std::string), 
-                  tag::width*(unsigned), 
-                  tag::height*(unsigned)) 
-              )0
-          );
-
-   or at least:
-
-      class_<window>("window")
-          .def(
-              "open", 
-              mpl::vector<
-                  void, 
-                  tag::title(std::string), 
-                  tag::width*(unsigned), 
-                  tag::height*(unsigned)
-              >()
-          );
-
-   assuming, that is, that we will have to repeat the tags (yes,
-   users of broken compilers will have to give us function pointer
-   types instead).
-
------------------------------------------------------------------------------
-
-concept |ParameterSpec|
-----------------------
-
-A |ParameterSpec| is a function type ``K(T)`` that describes both the keyword tag,
-``K``, and the argument type, ``T``, for a parameter.
-
-``K`` is either:
-
-* A *required* keyword of the form ``Tag``
-* **or**, an *optional* keyword of the form ``Tag*``
-* **or**, a *special* keyword of the form ``Tag**``
-
-where ``Tag`` is a keyword tag type, as used in a specialization
-of |keyword|__.
-
-.. |keyword| replace:: ``boost::parameter::keyword``
-__ ../../../parameter/doc/html/reference.html#keyword
-
-The **arity range** for an `MPL Sequence`_ of |ParameterSpec|'s is
-defined as the closed range:
-
-.. parsed-literal::
-
-  [ mpl::size<S> - number of *special* keyword tags in ``S``, mpl::size<S> ]
-
-For example, the **arity range** of ``mpl::vector2<x(int),y(int)>`` is ``[2,2]``,
-the **arity range** of ``mpl::vector2<x(int),y*(int)>`` is ``[2,2]`` and the
-**arity range** of ``mpl::vector2<x(int),y**(int)>`` is ``[1,2]``.
-
-
-
-*special* keywords
---------------------------------
-
-Sometimes it is desirable to have a default value for a parameter that differ
-in type from the parameter. This technique is useful for doing simple tag-dispatching
-based on the presence of a parameter. For example:
-
-.. An example_ of this is given in the Boost.Parameter
-   docs. The example uses a different technique, but could also have been written like this:
-
-.. parsed-literal::
-
-  namespace core
-  {
-    template <class ArgumentPack>
-    void dfs_dispatch(ArgumentPack const& args, mpl::false\_)
-    {
-        *…compute and use default color map…*
-    }
-
-    template <class ArgumentPack, class ColorMap>
-    void dfs_dispatch(ArgumentPack const& args, ColorMap colormap)
-    {
-        *…use colormap…*
-    }
-  }
-
-  template <class ArgumentPack>
-  void depth_first_search(ArgumentPack const& args)
-  {
-      core::dfs_dispatch(args, args[color | mpl::false_()]);
-  }
-
-.. @example.prepend('''
-   #include <boost/parameter/keyword.hpp>
-   #include <boost/parameter/parameters.hpp>
-   #include <boost/mpl/bool.hpp>
-   #include <cassert>
-
-   BOOST_PARAMETER_KEYWORD(tag, color);
-
-   typedef boost::parameter::parameters<tag::color> params;
-
-   namespace mpl = boost::mpl;
-   ''')
-
-.. @example.replace_emphasis('''
-   assert(args[color | 1] == 1);
-   ''')
-
-.. @example.replace_emphasis('''
-   assert(args[color | 1] == 0);
-   ''')
-
-.. @example.append('''
-   int main()
-   {
-       depth_first_search(params()());
-       depth_first_search(params()(color = 0));
-   }''')
-
-.. @build()
-
-.. .. _example: index.html#dispatching-based-on-the-presence-of-a-default
-
-In the above example the type of the default for ``color`` is ``mpl::false_``, a
-type that is distinct from any color map that the user might supply.
-
-When binding the case outlined above, the default type for ``color`` will not
-be convertible to the parameter type. Therefore we need to tag the ``color``
-keyword as a *special* keyword. This is done by specifying the tag as
-``tag::color**`` when binding the function (see `concept ParameterSpec`_ for
-more details on the tagging). By doing this we tell the binding functions that
-it needs to generate two overloads, one with the ``color`` parameter present
-and one without. Had there been two *special* keywords, four overloads would
-need to be generated. The number of generated overloads is equal to 2\
-:sup:`N`, where ``N`` is the number of *special* keywords.
-
------------------------------------------------------------------------------
-
-class template ``init``
-----------------------
-
-Defines a named parameter enabled constructor.
-
-.. parsed-literal::
-
-    template <class ParameterSpecs>
-    struct init : python::def_visitor<init<ParameterSpecs> >
-    {
-        template <class Class> 
-        void def(Class& class\_);
-
-        template <class CallPolicies>
-        *def\_visitor* operator[](CallPolicies const& policies) const;
-    };
-
-.. @ignore()
-
-``init`` requirements 
-~~~~~~~~~~~~~~~~~~~~~
-
-* ``ParameterSpecs`` is an `MPL sequence`_ where each element is a
-  model of |ParameterSpec|. 
-* For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity
-  range** of ``ParameterSpecs``, ``Class`` must support these
-  expressions: 
-
-  ======================= ============= =========================================
-  Expression              Return type   Requirements
-  ======================= ============= =========================================
-  ``Class(a0, …, aN)``    \-            ``a0``\ …\ ``aN`` are tagged arguments.
-  ======================= ============= =========================================
-
-
-
-``template <class CallPolicies> operator[](CallPolicies const&)``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Returns a ``def_visitor`` equivalent to ``*this``, except that it
-uses CallPolicies when creating the binding.
-
-
-Example
-~~~~~~~
-
-.. parsed-literal::
-
-    #include <boost/parameter/keyword.hpp>
-    #include <boost/parameter/preprocessor.hpp>
-    #include <boost/parameter/python.hpp>
-    #include <boost/python.hpp>
-    #include <boost/mpl/vector.hpp>
-
-    BOOST_PARAMETER_KEYWORD(tag, x)
-    BOOST_PARAMETER_KEYWORD(tag, y)
-
-    struct base 
-    { 
-        template <class ArgumentPack>
-        base(ArgumentPack const& args)
-        {
-            *… use args …*
-        }
-    };
-
-    class X : base
-    {
-    public:
-        BOOST_PARAMETER_CONSTRUCTOR(X, (base), tag,
-            (required (x, \*))
-            (optional (y, \*))
-        )
-    };
-
-    BOOST_PYTHON_MODULE(*module name*)
-    {
-        using namespace boost::python;
-        namespace py = boost::parameter::python;
-        namespace mpl = boost::mpl;
-
-        class_<X>("X", no_init)
-            .def(
-                py::init<
-                    mpl::vector<tag::x(int), tag::y\*(int)>
-                >()
-            );
-    }
-
-.. @example.replace_emphasis('''
-   assert(args[x] == 0);
-   assert(args[y | 1] == 1);
-   ''')
-
-.. @example.replace_emphasis('my_module')
-
-.. @jam_prefix.append('import python ;')
-.. @jam_prefix.append('stage . : my_module /boost/python//boost_python ;')
-.. @my_module = build(
-        output = 'my_module'
-      , target_rule = 'python-extension'
-      , input = '/boost/python//boost_python'
-    )
-
------------------------------------------------------------------------------
-
-class template ``call``
-----------------------
-
-Defines a ``__call__`` operator, mapped to ``operator()`` in C++.
-
-.. parsed-literal::
-
-    template <class ParameterSpecs>
-    struct call : python::def_visitor<call<ParameterSpecs> >
-    {
-        template <class Class> 
-        void def(Class& class\_);
-
-        template <class CallPolicies>
-        *def\_visitor* operator[](CallPolicies const& policies) const;
-    };
-
-.. @ignore()
-
-``call`` requirements 
-~~~~~~~~~~~~~~~~~~~~~
-
-* ``ParameterSpecs`` is an `MPL sequence`_ where each element
-  except the first models |ParameterSpec|. The first element
-  is the result type of ``c(…)``.
-* ``Class`` must support these expressions, where ``c`` is an 
-  instance of ``Class``:
-
-  =================== ==================== =======================================
-  Expression          Return type          Requirements
-  =================== ==================== =======================================
-  ``c(a0, …, aN)``    Convertible to ``R`` ``a0``\ …\ ``aN`` are tagged arguments.
-  =================== ==================== =======================================
-
-  For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity range** of ``ParameterSpecs``.
-
-
-``template <class CallPolicies> operator[](CallPolicies const&)``
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Returns a ``def_visitor`` equivalent to ``*this``, except that it
-uses CallPolicies when creating the binding.
-
-
-Example
-~~~~~~~
-
-.. parsed-literal::
-
-    #include <boost/parameter/keyword.hpp>
-    #include <boost/parameter/preprocessor.hpp>
-    #include <boost/parameter/python.hpp>
-    #include <boost/python.hpp>
-    #include <boost/mpl/vector.hpp>
-
-    BOOST_PARAMETER_KEYWORD(tag, x)
-    BOOST_PARAMETER_KEYWORD(tag, y)
-
-    namespace parameter = boost::parameter;
-
-    typedef parameter::parameters<
-        parameter::required<tag::x>
-      , parameter::optional<tag::y>
-    > call_parameters;
-
-    class X
-    {
-    public:
-        template <class ArgumentPack>
-        int call_impl(ArgumentPack const& args)
-        {
-            *… use args …*
-        }
-
-        template <class A0>
-        int operator()(A0 const& a0)
-        {
-            return call_impl(call_parameters()(a0));
-        }
-
-        template <class A0, class A1>
-        int operator()(A0 const& a0, A1 const& a1)
-        {
-            return call_impl(call_parameters()(a0,a1));
-        }
-    };
-
-    BOOST_PYTHON_MODULE(*module name*)
-    {
-        using namespace boost::python;
-        namespace py = parameter::python;
-        namespace mpl = boost::mpl;
-
-        class_<X>("X")
-            .def(
-                py::call<
-                    mpl::vector<int, tag::x(int), tag::y\*(int)>
-                >()
-            );
-    }    
-
-.. @example.replace_emphasis('''
-   assert(args[x] == 0);
-   assert(args[y | 1] == 1);
-   return 0;
-   ''')
-
-.. @example.replace_emphasis('my_module')
-
-.. @my_module = build(
-        output = 'my_module'
-      , target_rule = 'python-extension'
-      , input = '/boost/python//boost_python'
-    )
-
------------------------------------------------------------------------------
-
-class template ``function``
---------------------------
-
-Defines a named parameter enabled member function.
-
-.. parsed-literal::
-
-    template <class Fwd, class ParameterSpecs>
-    struct function : python::def_visitor<function<Fwd, ParameterSpecs> >
-    {
-        template <class Class, class Options> 
-        void def(Class& class\_, char const* name, Options const& options);
-    };
-
-.. @ignore()
-
-``function`` requirements 
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-* ``ParameterSpecs`` is an `MPL sequence`_ where each element
-  except the first models |ParameterSpec|. The first element
-  is the result type of ``c.f(…)``, where ``f`` is the member
-  function.
-* An instance of ``Fwd`` must support this expression:
-
-  ============================================ ==================== =================================================
-  Expression                                   Return type          Requirements
-  ============================================ ==================== =================================================
-  ``fwd(boost::type<R>(), self, a0, …, aN)``   Convertible to ``R`` ``self`` is a reference to the object on which
-                                                                    the function should be invoked. ``a0``\ …\ ``aN``
-                                                                    are tagged arguments.
-  ============================================ ==================== =================================================
-
-  For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity range** of ``ParameterSpecs``.
-
-
-Example
-~~~~~~~
-
-This example exports a member function ``f(int x, int y = …)`` to Python. The
-sequence of |ParameterSpec|'s ``mpl::vector2<tag::x(int), tag::y*(int)>`` has
-an **arity range** of [2,2], so we only need one forwarding overload.
-
-.. parsed-literal::
-
-    #include <boost/parameter/keyword.hpp>
-    #include <boost/parameter/preprocessor.hpp>
-    #include <boost/parameter/python.hpp>
-    #include <boost/python.hpp>
-    #include <boost/mpl/vector.hpp>
-
-    BOOST_PARAMETER_KEYWORD(tag, x)
-    BOOST_PARAMETER_KEYWORD(tag, y)
-
-    class X
-    {
-    public:
-        BOOST_PARAMETER_MEMBER_FUNCTION((void), f, tag,
-            (required (x, \*))
-            (optional (y, \*, 1))
-        )
-        {
-            *…*
-        }
-    };
-
-    struct f_fwd
-    {
-        template <class A0, class A1>
-        void operator()(boost::type<void>, X& self, A0 const& a0, A1 const& a1)
-        {
-            self.f(a0, a1);
-        }
-    };
-
-    BOOST_PYTHON_MODULE(*module name*)
-    {
-        using namespace boost::python;
-        namespace py = boost::parameter::python;
-        namespace mpl = boost::mpl;
-
-        class_<X>("X")
-            .def("f",
-                py::function<
-                    f_fwd
-                  , mpl::vector<void, tag::x(int), tag::y\*(int)>
-                >()
-            );
-    }
-
-.. @example.replace_emphasis('''
-   assert(x == 0);
-   assert(y == 1);
-   ''')
-
-.. @example.replace_emphasis('my_module')
-
-.. @my_module = build(
-        output = 'my_module'
-      , target_rule = 'python-extension'
-      , input = '/boost/python//boost_python'
-    )
-
------------------------------------------------------------------------------
-
-function template ``def``
-------------------------
-
-Defines a named parameter enabled free function in the current Python scope.
-
-.. parsed-literal::
-
-    template <class Fwd, class ParameterSpecs>
-    void def(char const* name);
-
-.. @ignore()
-
-``def`` requirements 
-~~~~~~~~~~~~~~~~~~~~
-
-* ``ParameterSpecs`` is an `MPL sequence`_ where each element
-  except the first models |ParameterSpec|. The first element
-  is the result type of ``f(…)``, where ``f`` is the function.
-* An instance of ``Fwd`` must support this expression:
-
-  ====================================== ==================== =======================================
-  Expression                             Return type          Requirements
-  ====================================== ==================== =======================================
-  ``fwd(boost::type<R>(), a0, …, aN)``   Convertible to ``R`` ``a0``\ …\ ``aN`` are tagged arguments.
-  ====================================== ==================== =======================================
-
-  For every ``N`` in ``[U,V]``, where ``[U,V]`` is the **arity range** of ``ParameterSpecs``.
-
-
-Example
-~~~~~~~
-
-This example exports a function ``f(int x, int y = …)`` to Python. The
-sequence of |ParameterSpec|'s ``mpl::vector2<tag::x(int), tag::y*(int)>`` has
-an **arity range** of [2,2], so we only need one forwarding overload.
-
-.. parsed-literal::
-
-    BOOST_PARAMETER_FUNCTION((void), f, tag,
-        (required (x, \*))
-        (optional (y, \*, 1))
-    )
-    {
-        *…*
-    }
-
-    struct f_fwd
-    {
-        template <class A0, class A1>
-        void operator()(boost::type<void>, A0 const& a0, A1 const& a1)
-        {
-            f(a0, a1);
-        }
-    };
-
-    BOOST_PYTHON_MODULE(…)
-    {
-        def<
-            f_fwd
-          , mpl::vector<
-                void, tag::\ x(int), tag::\ y\*(int)
-            >
-        >("f");
-    }
-
-.. @ignore()
-
-.. again, the undefined ``fwd`` identifier.
-
-Portability
-----------
-
-The Boost.Parameter Python binding library requires *partial template
-specialization*.
-
--- a/include/boost/parameter.hpp
+++ b/include/boost/parameter.hpp
--- a/include/boost/parameter/aux_/arg_list.hpp
+++ b/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
@@ -358,6 +339,7 @@ struct arg_list : Next
    template <class Default>
    reference operator[](lazy_default<key_type, Default>) const
    {
+        BOOST_MPL_ASSERT_NOT((holds_maybe));
        return arg.value;
    }

@@ -407,10 +389,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
--- a/include/boost/parameter/aux_/cast.hpp
+++ b/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

--- a/include/boost/parameter/aux_/default.hpp
+++ b/include/boost/parameter/aux_/default.hpp
--- a/include/boost/parameter/aux_/overloads.hpp
+++ b/include/boost/parameter/aux_/overloads.hpp
--- a/include/boost/parameter/aux_/parameter_requirements.hpp
+++ b/include/boost/parameter/aux_/parameter_requirements.hpp
--- a/include/boost/parameter/aux_/parenthesized_type.hpp
+++ b/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)>
 {
--- a/include/boost/parameter/aux_/preprocessor/flatten.hpp
+++ b/include/boost/parameter/aux_/preprocessor/flatten.hpp
--- a/include/boost/parameter/aux_/preprocessor/for_each.hpp
+++ b/include/boost/parameter/aux_/preprocessor/for_each.hpp
--- a/include/boost/parameter/aux_/python/invoker.hpp
+++ b/include/boost/parameter/aux_/python/invoker.hpp
@@ -1,132 +0,0 @@
-// Copyright Daniel Wallin 2005. Use, modification and distribution is
-// subject to the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PARAMETER_INVOKER_051210_HPP
-# define BOOST_PARAMETER_INVOKER_051210_HPP
-
-# include <boost/mpl/begin.hpp>
-# include <boost/mpl/next.hpp>
-# include <boost/mpl/deref.hpp>
-# include <boost/mpl/size.hpp>
-# include <boost/parameter/keyword.hpp>
-# include <boost/preprocessor/iteration/iterate.hpp>
-
-namespace boost { namespace parameter { namespace python { namespace aux {
-
-template <long Arity, class M, class R, class Args>
-struct invoker;
-
-template <class M, class R>
-struct make_invoker
-{
-    template <class Args>
-    struct apply
-    {
-        typedef invoker<
-            mpl::size<Args>::value, M, R, Args
-        > type;
-    };
-};
-
-template <long Arity, class M, class R, class T, class Args>
-struct member_invoker;
-
-template <class M, class R, class T>
-struct make_member_invoker
-{
-    template <class Args>
-    struct apply
-    {
-        typedef member_invoker<
-            mpl::size<Args>::value, M, R, T, Args
-        > type;
-    };
-};
-
-template <long Arity, class T, class R, class Args>
-struct call_invoker;
-
-template <class T, class R>
-struct make_call_invoker
-{
-    template <class Args>
-    struct apply
-    {
-        typedef call_invoker<
-            mpl::size<Args>::value, T, R, Args
-        > type;
-    };
-};
-
-template <long Arity, class T, class Args>
-struct init_invoker;
-
-template <class T>
-struct make_init_invoker
-{
-    template <class Args>
-    struct apply
-    {
-        typedef init_invoker<
-            mpl::size<Args>::value, T, Args
-        > type;
-    };
-};
-
-template <class M, class R, class Args>
-struct invoker<0, M, R, Args>
-{
-    static R execute()
-    {
-        return M()(boost::type<R>());
-    }
-};
-
-template <class M, class R, class T, class Args>
-struct member_invoker<0, M, R, T, Args>
-{
-    static R execute(T& self)
-    {
-        return M()(boost::type<R>(), self);
-    }
-};
-
-template <class T, class R, class Args>
-struct call_invoker<0, T, R, Args>
-{
-    static R execute(T& self)
-    {
-        return self();
-    }
-};
-
-template <class T, class Args>
-struct init_invoker<0, T, Args>
-{
-    static T* execute(T& self)
-    {
-        return new T;
-    }
-};
-
-# define BOOST_PP_ITERATION_PARAMS_1 (4, \
-    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 1))
-# include BOOST_PP_ITERATE()
-
-# define BOOST_PP_ITERATION_PARAMS_1 (4, \
-    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 2))
-# include BOOST_PP_ITERATE()
-
-# define BOOST_PP_ITERATION_PARAMS_1 (4, \
-    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 3))
-# include BOOST_PP_ITERATE()
-
-# define BOOST_PP_ITERATION_PARAMS_1 (4, \
-    (1, BOOST_PARAMETER_MAX_ARITY, <boost/parameter/aux_/python/invoker_iterate.hpp>, 4))
-# include BOOST_PP_ITERATE()
-
-}}}} // namespace boost::parameter::python::aux
-
-#endif // BOOST_PARAMETER_INVOKER_051210_HPP
-
--- a/include/boost/parameter/aux_/python/invoker_iterate.hpp
+++ b/include/boost/parameter/aux_/python/invoker_iterate.hpp
@@ -1,93 +0,0 @@
-// Copyright Daniel Wallin 2005. Use, modification and distribution is
-// subject to the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/dec.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-
-#define N BOOST_PP_ITERATION()
-
-#define BOOST_PARAMETER_PY_ARG_TYPES(z, n, _) \
-    typedef typename mpl::next< \
-        BOOST_PP_CAT(iter,BOOST_PP_DEC(n)) \
-    >::type BOOST_PP_CAT(iter,n); \
-    \
-    typedef typename mpl::deref<BOOST_PP_CAT(iter,n)>::type BOOST_PP_CAT(spec,n); \
-    typedef typename mpl::if_< \
-        mpl::and_< \
-            mpl::not_<typename BOOST_PP_CAT(spec,n)::required> \
-          , typename BOOST_PP_CAT(spec,n)::optimized_default \
-        > \
-      , parameter::aux::maybe<typename BOOST_PP_CAT(spec,n)::type> \
-      , typename BOOST_PP_CAT(spec,n)::type \
-    >::type BOOST_PP_CAT(arg,n); \
-    typedef typename BOOST_PP_CAT(spec,n)::keyword BOOST_PP_CAT(kw,n);
-
-#if BOOST_PP_ITERATION_FLAGS() == 1
-template <class M, class R, class Args>
-struct invoker<N, M, R, Args>
-#elif BOOST_PP_ITERATION_FLAGS() == 2
-template <class T, class R, class Args>
-struct call_invoker<N, T, R, Args>
-#elif BOOST_PP_ITERATION_FLAGS() == 3
-template <class T, class Args>
-struct init_invoker<N, T, Args>
-#elif BOOST_PP_ITERATION_FLAGS() == 4
-template <class M, class R, class T, class Args>
-struct member_invoker<N, M, R, T, Args>
-#endif
-{
-    typedef typename mpl::begin<Args>::type iter0;
-    typedef typename mpl::deref<iter0>::type spec0;
-    typedef typename mpl::if_<
-        mpl::and_<
-            mpl::not_<typename spec0::required>
-          , typename spec0::optimized_default
-        >
-      , parameter::aux::maybe<typename spec0::type>
-      , typename spec0::type
-    >::type arg0;
-    typedef typename spec0::keyword kw0;
-
-    BOOST_PP_REPEAT_FROM_TO(1, N, BOOST_PARAMETER_PY_ARG_TYPES, ~)
-
-    static
-#if BOOST_PP_ITERATION_FLAGS() == 3
-    T*
-#else
-    R
-#endif 
-    execute(
-#if BOOST_PP_ITERATION_FLAGS() == 2 || BOOST_PP_ITERATION_FLAGS() == 4
-        T& self
-      ,
-#endif
-        BOOST_PP_ENUM_BINARY_PARAMS(N, arg, a)
-    )
-    {
-        return
-#if BOOST_PP_ITERATION_FLAGS() == 1 || BOOST_PP_ITERATION_FLAGS() == 4
-         M()(
-              boost::type<R>()
-# if BOOST_PP_ITERATION_FLAGS() == 4
-            , self
-# endif
-            , BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
-         );
-#elif BOOST_PP_ITERATION_FLAGS() == 2
-         self(
-            BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
-         );
-#elif BOOST_PP_ITERATION_FLAGS() == 3
-         new T(
-             BOOST_PP_ENUM_BINARY_PARAMS(N, parameter::keyword<kw, >::get() = a)
-         );
-#endif
-    }
-};
-
-#undef BOOST_PARAMETER_PY_ARG_TYPES
-#undef N
-
--- a/include/boost/parameter/aux_/result_of0.hpp
+++ b/include/boost/parameter/aux_/result_of0.hpp
--- a/include/boost/parameter/aux_/set.hpp
+++ b/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>
--- a/include/boost/parameter/aux_/tag.hpp
+++ b/include/boost/parameter/aux_/tag.hpp
--- a/include/boost/parameter/aux_/tagged_argument.hpp
+++ b/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;
    }
--- a/include/boost/parameter/aux_/template_keyword.hpp
+++ b/include/boost/parameter/aux_/template_keyword.hpp
--- a/include/boost/parameter/aux_/unwrap_cv_reference.hpp
+++ b/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>
--- a/include/boost/parameter/aux_/void.hpp
+++ b/include/boost/parameter/aux_/void.hpp
--- a/include/boost/parameter/aux_/yesno.hpp
+++ b/include/boost/parameter/aux_/yesno.hpp
--- a/include/boost/parameter/binding.hpp
+++ b/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
--- a/include/boost/parameter/keyword.hpp
+++ b/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
--- a/include/boost/parameter/macros.hpp
+++ b/include/boost/parameter/macros.hpp
--- a/include/boost/parameter/match.hpp
+++ b/include/boost/parameter/match.hpp
--- a/include/boost/parameter/name.hpp
+++ b/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>
@@ -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), ~
--- a/include/boost/parameter/parameters.hpp
+++ b/include/boost/parameter/parameters.hpp
--- a/include/boost/parameter/preprocessor.hpp
+++ b/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>                                   \
@@ -896,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 \
@@ -915,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);                   \
@@ -1021,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 \
@@ -1057,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) \
            ) \
@@ -1148,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( \
--- a/include/boost/parameter/python.hpp
+++ b/include/boost/parameter/python.hpp
@@ -1,735 +0,0 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_PARAMETER_PYTHON_060209_HPP
-# define BOOST_PARAMETER_PYTHON_060209_HPP
-
-# include <boost/mpl/vector.hpp>
-# include <boost/mpl/fold.hpp>
-# include <boost/mpl/prior.hpp>
-# include <boost/mpl/shift_right.hpp>
-# include <boost/mpl/shift_left.hpp>
-# include <boost/mpl/bitand.hpp>
-# include <boost/mpl/pair.hpp>
-# include <boost/mpl/size.hpp>
-# include <boost/mpl/push_back.hpp>
-# include <boost/mpl/or.hpp>
-# include <boost/mpl/count_if.hpp>
-# include <boost/mpl/transform.hpp>
-# include <boost/mpl/front.hpp>
-# include <boost/mpl/iterator_range.hpp>
-# include <boost/mpl/next.hpp>
-# include <boost/mpl/begin_end.hpp>
-# include <boost/mpl/not.hpp>
-# include <boost/mpl/empty.hpp>
-# include <boost/python/def.hpp>
-# include <boost/python/make_constructor.hpp>
-# include <boost/python/init.hpp>
-# include <boost/python/to_python_converter.hpp>
-# include <boost/parameter/aux_/maybe.hpp>
-# include <boost/parameter/aux_/python/invoker.hpp>
-
-namespace boost { namespace parameter { namespace python 
-{
-  namespace python_ = boost::python;
-}}}
-
-namespace boost { namespace parameter { namespace python { namespace aux 
-{
-
-  inline PyObject* unspecified_type()
-  {
-      static PyTypeObject unspecified = {
-          PyObject_HEAD_INIT(NULL)
-          0,                                /* ob_size        */
-          "Boost.Parameter.Unspecified",    /* tp_name        */
-          PyType_Type.tp_basicsize,         /* tp_basicsize   */
-          0,                                /* tp_itemsize    */
-          0,                                /* tp_dealloc     */
-          0,                                /* tp_print       */
-          0,                                /* tp_getattr     */
-          0,                                /* tp_setattr     */
-          0,                                /* tp_compare     */
-          0,                                /* tp_repr        */
-          0,                                /* tp_as_number   */
-          0,                                /* tp_as_sequence */
-          0,                                /* tp_as_mapping  */
-          0,                                /* tp_hash        */
-          0,                                /* tp_call        */
-          0,                                /* tp_str         */
-          0,                                /* tp_getattro    */
-          0,                                /* tp_setattro    */
-          0,                                /* tp_as_buffer   */
-          Py_TPFLAGS_DEFAULT,               /* tp_flags       */
-          0,                                /* tp_doc         */
-      };
-
-      if (unspecified.ob_type == 0)
-      {
-          unspecified.ob_type = &PyType_Type;
-          PyType_Ready(&unspecified);
-      }
-
-      return (PyObject*)&unspecified;
-  }
-
-  struct empty_tag {};
-
-  struct empty_tag_to_python
-  {
-      static PyObject* convert(empty_tag)
-      {
-          return python_::xincref(unspecified_type());
-      }
-  };
-
-}}}} // namespace boost::parameter::python::aux
-
-namespace boost { namespace python 
-{
-
-  // Converts a Python value to a maybe<T>
-  template <class T>
-  struct arg_from_python<parameter::aux::maybe<T> >
-    : arg_from_python<T>
-  {
-      arg_from_python(PyObject* p)
-        : arg_from_python<T>(p)
-        , empty(parameter::python::aux::unspecified_type() == p)
-      {}
-
-      bool convertible() const
-      {
-          return empty || arg_from_python<T>::convertible();
-      }
-
-      parameter::aux::maybe<T> operator()()
-      {
-          if (empty)
-          {
-              return parameter::aux::maybe<T>();
-          }
-          else
-          {
-              return parameter::aux::maybe<T>(
-                  arg_from_python<T>::operator()()
-              );
-          }
-      }
-
-      bool empty;
-  };
-
-}} // namespace boost::python
-
-namespace boost { namespace parameter { namespace python {
-
-namespace aux
-{
-
-  template <class K>
-  struct is_optional
-    : mpl::not_<
-          mpl::or_<typename K::required, typename K::optimized_default>
-      >
-  {};
-
-  template <class K, class Required, class Optimized, class T>
-  struct arg_spec
-  {
-      typedef K keyword;
-      typedef Required required;
-      typedef T type;
-      typedef Optimized optimized_default;
-  };
-  
-  template <class K, class T, class Optimized = mpl::false_>
-  struct make_arg_spec_impl
-  {
-      typedef arg_spec<
-          typename K::first, typename K::second, Optimized, T
-      > type;
-  };
-
-  template <class K, class T>
-  struct make_arg_spec_impl<K, T, typename K::third>
-  {
-      typedef arg_spec<
-          typename K::first, typename K::second, typename K::third, T
-      > type;
-  };
-
-  template <class K, class T>
-  struct make_arg_spec
-    : make_arg_spec_impl<K, T>
-  {
-  };
-
-  template <class Spec, class State>
-  struct combinations_op
-  {
-      typedef typename State::second bits;
-      typedef typename State::first result0;
-
-      typedef typename mpl::if_<
-          mpl::or_<
-              typename Spec::required
-            , typename Spec::optimized_default
-            , mpl::bitand_<bits, mpl::long_<1> >
-          >
-        , typename mpl::push_back<result0, Spec>::type
-        , result0
-      >::type result;
-
-      typedef typename mpl::if_<
-          mpl::or_<
-              typename Spec::required
-            , typename Spec::optimized_default
-          >
-        , bits
-        , typename mpl::shift_right<bits, mpl::long_<1> >::type
-      >::type next_bits;
-
-      typedef mpl::pair<
-          result
-        , next_bits
-      > type;
-  };
-
-  // Used as start value in the recursive arg() composition below.
-  struct no_keywords
-  {
-      template <class T>
-      T const& operator,(T const& x) const
-      {
-          return x;
-      }
-  };
-
-  template <class Def, class F, class Iter, class End, class Keywords>
-  void def_combination_aux0(
-      Def def, F f, Iter, End, Keywords const& keywords, mpl::false_)
-  {
-      typedef typename mpl::deref<Iter>::type spec;
-      typedef typename spec::keyword kw;
-
-      def_combination_aux(
-          def, f, typename mpl::next<Iter>::type(), End()
-        , (
-              keywords, boost::python::arg(kw::keyword_name())
-          )
-      );
-  }
-
-  template <class Def, class F, class Iter, class End, class Keywords>
-  void def_combination_aux0(
-      Def def, F f, Iter, End, Keywords const& keywords, mpl::true_)
-  {
-      typedef typename mpl::deref<Iter>::type spec;
-      typedef typename spec::keyword kw;
-
-      def_combination_aux(
-          def, f, typename mpl::next<Iter>::type(), End()
-        , (
-              keywords, boost::python::arg(kw::keyword_name()) = empty_tag()
-          )
-      );
-  }
-
-  inline void initialize_converter()
-  {
-      static python_::to_python_converter<empty_tag, empty_tag_to_python> x;
-  }
-
-  template <class Def, class F, class Iter, class End, class Keywords>
-  void def_combination_aux(
-      Def def, F f, Iter, End, Keywords const& keywords)
-  {
-      typedef typename mpl::deref<Iter>::type spec;
-
-      typedef typename mpl::and_<
-          typename spec::optimized_default
-        , mpl::not_<typename spec::required>
-      >::type optimized_default;
-      
-      def_combination_aux0(
-          def, f, Iter(), End(), keywords, optimized_default()
-      );
-  }
-
-  template <class Def, class F, class End, class Keywords>
-  void def_combination_aux(
-      Def def, F f, End, End, Keywords const& keywords)
-  {
-      def(f, keywords);
-  } 
-
-  template <class Def, class F, class End>
-  void def_combination_aux(
-      Def def, F f, End, End, no_keywords const&)
-  {
-      def(f);
-  }
-
-  template <
-      class Def, class Specs, class Bits, class Invoker
-  >
-  void def_combination(
-      Def def, Specs*, Bits, Invoker*)
-  {
-      typedef typename mpl::fold<
-          Specs
-        , mpl::pair<mpl::vector0<>, Bits>
-        , combinations_op<mpl::_2, mpl::_1>
-      >::type combination0;
-
-      typedef typename combination0::first combination;
-
-      typedef typename mpl::apply_wrap1<
-          Invoker, combination
-      >::type invoker;
-
-      def_combination_aux(
-          def
-        , &invoker::execute
-        , typename mpl::begin<combination>::type()
-        , typename mpl::end<combination>::type()
-        , no_keywords()
-      );
-  }
-
-  template <
-      class Def, class Specs, class Bits, class End, class Invoker
-  >
-  void def_combinations(
-      Def def, Specs*, Bits, End, Invoker*)
-  {
-      initialize_converter();
-
-      def_combination(def, (Specs*)0, Bits(), (Invoker*)0);
-
-      def_combinations(
-          def
-        , (Specs*)0
-        , mpl::long_<Bits::value + 1>()
-        , End()
-        , (Invoker*)0
-      );
-  }
-
-  template <
-      class Def, class Specs, class End, class Invoker
-  >
-  void def_combinations(
-      Def, Specs*, End, End, Invoker*)
-  {}
-
-  struct not_specified {};
-
-  template <class CallPolicies>
-  struct call_policies_as_options
-  {
-      call_policies_as_options(CallPolicies const& call_policies)
-        : call_policies(call_policies)
-      {}
-
-      CallPolicies const& policies() const
-      {
-          return call_policies;
-      }
-
-      char const* doc() const
-      {
-          return 0;
-      }
-
-      CallPolicies call_policies;
-  };
-
-  template <class Class, class Options = not_specified>
-  struct def_class
-  {
-      def_class(Class& cl, char const* name, Options options = Options())
-        : cl(cl)
-        , name(name)
-        , options(options)
-      {}
-
-      template <class F>
-      void def(F f, not_specified const*) const
-      {
-          cl.def(name, f);
-      }
-
-      template <class F>
-      void def(F f, void const*) const
-      {
-          cl.def(name, f, options.doc(), options.policies());
-      }
-      
-      template <class F>
-      void operator()(F f) const
-      {
-          this->def(f, &options);
-      }
-
-      template <class F, class Keywords>
-      void def(F f, Keywords const& keywords, not_specified const*) const
-      {
-          cl.def(name, f, keywords);
-      }
-
-      template <class F, class Keywords>
-      void def(F f, Keywords const& keywords, void const*) const
-      {
-          cl.def(name, f, keywords, options.doc(), options.policies());
-      }
-
-      template <class F, class Keywords>
-      void operator()(F f, Keywords const& keywords) const
-      {
-          this->def(f, keywords, &options);
-      }
-
-      Class& cl;
-      char const* name;
-      Options options;
-  };
-
-  template <class Class, class CallPolicies = boost::python::default_call_policies>
-  struct def_init
-  {
-      def_init(Class& cl, CallPolicies call_policies = CallPolicies())
-        : cl(cl)
-        , call_policies(call_policies)
-      {}
-
-      template <class F>
-      void operator()(F f) const
-      {
-          cl.def(
-              "__init__"
-            , boost::python::make_constructor(f, call_policies)
-          );
-      }
-
-      template <class F, class Keywords>
-      void operator()(F f, Keywords const& keywords) const
-      {
-          cl.def(
-              "__init__"
-            , boost::python::make_constructor(f, call_policies, keywords)
-          );
-      }
-
-      Class& cl;
-      CallPolicies call_policies;
-  };
-
-  struct def_function
-  {
-      def_function(char const* name)
-        : name(name)
-      {}
-      
-      template <class F>
-      void operator()(F f) const
-      {
-          boost::python::def(name, f);
-      }
-
-      template <class F, class Keywords>
-      void operator()(F f, Keywords const& keywords) const
-      {
-          boost::python::def(name, f, keywords);
-      }
-
-      char const* name;
-  };
-
-} // namespace aux
-
-template <class M, class Signature>
-void def(char const* name, Signature)
-{
-    typedef mpl::iterator_range<
-        typename mpl::next<
-            typename mpl::begin<Signature>::type
-        >::type
-      , typename mpl::end<Signature>::type
-    > arg_types;
-
-    typedef typename mpl::transform<
-        typename M::keywords
-      , arg_types
-      , aux::make_arg_spec<mpl::_1, mpl::_2>
-      , mpl::back_inserter<mpl::vector0<> >
-    >::type arg_specs;
-
-    typedef typename mpl::count_if<
-        arg_specs
-      , aux::is_optional<mpl::_1>
-    >::type optional_arity;
-    
-    typedef typename mpl::front<Signature>::type result_type;
-    typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
-
-    aux::def_combinations(
-        aux::def_function(name)
-      , (arg_specs*)0
-      , mpl::long_<0>()
-      , mpl::long_<upper::value>()
-      , (aux::make_invoker<M, result_type>*)0
-    );
-}
-
-template <class M, class Class, class Signature>
-void def(Class& cl, char const* name, Signature)
-{
-    typedef mpl::iterator_range<
-        typename mpl::next<
-            typename mpl::begin<Signature>::type
-        >::type
-      , typename mpl::end<Signature>::type
-    > arg_types;
-
-    typedef typename mpl::transform<
-        typename M::keywords
-      , arg_types
-      , aux::make_arg_spec<mpl::_1, mpl::_2>
-      , mpl::back_inserter<mpl::vector0<> >
-    >::type arg_specs;
-
-    typedef typename mpl::count_if<
-        arg_specs
-      , aux::is_optional<mpl::_1>
-    >::type optional_arity;
-    
-    typedef typename mpl::front<Signature>::type result_type;
-    typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
-
-    aux::def_combinations(
-        aux::def_class<Class>(cl, name)
-      , (arg_specs*)0
-      , mpl::long_<0>()
-      , mpl::long_<upper::value>()
-      , (aux::make_invoker<M, result_type>*)0
-    );
-}
-
-namespace aux
-{
-
-  template <class K>
-  struct keyword
-  {
-      typedef K type;
-  };
-
-  template <class K>
-  struct keyword<K*>
-  {
-      typedef K type;
-  };
-
-  template <class K>
-  struct keyword<K**>
-  {
-      typedef K type;
-  };
-
-  template <class K>
-  struct required
-  {
-      typedef mpl::true_ type;
-  };
-
-  template <class K>
-  struct required<K*>
-  {
-      typedef mpl::false_ type;
-  };
-
-  template <class K>
-  struct optimized
-  {
-      typedef mpl::true_ type;
-  };
-
-  template <class K>
-  struct optimized<K**>
-  {
-      typedef mpl::false_ type;
-  };
-
-  template <class T>
-  struct make_kw_spec;
-
-  template <class K, class T>
-  struct make_kw_spec<K(T)>
-  {
-      typedef arg_spec<
-          typename keyword<K>::type
-        , typename required<K>::type
-        , typename optimized<K>::type
-        , T
-      > type;
-  };
-
-} // namespace aux
-
-template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies>
-struct init 
-  : boost::python::def_visitor<init<ParameterSpecs, CallPolicies> >
-{
-    init(CallPolicies call_policies = CallPolicies())
-      : call_policies(call_policies)
-    {}
-
-    template <class CallPolicies1>
-    init<ParameterSpecs, CallPolicies1> 
-    operator[](CallPolicies1 const& call_policies) const
-    {
-        return init<ParameterSpecs, CallPolicies1>(call_policies);
-    }
-
-    template <class Class>
-    void visit_aux(Class& cl, mpl::true_) const
-    {
-        cl.def(boost::python::init<>()[call_policies]);
-    }
-
-    template <class Class>
-    void visit_aux(Class& cl, mpl::false_) const
-    {
-        typedef typename mpl::transform<
-            ParameterSpecs
-          , aux::make_kw_spec<mpl::_>
-          , mpl::back_inserter<mpl::vector0<> >
-        >::type arg_specs;
-
-        typedef typename mpl::count_if<
-            arg_specs
-          , aux::is_optional<mpl::_>
-        >::type optional_arity;
-
-        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
-
-        aux::def_combinations(
-            aux::def_init<Class, CallPolicies>(cl, call_policies)
-          , (arg_specs*)0
-          , mpl::long_<0>()
-          , mpl::long_<upper::value>()
-          , (aux::make_init_invoker<typename Class::wrapped_type>*)0
-        );
-    }
-
-    template <class Class>
-    void visit(Class& cl) const
-    {
-        visit_aux(cl, mpl::empty<ParameterSpecs>());
-    }
-
-    CallPolicies call_policies;
-};
-
-template <class ParameterSpecs, class CallPolicies = boost::python::default_call_policies>
-struct call 
-  : boost::python::def_visitor<call<ParameterSpecs, CallPolicies> >
-{
-    call(CallPolicies const& call_policies = CallPolicies())
-      : call_policies(call_policies)
-    {}
-
-    template <class CallPolicies1>
-    call<ParameterSpecs, CallPolicies1>
-    operator[](CallPolicies1 const& call_policies) const
-    {
-        return call<ParameterSpecs, CallPolicies1>(call_policies);
-    }
-
-    template <class Class>
-    void visit(Class& cl) const
-    {
-        typedef mpl::iterator_range<
-            typename mpl::next<
-                typename mpl::begin<ParameterSpecs>::type
-            >::type
-          , typename mpl::end<ParameterSpecs>::type
-        > arg_types;
-
-        typedef typename mpl::front<ParameterSpecs>::type result_type;
-
-        typedef typename mpl::transform<
-            arg_types
-          , aux::make_kw_spec<mpl::_>
-          , mpl::back_inserter<mpl::vector0<> >
-        >::type arg_specs;
-
-        typedef typename mpl::count_if<
-            arg_specs
-          , aux::is_optional<mpl::_>
-        >::type optional_arity;
-
-        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
-
-        typedef aux::call_policies_as_options<CallPolicies> options;
-
-        aux::def_combinations(
-            aux::def_class<Class, options>(cl, "__call__", options(call_policies))
-          , (arg_specs*)0
-          , mpl::long_<0>()
-          , mpl::long_<upper::value>()
-          , (aux::make_call_invoker<typename Class::wrapped_type, result_type>*)0
-        );
-    }
-
-    CallPolicies call_policies;
-};
-
-template <class Fwd, class ParameterSpecs>
-struct function 
-  : boost::python::def_visitor<function<Fwd, ParameterSpecs> >
-{
-    template <class Class, class Options>
-    void visit(Class& cl, char const* name, Options const& options) const
-    {
-        typedef mpl::iterator_range<
-            typename mpl::next<
-                typename mpl::begin<ParameterSpecs>::type
-            >::type
-          , typename mpl::end<ParameterSpecs>::type
-        > arg_types;
-
-        typedef typename mpl::front<ParameterSpecs>::type result_type;
-
-        typedef typename mpl::transform<
-            arg_types
-          , aux::make_kw_spec<mpl::_>
-          , mpl::back_inserter<mpl::vector0<> >
-        >::type arg_specs;
-
-        typedef typename mpl::count_if<
-            arg_specs
-          , aux::is_optional<mpl::_>
-        >::type optional_arity;
-
-        typedef typename mpl::shift_left<mpl::long_<1>, optional_arity>::type upper;
-
-        aux::def_combinations(
-            aux::def_class<Class, Options>(cl, name, options)
-          , (arg_specs*)0
-          , mpl::long_<0>()
-          , mpl::long_<upper::value>()
-          , (aux::make_member_invoker<
-                Fwd, result_type, typename Class::wrapped_type
-            >*)0
-        );
-    }
-};
-
-}}} // namespace boost::parameter::python
-
-#endif // BOOST_PARAMETER_PYTHON_060209_HPP
-
--- a/include/boost/parameter/value_type.hpp
+++ b/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
--- a/index.html
+++ b/index.html
--- a/meta/libraries.json
+++ b/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>"
+    ]
+}
--- a/test/basics.cpp
+++ b/test/basics.cpp
--- a/test/basics.hpp
+++ b/test/basics.hpp
--- a/test/deduced.cpp
+++ b/test/deduced.cpp
--- a/test/deduced.hpp
+++ b/test/deduced.hpp
--- a/test/deduced_dependent_predicate.cpp
+++ b/test/deduced_dependent_predicate.cpp
--- a/test/deduced_unmatched_arg.cpp
+++ b/test/deduced_unmatched_arg.cpp
--- a/test/duplicates.cpp
+++ b/test/duplicates.cpp
--- a/test/earwicker.cpp
+++ b/test/earwicker.cpp
--- a/test/efficiency.cpp
+++ b/test/efficiency.cpp
--- a/test/literate/building-argumentpacks0.cpp
+++ b/test/literate/building-argumentpacks0.cpp
@@ -1,8 +1,6 @@

-#line 1744 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
-#line 1733 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(index)

 template <class ArgumentPack>
@@ -14,7 +12,6 @@ int print_index(ArgumentPack const& args)

 int x = print_index(_index = 3);  // prints "index = 3"

-#line 1752 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(name)

 template <class ArgumentPack>
@@ -27,13 +24,11 @@ int print_name_and_index(ArgumentPack const& args)
 int y = print_name_and_index((_index = 3, _name = "jones"));


-#line 1787 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace parameter = boost::parameter;
 using parameter::required;
 using parameter::optional;
 using boost::is_convertible;
 using boost::mpl::_;
-#line 1773 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 parameter::parameters<
    required<tag::name, is_convertible<_,char const*> >
  , optional<tag::index, is_convertible<_,int> >
@@ -47,7 +42,6 @@ int z0 = print_name_and_index( spec(sam, twelve) );
 int z1 = print_name_and_index(
   spec(_index=12, _name="sam")
 );
-#line 1794 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {}

--- a/test/literate/class-template-skeleton0.cpp
+++ b/test/literate/class-template-skeleton0.cpp
@@ -1,7 +1,5 @@

-#line 1387 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
-#line 1373 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 template <
--- a/test/literate/deduced-parameters0.cpp
+++ b/test/literate/deduced-parameters0.cpp
@@ -1,5 +1,4 @@

-#line 1062 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 BOOST_PARAMETER_NAME(name)
@@ -31,7 +30,6 @@ default_call_policies some_policies;

 void f()
 {}
-#line 1029 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace mpl = boost::mpl;

 BOOST_PARAMETER_FUNCTION(
@@ -64,17 +62,13 @@ BOOST_PARAMETER_FUNCTION(
 }


-#line 1111 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {
-#line 1108 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 def("f", &f, some_policies, "Documentation for f");
 def("f", &f, "Documentation for f", some_policies);

-#line 1121 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 def(
    "f", &f
   , _policies = some_policies, "Documentation for f");
-#line 1124 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 }

--- a/test/literate/deduced-template-parameters0.cpp
+++ b/test/literate/deduced-template-parameters0.cpp
@@ -1,9 +1,9 @@

-#line 1557 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/noncopyable.hpp>
 #include <memory>
+#include <boost/config.hpp>

 using namespace boost::parameter;
 using boost::mpl::_;
@@ -16,7 +16,6 @@ BOOST_PARAMETER_TEMPLATE_KEYWORD(held_type)
 BOOST_PARAMETER_TEMPLATE_KEYWORD(copyable)

 }}
-#line 1546 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 namespace detail { struct bases_base {}; }
@@ -28,10 +27,8 @@ struct bases : detail::bases_base
 }}


-#line 1600 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/type_traits/is_class.hpp>
 namespace boost { namespace python {
-#line 1578 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typedef parameter::parameters<
    required<tag::class_type, is_class<_> >

@@ -53,7 +50,6 @@ typedef parameter::parameters<
  , parameter::optional<deduced<tag::copyable>, is_same<noncopyable,_> >

 > class_signature;
-#line 1604 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 template <
    class A0
  , class A1 = parameter::void_
@@ -85,16 +81,22 @@ struct class_



-#line 1644 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 struct B {};
 struct D {};

 using boost::python::bases;
-#line 1640 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typedef boost::python::class_<B, boost::noncopyable> c1;

+#if defined(BOOST_NO_CXX11_SMART_PTR)
+
 typedef boost::python::class_<D, std::auto_ptr<D>, bases<B> > c2;
-#line 1650 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
+
+#else
+
+typedef boost::python::class_<D, std::unique_ptr<D>, bases<B> > c2;
+
+#endif
+
 BOOST_MPL_ASSERT((boost::is_same<c1::class_type, B>));
 BOOST_MPL_ASSERT((boost::is_same<c1::base_list, bases<> >));
 BOOST_MPL_ASSERT((boost::is_same<c1::held_type, B>));
@@ -104,8 +106,19 @@ BOOST_MPL_ASSERT((

 BOOST_MPL_ASSERT((boost::is_same<c2::class_type, D>));
 BOOST_MPL_ASSERT((boost::is_same<c2::base_list, bases<B> >));
+
+#if defined(BOOST_NO_CXX11_SMART_PTR)
+
 BOOST_MPL_ASSERT((
    boost::is_same<c2::held_type, std::auto_ptr<D> >
 ));
-BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));

+#else
+
+BOOST_MPL_ASSERT((
+    boost::is_same<c2::held_type, std::unique_ptr<D> >
+));
+
+#endif
+
+BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));
--- a/test/literate/default-expression-evaluation0.cpp
+++ b/test/literate/default-expression-evaluation0.cpp
@@ -1,5 +1,4 @@

-#line 730 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>

@@ -8,7 +7,6 @@ BOOST_PARAMETER_NAME(visitor)
 BOOST_PARAMETER_NAME(root_vertex)
 BOOST_PARAMETER_NAME(index_map)
 BOOST_PARAMETER_NAME(color_map)
-#line 702 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/graph/depth_first_search.hpp> // for dfs_visitor

 BOOST_PARAMETER_FUNCTION(
--- a/test/literate/defining-the-keywords0.cpp
+++ b/test/literate/defining-the-keywords0.cpp
@@ -1,4 +1,3 @@
-#line 397 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/name.hpp>

 namespace graphs
--- a/test/literate/defining-the-keywords1.cpp
+++ b/test/literate/defining-the-keywords1.cpp
@@ -1,7 +1,5 @@

-#line 424 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/keyword.hpp>
-#line 413 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace graphs
 {
  namespace tag { struct graph; } // keyword tag type
--- a/test/literate/exercising-the-code-so-far0.cpp
+++ b/test/literate/exercising-the-code-so-far0.cpp
@@ -1,10 +1,10 @@

-#line 1415 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/type_traits/is_class.hpp>
 #include <memory>
+#include <boost/config.hpp>

 using namespace boost::parameter;

@@ -20,7 +20,6 @@ struct bases
 {};

 }}
-#line 1402 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 using boost::mpl::_;
@@ -34,7 +33,6 @@ typedef parameter::parameters<

 }}

-#line 1454 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 template <
@@ -67,7 +65,6 @@ struct class_
 }}


-#line 1 "None"
 using boost::python::class_type;
 using boost::python::copyable;
 using boost::python::held_type;
@@ -76,16 +73,24 @@ using boost::python::bases;

 struct B {};
 struct D {};
-#line 1495 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typedef boost::python::class_<
    class_type<B>, copyable<boost::noncopyable>
 > c1;

 typedef boost::python::class_<
+
+#if defined(BOOST_NO_CXX11_SMART_PTR)
+
    D, held_type<std::auto_ptr<D> >, base_list<bases<B> >
+    
+#else
+
+    D, held_type<std::unique_ptr<D> >, base_list<bases<B> >
+    
+#endif
+
 > c2;

-#line 1515 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_MPL_ASSERT((boost::is_same<c1::class_type, B>));
 BOOST_MPL_ASSERT((boost::is_same<c1::base_list, bases<> >));
 BOOST_MPL_ASSERT((boost::is_same<c1::held_type, B>));
@@ -95,7 +100,19 @@ BOOST_MPL_ASSERT((

 BOOST_MPL_ASSERT((boost::is_same<c2::class_type, D>));
 BOOST_MPL_ASSERT((boost::is_same<c2::base_list, bases<B> >));
+
+#if defined(BOOST_NO_CXX11_SMART_PTR)
+
 BOOST_MPL_ASSERT((
    boost::is_same<c2::held_type, std::auto_ptr<D> >
 ));
+
+#else
+
+BOOST_MPL_ASSERT((
+    boost::is_same<c2::held_type, std::unique_ptr<D> >
+));
+
+#endif
+
 BOOST_MPL_ASSERT((boost::is_same<c2::copyable, void>));
--- a/test/literate/extracting-parameter-types0.cpp
+++ b/test/literate/extracting-parameter-types0.cpp
@@ -1,8 +1,6 @@

-#line 1830 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <cassert>
-#line 1813 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(name)
 BOOST_PARAMETER_NAME(index)

@@ -19,7 +17,6 @@ int deduce_arg_types(ArgumentPack const& args)
 {
    return deduce_arg_types_impl(args[_name], args[_index|42]);
 }
-#line 1834 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int a1 = deduce_arg_types((_name = "foo"));
 int a2 = deduce_arg_types((_name = "foo", _index = 3));

--- a/test/literate/extracting-parameter-types1.cpp
+++ b/test/literate/extracting-parameter-types1.cpp
@@ -1,11 +1,9 @@

-#line 1863 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <cassert>

 namespace parameter = boost::parameter;
-#line 1852 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(index)

 template <class ArgumentPack>
@@ -16,7 +14,6 @@ twice_index(ArgumentPack const& args)
 }

 int six = twice_index(_index = 3);
-#line 1871 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {
    assert(six == 6);
--- a/test/literate/fine-grained-name-control0.cpp
+++ b/test/literate/fine-grained-name-control0.cpp
@@ -1,7 +1,5 @@

-#line 1703 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
-#line 1693 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME((pass_foo, keywords) foo)

 BOOST_PARAMETER_FUNCTION(
@@ -12,7 +10,6 @@ BOOST_PARAMETER_FUNCTION(
 }

 int x = f(pass_foo = 41);
-#line 1704 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {}

--- a/test/literate/handling-out-parameters0.cpp
+++ b/test/literate/handling-out-parameters0.cpp
@@ -1,5 +1,4 @@

-#line 620 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 namespace boost
@@ -20,7 +19,6 @@ BOOST_PARAMETER_NAME(color_map)

 BOOST_PARAMETER_FUNCTION((void), f, tag,
  (required (graph, *))
-#line 612 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 (optional
    (visitor,            *, boost::dfs_visitor<>())
    (root_vertex,        *, *vertices(graph).first)
@@ -28,6 +26,5 @@ BOOST_PARAMETER_FUNCTION((void), f, tag,
    (in_out(color_map), *,
      default_color_map(num_vertices(graph), index_map) )
 )
-#line 642 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 ) {}

--- a/test/literate/headers-and-namespaces0.cpp
+++ b/test/literate/headers-and-namespaces0.cpp
@@ -1,5 +1,3 @@
-#line 274 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/keyword.hpp>
-#line 283 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using boost::parameter::keyword;

--- a/test/literate/lazy-default-computation0.cpp
+++ b/test/literate/lazy-default-computation0.cpp
@@ -1,10 +1,8 @@

-#line 1911 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <string>

 namespace parameter = boost::parameter;
-#line 1894 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(s1)
 BOOST_PARAMETER_NAME(s2)
 BOOST_PARAMETER_NAME(s3)
@@ -21,7 +19,6 @@ std::string f(ArgumentPack const& args)
 }

 std::string x = f((_s1="hello,", _s2=" world", _s3="hi world"));
-#line 1917 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main()
 {}

--- a/test/literate/lazy-default-computation1.cpp
+++ b/test/literate/lazy-default-computation1.cpp
@@ -1,5 +1,4 @@

-#line 1943 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/bind.hpp>
 #include <boost/ref.hpp>
 #include <boost/parameter.hpp>
@@ -17,12 +16,10 @@ std::string f(ArgumentPack const& args)
 {
    std::string const& s1 = args[_s1];
    std::string const& s2 = args[_s2];
-#line 1938 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 typename parameter::binding<
    ArgumentPack, tag::s3, std::string
 >::type s3 = args[_s3
    || boost::bind(std::plus<std::string>(), boost::ref(s1), boost::ref(s2)) ];
-#line 1962 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
    return s3;
 }

--- a/test/literate/namespaces0.cpp
+++ b/test/literate/namespaces0.cpp
@@ -1,9 +1,6 @@

-#line 2082 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
-#line 2085 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
-#line 2071 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  BOOST_PARAMETER_NAME(name)
@@ -18,8 +15,6 @@ namespace lib
      return index;
  }
 }
-#line 2098 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int x = lib::f(lib::_name = "jill", lib::_index = 1);
-#line 2102 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/namespaces1.cpp
+++ b/test/literate/namespaces1.cpp
@@ -1,9 +1,6 @@

-#line 2100 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
-#line 2085 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
-#line 2071 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  BOOST_PARAMETER_NAME(name)
@@ -18,11 +15,9 @@ namespace lib
      return index;
  }
 }
-#line 2111 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using lib::_name;
 using lib::_index;

 int x = lib::f(_name = "jill", _index = 1);
-#line 2120 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/namespaces2.cpp
+++ b/test/literate/namespaces2.cpp
@@ -1,9 +1,6 @@

-#line 2114 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
-#line 2085 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
-#line 2071 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  BOOST_PARAMETER_NAME(name)
@@ -18,9 +15,7 @@ namespace lib
      return index;
  }
 }
-#line 2128 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using namespace lib;
 int x = f(_name = "jill", _index = 3);
-#line 2134 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/namespaces3.cpp
+++ b/test/literate/namespaces3.cpp
@@ -1,8 +1,6 @@

-#line 2161 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
-#line 2143 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace lib
 {
  namespace keywords
@@ -21,9 +19,7 @@ namespace lib
  }
 }

-#line 2170 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 using namespace lib::keywords;
 int y = lib::f(_name = "bob", _index = 2);
-#line 2172 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {}

--- a/test/literate/optional-parameters0.cpp
+++ b/test/literate/optional-parameters0.cpp
@@ -1,5 +1,4 @@

-#line 571 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 namespace boost
@@ -19,13 +18,11 @@ BOOST_PARAMETER_NAME(color_map)

 BOOST_PARAMETER_FUNCTION((void), f, tag,
  (required (graph, *))
-#line 563 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 (optional     (visitor,           *, boost::dfs_visitor<>())
    (root_vertex,       *, *vertices(graph).first)
    (index_map,         *, get(boost::vertex_index,graph))
    (in_out(color_map), *,
      default_color_map(num_vertices(graph), index_map) )
 )
-#line 592 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 ) {}

--- a/test/literate/parameter-enabled-constructors0.cpp
+++ b/test/literate/parameter-enabled-constructors0.cpp
@@ -1,8 +1,6 @@

-#line 1248 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
-#line 1234 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(name)
 BOOST_PARAMETER_NAME(index)

@@ -17,7 +15,6 @@ struct myclass_impl
    }
 };

-#line 1261 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 struct myclass : myclass_impl
 {
    BOOST_PARAMETER_CONSTRUCTOR(
@@ -26,12 +23,9 @@ struct myclass : myclass_impl
 };


-#line 1275 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 int main() {
-#line 1272 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 myclass x("bob", 3);                     // positional
 myclass y(_index = 12, _name = "sally"); // named
 myclass z("june");                       // positional/defaulted
-#line 1275 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 }

--- a/test/literate/parameter-enabled-member-functions0.cpp
+++ b/test/literate/parameter-enabled-member-functions0.cpp
@@ -1,9 +1,7 @@

-#line 1154 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
 using namespace boost::parameter;
-#line 1142 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(arg1)
 BOOST_PARAMETER_NAME(arg2)

--- a/test/literate/parameter-enabled-member-functions1.cpp
+++ b/test/literate/parameter-enabled-member-functions1.cpp
@@ -1,11 +1,9 @@

-#line 1177 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 BOOST_PARAMETER_NAME(arg1)
 BOOST_PARAMETER_NAME(arg2)
 using namespace boost::parameter;
-#line 1166 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 struct callable2
 {
    BOOST_PARAMETER_CONST_MEMBER_FUNCTION(
--- a/test/literate/predicate-requirements0.cpp
+++ b/test/literate/predicate-requirements0.cpp
@@ -1,5 +1,4 @@

-#line 935 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/depth_first_search.hpp>
@@ -11,7 +10,6 @@ BOOST_PARAMETER_NAME((_index_map, graphs) index_map)
 BOOST_PARAMETER_NAME((_color_map, graphs) color_map)

 using boost::mpl::_;
-#line 859 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 // We first need to define a few metafunction that we use in the
 // predicates below.

@@ -87,7 +85,6 @@ BOOST_PARAMETER_FUNCTION(
       , default_color_map(num_vertices(graph), index_map) )
    )
 )
-#line 949 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 {}

 int main()
@@ -100,7 +97,7 @@ int main()
                 E(w,z), E(z, z)};
    G g(edges, edges + sizeof(edges) / sizeof(E), N);

-    depth_first_search(g);
-    depth_first_search(g, _root_vertex = (int)x);
+    ::depth_first_search(g);
+    ::depth_first_search(g, _root_vertex = (int)x);
 }

--- a/test/literate/required-parameters0.cpp
+++ b/test/literate/required-parameters0.cpp
@@ -1,12 +1,9 @@

-#line 540 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 BOOST_PARAMETER_NAME(graph)

 BOOST_PARAMETER_FUNCTION((void), f, tag,
-#line 531 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 (required (graph, *) )
-#line 547 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 ) {}

--- a/test/literate/static-member-functions0.cpp
+++ b/test/literate/static-member-functions0.cpp
@@ -1,9 +1,7 @@

-#line 1206 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
 #include <iostream>
 using namespace boost::parameter;
-#line 1195 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 BOOST_PARAMETER_NAME(arg1)

 struct somebody
--- a/test/literate/template-keywords0.cpp
+++ b/test/literate/template-keywords0.cpp
@@ -1,7 +1,5 @@

-#line 1337 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
-#line 1329 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 BOOST_PARAMETER_TEMPLATE_KEYWORD(class_type)
--- a/test/literate/template-keywords1.cpp
+++ b/test/literate/template-keywords1.cpp
@@ -1,7 +1,5 @@

-#line 1353 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>
-#line 1344 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 namespace boost { namespace python {

 namespace tag { struct class_type; } // keyword tag type
--- a/test/literate/top-level0.cpp
+++ b/test/literate/top-level0.cpp
@@ -1,5 +1,4 @@

-#line 35 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter.hpp>

 namespace test
@@ -31,7 +30,6 @@ namespace test
 }
 using namespace test;
 int x = 
-#line 19
 new_window("alert", _width=10, _titlebar=false);

 smart_ptr<
--- a/test/literate/writing-the-function0.cpp
+++ b/test/literate/writing-the-function0.cpp
@@ -1,5 +1,4 @@

-#line 472 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/name.hpp>

 BOOST_PARAMETER_NAME(graph)
@@ -17,7 +16,6 @@ struct dfs_visitor
 int vertex_index = 0;

 }
-#line 446 "/home/daniel/dev/boost/trunk/libs/parameter/doc/index.rst"
 #include <boost/parameter/preprocessor.hpp>

 namespace graphs
--- a/test/macros.cpp
+++ b/test/macros.cpp
@@ -52,6 +52,6 @@ int main()
     , index = boost::ref(x), name = "foo"
   );

-   return 0;
+   return boost::report_errors();
 }

--- a/test/maybe.cpp
+++ b/test/maybe.cpp
--- a/test/mpl.cpp
+++ b/test/mpl.cpp
--- a/test/normalized_argument_types.cpp
+++ b/test/normalized_argument_types.cpp
--- a/test/ntp.cpp
+++ b/test/ntp.cpp
--- a/test/optional_deduced_sfinae.cpp
+++ b/test/optional_deduced_sfinae.cpp
--- a/test/preprocessor.cpp
+++ b/test/preprocessor.cpp
@@ -477,6 +477,6 @@ int main()
      , test::index = 2
    );

-    return 0;
+    return boost::report_errors();
 }

--- a/test/preprocessor_deduced.cpp
+++ b/test/preprocessor_deduced.cpp
--- a/test/python_test.cpp
+++ b/test/python_test.cpp
@@ -2,6 +2,7 @@
 // subject to the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

+#include <math.h>
 #include <boost/python.hpp>
 #include <boost/parameter/preprocessor.hpp>
 #include <boost/parameter/keyword.hpp>
--- a/test/sfinae.cpp
+++ b/test/sfinae.cpp
--- a/test/singular.cpp
+++ b/test/singular.cpp
--- a/test/timings.txt
+++ b/test/timings.txt
--- a/test/tutorial.cpp
+++ b/test/tutorial.cpp
--- a/test/unwrap_cv_reference.cpp
+++ b/test/unwrap_cv_reference.cpp
Author	SHA1	Message	Date
Peter Dimov	5d3e39325e	Fix link to Python bindings	2018-10-16 06:40:55 +03:00
Peter Dimov	058b1394f5	Use glob instead of path.glob, as it's relative to the Jamfile	2018-10-16 06:26:47 +03:00
Peter Dimov	de183a3b75	Update the parameter_python submodule, as we still keep the Python tests here	2018-10-15 00:29:51 +03:00
Peter Dimov	28a8f75d83	Remove parameter_python documentation	2018-10-15 00:27:41 +03:00
Peter Dimov	2e9b937082	Remove parameter_python headers	2018-10-15 00:26:55 +03:00
Peter Dimov	61d476d4b6	Add libstdc++-5-dev for clang, or <complex> doesn't compile in C++14 mode	2018-10-14 07:35:10 +03:00
Peter Dimov	02a59d2091	Add `return boost::report_errors();`	2018-10-13 19:50:17 +03:00
Peter Dimov	007a24b76c	Add more Travis configurations	2018-10-13 04:44:05 +03:00
eldiener	672ae1c0ce	Removed --depth 1	2017-10-29 21:44:39 -04:00
Edward Diener	f7829bd91c	Better appveyor file setup.	2017-10-09 12:08:35 -04:00
Edward Diener	3736a0581e	Added Appveyor file and Travis CI file.	2017-10-09 08:20:05 -04:00
Edward Diener	6f747e9869	Removed git executable tag.	2017-09-14 07:57:05 -04:00
Edward Diener	b31fc2bb17	Removed executable under git	2017-09-14 06:43:45 -04:00
Edward Diener	247536c841	Merge remote-tracking branch 'remotes/origin/master' into develop	2017-04-24 12:35:13 -04:00
Edward Diener	fd4a18d490	Merge branch 'develop'	2017-01-04 11:24:52 -05:00
Edward Diener	a2da4c32f5	Merge pull request #9 from rick68/patch-1 improve aux::arg_list<>::operator[]()	2016-12-24 01:27:15 -05:00
Wei-Ming Yang	a3b5ce8a93	improve aux::arg_list<>::operator[]() Add the assert to avoid ugly message when invoked `arg_list<>::operator[](lazy_default<>)` with `maybe<>`	2016-11-23 09:53:54 +08:00
Edward Diener	612563e0fe	Include math.h first to avoid Python _hypot redefinition bug	2016-11-07 15:33:55 -05:00
Edward Diener	904e2f5020	Use unique_ptr instead of auto_ptr where appropriate	2016-11-07 15:32:11 -05:00
Rene Rivera	c303922fe9	Add, and update, documentation build targets.	2016-10-10 11:39:51 -05:00
Rene Rivera	9a8ad86fd7	Add, and update, documentation build targets.	2016-10-07 23:07:35 -05:00
Edward Diener	0461c0a070	Merge branch 'develop' Conflicts: doc/html/index.html doc/html/python.html doc/html/reference.html doc/index.rst	2015-10-15 01:01:28 -04:00
Edward Diener	6ad2d6b207	Fixed ADL problem upon invocation	2015-07-19 13:03:39 -04:00
Sebastien Loriot	45eebd0b85	fix a unused variable warning	2015-07-19 10:09:24 -04:00
Stephen Kelly	d6132a7645	Remove remaining occurances of BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION These evaded scripting. [SVN r86249]	2015-07-19 10:08:31 -04:00
Stephen Kelly	3462c3dc06	Simplify multi-component ifdefs containing BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION [SVN r86248]	2015-07-19 10:08:17 -04:00
Stephen Kelly	bc19656218	Parameter: Remove obsolete MSVC version checks. [SVN r86119]	2015-07-19 10:07:55 -04:00
Stephen Kelly	09cc5cf219	Parameter: Remove obsolete GCC version checks. [SVN r86067]	2015-07-19 10:07:24 -04:00
Vicente J. Botet Escriba	dd466e7d54	Parameter: fix minor warnings. [SVN r83985]	2015-07-19 10:06:01 -04:00
Edward Diener	368205ab37	Merge pull request #8 from sloriot/patch-2 fix a unused variable warning	2015-07-16 07:40:24 -04:00
Sebastien Loriot	9821c1a5f9	fix a unused variable warning	2015-07-16 13:11:12 +02:00
Edward Diener	d3a422ba6e	Merge pull request #6 from eldiener/develop Remove unneeded and incorrect #line directives, which just confuse so…	2015-05-29 13:13:07 -04:00
Edward Diener	aaf00c5449	Remove unneeded and incorrect #line directives, which just confuse some compilers, most notably VC++ which fails some tests purely on its confusion.	2015-05-27 10:03:38 -04:00
Daniel James	a9a4287f4d	Add metadata file.	2015-01-25 21:28:29 +02:00
Peter Dimov	e1f43668e7	Merge pull request #5 from danieljames/metadata Create metadata file.	2015-01-25 20:32:38 +02:00
Daniel James	3b34198a6f	Add metadata file.	2014-08-18 15:08:36 +01:00
Michel Morin	49ab4faa2b	Merge r86524 (Correct broken links to C++ standard papers); fixes #9212 [SVN r86673]	2013-11-13 03:22:55 +00:00
Michel Morin	54854d4a3a	Correct broken links to C++ standard papers. Refs #9212 . [SVN r86524]	2013-10-30 12:51:24 +00:00
Beman Dawes	45295c87bc	Merge 86392 from trunk. The spirit change was not applied because the file is not present in branches/release. [SVN r86489]	2013-10-27 21:10:04 +00:00
Beman Dawes	0dcd40da74	Add Boost.Build support for the Git modular layout, using links to to new header locations, thus preventing breakage to vast amounts of user code and build setups. Being added to SVN so that changes will automatically propagate to Git and modular Boost. Thanks to Steven Watanabe, Jürgen Hunold, Vladimir Prus, and Bjørn Roald for developing this patch. Steven in particular conceived the approach and did the initial implementation, which was further refined by the other contributors. [SVN r86392]	2013-10-22 15:23:42 +00:00
Stephen Kelly	a510824ee4	Remove remaining occurances of BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION These evaded scripting. [SVN r86249]	2013-10-11 23:22:36 +00:00
Stephen Kelly	7465ba08d3	Simplify multi-component ifdefs containing BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION [SVN r86248]	2013-10-11 23:20:59 +00:00
Stephen Kelly	8dca3b7307	Parameter: Remove obsolete MSVC version checks. [SVN r86119]	2013-10-01 08:48:50 +00:00
Stephen Kelly	51a02e0822	Parameter: Remove obsolete GCC version checks. [SVN r86067]	2013-09-30 15:58:35 +00:00
Vladimir Prus	a07961f561	Undo previous commit, it was meant for another branch [SVN r85888]	2013-09-25 08:32:03 +00:00
Vladimir Prus	4e26b448e9	Initial modular patch, from Bjorn. [SVN r85884]	2013-09-25 08:13:57 +00:00
Vicente J. Botet Escriba	b5e57e0024	Parameter: fix minor warnings. [SVN r83985]	2013-04-20 14:12:43 +00:00
Lorenzo Caminiti	b74489d477	Merged Boost.Parameter fixes from trunk to support accessing named paramter types tag::x::_. [SVN r78851]	2012-06-07 18:21:25 +00:00
Tim Blechmann	475001a591	parameter: merge fix from trunk (required for boost.heap) [SVN r76090]	2011-12-21 11:20:00 +00:00
Tim Blechmann	f9e0d1c5c3	parameter: merge enable_if fix from trunk [SVN r76069]	2011-12-19 18:00:17 +00:00
Marshall Clow	bdcbf442bf	Merge fix to release branch, fixes #4983 [SVN r68366]	2011-01-22 15:42:09 +00:00
Andrey Semashev	c9cf0ab0f5	Merged changes from trunk. [SVN r62272]	2010-05-27 17:58:58 +00:00
Douglas Gregor	20301b3da4	Add some missing includes for the parameter library [SVN r62231]	2010-05-26 07:47:05 +00:00
Andrey Semashev	59e172adb3	Added missing include. [SVN r60776]	2010-03-22 20:18:30 +00:00
Troy D. Straszheim	9f4334c1c1	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Daniel James	7ff5c4b996	Merge some missing link/libraries changes. Fixes #2279,#3454. Merged revisions 52231,53476 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r52231 \| jewillco \| 2009-04-07 17:46:32 +0100 (Tue, 07 Apr 2009) \| 1 line Updating maintainer info for BGL, fixes #2279 ........ r53476 \| jewillco \| 2009-05-31 02:40:59 +0100 (Sun, 31 May 2009) \| 1 line Fixed more links to property_map ........ [SVN r56226]	2009-09-15 21:16:58 +00:00
Troy D. Straszheim	1b1499b94c	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Troy D. Straszheim	3cf03f73ca	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Dave Abrahams	04cea6497d	Merging all parameter changes from trunk. These all look like they fix bugs, although the one that lets you use the argument pack to compute a return type was never tested (still isn't). [SVN r47446]	2008-07-15 16:02:00 +00:00
Daniel James	e6eda9a776	Merged revisions 43206,43208-43213 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r43206 \| danieljames \| 2008-02-10 09:55:03 +0000 (Sun, 10 Feb 2008) \| 1 line Fix some broken links. ........ r43209 \| danieljames \| 2008-02-10 14:56:22 +0000 (Sun, 10 Feb 2008) \| 1 line Link to people pages on the website, as they've been removed from the download. ........ r43210 \| danieljames \| 2008-02-10 15:02:17 +0000 (Sun, 10 Feb 2008) \| 1 line Point links to the pages that used to be in 'more' to the site. ........ r43212 \| danieljames \| 2008-02-10 16:10:16 +0000 (Sun, 10 Feb 2008) \| 1 line Fix links on the home page as well. ........ r43213 \| danieljames \| 2008-02-10 16:21:22 +0000 (Sun, 10 Feb 2008) \| 1 line Generated documentation which is no longer generated. ........ [SVN r43214]	2008-02-10 16:39:38 +00:00
Beman Dawes	8a404e2d67	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41370]	2007-11-25 18:38:02 +00:00
Beman Dawes	31f9f620fe	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	56ddeddfaf	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	fe43dad724	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Daniel Wallin	ce2d43c1b5	Merged HEAD to RC_1_34_0 [SVN r37582]	2007-05-03 14:39:42 +00:00
nobody	86d7201a99	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r37579]	2007-05-03 14:11:06 +00:00
Dave Abrahams	ccf40a29c1	Correct testing bugs: either changing assert(...) or BOOST_ASSERT(...) to BOOST_TEST (in my code only) or adding "return boost::report_errors();" where it was clearly missing (and a pure bug, in anyone's code). or changing BOOST_TEST to BOOST_CHECK where the integer library was clearly using Boost.Test and not returning report_errors(). [SVN r37063]	2007-02-25 15:28:02 +00:00
Dave Abrahams	28ed7b9704	fix table styles [SVN r36573]	2007-01-03 17:12:34 +00:00
Dave Abrahams	6c3ee189d1	replace "write something here" [SVN r36569]	2007-01-03 16:45:10 +00:00
Rene Rivera	15048a1d82	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
Daniel Wallin	3852ff760c	merged HEAD to RC [SVN r35452]	2006-10-02 23:37:18 +00:00
Daniel Wallin	916b4d2c2f	merged HEAD to RC [SVN r35405]	2006-09-29 00:31:28 +00:00
Daniel Wallin	af9b04e7ad	merged HEAD to RC [SVN r35364]	2006-09-28 13:11:46 +00:00
Daniel Wallin	894dffe6ff	merged HEAD to RC [SVN r35360]	2006-09-28 10:22:54 +00:00
Daniel Wallin	c17ea8d26d	merged HEAD to RC [SVN r35357]	2006-09-27 20:59:14 +00:00
Daniel Wallin	1844c27699	Merged HEAD to RC. [SVN r35339]	2006-09-26 14:49:52 +00:00
Markus Schöpflin	9694b76bf2	Merged python header inclusion fix from trunk. [SVN r35320]	2006-09-25 10:49:42 +00:00
Daniel Wallin	7c9ddf23e0	merged HEAD to RC [SVN r35300]	2006-09-23 22:53:35 +00:00
Daniel Wallin	224d313a05	Merged HEAD to RC. [SVN r35285]	2006-09-23 10:41:14 +00:00
Daniel Wallin	47c53efbaa	merged HEAD to RC [SVN r35260]	2006-09-21 17:33:28 +00:00
nobody	57ef2b6ee9	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r35259]	2006-09-21 17:29:16 +00:00
Dave Abrahams	297e85c0f1	fix license [SVN r35232]	2006-09-20 17:34:41 +00:00
Dave Abrahams	3a59d2cea3	merged from HEAD [SVN r35231]	2006-09-20 17:30:10 +00:00
Daniel Wallin	58bb633dc0	Merged HEAD to RC. [SVN r35228]	2006-09-20 15:05:46 +00:00
nobody	3397bafb4a	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r35227]	2006-09-20 15:03:36 +00:00
Daniel Wallin	cc256f0bb3	Merged HEAD to RC [SVN r35215]	2006-09-19 18:23:18 +00:00
Dave Abrahams	e3b060b3e5	merged from HEAD [SVN r35207]	2006-09-19 15:34:02 +00:00
Daniel Wallin	0791667e33	Merged HEAD to RC [SVN r35197]	2006-09-19 13:13:43 +00:00
Daniel Wallin	91ffd43483	Merged changes from HEAD to RC. [SVN r35195]	2006-09-19 11:51:07 +00:00
nobody	fa751e022e	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r35193]	2006-09-19 11:47:55 +00:00
Daniel Wallin	1f6c9a3034	Merged changes from HEAD to RC_1_34_0. [SVN r35183]	2006-09-18 20:54:56 +00:00
nobody	6c209395aa	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r35179]	2006-09-18 20:47:47 +00:00
Daniel Wallin	5231f04b27	Merged changes from head to RC_1_34_0. [SVN r35177]	2006-09-18 20:42:44 +00:00
nobody	c7258e9c9e	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r35173]	2006-09-18 20:05:46 +00:00
nobody	22a1f905e9	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r35170]	2006-09-18 19:56:20 +00:00
Dave Abrahams	0417a36693	merged from HEAD [SVN r35163]	2006-09-18 18:11:49 +00:00
Dave Abrahams	d42b860b8d	Sun workarounds [SVN r35137]	2006-09-16 18:15:08 +00:00
Dave Abrahams	c5168be5d7	Parameter library Workarounds for Borland and MSVC Parameter library explicit markup for expected failures value_init.hpp: Borland workarounds Use angle-includes consistently [SVN r35085]	2006-09-13 03:15:16 +00:00
Dave Abrahams	c29a75c9df	merged from trunk [SVN r35083]	2006-09-13 00:40:00 +00:00
Dave Abrahams	e18d621508	Add missing license/copyright [SVN r35070]	2006-09-11 22:27:29 +00:00
nobody	40399d3505	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r35043]	2006-09-08 09:38:01 +00:00
Daniel Wallin	d6db8c6216	Merged name.hpp from HEAD. [SVN r34945]	2006-08-24 21:13:51 +00:00
Daniel Wallin	38817a8bb5	fixed missing include [SVN r34941]	2006-08-24 16:19:14 +00:00
Dave Abrahams	646c519dc0	merged from trunk [SVN r34930]	2006-08-23 13:01:56 +00:00
Daniel Wallin	cb501f9f38	merged changes from HEAD [SVN r34921]	2006-08-22 17:36:58 +00:00
Dave Abrahams	7eb7737095	merged from trunk [SVN r34918]	2006-08-22 14:01:34 +00:00
Daniel Wallin	bfc5811fdc	Merged HEAD to RC_1_34_0. [SVN r34899]	2006-08-16 22:34:35 +00:00
Daniel Wallin	1f8f44b26c	Merged changes from HEAD to RC_1_34_0. [SVN r34898]	2006-08-16 22:30:07 +00:00
Dave Abrahams	6729c38504	Borland workaround [SVN r34808]	2006-08-02 19:07:09 +00:00
Dave Abrahams	cf5d2c46f5	Workarounds for Borland [SVN r34805]	2006-08-02 16:16:36 +00:00
nobody	49e928273d	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r34788]	2006-07-30 21:33:23 +00:00
Gennaro Prota	00bbfbb20c	boost guidelines (mainly from inspect tool: tabs, license reference text, etc.); more to do... [SVN r34753]	2006-07-27 11:48:49 +00:00
Dave Abrahams	ca120a3f04	merged from trunk [SVN r34696]	2006-07-24 14:38:01 +00:00
Dave Abrahams	e2b452c1f4	merged from trunk [SVN r34290]	2006-06-12 20:00:14 +00:00
Rene Rivera	6695f76c5f	[merge from head] Allow keywords to be copyable and default constructable, to facilitate use of keywords outside of Boost.Parameter. [SVN r33691]	2006-04-13 20:12:20 +00:00
nobody	bf25a637c8	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00