Fix version number.

Fix traits qualification.
Remove 'numeric' documentation.
2026-01-19 16:32:16 +00:00 · 2017-08-19 11:57:56 -04:00 · 2017-08-19 11:57:39 -04:00 · 2017-07-31 11:38:40 -04:00 · 2017-07-20 13:04:44 -04:00 · 2017-06-25 18:27:19 -04:00
128 changed files with 2263 additions and 825 deletions
--- a/.ci/faber
+++ b/.ci/faber
@@ -1,3 +0,0 @@
-from faber.tools.python import python
-
-p = python(command='$PYTHON')
--- a/.ci/upload_docs.sh
+++ b/.ci/upload_docs.sh
@@ -22,10 +22,10 @@ fi
 REPO=`git config remote.origin.url`
 SHA=`git rev-parse --verify HEAD`

-# build happens to contain the "doc/html" tree that we want to push
+# bin.SCons happens to contain the "doc/html" tree that we want to push
 # into the gh-pages branch. So we step into that directory, create a new repo,
 # set the remote appropriately, then commit and push.
-cd build
+cd bin.SCons
 git init
 git config user.name "Travis CI"
 git config user.email "travis-ci"
--- a/.travis.yml
+++ b/.travis.yml
@@ -17,29 +17,29 @@ env:

 matrix:
  include:
-    - os: linux
+    - compiler: gcc
      env: CXX=g++ PYTHON=python CXXFLAGS=-std=c++98
-    - os: linux
+    - compiler: gcc
      env: CXX=g++ PYTHON=python CXXFLAGS=-std=c++11
-    - os: linux
+    - compiler: gcc
      env: CXX=g++ PYTHON=python3 CXXFLAGS=-std=c++98
-    - os: linux
+    - compiler: gcc
      env: CXX=g++ PYTHON=python3 CXXFLAGS=-std=c++11
-    - os: linux
-      env: CXX=clang++ PYTHON=python3 CXXFLAGS=-std=c++98
-    - os: linux
-      env: CXX=clang++ PYTHON=python3 CXXFLAGS=-std=c++11
-    - os: osx
-      env: CXX=clang++ PYTHON=python CXXFLAGS=-std=c++11
+    - compiler: clang
+      # clang generates an 'illegal instruction' error in the NumPy check.
+      # Perhaps we need to upgrade clang to a newer version ?
+      env: CXX=clang++ PYTHON=python3 CXXFLAGS=-std=c++98 OPTIONS=--no-numpy
+    - compiler: clang
+      env: CXX=clang++ PYTHON=python3 CXXFLAGS=-std=c++11 OPTIONS=--no-numpy
    - env: PYTHON=python DOC=1
-  allow_failures:
-    - os: osx
+

 addons:
  apt:
    sources:
    - ubuntu-toolchain-r-test
    packages:
+    - scons
    - gcc-4.8
    - g++-4.8
    - clang
@@ -66,46 +66,27 @@ before_install:
 install:
  # Install our own version of Boost (the subset we need) as the system version is
  # too old (for C++11 support).
+  - rm -rf $HOME/Boost
  - |
-     if [ ! -d $HOME/Boost/tools/boostbook ]; then
-       echo "rebuilding Boost prerequisites."
-       wget https://sourceforge.net/projects/boost/files/boost/1.66.0/boost_1_66_0.tar.gz/download
+     set -e
+     if [ ! -d $HOME/Boost ]; then
+       echo "rebuilding Boost prerequisites"
+       wget https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.tar.gz/download
       tar xf download
-       pushd boost_1_66_0
+       pushd boost_1_61_0
       ./bootstrap.sh
       ./b2 tools/bcp
       mkdir -p $HOME/Boost
-       # Install Boost.Python prerequisites, but not Boost.Python itself.
       dist/bin/bcp python tools/boostbook tools/quickbook $HOME/Boost &> /dev/null
-       rm -rf $HOME/Boost/boost/python*
       popd
-     else
-       echo "using cached Boost prerequisites."
     fi
-     # Install Faber, the build tool.
-     date=2018-04-08
-     wget https://github.com/stefanseefeld/faber/archive/snapshot/$date.tar.gz
-     tar xf $date.tar.gz
-     pushd faber-snapshot-$date
-     #wget https://github.com/stefanseefeld/faber/archive/release/0.2.tar.gz
-     #tar xf 0.2.tar.gz
-     #pushd faber-release-0.2
-     sudo python setup.py install
-     popd

 before_script:
- sed -e "s/\$PYTHON/$PYTHON/g" .ci/faber > ~/.faber
- $PYTHON --version
- faber -h
- ls -l $HOME/Boost
+- scons --version

 script:
- |
-   if [ "$DOC" ]; then
-     BOOST_ROOT=$HOME/Boost faber --builddir=build doc.html
-   else
-     faber --with-boost-include=$HOME/Boost --builddir=build test.report cxx.name=$CXX cxxflags=$CXXFLAGS
-   fi
+- scons config --python=$PYTHON --boost-include=$HOME/Boost $OPTIONS
+- if [ "$DOC" ]; then scons doc; else scons && scons test; fi

 after_success:
 # Upload docs only when building upstream.
--- a/68
+++ b/68
@@ -1,68 +0,0 @@
-# Copyright (c) 2018 Stefan Seefeld
-# All rights reserved.
-#
-# 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 option ;
-import regex ;
-import python ;
-
-#
-# The `version-suffix` rule really belongs into python.jam, and
-# should be moved there. `split-version` is only duplicated here
-# as a prerequisite. (See https://github.com/boostorg/build/pull/290)
-#
-
-
-# Validate the version string and extract the major/minor part we care about.
-#
-local rule split-version ( version )
-{
-    local major-minor = [ MATCH "^([0-9]+)\.([0-9]+)(.*)$" : $(version) : 1 2 3 ] ;
-    if ! $(major-minor[2]) || $(major-minor[3])
-    {
-        ECHO "Warning: \"using python\" expects a two part (major, minor) version number; got" $(version) instead ;
-
-        # Add a zero to account for the missing digit if necessary.
-        major-minor += 0 ;
-    }
-
-    return $(major-minor[1]) $(major-minor[2]) ;
-}
-
-# Define a version suffix for libraries depending on Python.
-# For example, Boost.Python built for Python 2.7 uses the suffix "27"
-rule version-suffix ( version )
-{
-    local major-minor = [ split-version $(version) ] ;
-    local suffix = $(major-minor:J="") ;
-    return $(suffix) ;
-}
-
-
-# Python build id (for Python libraries only).
-python-id = [ option.get "python-buildid" ] ;
-if $(python-id)
-{
-    PYTHON_ID = [ regex.replace $(python-id) "[*\\/:.\"\']" _ ] ;
-}
-
-rule python-tag ( name : type ? : property-set )
-{
-    local result = $(name) ;
-    if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB
-    {
-        local version = [ $(property-set).get <python> ] ;
-        local lib-suffix = [ version-suffix $(version) ] ;
-        result = $(result)$(lib-suffix) ;
-    }
-    if $(type) in STATIC_LIB SHARED_LIB IMPORT_LIB && $(PYTHON_ID)
-    {
-        result = $(result)-$(PYTHON_ID) ;
-    }
-
-    # forward to the boost tagging rule
-    return  [ tag $(result) : $(type) : $(property-set) ] ;
-}
--- a/README.md
+++ b/README.md
@@ -2,8 +2,6 @@

 # Synopsis

-[![Join the chat at https://gitter.im/boostorg/python](https://badges.gitter.im/boostorg/python.svg)](https://gitter.im/boostorg/python?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
 Welcome to Boost.Python, a C++ library which enables seamless interoperability between C++ and the Python programming language. The library includes support for:

 * References and Pointers
@@ -21,8 +19,7 @@ See the [Boost.Python](http://boostorg.github.io/python) documentation for detai

 **Hint :** Check out the [development version](http://boostorg.github.io/python/develop) of the documentation to see work in progress.

-# Building [![Build Status](https://travis-ci.org/boostorg/python.svg?branch=develop)](https://travis-ci.org/boostorg/python) [![Build status](https://ci.appveyor.com/api/projects/status/cgx9xma6v3gjav92/branch/develop?svg=true)](https://ci.appveyor.com/project/stefanseefeld/python/branch/develop)
-
+# Building ![Build Status](https://travis-ci.org/boostorg/python.svg?branch=develop)

 While Boost.Python is part of the Boost C++ Libraries super-project, and thus can be compiled as part of Boost, it can also be compiled and installed stand-alone, i.e. against a pre-installed Boost package.

@@ -30,14 +27,27 @@ While Boost.Python is part of the Boost C++ Libraries super-project, and thus ca

 * [Python](http://www.python.org)
 * [Boost](http://www.boost.org)
-* [Faber](https://stefanseefeld.github.io/faber)
+* [SCons](http://www.scons.org)
+
+## Configure
+
+Simply run
+
+```
+scons config [options]
+```
+to prepare a build. See `scons -h` for a description of the available options. For example
+```
+scons config --boost=/path/to/boost --python=/path/to/python
+```
+will configure Boost.Python to be built against the two specific versions of Boost and Python.

 ## Build

 Run

 ```
-faber
+scons
 ```
 to build the library.

@@ -46,7 +56,7 @@ to build the library.
 Run

 ```
-faber test.report
+scons test
 ```
 to run the tests.

@@ -55,6 +65,6 @@ to run the tests.
 Run

 ```
-faber doc.html
+scons doc
 ```
 to build the documentation.
--- a/101
+++ b/101
@@ -0,0 +1,101 @@
+# -*- python -*-
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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 SCons.Script.Main
+import config
+import config.ui
+import platform
+import os
+import subprocess
+import re
+
+#
+# We try to mimic the typical autotools-workflow.
+#
+# * In a 'configure' step all the essential build parameters are established
+#   (either by explicit command-line arguments or from configure checks)
+# * A subsequent build step can then simply read the cached variables, so
+#   users don't have to memorize and re-issue the arguments on each subsequent
+#   invocation, and neither do the config checks need to be re-run.
+#
+# The essential part here is to define a 'config' target, which removes any
+# caches that may still be lingering around, then runs the checks.
+
+if 'config' in COMMAND_LINE_TARGETS:
+    # Clear the cache
+    try: os.remove('bin.SCons/config.py')
+    except: pass
+if not os.path.exists('bin.SCons/'):
+    os.mkdir('bin.SCons/')
+vars = Variables('bin.SCons/config.py', ARGUMENTS)
+config.add_options(vars)
+arch = ARGUMENTS.get('arch', platform.machine())
+env_vars = {}
+if 'CXX' in os.environ: env_vars['CXX'] = os.environ['CXX']
+if 'CXXFLAGS' in os.environ: env_vars['CXXFLAGS'] = os.environ['CXXFLAGS'].split()
+env_vars['ENV'] = os.environ #{'PATH': os.environ['PATH'], 'TMP' : os.environ['TMP']}
+env = Environment(toolpath=['config/tools'],
+                  tools=['default', 'libs', 'tests', 'doc', 'sphinx4scons'],
+                  variables=vars,
+                  TARGET_ARCH=arch,
+                  **env_vars)
+if 'gcc' in env['TOOLS']:
+    # Earlier SCons versions (~ 2.3.0) can't handle CXX=clang++.
+    version = subprocess.check_output([env['CXX'], '--version'])
+    match = re.search(r'[0-9]+(\.[0-9]+)+', version)
+    if match:
+        version = match.group(0)
+    else:
+        version = 'unknown'
+    env['CXXVERSION'] = version
+
+Help(config.ui.help(vars, env) + """
+Variables are saved in bin.SCons/config.py and persist between scons invocations.
+""")
+
+if GetOption('help'):
+    Return()
+
+build_dir = config.prepare_build_dir(env)
+config_log = '{}/config.log'.format(build_dir)
+
+# configure
+SConsignFile('{}/.sconsign'.format(build_dir))
+#env.Decider('MD5-timestamp')
+env.Decider('timestamp-newer')
+checks = config.get_checks(env)
+if 'config' in COMMAND_LINE_TARGETS:
+    conf=env.Configure(custom_tests=checks, log_file=config_log, conf_dir=build_dir)
+    if False in (getattr(conf, c)() for c in checks):
+        Exit(1)
+    env = conf.Finish()
+    vars.Save('bin.SCons/config.py', env)
+
+if not os.path.exists(config_log):
+    print('Please run `scons config` first. (See `scons -h` for available options.)')
+    Exit(1)
+
+if not GetOption('verbose'):
+    config.ui.pretty_output(env)    
+
+# build
+env['BPL_VERSION'] = '1.65'
+for e in config.variants(env):
+    variant_dir=e.subst("$BOOST_CURRENT_VARIANT_DIR")
+    e.SConscript('src/SConscript', variant_dir=variant_dir + '/src',
+                 exports = { 'env' : e.Clone(BOOST_LIB = 'python') })
+    if 'test' in COMMAND_LINE_TARGETS:
+        test_env = e.Clone(BOOST_LIB = 'python', BOOST_TEST = True)
+        test_env.BoostUseLib('python')
+        e.SConscript('test/SConscript', variant_dir=variant_dir + '/test',
+                     exports = { 'env' : test_env })
+
+if 'doc' in COMMAND_LINE_TARGETS:
+    env.SConscript('doc/SConscript', variant_dir='bin.SCons/doc',
+                   exports = { 'env' : e.Clone(BOOST_LIB = 'python') })
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -4,7 +4,7 @@ environment:
    # /E:ON and /V:ON options are not enabled in the batch script intepreter
    # See: http://stackoverflow.com/a/13751649/163740
    CMD_IN_ENV: "cmd /E:ON /V:ON /C .\\ci\\run_with_env.cmd"
-    BOOST_PREFIX: C:\Libraries\boost_1_66_0
+    BOOST_PREFIX: C:\Libraries\boost_1_60_0

  matrix:

@@ -15,21 +15,20 @@ environment:
    - PYTHON: "C:\\Python27"
      PYTHON_VERSION: "2.7.x" # currently 2.7.9
      PYTHON_ARCH: "32"
-      MSVC: "14.0"
-      ARCH: x86
+      ARCH: "x86"

-    - PYTHON: "C:\\Python36-x64"
-      PYTHON_VERSION: "3.6.x"
-      PYTHON_ARCH: "64"
-      MSVC: "12.0"
-      ARCH: x86_64
+    #- PYTHON: "C:\\Python27-x64"
+    #  PYTHON_VERSION: "2.7.x" # currently 2.7.9
+    #  PYTHON_ARCH: "64"
+    #  ARCH: "x86_64"

-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      PYTHON: "C:\\Python36-x64"
-      PYTHON_VERSION: "3.6.x"
-      PYTHON_ARCH: "64"
-      MSVC: "14.13.26128"
-      ARCH: x86_64
+    #- PYTHON: "C:\\Python35"
+    #  PYTHON_VERSION: "3.5.x" # currently 3.4.3
+    #  PYTHON_ARCH: "32"
+
+    #- PYTHON: "C:\\Python35-x64"
+    #  PYTHON_VERSION: "3.5.x" # currently 3.4.3
+    #  PYTHON_ARCH: "64"

 install:
  # If there is a newer build queued for the same PR, cancel this one.
@@ -45,9 +44,8 @@ install:
  - ps: "ls \"C:/\""
  - ECHO "Installed libraries:"
  - ps: "ls \"C:/Libraries/\""
-  ## This path doesn't exist with the VS 2017 worker images
-  #- ECHO "Installed SDKs:"
-  #- ps: "ls \"C:/Program Files/Microsoft SDKs/Windows\""
+  - ECHO "Installed SDKs:"
+  - ps: "ls \"C:/Program Files/Microsoft SDKs/Windows\""

  # Install Python (from the official .msi of http://python.org) and pip when
  # not already installed.
@@ -70,22 +68,21 @@ install:
  # compiled extensions and are not provided as pre-built wheel packages,
  # pip will build them from source using the MSVC compiler matching the
  # target Python version and architecture
-  - |
-     curl -LfsS -o faber.tar.gz https://github.com/stefanseefeld/faber/archive/snapshot/2018-04-08.tar.gz
-     tar xf faber.tar.gz
-     CD faber-snapshot-2018-04-08
-     python setup.py install
-     CD ..
-  # report the available MSVC compilers
-  - faber --info=tools cxx
+  - easy_install scons
  - easy_install sphinx
  - pip install numpy
+  #- "%CMD_IN_ENV% pip install -r dev-requirements.txt"

 build_script:
-  - faber --with-boost-include=%BOOST_PREFIX% target.arch=%ARCH% msvc.version=%MSVC%
+  # Build the compiled extension
+  #- "%CMD_IN_ENV% python setup.py build"
+  - scons config arch=%ARCH% --boost-include=%BOOST_PREFIX%
+  - scons arch=%ARCH% --verbose

 test_script:
-  - faber --with-boost-include=%BOOST_PREFIX% test.report target.arch=%ARCH% msvc.version=%MSVC%
+  # Run the project tests
+  #- "%CMD_IN_ENV% python setup.py nosetests"
+  - scons test arch=%ARCH% --verbose

 after_test:
  # If tests are successful, create binary packages for the project.
@@ -100,4 +97,4 @@ after_test:

 #on_success:
 #  - TODO: upload the content of dist/*.whl to a public wheelhouse
-#
+#
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -7,6 +7,7 @@ import indirect ;
 import modules ;
 import feature ;
 import property ;
+
 import python ;

 if ! [ python.configured ] && ! ( --without-python in  [ modules.peek : ARGV ] )
@@ -30,8 +31,9 @@ else
        ;
 }

-if [ python.configured ]
-{
+py2-version = [ py-version 2 ] ;
+py3-version = [ py-version 3 ] ;
+
 project boost/python
  : source-location ../src
  ;
@@ -40,122 +42,146 @@ rule cond ( test ? : yes * : no * ) { if $(test) { return $(yes) ; } else { retu
 rule unless ( test ? : yes * : no * ) { if ! $(test) { return $(yes) ; } else { return $(no) ; } }
 local rule eq ( a : b ) { if $(a) = $(b) { return 1 ; } }

-lib boost_python
-    : # sources
-    list.cpp
-    long.cpp
-    dict.cpp
-    tuple.cpp
-    str.cpp
-    slice.cpp
+lib_boost_python(2) = boost_python ;
+lib_boost_python(3) = boost_python3 ;

-    converter/from_python.cpp
-    converter/registry.cpp
-    converter/type_id.cpp
-    object/enum.cpp
-    object/class.cpp
-    object/function.cpp
-    object/inheritance.cpp
-    object/life_support.cpp
-    object/pickle_support.cpp
-    errors.cpp
-    module.cpp
-    converter/builtin_converters.cpp
-    converter/arg_to_python_base.cpp
-    object/iterator.cpp
-    object/stl_iterator.cpp
-    object_protocol.cpp
-    object_operators.cpp
-    wrapper.cpp
-    import.cpp
-    exec.cpp
-    object/function_doc_signature.cpp
-    :   # requirements
-        <link>static:<define>BOOST_PYTHON_STATIC_LIB
-        <define>BOOST_PYTHON_SOURCE
+lib_boost_python($(py2-version)) = $(lib_boost_python(2)) ;
+lib_boost_python($(py3-version)) = $(lib_boost_python(3)) ;

-        # On Windows, all code using Python has to link to the Python
-        # import library.
-        #
-        # On *nix we never link libboost_python to libpython.  When
-        # extending Python, all Python symbols are provided by the
-        # Python interpreter executable.  When embedding Python, the
-        # client executable is expected to explicitly link to
-        # /python//python (the target representing libpython) itself.
-        #
-        # python_for_extensions is a target defined by Boost.Build to
-        # provide the Python include paths, and on Windows, the Python
-        # import library, as usage requirements.
-        [ cond [ python.configured ] : <library>/python//python_for_extensions ]
-
-        # we prevent building when there is no python available
-        # as it's not possible anyway, and to cause dependents to
-        # fail to build
-        [ unless [ python.configured ] : <build>no ]
-        <dependency>config-warning
-        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-        -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
-        <tag>@$(__name__).python-tag
-        <conditional>@python.require-py
-
-    :   # default build
-        <link>shared
-    :   # usage requirements
-        <link>static:<define>BOOST_PYTHON_STATIC_LIB
-        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-    ;
-
-numpy-include = [ python.numpy-include ] ;
-lib boost_numpy
-    : # sources
-    numpy/dtype.cpp
-    numpy/matrix.cpp
-    numpy/ndarray.cpp
-    numpy/numpy.cpp
-    numpy/scalars.cpp
-    numpy/ufunc.cpp
-    :   # requirements
-        <link>static:<define>BOOST_NUMPY_STATIC_LIB
-        <define>BOOST_NUMPY_SOURCE
-        [ cond [ python.numpy ] : <library>/python//python_for_extensions ]
-        [ unless [ python.numpy ] : <build>no ]
-        <include>$(numpy-include)
-        <library>boost_python
-        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-        -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
-	<tag>@$(__name__).python-tag
-        <conditional>@python.require-py
-
-    :   # default build
-        <link>shared
-    :   # usage requirements
-        <link>static:<define>BOOST_NUMPY_STATIC_LIB
-        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-    ;
-
-# boost-install creates `stage` and `install` targets
-#
-# `stage` stages (builds and copies into `stage/lib`) the given libraries
-#   `boost_python` and `boost_numpy` and their dependencies and is similar
-#   to issuing `b2 --with-python stage` from top level
-#
-# `install` installs the two libraries and their dependencies and is similar
-#   to issuing `b2 --with-python install` from top level
-
-boost-install boost_python boost_numpy ;
-
-}
-else
+rule lib_boost_python ( version )
 {
+    lib $(lib_boost_python($(version)))
+        : # sources
+        list.cpp
+        long.cpp
+        dict.cpp
+        tuple.cpp
+        str.cpp
+        slice.cpp

-# When Python isn't configured, the above `boost-install` is not executed,
-# so we create empty `stage` and `install` targets that do nothing but issue
-# a warning message unless `--without-python` is given
+        converter/from_python.cpp
+        converter/registry.cpp
+        converter/type_id.cpp
+        object/enum.cpp
+        object/class.cpp
+        object/function.cpp
+        object/inheritance.cpp
+        object/life_support.cpp
+        object/pickle_support.cpp
+        errors.cpp
+        module.cpp
+        converter/builtin_converters.cpp
+        converter/arg_to_python_base.cpp
+        object/iterator.cpp
+        object/stl_iterator.cpp
+        object_protocol.cpp
+        object_operators.cpp
+        wrapper.cpp
+        import.cpp
+        exec.cpp
+        object/function_doc_signature.cpp
+        :   # requirements
+            <link>static:<define>BOOST_PYTHON_STATIC_LIB 
+            <define>BOOST_PYTHON_SOURCE
+          
+            # On Windows, all code using Python has to link to the Python
+            # import library.
+            #
+            # On *nix we never link libboost_python to libpython.  When
+            # extending Python, all Python symbols are provided by the
+            # Python interpreter executable.  When embedding Python, the
+            # client executable is expected to explicitly link to
+            # /python//python (the target representing libpython) itself.
+            #
+            # python_for_extensions is a target defined by Boost.Build to
+            # provide the Python include paths, and on Windows, the Python
+            # import library, as usage requirements.
+            [ cond [ python.configured ] : <library>/python//python_for_extensions ]
+            
+            # we prevent building when there is no python available
+            # as it's not possible anyway, and to cause dependents to
+            # fail to build
+            [ unless [ python.configured ] : <build>no ]
+            <dependency>config-warning

-alias stage : config-warning ;
-explicit stage ;
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+            <python>$(version)

-alias install : config-warning ;
-explicit install ;
+            -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+            <tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).python-tag

+            <conditional>@python.require-py
+
+        :   # default build
+            <link>shared
+        :   # usage requirements
+            <link>static:<define>BOOST_PYTHON_STATIC_LIB
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        ;
 }
+
+lib_boost_numpy(2) = boost_numpy ;
+lib_boost_numpy(3) = boost_numpy3 ;
+
+lib_boost_numpy($(py2-version)) = $(lib_boost_numpy(2)) ;
+lib_boost_numpy($(py3-version)) = $(lib_boost_numpy(3)) ;
+
+rule lib_boost_numpy ( version )
+{
+    numpy-include = [ python.numpy-include ] ;
+    lib $(lib_boost_numpy($(version)))
+        : # sources
+        numpy/dtype.cpp
+        numpy/matrix.cpp
+        numpy/ndarray.cpp
+        numpy/numpy.cpp
+        numpy/scalars.cpp
+        numpy/ufunc.cpp
+        :   # requirements
+            <link>static:<define>BOOST_NUMPY_STATIC_LIB 
+            <define>BOOST_NUMPY_SOURCE
+            [ cond [ python.numpy ] : <library>/python//python_for_extensions ]
+            [ unless [ python.numpy ] : <build>no ]
+            <include>$(numpy-include)
+            <library>$(lib_boost_python($(version)))
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+            <python>$(version)
+
+            -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
+            <tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).python-tag
+
+            <conditional>@python.require-py
+
+        :   # default build
+            <link>shared
+        :   # usage requirements
+			<link>static:<define>BOOST_NUMPY_STATIC_LIB
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        ;
+}
+
+libraries = ;
+
+for local N in 2 3
+{
+    if $(py$(N)-version)
+    {
+        lib_boost_python $(py$(N)-version) ;
+        libraries += $(lib_boost_python($(py$(N)-version))) ;
+    }
+    else
+    {
+        alias $(lib_boost_python($(N))) ;
+    }
+    if $(py$(N)-version) && [ python.numpy ]
+    {
+        lib_boost_numpy $(py$(N)-version) ;
+        libraries += $(lib_boost_numpy($(py$(N)-version))) ;
+    }
+    else
+    {
+        alias $(lib_boost_numpy($(N))) ;
+    }
+}
+
+boost-install $(libraries) ;
--- a/config/init.py
+++ b/config/init.py
@@ -0,0 +1,140 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from SCons.Variables import *
+from SCons.Script import AddOption
+from collections import OrderedDict
+import platform
+from . import ui
+from . import cxx
+from . import python
+from . import numpy
+from . import boost
+
+def add_options(vars):
+    ui.add_option('-V', '--verbose', dest='verbose', action='store_true', help='verbose mode: print full commands.')
+    ui.add_option('--no-numpy', dest='numpy', action='store_false', help='do not attempt to build NumPy bindings.')
+    python.add_options(vars)
+    numpy.add_options(vars)
+    boost.add_options(vars)
+
+    vars.Add('CXX')
+    vars.Add('CPPPATH', converter=lambda v:v.split())
+    vars.Add('CCFLAGS', converter=lambda v:v.split())
+    vars.Add('CXXFLAGS', converter=lambda v:v.split())
+    vars.Add('LIBPATH', converter=lambda v:v.split())
+    vars.Add('LIBS', converter=lambda v:v.split())
+    vars.Add('PYTHON')
+    vars.Add('PYTHONLIBS')
+    vars.Add('prefix')
+    vars.Add('boostbook_prefix')
+    vars.Add('CXX11')
+    vars.Add('NUMPY')
+    vars.Add('NUMPY_CPPPATH', converter=lambda v:v.split())
+
+    ui.add_variable(vars, ("arch", "target architeture", platform.machine()))
+    ui.add_variable(vars, ("toolchain", "toolchain to use", 'gcc'))
+    ui.add_variable(vars, ListVariable("variant", "Build configuration", "release", ["release", "debug", "profile"]))
+    ui.add_variable(vars, ListVariable("link", "Library linking", "dynamic", ["static", "dynamic"]))
+    ui.add_variable(vars, ListVariable("threading", "Multi-threading support", "multi", ["single", "multi"]))
+    ui.add_variable(vars, EnumVariable("layout", "Layout of library names and header locations", "versioned", ["versioned", "system"]))
+    ui.add_variable(vars, PathVariable("stagedir", "If --stage is passed install only compiled library files in this location", "stage", PathVariable.PathAccept))
+    ui.add_variable(vars, PathVariable("prefix", "Install prefix", "/usr/local", PathVariable.PathAccept))
+
+
+def get_checks(env):
+  checks = OrderedDict()
+  checks['cxx'] = cxx.check
+  checks['python'] = python.check
+  if env.GetOption('numpy') is not False:
+      checks['numpy'] = numpy.check
+  else:
+      env['NUMPY'] = False
+  checks['boost'] = boost.check
+  return checks
+
+
+def set_property(env, **kw):
+
+    from toolchains.gcc import features as gcc_features
+    from toolchains.msvc import features as msvc_features
+
+    if 'gcc' in env['TOOLS']: features = gcc_features
+    elif 'msvc' in env['TOOLS']: features = msvc_features
+    else: raise Error('unknown toolchain')
+    features.init_once(env)
+    for (prop,value) in kw.items():
+        getattr(features, prop, lambda x, y : None)(env, value)
+        env[prop.upper()] = value
+
+
+def boost_suffix(env):
+    suffix = str()
+
+    if env["layout"] == "versioned":
+        if "gcc" in env["TOOLS"]:
+            if env['CXX'] in ('clang', 'clang++'):
+                suffix += "-clang" + "".join(env["CXXVERSION"].split(".")[0:2])
+            else: # assume g++
+                suffix += "-gcc" + "".join(env["CXXVERSION"].split(".")[0:2])
+    if env["THREADING"] == "multi":
+        suffix += "-mt"
+    if env["DEBUG"]:
+        suffix += "-d"
+    if env["layout"] == "versioned":
+        suffix += "-" + "_".join(env["BPL_VERSION"].split("."))
+
+    return suffix
+
+
+def prepare_build_dir(env):
+
+    vars = {}
+    env["boost_suffix"] = boost_suffix
+    build_dir="bin.SCons"
+    # FIXME: Support 'toolchain' variable properly.
+    #        For now, we simply check whether $CXX refers to clang or gcc.
+    if "gcc" in env["TOOLS"]:
+        if env['CXX'] in ('clang', 'clang++'):
+            build_dir+="/clang-%s"%env["CXXVERSION"]
+        else: # assume g++
+            build_dir+="/gcc-%s"%env["CXXVERSION"]
+        default_cxxflags = ['-ftemplate-depth-128', '-Wall', '-g', '-O2']
+        vars['CXXFLAGS'] = env.get('CXXFLAGS', default_cxxflags)
+    elif "msvc" in env["TOOLS"]:
+        build_dir+="/msvc-%s"%env["MSVS_VERSION"]
+    vars['BOOST_BUILD_DIR'] = build_dir
+    vars['BOOST_SUFFIX'] = "${boost_suffix(__env__)}"
+    env.Replace(**vars)    
+    return build_dir
+
+
+def variants(env):
+
+    env.Prepend(CPPPATH = "#/include", CPPDEFINES = ["BOOST_ALL_NO_LIB=1"])
+    set_property(env, architecture = env['TARGET_ARCH'])
+    for variant in env["variant"]:
+        e = env.Clone()
+        e["current_variant"] = variant
+        set_property(env, profile = False)
+        if variant == "release":
+            set_property(e, optimize = "speed", debug = False)
+        elif variant == "debug":
+            set_property(e, optimize = "no", debug = True)
+        elif variant == "profile":
+            set_property(e, optimize = "speed", profile = True, debug = True)
+        for linking in env["link"]:
+            e["linking"] = linking
+            if linking == "dynamic":
+                e["LINK_DYNAMIC"] = True
+            else:
+                e["LINK_DYNAMIC"] = False
+            for threading in e["threading"]:
+                e["current_threading"] = threading
+                set_property(e, threading = threading)
+                yield e
--- a/config/boost.py
+++ b/config/boost.py
@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from . import ui
+import os
+
+def add_options(vars):
+    
+    ui.add_option("--boost-prefix", dest="boost_prefix", type="string", nargs=1, action="store",
+                  metavar="DIR", default=os.environ.get("BOOST_DIR"),
+                  help="prefix for Boost libraries; should have 'include' and 'lib' subdirectories, 'boost' and 'stage\\lib' subdirectories on Windows")
+    ui.add_option("--boost-include", dest="boost_include", type="string", nargs=1, action="store",
+                  metavar="DIR", help="location of Boost header files")
+    ui.add_option("--boostbook-prefix", dest="boostbook_prefix", type="string",
+                  nargs=1, action="store",
+                  metavar="DIR", default="/usr/share/boostbook",
+                  help="prefix for BoostBook stylesheets")
+    
+def check(context):
+
+    boost_source_file = r"#include <boost/config.hpp>"
+
+    context.Message('Checking for Boost...')
+
+    boost_prefix = context.env.GetOption('boost_prefix')
+    boost_include = context.env.GetOption('boost_include')
+    boostbook_prefix = context.env.GetOption('boostbook_prefix')
+    incpath=None
+    if boost_include:
+        incpath=boost_include
+    elif boost_prefix:
+        incpath=boost_prefix
+    if incpath:
+        context.env.AppendUnique(CPPPATH=[incpath])
+    if not context.TryCompile(boost_source_file, '.cpp'):
+        context.Result(0)
+        return False
+    context.env.AppendUnique(boostbook_prefix=boostbook_prefix)
+    context.Result(1)
+    return True
--- a/config/cxx.py
+++ b/config/cxx.py
@@ -0,0 +1,30 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from . import ui
+import os
+
+def add_options(vars):
+
+    pass
+
+def check(context):
+
+    source = r"""#if __cplusplus < 201103L
+#error no C++11
+#endif"""
+
+    context.Message('Checking for C++11 support...')
+
+    if not context.TryCompile(source, '.cpp'):
+        context.env['CXX11'] = False
+        context.Result(0)
+    else:
+        context.env['CXX11'] = True
+        context.Result(1)
+    return True
--- a/config/numpy.py
+++ b/config/numpy.py
@@ -0,0 +1,86 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from . import ui
+from contextlib import contextmanager
+
+@contextmanager
+def saved(context):
+    save_cpppath = context.env.get('CPPPATH', [])
+    save_libs = context.env.get('LIBS', [])
+    yield context
+    context.env.Replace(LIBS=save_libs)
+    context.env.Replace(CPPPATH=save_cpppath)
+
+
+def add_options(vars):
+
+    pass
+
+
+def check(context):
+
+    numpy_source_file = r"""
+// If defined, enforces linking againg PythonXXd.lib, which
+// is usually not included in Python environments.
+#undef _DEBUG
+#include "Python.h"
+#include "numpy/arrayobject.h"
+
+#if PY_VERSION_HEX >= 0x03000000
+void *initialize() { import_array();}
+#else
+void initialize() { import_array();}
+#endif
+
+int main()
+{
+  int result = 0;
+  Py_Initialize();
+  initialize();
+  if (PyErr_Occurred())
+  {
+    result = 1;
+  }
+  else
+  {
+    npy_intp dims = 2;
+    PyObject * a = PyArray_SimpleNew(1, &dims, NPY_INT);
+    if (!a) result = 1;
+    Py_DECREF(a);
+  }
+  Py_Finalize();
+  return result;
+}
+"""
+
+    import platform
+    import subprocess
+    import re, os
+
+    def check_python(cmd):
+        try:
+            return True, subprocess.check_output([python, '-c', cmd]).strip()
+        except subprocess.CalledProcessError as e:
+            return False, e
+
+    context.Message('Checking for NumPy...')
+    with saved(context):
+        python = context.env['PYTHON']
+        result, numpy_incpath = check_python('import numpy; print(numpy.get_include())')
+        if result:
+            context.env.AppendUnique(CPPPATH=numpy_incpath)
+            context.env.AppendUnique(LIBS=context.env['PYTHONLIBS'])
+            result, output = context.TryRun(numpy_source_file,'.cpp')
+        if not result:
+            context.Result(0)
+            return False
+        context.env['NUMPY'] = True
+        context.env['NUMPY_CPPPATH'] = numpy_incpath
+        context.Result(1)
+        return True
--- a/config/python.py
+++ b/config/python.py
@@ -0,0 +1,98 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from . import ui
+
+def add_options(vars):
+
+    ui.add_option('--python', help='the python executable')
+
+
+def check(context):
+
+    python_source_file = r"""
+// If defined, enforces linking againg PythonXXd.lib, which
+// is usually not included in Python environments.
+#undef _DEBUG
+#include "Python.h"
+int main()
+{
+  Py_Initialize();
+  Py_Finalize();
+  return 0;
+}
+"""
+
+    import platform
+    import subprocess
+    import re, os
+
+    def check_python(cmd):
+        return subprocess.check_output([python, '-c', cmd]).strip()
+
+    def check_sysconfig(cmd):
+        r = check_python('import distutils.sysconfig as c; print(c.%s)'%cmd)
+        return r if r != 'None' else ''
+
+    context.Message('Checking for Python...')
+    python = context.env.GetOption('python') or 'python'
+    context.env['PYTHON'] = python
+    incpath = check_sysconfig('get_python_inc()')
+    context.env.AppendUnique(CPPPATH=[incpath])
+    if platform.system() == 'Windows':
+        version = check_python('import sys; print("%d%d"%sys.version_info[0:2])')
+        prefix = check_python('import sys; print(sys.prefix)')
+        libfile = os.path.join(prefix, 'libs', 'python%s.lib'%version)
+        libpath = os.path.join(prefix, 'libs')
+        lib = 'python%s'%version
+        context.env.AppendUnique(LIBS=[lib])
+    else:
+        libpath = check_sysconfig('get_config_var("LIBDIR")')
+        libfile = check_sysconfig('get_config_var("LIBRARY")')
+        match = re.search('(python.*)\.(a|so|dylib)', libfile)
+        lib = None
+        if match:
+            lib = match.group(1)
+            context.env.AppendUnique(PYTHONLIBS=[lib])
+            if match.group(2) == 'a':
+                flags = check_sysconfig('get_config_var("LINKFORSHARED")')
+                if flags is not None:
+                    context.env.AppendUnique(LINKFLAGS=flags.split())
+    context.env.AppendUnique(LIBPATH=[libpath])
+    oldlibs = context.AppendLIBS([lib])
+    flags = check_sysconfig('get_config_var("MODLIBS")')
+    flags += ' ' + check_sysconfig('get_config_var("SHLIBS")')
+    flags = [f[2:] for f in flags.strip().split() if f.startswith('-l')]
+    if flags:
+        context.AppendLIBS([flags])
+    result = context.TryLink(python_source_file,'.cpp')
+    if not result and context.env['PLATFORM'] == 'darwin':
+        # Sometimes we need some extra stuff on Mac OS
+        frameworkDir = libpath # search up the libDir tree for the proper home for frameworks
+        while frameworkDir and frameworkDir != "/":
+            frameworkDir, d2 = os.path.split(frameworkDir)
+            if d2 == "Python.framework":
+                if not "Python" in os.listdir(os.path.join(frameworkDir, d2)):
+                    context.Result(0)
+                    print((
+                        "Expected to find Python in framework directory %s, but it isn't there"
+                        % frameworkDir))
+                    return False
+                break
+        context.env.AppendUnique(LINKFLAGS="-F%s" % frameworkDir)
+        result = context.TryLink(python_source_file,'.cpp')
+    if not result:
+        context.Result(0)
+        print("Cannot link program with Python.")
+        return False
+    if context.env['PLATFORM'] == 'darwin':
+        context.env['LDMODULESUFFIX'] = '.so'
+    context.Result(1)
+    context.SetLIBS(oldlibs)
+    context.env.AppendUnique(PYTHONLIBS=[lib] + flags)
+    return True
--- a/config/toolchains/init.py
+++ b/config/toolchains/init.py
@@ -0,0 +1,18 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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 traceback
+
+def append_feature_flag(env, **kw):
+    stack = traceback.extract_stack(limit = 3)
+    feature = stack[0][2].upper()
+    for (key, val) in kw.items():
+        feature_var = feature + "_" + key
+        env.AppendUnique(**{ key : "$" + feature_var })
+        env[feature_var] = val
+
--- a/config/toolchains/gcc.py
+++ b/config/toolchains/gcc.py
@@ -0,0 +1,55 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from . import append_feature_flag
+
+class features:
+
+    @classmethod
+    def init_once(cls, env):
+        pass
+
+    @staticmethod
+    def architecture(env, arch):
+        if arch:
+            flag = {'x86' :    '-m32',
+                    'x86_64' : '-m64',}.get(arch)
+            if flag:
+                append_feature_flag(env, CCFLAGS = flag)
+    
+    @staticmethod
+    def optimize(env, optimize):
+        if not optimize or optimize == "no":
+            append_feature_flag(env, CCFLAGS = "-O0 -fno-inline")
+        elif optimize == "speed":
+            append_feature_flag(env, CCFLAGS = "-O3 -finline-functions -Wno-inline")
+        elif optimize == "space":
+            append_feature_flag(env, CCFLAGS = "-Os")
+        else:
+            append_feature_flag(env, CCFLAGS = "")
+
+    @staticmethod
+    def profile(env, profile):
+        if profile:
+            append_feature_flag(env, CCFLAGS = "-pg", LINKFLAGS = "-pg")
+        else:
+            append_feature_flag(env, CCFLAGS = "", LINKFLAGS = "")
+
+    @staticmethod
+    def threading(env, threading):
+        if threading == "multi":
+            append_feature_flag(env, CCFLAGS = "-pthread", LINKFLAGS = "-pthread")
+        else:
+            append_feature_flag(env, CCFLAGS = "", LINKFLAGS = "")
+
+    @staticmethod
+    def debug(env, debug):
+        if debug:
+            append_feature_flag(env, CCFLAGS = "-g", CPPDEFINES = [])
+        else:
+            append_feature_flag(env, CCFLAGS = "", CPPDEFINES = "NDEBUG")
--- a/config/toolchains/msvc.py
+++ b/config/toolchains/msvc.py
@@ -0,0 +1,57 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from . import append_feature_flag
+
+class features:
+
+    @classmethod
+    def init_once(cls, env):
+        env.AppendUnique(CCFLAGS = ['-TP', '/Z7', '/W3' ,'/GR', '/MDd', '/Zc:forScope', '/Zc:wchar_t', '/wd4675', '/EHs'])
+        env.AppendUnique(LINKFLAGS = ['/subsystem:console'])
+
+    @staticmethod
+    def architecture(env, arch):
+        if arch:
+            flag = {'x86' :    '/MACHINE:X86',
+                    'x86_64' : '/MACHINE:X64',}.get(arch)
+            if flag:
+                append_feature_flag(env, LINKFLAGS = flag)
+
+    @staticmethod
+    def optimize(env, optimize):
+        #if not optimize or optimize == "no":
+        #    append_feature_flag(env, CCFLAGS = "-O0 -fno-inline")
+        #elif optimize == "speed":
+        #    append_feature_flag(env, CCFLAGS = "-O3 -finline-functions -Wno-inline")
+        #elif optimize == "space":
+        #    append_feature_flag(env, CCFLAGS = "-Os")
+        #else:
+            append_feature_flag(env, CCFLAGS = "")
+
+    @staticmethod
+    def profile(env, profile):
+        #if profile:
+        #    append_feature_flag(env, CCFLAGS = "-pg", LINKFLAGS = "-pg")
+        #else:
+            append_feature_flag(env, CCFLAGS = "", LINKFLAGS = "")
+
+    @staticmethod
+    def threading(env, threading):
+        #if threading == "multi":
+        #    append_feature_flag(env, CCFLAGS = "/MT")
+        #else:
+        #    append_feature_flag(env, CCFLAGS = "", LINKFLAGS = "")
+        pass
+
+    @staticmethod
+    def debug(env, debug):
+        #if debug:
+        #    append_feature_flag(env, CCFLAGS = "-g", CPPDEFINES = [])
+        #else:
+            append_feature_flag(env, CCFLAGS = "", CPPDEFINES = "NDEBUG")
--- a/config/tools/clang.py
+++ b/config/tools/clang.py
@@ -0,0 +1,44 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+# Based on SCons/Tool/gcc.py
+
+import os
+import re
+import subprocess
+
+import SCons.Util
+import SCons.Tool.cc
+
+compilers = ['clang']
+
+def generate(env):
+    """Add Builders and construction variables for clang to an Environment."""
+    SCons.Tool.cc.generate(env)
+
+    env['CC'] = env.Detect(compilers) or 'clang'
+    if env['PLATFORM'] in ['cygwin', 'win32']:
+        env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS')
+    else:
+        env['SHCCFLAGS'] = SCons.Util.CLVar('$CCFLAGS -fPIC')
+    # determine compiler version
+    if env['CC']:
+        #pipe = SCons.Action._subproc(env, [env['CC'], '-dumpversion'],
+        pipe = SCons.Action._subproc(env, [env['CC'], '--version'],
+                                     stdin = 'devnull',
+                                     stderr = 'devnull',
+                                     stdout = subprocess.PIPE)
+        if pipe.wait() != 0: return
+        # clang -dumpversion is of no use
+        line = pipe.stdout.readline()
+        match = re.search(r'clang +version +([0-9]+(?:\.[0-9]+)+)', line)
+        if match:
+            env['CCVERSION'] = match.group(1)
+
+def exists(env):
+    return env.Detect(compilers)
--- a/config/tools/doc.py
+++ b/config/tools/doc.py
@@ -0,0 +1,75 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from SCons.Script import AddOption, Flatten
+from SCons.Script import Builder
+from SCons.Action import Action
+from SCons.Defaults import Copy
+from SCons.Script import *
+from subprocess import check_output, STDOUT, CalledProcessError
+import sys
+import os
+
+def QuickBook(env, target, source, dependencies=[]):
+    """Compile a QuickBook document to BoostBook."""
+
+    for d in dependencies:
+        env.Depends(target, d)
+    env.Command(target, source, 'quickbook --input-file=$SOURCE --output-file=$TARGET')
+
+
+def BoostBook(env, target, source, resources=[], args=[]):
+    """Compile a BoostBook document to DocBook."""
+
+    bb_prefix = env.GetOption('boostbook_prefix')
+    stylesheet = bb_prefix + '/xsl/docbook.xsl'
+    env.Command(target, source,
+                'xsltproc {} -o $TARGET {} $SOURCE'.format(' '.join(args), stylesheet))
+
+
+def BoostHTML(env, target, source, resources=[], args=[]):
+    """Compile a DocBook document to HTML."""
+
+    bb_prefix = env.GetOption('boostbook_prefix')
+    stylesheet = bb_prefix + '/xsl/html.xsl'
+    env.Command(target, source,
+                'xsltproc {} -o $TARGET/ {} $SOURCE'.format(' '.join(args), stylesheet))
+    prefix=Dir('.').path
+    for r in resources:
+        r = File(r).path[len(prefix)+1:]
+        env.Depends(target, target + r)
+        env.Command(target + r, r, Copy('$TARGET', '$SOURCE'))
+
+
+def BoostRST(env, target, source, resources=[]):
+    """Compile an RST document to HTML."""
+
+    prefix=Dir('.').path
+    for r in resources:
+        r = File(r).path[len(prefix)+1:]
+        env.Depends('html/' + r, r)
+        env.Command('html/' + r, r, Copy('$TARGET', '$SOURCE'))
+    env.Command(target, source,
+                'rst2html --link-stylesheet --traceback --trim-footnote-reference-space --footnote-references=superscript --stylesheet=rst.css $SOURCE $TARGET')
+
+
+def BoostSphinx(env, target, source):
+    env.Sphinx(target, source)
+
+
+def exists(env):
+    return True
+
+
+def generate(env):
+
+    env.AddMethod(QuickBook)
+    env.AddMethod(BoostBook)
+    env.AddMethod(BoostHTML)
+    env.AddMethod(BoostRST)
+    env.AddMethod(BoostSphinx)
--- a/config/tools/libs.py
+++ b/config/tools/libs.py
@@ -0,0 +1,85 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from SCons.Script import AddOption, COMMAND_LINE_TARGETS, BUILD_TARGETS
+import distutils.sysconfig
+import platform
+
+
+def BoostLibrary(env, lib, sources, make_aliases = True, **kw):
+    if env["LINK_DYNAMIC"]:
+        lib_node = env.SharedLibrary("boost_" + lib + env["BOOST_SUFFIX"], sources, **kw)
+    else:
+        lib_node = env.StaticLibrary("boost_" + lib + env["BOOST_SUFFIX"], sources, **kw)
+
+    if make_aliases:
+        if env.GetOption("stage"):
+            env.Alias(lib, env.Install(env.Dir("$stagedir", "#"), lib_node))
+        env.Default(env.Alias(lib, lib_node))
+
+        if env.GetOption("install"):
+            env.Alias(lib, env.Install("$prefix/lib", lib_node))
+            env.Alias(lib, env.Install('$prefix/include/boost', '#/include/boost/python'))
+            env.Alias(lib, env.Install('$prefix/include/boost', '#/include/boost/python.hpp'))
+    return lib_node
+
+
+def BoostUseLib(env, lib):
+    build_dir = env.Dir('$BOOST_CURRENT_VARIANT_DIR/src')
+    env.AppendUnique(LIBPATH = [build_dir],
+                     LIBS = ["boost_" + lib + env["BOOST_SUFFIX"]])
+    if env.get("BOOST_TEST"):
+        env.AppendUnique(RPATH = [build_dir])
+        if platform.system() == 'Windows':
+            env.PrependENVPath('PATH', build_dir.abspath)
+        else:
+            env.PrependENVPath('LD_LIBRARY_PATH', build_dir.abspath)
+
+
+def PythonExtension(env, lib, sources, **kw):
+    if env["LINK_DYNAMIC"]:
+        ext = env.SharedLibrary(lib, sources, SHLIBPREFIX='', SHLIBSUFFIX=distutils.sysconfig.get_config_var("SO"), **kw)
+        return ext
+
+
+def boost_copy_func(dest, source, env):
+    import os, stat, shutil
+
+    if os.path.isdir(source):
+        if os.path.exists(dest):
+            if not os.path.isdir(dest):
+                raise SCons.Errors.UserError, "cannot overwrite non-directory `%s' with a directory `%s'" % (str(dest), str(source))
+        else:
+            os.makedirs(dest)
+        for file in os.listdir(source):
+            if file == ".svn": continue
+            boost_copy_func(os.path.join(dest, file), os.path.join(source, file), env)
+    else:
+        shutil.copy2(source, dest)
+        st = os.stat(source)
+        os.chmod(dest, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
+
+    return 0
+
+
+def exists(env):
+    return True
+
+
+def generate(env):
+    env.AddMethod(BoostLibrary)
+    env.AddMethod(BoostUseLib)
+    env.AddMethod(PythonExtension)
+
+    env.Replace(
+        INSTALL = boost_copy_func,
+        BOOST_CURRENT_VARIANT_DIR = "#/$BOOST_BUILD_DIR/$current_variant/$linking/threading-$current_threading"
+    )
+
+    AddOption('--stage', dest='stage', action="store_true")
+    AddOption('--install', dest='install', action="store_true")
--- a/config/tools/sphinx4scons.py
+++ b/config/tools/sphinx4scons.py
@@ -0,0 +1,592 @@
+"""SCons.Tool.spinx4scons
+
+Tool-specific initialization for the Sphinx document build system.
+
+There normally shouldn't be any need to import this module directly.
+It will usually be imported through the generic SCons.Tool.Tool()
+selection method.
+
+It should be placed in e.g. ~/site_scons/site_tools/sphinx4scons/
+directory. Then it may be loaded by placing
+
+  sphinx = Tool('sphinx4scons')
+  sphinx(env)
+
+in your SConstruct file.
+
+For further details, please see the SCons documentation on how to
+install and enable custom tools.
+"""
+
+#
+# This package is provided under the Expat license
+#
+# Copyright (c) 2012 Orlando Wingbrant
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+__author__ = "Orlando Wingbrant"
+__email__ = "orlando@widesite.org"
+__url__ = "https://bitbucket.org/wingbrant/sphinx4scons"
+__license__ = "Expat license"
+
+import SCons.Action
+import SCons.Builder
+import SCons.Defaults
+import SCons.Util
+import SCons.Node.FS
+import os
+
+from sphinx.util.matching import patfilter, compile_matchers
+from sphinx.util.osutil import make_filename
+
+
+class ToolSphinxWarning(SCons.Warnings.Warning):
+    pass
+
+
+class SphinxBuilderNotFound(ToolSphinxWarning):
+    pass
+
+SCons.Warnings.enableWarningClass(ToolSphinxWarning)
+
+
+def exists(env):
+    return _detect(env)
+
+
+def _detect(env):
+    """Try to detect the sphinx-build script."""
+    try:
+        return env['SPHINXBUILD']
+    except KeyError:
+        pass
+
+    sphinx = env.WhereIs('sphinx-build')
+    if sphinx:
+        return sphinx
+
+    raise SCons.Errors.StopError(
+        SphinxBuilderNotFound,
+        "Could not detect sphinx-build script")
+    return None
+
+
+def generate(env):
+    """Add Builders and construction variables to the Environment."""
+
+    env['SPHINXBUILD'] = _detect(env)
+    sphinx = _create_sphinx_builder(env)
+
+    env.SetDefault(
+        # Additional command-line flags
+        SPHINXFLAGS = '',
+
+        # Tag definitions, each entry will appear on the command line preceded by -t
+        SPHINXTAGS = [],
+
+        # Directory for doctrees
+        SPHINXDOCTREE = '',
+
+        # Path to sphinx configuration file
+        SPHINXCONFIG = '',
+
+        # Config file override settings, each entry will be preceded by -D
+        SPHINXSETTINGS = {},
+
+        # Default sphinx builder,
+        SPHINXBUILDER = 'html',
+
+        # Sphinx command
+        SPHINXCOM = "$SPHINXBUILD $_SPHINXOPTIONS ${SOURCE.attributes.root} ${TARGET.attributes.root}",
+
+        # Alternate console output when building sphinx documents
+        SPHINXCOMSTR = ""
+        )
+
+    try:
+        env.AddMethod(Sphinx, "Sphinx")
+    except AttributeError:
+        # Looks like we use a pre-0.98 version of SCons...
+        from SCons.Script.SConscript import SConsEnvironment
+        SConsEnvironment.Sphinx = Sphinx
+
+
+def Sphinx(env, target, source, **kw):
+    """A pseudo-builder wrapper for the sphinx builder."""
+    builder = env['BUILDERS']['Sphinx4Scons']
+    env_kw = env.Override(kw)
+    options = _get_sphinxoptions(env_kw, target, source)
+    output = builder(env, target, source, _SPHINXOPTIONS=options, **kw)
+    return output
+
+
+def _get_sphinxoptions(env, target, source):
+    """Concatenates all the options for the sphinx command line."""
+    options = []
+
+    builder = _get_sphinxbuilder(env)
+    options.append("-b %s" % env.subst(builder, target=target, source=source))
+
+    flags = env.get('options', env.get('SPHINXFLAGS', ''))
+    options.append(env.subst(flags, target=target, source=source))
+
+    tags = env.get('tags', env.get('SPHINXTAGS', None))
+    if tags is not None:
+        if not SCons.SCons.Util.is_List(tags):
+            tags = [tags]
+        for tag in tags:
+            if tag != '':
+                tag = env.subst(tag, target=target, source=source)
+                options.append("-t %s" % tag)
+
+    settings = env.get('settings', env.get('SPHINXSETTINGS', None))
+    if settings is not None:
+        if not SCons.SCons.Util.is_Dict(settings):
+            raise TypeError('SPHINXSETTINGS and/or settings argument must be a dictionary')
+        for key, value in settings.iteritems():
+            if value != '':
+                value = env.subst(value, target=target, source=source)
+                options.append('-D "%s=%s"' % (key, value))
+
+    doctree = env.get('doctree', env.get("SPHINXDOCTREE", None))
+    if isinstance(doctree, SCons.Node.FS.Dir):
+        options.append("-d %s" % doctree.get_abspath())
+    elif doctree is not None and doctree != '':
+        doctree = env.subst(doctree, target=target, source=source)
+        options.append("-d %s" % env.Dir(doctree).get_abspath())
+
+    config = _get_sphinxconfig_path(env, None)
+    if config is not None and config != '':
+        config = env.subst(config, target=target, source=source)
+        options.append("-c %s" % env.Dir(config).File('conf.py').rfile().dir.get_abspath())
+    return " ".join(options)
+
+
+def _create_sphinx_builder(env):
+    try:
+        sphinx = env['BUILDERS']['Sphinx4Scons']
+    except KeyError:
+        fs = SCons.Node.FS.get_default_fs()
+        sphinx_com = SCons.Action.Action('$SPHINXCOM', '$SPHINXCOMSTR')
+        sphinx = SCons.Builder.Builder(action=sphinx_com,
+                                       emitter=sphinx_emitter,
+                                       target_factory=fs.Dir,
+                                       source_factory=fs.Dir
+                                       )
+        env['BUILDERS']['Sphinx4Scons'] = sphinx
+    return sphinx
+
+
+def sphinx_emitter(target, source, env):
+    target[0].must_be_same(SCons.Node.FS.Dir)
+    targetnode = target[0]
+
+    source[0].must_be_same(SCons.Node.FS.Dir)
+    srcnode = source[0]
+
+    configdir = _get_sphinxconfig_path(env, None)
+    if not configdir:
+        confignode = srcnode
+    else:
+        confignode = env.Dir(configdir)
+
+    srcinfo = SourceInfo(srcnode, confignode, env)
+    targets, sources = _get_emissions(env, target, srcinfo)
+    env.Clean(targets, target[0])
+
+    return targets, sources
+
+
+def sphinx_path(os_path):
+    """Create sphinx-style path from os-style path."""
+    return os_path.replace(os.sep, "/")
+
+
+def os_path(sphinx_path):
+    """Create os-style path from sphinx-style path."""
+    return sphinx_path.replace("/", os.sep)
+
+
+class SourceInfo(object):
+    """
+    Data container for all different kinds of source files used in
+    a sphinx project.
+    """
+    def __init__(self, srcnode, confignode, env):
+        self.confignode = confignode
+        self.config = self._get_config(self.confignode, env)
+        self.templates = self._get_templates(self.confignode, self.config)
+        self.statics = self._get_statics(self.confignode, self.config)
+        self.srcnode = srcnode
+        self.sources = self._get_sources(self.srcnode, self.config)
+
+        self.srcroot = srcnode
+        if not srcnode.duplicate:
+            self.srcroot = srcnode.srcnode().rdir()
+
+
+    def _get_config(self, confignode, env):
+        config = {}
+        execfile(confignode.File('conf.py').rfile().get_abspath(), config)
+        return config
+
+
+    def _get_templates(self, confignode, config):
+        """Returns template files defined in the project."""
+        templates = []
+        for path in config.get('templates_path', []):
+            # Check if path is dir or file.
+            # We can't use FS.Entry since that will create nodes, and
+            # these nodes don't know about the source tree and will
+            # get disambiguated to files even if they are directories in the
+            # source tree.
+            p = confignode.File('conf.py').rfile().dir.srcnode().get_abspath()
+            p = os.path.join(p, os_path(path))
+            if os.path.isfile(p):
+                templates.append(confignode.File(path))
+            elif os.path.isdir(p):
+                node = confignode.Dir(path)
+                for root, dirs, files in os.walk(p):
+                    mydir = node.Dir(os.path.relpath(root, p))
+                    templates += [mydir.File(f) for f in files]
+        return templates
+
+
+    def _get_statics(self, confignode, config):
+        """Returns static files, filtered through exclude_patterns."""
+        statics = []
+        matchers = compile_matchers(config.get('exclude_patterns', []))
+
+        for path in config.get('html_static_path', []):
+            # Check _get_templates() why we use this construction.
+            p = confignode.File('conf.py').rfile().dir.srcnode().get_abspath()
+            p = os.path.join(p, os_path(path))
+            if os.path.isfile(p):
+                statics.append(confignode.File(path))
+            elif os.path.isdir(p):
+                node = confignode.Dir(path)
+                for root, dirs, files in os.walk(p):
+                    relpath = os.path.relpath(root, p)
+                    for entry in [d for d in dirs if
+                                  self._anymatch(matchers,
+                                                 sphinx_path(os.path.join(relpath, d)))]:
+                        dirs.remove(entry)
+                    statics += [node.File(os_path(f)) for f in
+                                self._exclude(matchers,
+                                              [sphinx_path(os.path.join(relpath, name))
+                                               for name in files])]
+        return statics
+
+
+    def _get_sources(self, srcnode, config):
+        """Returns all source files in the project filtered through exclude_patterns."""
+        suffix = config.get('source_suffix', '.rst')
+        matchers = compile_matchers(config.get('exclude_patterns', []))
+
+        srcfiles = []
+        scannode = srcnode.srcnode().rdir()
+
+        for root, dirs, files in os.walk(scannode.get_abspath()):
+            relpath = os.path.relpath(root, scannode.get_abspath())
+            for entry in [d for d in dirs if
+                          self._anymatch(matchers,
+                                         sphinx_path(os.path.join(relpath, d)))]:
+                dirs.remove(entry)
+            srcfiles += [srcnode.File(os_path(f)) for f in
+                         self._exclude(matchers,
+                                       [sphinx_path(os.path.join(relpath, name))
+                                        for name in files if name.endswith(suffix)])]
+        return srcfiles
+
+
+    def _exclude(self, matchers, items):
+        result = items
+        for matcher in matchers:
+            result = filter(lambda x: not matcher(x), result)
+        return result
+
+
+    def _anymatch(self, matchers, item):
+        for matcher in matchers:
+            if matcher(item):
+                return True
+        return False
+
+
+def _get_sphinxconfig_path(env, default):
+    path = env.get('config', env.get('SPHINXCONFIG', None))
+    if path is None or path == '':
+        path = default
+    return path
+
+
+def _get_emissions(env, target, srcinfo):
+    targets = []
+    sources = []
+    builder = _get_sphinxbuilder(env)
+    if builder == 'changes':
+        targets, sources = _get_changes_emissions(env, target, srcinfo)
+    if builder == 'devhelp':
+        targets, sources = _get_help_emissions(env, target, srcinfo,
+                                                ['.devhelp.gz'])
+    elif builder == 'dirhtml':
+        targets, sources = _get_dirhtml_emissions(env, target, srcinfo)
+    elif builder == 'doctest':
+        targets, sources = _get_doctest_emissions(env, target, srcinfo)
+    elif builder == 'epub':
+        targets, sources = _get_epub_emissions(env, target, srcinfo)
+    elif builder == 'html':
+        targets, sources = _get_serialize_emissions(env, target, srcinfo)
+    elif builder == 'htmlhelp':
+        targets, sources = _get_help_emissions(env, target, srcinfo,
+                                               ['.hhp'], 'htmlhelp_basename')
+    elif builder == 'gettext':
+        targets, sources = _get_gettext_emissions(env, target, srcinfo)
+    elif builder == 'json':
+        targets, sources = _get_serialize_emissions(env, target, srcinfo,
+                                                     '.fjson',
+                                                     ['globalcontext.json',
+                                                      'searchindex.json',
+                                                      'self.environment.pickle'])
+    elif builder == 'latex':
+        targets, sources = _get_latex_emissions(env, target, srcinfo)
+    elif builder == 'linkcheck':
+        targets, sources = _get_linkcheck_emissions(env, target, srcinfo)
+    elif builder == 'man':
+        targets, sources = _get_man_emissions(env, target, srcinfo)
+    elif builder == 'pickle':
+        targets, sources = _get_serialize_emissions(env, target, srcinfo,
+                                                    '.fpickle',
+                                                    ['globalcontext.pickle',
+                                                     'searchindex.pickle',
+                                                     'environment.pickle'])
+    elif builder == 'qthelp':
+        targets, sources = _get_help_emissions(env, target, srcinfo,
+                                               ['.qhp', '.qhcp'])
+    elif builder == 'singlehtml':
+        targets, sources = _get_singlehtml_emissions(env, target, srcinfo)
+    elif builder == 'texinfo':
+        targets, sources = _get_texinfo_emissions(env, target, srcinfo)
+    elif builder == 'text':
+        targets, sources = _get_text_emissions(env, target, srcinfo)
+
+    sources.append(srcinfo.confignode.File('conf.py'))
+
+    for s in sources:
+        s.attributes.root = srcinfo.srcroot
+
+    for t in targets:
+        t.attributes.root = target[0]
+
+    return targets, sources
+
+
+def _get_sphinxbuilder(env):
+    builder = env.get('builder', env["SPHINXBUILDER"])
+    if builder is None or builder == '':
+        raise SCons.Errors.UserError(("Missing construction variable " +
+                                      "SPHINXBUILDER or variable is empty."))
+    return builder
+
+
+def _get_changes_emissions(env, target, srcinfo):
+    sources = []
+    sources.extend(srcinfo.sources)
+    targets = [target[0].File("changes.html")]
+    return targets, sources
+
+
+def _get_dirhtml_emissions(env, target, srcinfo):
+    suffix = srcinfo.config.get('html_file_suffix', ".html")
+
+    def get_outfilename(pagename):
+        pagename = os.path.splitext(pagename)[0]
+
+        #Special treatment of files named "index". Don't create directory.
+        if pagename == 'index' or pagename.endswith(os.sep + 'index'):
+            outfilename = pagename + suffix
+        else:
+            outfilename = os.path.join(pagename, 'index' + suffix)
+        return outfilename
+
+    sources = []
+    sources.extend(srcinfo.sources)
+    sources.extend(srcinfo.templates)
+    sources.extend(srcinfo.statics)
+
+    targets = []
+    for s in srcinfo.sources:
+        t = os.path.relpath(str(s), str(srcinfo.srcroot))
+        targets.append(target[0].File(get_outfilename(t)))
+
+    for key in srcinfo.config.get('html_additional_pages', {}):
+        t = target[0].File(get_outfilename(key))
+        targets.append(t)
+
+    return targets, sources
+
+
+def _get_doctest_emissions(env, target, srcinfo):
+    sources = []
+    sources.extend(srcinfo.sources)
+    targets = [target[0].File("output.txt")]
+    return targets, sources
+
+
+def _get_epub_emissions(env, target, srcinfo):
+    epubPreFiles = srcinfo.config.get('epub_pre_files', [])
+    epubPostFiles = srcinfo.config.get('epub_post_files', [])
+    epubCover = srcinfo.config.get('epub_cover', (None, None))
+
+    sources = []
+    sources.extend(srcinfo.sources)
+    sources.extend([srcinfo.srcroot.File(os_path(f[0])) for f in epubPreFiles])
+    sources.extend([srcinfo.srcroot.File(os_path(f[0])) for f in epubPostFiles])
+    if not (epubCover[0] is None or epubCover[0] == ''):
+        sources.append(srcinfo.srcroot.File(os_path(epubCover[0])))
+    if not (epubCover[1] is None or epubCover[1] == ''):
+        sources.append(srcinfo.srcroot.File(os_path(epubCover[1])))
+
+    t = srcinfo.config.get('epub_basename',
+                        srcinfo.config.get('project',
+                                         'Python'))
+
+    targets = [target[0].File("%s.epub" % make_filename(t))]
+
+    return targets, sources
+
+
+def _get_gettext_emissions(env, target, srcinfo):
+    sources = []
+    sources.extend(srcinfo.sources)
+
+    targets = [os.path.relpath(str(s), str(srcinfo.srcroot)) for s in sources]
+    targets = [os.path.splitext(t)[0] for t in targets]
+    targets = set([t.split(os.sep)[0] for t in targets])
+    targets = [target[0].File(t + ".pot") for t in targets]
+
+    return targets, sources
+
+
+def _get_help_emissions(env, target, srcinfo, suffixes, basenameConfigKey='project'):
+    basename = make_filename(
+        srcinfo.config.get(basenameConfigKey, srcinfo.config['project']))
+
+    sources = []
+    sources.extend(srcinfo.sources)
+    sources.extend(srcinfo.templates)
+    sources.extend(srcinfo.statics)
+
+    targets = [target[0].File(basename + s) for s in suffixes]
+
+    return targets, sources
+
+
+def _get_latex_emissions(env, target, srcinfo):
+    sources = []
+    sources.extend(srcinfo.sources)
+
+    targets = map(lambda x: target[0].File(os_path(x[1])),
+                  srcinfo.config.get('latex_documents'))
+
+    return targets, sources
+
+
+def _get_linkcheck_emissions(env, target, srcinfo):
+    sources = []
+    sources.extend(srcinfo.sources)
+    targets = [target[0].File("output.txt")]
+    return targets, sources
+
+
+def _get_man_emissions(env, target, srcinfo):
+    sources = []
+    sources.extend(srcinfo.sources)
+    targets = map(lambda x: target[0].File(os_path("%s.%s" % (x[1], x[4]))),
+                  srcinfo.config.get('man_pages'))
+    return targets, sources
+
+
+def _get_serialize_emissions(env, target, srcinfo, suffix=None, extrafiles=[]):
+    if suffix is None:
+        suffix = srcinfo.config.get('html_file_suffix', '.html')
+
+    sources = []
+    sources.extend(srcinfo.sources)
+    sources.extend(srcinfo.templates)
+    sources.extend(srcinfo.statics)
+
+    targets = []
+    for s in srcinfo.sources:
+        t = os.path.splitext(str(s))[0] + suffix
+        t = os.path.relpath(t, str(srcinfo.srcroot))
+        targets.append(t)
+
+    for key in srcinfo.config.get('html_additional_pages', {}):
+        targets.append(os_path("%s%s" % (key, suffix)))
+
+    targets.extend(extrafiles)
+    targets = [target[0].File(t) for t in targets]
+
+    return targets, sources
+
+
+def _get_singlehtml_emissions(env, target, srcinfo):
+    suffix = srcinfo.config.get('html_file_suffix', ".html")
+
+    sources = []
+    sources.extend(srcinfo.sources)
+    sources.extend(srcinfo.templates)
+    sources.extend(srcinfo.statics)
+
+    t = os.path.relpath(srcinfo.config['master_doc'] + suffix,
+                        str(srcinfo.srcroot))
+    targets = [target[0].File(t)]
+
+    return targets, sources
+
+
+def _get_texinfo_emissions(env, target, srcinfo):
+    suffix = srcinfo.config.get('source_suffix', '.rst')
+
+    sources = []
+    sources.extend(srcinfo.sources)
+    sources.extend(map(lambda x: source[0].File(os_path(x + suffix)),
+                       srcinfo.config.get('texinfo_appendices', [])))
+
+    targets = map(lambda x: target[0].File(os_path("%s.texi" % x[1])),
+                  srcinfo.config.get('texinfo_documents'))
+
+    return targets, sources
+
+
+def _get_text_emissions(env, target, srcinfo):
+    sources = []
+    sources.extend(srcinfo.sources)
+
+    targets = []
+    for s in sources:
+        t = os.path.relpath(str(s), str(srcinfo.srcroot))
+        t = os.path.splitext(t)[0] + ".txt"
+        targets.append(target[0].File(t))
+
+    return targets, sources
--- a/config/tools/tests.py
+++ b/config/tools/tests.py
@@ -0,0 +1,123 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from SCons.Script import AddOption, Flatten
+from SCons.Script import Builder
+from SCons.Action import Action
+from subprocess import check_output, STDOUT, CalledProcessError
+import sys
+import os
+
+
+def BoostCompileTest(env, test, source = None, **kw):
+
+    def gen_result(target, source, env=env):
+        target_file = target[0].abspath
+        result_file = os.path.splitext(target_file)[0] + '.result'
+        if sys.stdout.isatty():
+            env['RESULT']='\033[92mPASS\033[0m'
+        else:
+            env['RESULT']='PASS'
+
+        with open(result_file, 'w+') as result:
+            result.write('Result: {}\n'.format('pass'))
+
+    obj = env.Object(test, source if source is not None else test + '.cpp')
+    env.AddPostAction(obj, Action(gen_result, cmdstr=None))
+    env.AddPostAction(obj, Action('@echo $RESULT'))
+    return obj
+
+def BoostRun(env, prog, target, command = '$SOURCE'):
+
+    def call(target, source, env=env):
+        cmd = env.subst(command, target=target, source=source)
+        result_file = env.subst('$TARGET', target=target)
+        output=''
+        try:
+            output=check_output(cmd, stderr=STDOUT, shell=True, env=env['ENV'])
+            success=True
+        except CalledProcessError as e:
+            output=e.output
+            success=False
+        with open(result_file, 'w+') as result:
+            result.write('Result: {}\n'.format(success and 'pass' or 'fail'))
+            result.write('Output: {}\n'.format(output))
+        if sys.stdout.isatty():
+            env['RESULT']=success and '\033[92mPASS\033[0m' or '\033[91mFAIL\033[0m'
+        else:
+            env['RESULT']=success and 'PASS' or 'FAIL'
+     
+    testcomstr = env.get('TESTCOMSTR')
+    if testcomstr:
+        run = env.Command(target, prog, Action(call, cmdstr=testcomstr))
+    else:
+        run = env.Command(target, prog, Action(call, cmdstr=command))
+    env.AddPostAction(target, Action('@echo $RESULT'))
+    return run
+
+
+def BoostRunPythonScript(env, script):
+    return env.BoostRun(env.File(script), script.replace('.py', '.result'), '"${PYTHON}" $SOURCE')
+
+
+def BoostRunTest(env, test, source = None, command = '$SOURCE', command_sources = [], **kw):
+    test_prog = env.Program(test, (source is None) and (test + ".cpp") or source, **kw)
+    command += '> $TARGET'
+    run = env.BoostRun([test_prog, command_sources], test + '.result', command)
+    return run
+
+
+def BoostRunTests(env, tests, **kw):
+    run = []
+    for test in Flatten(tests):
+        run += env.BoostRunTest(test, **kw)
+    return run
+
+def BoostCompileTests(env, tests, **kw):
+    comp = []
+    for test in Flatten(tests):
+        comp += env.BoostCompileTest(test, **kw)
+    return comp
+
+
+def BoostTestSummary(env, tests, **kw):
+
+    def print_summary(target, source, **kw):
+        results = tests
+        failures = [r for r in results
+                    if r.get_path().endswith('.result') and not 'Result: pass' in r.get_contents()]
+        print('%s tests; %s pass; %s fails'%(len(results), len(results)-len(failures), len(failures)))
+        if failures:
+            print('For detailed failure reports, see:')
+        for f in failures:
+            print(f.get_path())
+
+    testsumcomstr = env.get('TESTSUMCOMSTR')
+    if testsumcomstr:
+        run = env.Command('summary', tests, Action(print_summary, cmdstr=testsumcomstr))
+    else:
+        run = env.Command('summary', tests, print_summary, cmdstr='')
+
+    
+
+
+
+def exists(env):
+    return True
+
+
+def generate(env):
+    AddOption('--test', dest='test', action="store_true")
+
+    env.AddMethod(BoostCompileTest)
+    env.AddMethod(BoostRun)
+    env.AddMethod(BoostRunPythonScript)
+    env.AddMethod(BoostRunTest)
+    env.AddMethod(BoostRunTests)
+    env.AddMethod(BoostCompileTests)
+    env.AddMethod(BoostTestSummary)
--- a/config/ui.py
+++ b/config/ui.py
@@ -0,0 +1,96 @@
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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)
+
+from SCons.Script import AddOption
+import sys
+
+variables=[] # remember 'public' variables
+options=[]
+
+def add_option(*args, **kwds):
+    """Capture the help messages so we can produce a helpful usage text."""
+    options.append('{:25} {}'.format(', '.join(args), kwds.get('help', '')))
+    AddOption(*args, **kwds)
+
+def add_variable(vars, var):
+    variables.append(var[0])
+    vars.Add(var)
+
+
+def options_help(env):
+
+    return '\n  '.join(options)
+
+    
+def variables_help(vars, env):
+    """This is cloned from SCons' Variables.GenerateHelpText, to only report 'public' variables."""
+
+    opts = [o for o in vars.options if o.key in variables]
+    
+    def format(opt):
+        if opt.key in env:
+            actual = env.subst('${%s}' % opt.key)
+        else:
+            actual = None
+        return vars.FormatVariableHelpText(env, opt.key, opt.help, opt.default, actual, opt.aliases)
+    text = ''.join([f for f in map(format, opts) if f])
+    lines = ['  %s'%l for l in text.split('\n')] # Add some indentation
+    return '\n'.join(lines)
+
+
+    
+def help(vars, env):
+
+    return """Usage: scons [--option...] [variable=value...] [target...]
+
+available options:
+
+  {}
+
+available variables:
+  {}
+""".format(options_help(env), variables_help(vars, env))
+
+def pretty_output(env):
+
+    colors = {}
+    colors['red']    = '\033[31m'
+    colors['green']  = '\033[32m'
+    colors['blue']   = '\033[34m'
+    colors['yellow'] = '\033[93m'
+    colors['Red']    = '\033[91m'
+    colors['Green']  = '\033[92m'
+    colors['Blue']   = '\033[94m'
+    colors['Purple'] = '\033[95m'
+    colors['Cyan']   = '\033[96m'
+    colors['end']    = '\033[0m'
+
+    #If the output is not a terminal, remove the colors
+    if not sys.stdout.isatty():
+        for key, value in colors.iteritems():
+            colors[key] = ''
+
+    compile_source_message = '{green}Compiling $TARGET{end}'.format(**colors)
+    compile_shared_source_message = '{green}Compiling $TARGET{end}'.format(**colors)
+    link_program_message = '{blue}Linking $TARGET{end}'.format(**colors)
+    link_library_message = '{blue}Linking $TARGET{end}'.format(**colors)
+    ranlib_library_message = '{blue}Ranlib $TARGET{end}'.format(**colors)
+    link_shared_library_message = '{blue}Linking $TARGET{end}'.format(**colors)
+    test_message = '{blue}Testing $SOURCE{end}'.format(**colors)
+    testsum_message = '{Blue}Test Summary{end}'.format(**colors)
+
+    env.Replace(CXXCOMSTR = compile_source_message,
+                CCCOMSTR = compile_source_message,
+                SHCCCOMSTR = compile_shared_source_message,
+                SHCXXCOMSTR = compile_shared_source_message,
+                ARCOMSTR = link_library_message,
+                RANLIBCOMSTR = ranlib_library_message,
+                SHLINKCOMSTR = link_shared_library_message,
+                LINKCOMSTR = link_program_message,
+                TESTCOMSTR = test_message,
+                TESTSUMCOMSTR = testsum_message)
--- a/doc/SConscript
+++ b/doc/SConscript
@@ -0,0 +1,52 @@
+# -*- python -*-
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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('env')
+
+env.QuickBook('python.bbk', 'python.qbk',
+              ['building.qbk',
+               'configuration.qbk',
+               'support.qbk',
+               'faq.qbk',
+               'glossary.qbk'])
+
+env.QuickBook('tutorial.bbk', 'tutorial.qbk')
+env.QuickBook('reference.bbk', 'reference.qbk',
+              Glob('reference/*.qbk'))
+
+
+env.BoostBook('python.dbk', 'python.bbk')
+env.BoostBook('tutorial.dbk', 'tutorial.bbk')
+env.BoostBook('reference.dbk', 'reference.bbk')
+
+images = Glob('images/*.*') + Glob('images/callouts/*.*')
+
+env.BoostHTML('html/', 'python.dbk',
+              resources=['boostbook.css'] + images,
+              args=['--stringparam', 'generate.toc', '"library nop; chapter toc; section toc;"',
+                    '--stringparam', 'html.stylesheet', 'boostbook.css',
+                    '--stringparam', 'boost.image.src', 'images/bpl.png',
+                    '--stringparam', 'boost.graphics.root', 'images/',
+                    '--stringparam', 'boost.defaults', 'none',
+                    '--param', 'toc.max.depth', '3',
+                    '--param', 'toc.section.depth' ,'2',
+                    '--param', 'chunk.section.depth', '1'])
+env.BoostHTML('html/tutorial/', 'tutorial.dbk',
+              args=['--stringparam', 'html.stylesheet', '../boostbook.css',
+                    '--stringparam', 'boost.image.src', '../images/bpl.png',
+                    '--stringparam', 'boost.graphics.root', '../images/'])
+env.BoostHTML('html/reference/', 'reference.dbk',
+              args=['--stringparam', 'html.stylesheet', '../boostbook.css',
+                    '--stringparam', 'boost.image.src', '../images/bpl.png',
+                    '--stringparam', 'boost.graphics.root', '../images/'])
+
+env.BoostRST('html/article.html', 'article.rst', resources=['rst.css'])
+
+if env['NUMPY']:
+    env.BoostSphinx('html/numpy', 'numpy/')
--- a/doc/fabscript
+++ b/doc/fabscript
@@ -1,83 +0,0 @@
-# -*- python -*-
-#
-# Copyright (c) 2016 Stefan Seefeld
-# All rights reserved.
-#
-# 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)
-
-from faber.tools.xslt import xsltflags
-from faber.tools.boost import quickbook, boostbook
-from faber.artefacts import html
-from glob import glob as G
-from os import makedirs
-from os.path import relpath, dirname, exists
-from shutil import copyfile
-
-
-def glob(pattern):
-    prefix = srcdir + '/'
-    p = len(prefix)+1
-    return [f[p:] for f in G(prefix + pattern)]
-
-
-class make_html(action):
-
-    def __init__(self):
-        action.__init__(self, 'make_html', self.process)
-
-    def map(self, fs):
-        return boostbook.html.map(fs)
-
-    def process(self, target, source):
-        boostbook.html(target, source[0:1])
-        for s in source[1:]:
-            t = target[0]._filename + relpath(s._filename, srcdir)
-            d = dirname(t)
-            if not exists(d):
-                makedirs(d)
-            copyfile(s._filename, t)
-
-
-sphinx_build  = action('sphinx-build', 'sphinx-build -b html $(>) $(<)')
-rst2html  = action('rst2html', 'rst2html --trim-footnote-reference-space --footnote-references=superscript --stylesheet=$(>:D)/rst.css $(>) $(<)')
-
-python_bbk = rule(quickbook.process, 'python.bbk', 'python.qbk',
-                  dependencies=['release_notes.qbk',
-                                'building.qbk',
-                                'configuration.qbk',
-                                'suport.qbk',
-                                'faq.qbk',
-                                'glossary.qbk'])
-tutorial_bbk = rule(quickbook.process, 'tutorial.bbk', 'tutorial.qbk')
-reference_bbk = rule(quickbook.process, 'reference.bbk', 'reference.qbk')
-
-python_db = rule(boostbook.db, 'python.db', python_bbk)
-tutorial_db = rule(boostbook.db, 'tutorial.db', tutorial_bbk)
-reference_db = rule(boostbook.db, 'reference.db', reference_bbk)
-
-python = html.dir(make_html(), 'html', [python_db, 'boostbook.css'] + glob('/images/*.*') + glob('/images/callouts/*.*'),
-                  features=xsltflags('--stringparam generate.toc "library nop; chaper toc; section toc;"',
-                                     '--stringparam html.stylesheet boostbook.css',
-                                     '--stringparam boost.image.src images/bpl.png',
-                                     '--stringparam boost.graphics.root images/',
-                                     '--stringparam boost.defaults none',
-                                     '--param toc.max.depth 3',
-                                     '--param toc.section.depth 2',
-                                     '--param chunk.section.depth 1'))
-tutorial = html.dir(boostbook.html, 'html/tutorial', tutorial_db, dependencies=[python],
-                    features=xsltflags('--stringparam html.stylesheet ../boostbook.css',
-                                       '--stringparam boost.image.src ../images/bpl.png',
-                                       '--stringparam boost.graphics.root ../images/'))
-reference = html.dir(boostbook.html, 'html/reference', reference_db, dependencies=[python],
-                     features=xsltflags('--stringparam html.stylesheet ../boostbook.css',
-                                        '--stringparam boost.image.src ../images/bpl.png',
-                                        '--stringparam boost.graphics.root ../images/'))
-numpy = rule(sphinx_build, 'html/numpy', 'numpy', attrs=always, dependencies=[python])
-
-article = rule(rst2html, 'html/article.html', 'article.rst')
-
-html = alias('html', [python, tutorial, reference, numpy, article])
-
-default = html
--- a/doc/html/images/python_cpp_mix.png
+++ b/doc/html/images/python_cpp_mix.png
--- a/doc/internals.html
+++ b/doc/internals.html
--- a/doc/internals.rst
+++ b/doc/internals.rst
--- a/doc/python.qbk
+++ b/doc/python.qbk
@@ -43,7 +43,6 @@ The development of these features was funded in part by grants to `Boost Consult

 [section Contents]

-* [link rn Release Notes]
 * _tutorial_
 * [link building Building and Testing]
 * _reference_
@@ -59,7 +58,6 @@ The development of these features was funded in part by grants to `Boost Consult

 [@article.html Building Hybrid Systems With Boost Python], by Dave Abrahams and Ralf W. Grosse-Kunstleve

-[include release_notes.qbk]
 [include building.qbk]
 [include configuration.qbk]
 [include support.qbk]
--- a/doc/reference/operators.qbk
+++ b/doc/reference/operators.qbk
@@ -86,8 +86,8 @@ The column of Python Expressions illustrates the expressions that will be suppor
 [[C++ Expression][Python Method Name][C++ Implementation][Python Expression (primary, secondary)]]
 [[`self == r`][`__eq__`][`x == y`][`x == y`, `y == x`]]
 [[`l == self`][`__eq__`][`y == x`][`y == x`, `x == y`]]
-[[`self != r`][`__ne__`][`x != y`][`x != y`, `y != x`]]
-[[`l != self`][`__ne__`][`y != x`][`y != x`, `x != y`]]
+[[`self != r`][`__nq__`][`x != y`][`x != y`, `y != x`]]
+[[`l != self`][`__nq__`][`y != x`][`y != x`, `x != y`]]
 [[`self < r`][`__lt__`][`x < y`][`x < y`, `y > x`]]
 [[`l < self`][`__gt__`][`y < x`][`y > x`, `x < y`]]
 [[`self > r`][`__gt__`][`x > y`][`x > y`, `y < x`]]
--- a/doc/release_notes.qbk
+++ b/doc/release_notes.qbk
@@ -1,11 +0,0 @@
-[chapter Release Notes
-    [quickbook 1.7]
-    [id rn]
-]
-
-[section Version 1.67]
-
-* The Boost.Python library names now contain the Python version suffix.
-  A variant compiled with Python 2.7 will thus produce library names
-  `boost_python27` and `boost_numpy27`, etc., making it possible to host
-  variants for multiple Python versions next to each other.
--- a/doc/tutorial.qbk
+++ b/doc/tutorial.qbk
@@ -1871,6 +1871,36 @@ This technique has several advantages:
 * Minimize the need to recompile
 * Rapid prototyping (you can move the code to C++ if required without changing the interface)

+You can even add a little syntactic sugar with the use of metaclasses. Let's
+create a special metaclass that "injects" methods in other classes.
+
+    # The one Boost.Python uses for all wrapped classes.
+    # You can use here any class exported by Boost instead of "point"
+    BoostPythonMetaclass = point.__class__
+
+    class injector(object):
+        class __metaclass__(BoostPythonMetaclass):
+            def __init__(self, name, bases, dict):
+                for b in bases:
+                    if type(b) not in (self, type):
+                        for k,v in dict.items():
+                            setattr(b,k,v)
+                return type.__init__(self, name, bases, dict)
+
+    # inject some methods in the point foo
+    class more_point(injector, point):
+        def __repr__(self):
+            return 'Point(x=%s, y=%s)' % (self.x, self.y)
+        def foo(self):
+            print 'foo!'
+
+Now let's see how it got:
+
+    >>> print point()
+    Point(x=10, y=10)
+    >>> point().foo()
+    foo!
+
 Another useful idea is to replace constructors with factory functions:

    _point = point
--- a/82
+++ b/82
@@ -1,82 +0,0 @@
-# -*- python -*-
-#
-# Copyright (c) 2016 Stefan Seefeld
-# All rights reserved.
-#
-# 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)
-
-from faber.feature import set
-from faber.types import cxx
-from faber.tools.compiler import cxxflags, define, include
-from faber.tools.python import python
-from faber.config import report, cxx_checks
-from faber.config.try_run import try_run
-
-features += include('include')
-features += define('BOOST_ALL_NO_LIB')  # disable auto-linking
-boost_include = options.get_with('boost-include')
-if boost_include:
-    features += include(boost_include)
-python = python.instance()
-py_suffix = '{}{}'.format(*python.version.split('.')[:2])
-features |= set(python.include, python.linkpath, python.libs)
-
-class has_numpy(try_run):
-
-    src = r"""
-// If defined, enforces linking against PythonXXd.lib, which
-// is usually not included in Python environments.
-#undef _DEBUG
-#include "Python.h"
-#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
-#include "numpy/arrayobject.h"
-
-#if PY_VERSION_HEX >= 0x03000000
-void *initialize() { import_array();}
-#else
-void initialize() { import_array();}
-#endif
-
-int main()
-{
-  int result = 0;
-  Py_Initialize();
-  initialize();
-  if (PyErr_Occurred())
-  {
-    result = 1;
-  }
-  else
-  {
-    npy_intp dims = 2;
-    PyObject * a = PyArray_SimpleNew(1, &dims, NPY_INT);
-    if (!a) result = 1;
-    Py_DECREF(a);
-  }
-  Py_Finalize();
-  return result;
-}
-"""
-    def __init__(self, features=()):
-
-        inc = ''
-        try:
-            inc = python.check_python('import numpy; print(numpy.get_include())')
-            features |= include(inc)
-        except Exception:
-            # ignore errors, the check will fail during compilation...
-            pass
-        try_run.__init__(self, 'has_numpy', has_numpy.src, cxx, features,
-                         if_=(include(inc), define('HAS_NUMPY')))
-
-checks = [cxx_checks.has_cxx11(features, define('HAS_CXX11')),
-          has_numpy(features)]
-config = report('config', checks)
-
-src = module('src', features=config.use)
-test = module('test', features=config.use)
-doc = module('doc', features=config.use)
-
-default = src.default
--- a/include/boost/python/arg_from_python.hpp
+++ b/include/boost/python/arg_from_python.hpp
--- a/include/boost/python/base_type_traits.hpp
+++ b/include/boost/python/base_type_traits.hpp
--- a/include/boost/python/borrowed.hpp
+++ b/include/boost/python/borrowed.hpp
--- a/include/boost/python/cast.hpp
+++ b/include/boost/python/cast.hpp
--- a/include/boost/python/converter/arg_to_python.hpp
+++ b/include/boost/python/converter/arg_to_python.hpp
--- a/include/boost/python/converter/context_result_converter.hpp
+++ b/include/boost/python/converter/context_result_converter.hpp
--- a/include/boost/python/converter/pytype_function.hpp
+++ b/include/boost/python/converter/pytype_function.hpp
--- a/include/boost/python/converter/registered.hpp
+++ b/include/boost/python/converter/registered.hpp
@@ -76,7 +76,7 @@ namespace detail
      registry::lookup_shared_ptr(type_id<shared_ptr<T> >());
  }

-#if !defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus >= 201103L
  template <class T>
  inline void
  register_shared_ptr0(std::shared_ptr<T>*)
--- a/include/boost/python/converter/return_from_python.hpp
+++ b/include/boost/python/converter/return_from_python.hpp
--- a/include/boost/python/converter/shared_ptr_to_python.hpp
+++ b/include/boost/python/converter/shared_ptr_to_python.hpp
@@ -25,7 +25,7 @@ PyObject* shared_ptr_to_python(shared_ptr<T> const& x)
        return converter::registered<shared_ptr<T> const&>::converters.to_python(&x);
 }

-#if !defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus >= 201103L
 template <class T>
 PyObject* shared_ptr_to_python(std::shared_ptr<T> const& x)
 {
--- a/include/boost/python/def_visitor.hpp
+++ b/include/boost/python/def_visitor.hpp
--- a/include/boost/python/detail/caller.hpp
+++ b/include/boost/python/detail/caller.hpp
@@ -48,7 +48,7 @@ inline PyObject* get(mpl::int_<N>, PyObject* const& args_)
    return PyTuple_GET_ITEM(args_,N);
 }

-inline Py_ssize_t arity(PyObject* const& args_)
+inline unsigned arity(PyObject* const& args_)
 {
    return PyTuple_GET_SIZE(args_);
 }
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -105,9 +105,11 @@
 // Set the name of our library, this will get undef'ed by auto_link.hpp
 // once it's done with it:
 //
-#define _BOOST_PYTHON_CONCAT(N, M, m) N ## M ## m
-#define BOOST_PYTHON_CONCAT(N, M, m) _BOOST_PYTHON_CONCAT(N, M, m)
-#define BOOST_LIB_NAME BOOST_PYTHON_CONCAT(boost_python, PY_MAJOR_VERSION, PY_MINOR_VERSION)
+#if PY_MAJOR_VERSION == 2
+#  define BOOST_LIB_NAME boost_python
+#elif PY_MAJOR_VERSION == 3
+#  define BOOST_LIB_NAME boost_python3
+#endif
 //
 // If we're importing code from a dll, then tell auto_link.hpp about it:
 //
@@ -120,9 +122,6 @@
 #include <boost/config/auto_link.hpp>
 #endif  // auto-linking disabled

-#undef BOOST_PYTHON_CONCAT
-#undef _BOOST_PYTHON_CONCAT
-
 #ifndef BOOST_PYTHON_NO_PY_SIGNATURES
 #define BOOST_PYTHON_SUPPORTS_PY_SIGNATURES // enables smooth transition
 #endif
--- a/include/boost/python/detail/convertible.hpp
+++ b/include/boost/python/detail/convertible.hpp
--- a/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
+++ b/include/boost/python/detail/copy_ctor_mutates_rhs.hpp
--- a/include/boost/python/detail/def_helper_fwd.hpp
+++ b/include/boost/python/detail/def_helper_fwd.hpp
--- a/include/boost/python/detail/is_shared_ptr.hpp
+++ b/include/boost/python/detail/is_shared_ptr.hpp
@@ -13,7 +13,7 @@
 namespace boost { namespace python { namespace detail { 

 BOOST_PYTHON_IS_XXX_DEF(shared_ptr, shared_ptr, 1)
-#if !defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus >= 201103L
 template <typename T>
 struct is_shared_ptr<std::shared_ptr<T> > : std::true_type {};
 #endif
--- a/include/boost/python/detail/is_wrapper.hpp
+++ b/include/boost/python/detail/is_wrapper.hpp
--- a/include/boost/python/detail/nullary_function_adaptor.hpp
+++ b/include/boost/python/detail/nullary_function_adaptor.hpp
--- a/include/boost/python/detail/prefix.hpp
+++ b/include/boost/python/detail/prefix.hpp
--- a/include/boost/python/detail/python_type.hpp
+++ b/include/boost/python/detail/python_type.hpp
--- a/include/boost/python/detail/sfinae.hpp
+++ b/include/boost/python/detail/sfinae.hpp
--- a/include/boost/python/detail/type_traits.hpp
+++ b/include/boost/python/detail/type_traits.hpp
@@ -7,8 +7,7 @@
 # define BOOST_PYTHON_DETAIL_TYPE_TRAITS_HPP


-#include <boost/config.hpp>
-#ifdef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#if __cplusplus < 201103L
 # include <boost/type_traits/transform_traits.hpp>
 # include <boost/type_traits/same_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
@@ -35,7 +34,7 @@

 namespace boost { namespace python { namespace detail {

-#ifdef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#if __cplusplus < 201103L
    using boost::alignment_of;
    using boost::add_const;
    using boost::add_cv;
@@ -99,8 +98,8 @@ namespace boost { namespace python { namespace detail {
    using std::remove_cv;
    using std::remove_const;

-    typedef std::integral_constant<bool, true> true_;
-    typedef std::integral_constant<bool, false> false_;
+    using true_ = std::integral_constant<bool, true>;
+    using false_ = std::integral_constant<bool, false>;
 #endif
    using boost::is_base_and_derived;
    using boost::type_with_alignment;
--- a/include/boost/python/detail/unwind_type.hpp
+++ b/include/boost/python/detail/unwind_type.hpp
--- a/include/boost/python/detail/unwrap_type_id.hpp
+++ b/include/boost/python/detail/unwrap_type_id.hpp
--- a/include/boost/python/detail/unwrap_wrapper.hpp
+++ b/include/boost/python/detail/unwrap_wrapper.hpp
--- a/include/boost/python/detail/value_arg.hpp
+++ b/include/boost/python/detail/value_arg.hpp
--- a/include/boost/python/docstring_options.hpp
+++ b/include/boost/python/docstring_options.hpp
--- a/include/boost/python/handle_fwd.hpp
+++ b/include/boost/python/handle_fwd.hpp
--- a/include/boost/python/make_constructor.hpp
+++ b/include/boost/python/make_constructor.hpp
@@ -45,7 +45,7 @@ namespace detail
      template <class U>
      void dispatch(U* x, detail::true_) const
      {
-#if defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus < 201103L
 	std::auto_ptr<U> owner(x);
 	dispatch(owner, detail::false_());
 #else
@@ -63,7 +63,7 @@ namespace detail

          void* memory = holder::allocate(this->m_self, offsetof(instance_t, storage), sizeof(holder));
          try {
-#if defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus < 201103L
              (new (memory) holder(x))->install(this->m_self);
 #else
              (new (memory) holder(std::move(x)))->install(this->m_self);
--- a/include/boost/python/module_init.hpp
+++ b/include/boost/python/module_init.hpp
@@ -66,9 +66,25 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());

 #  endif

-#  define BOOST_PYTHON_MODULE_INIT(name)                       \
-  void BOOST_PP_CAT(init_module_,name)();                      \
-extern "C" BOOST_SYMBOL_EXPORT _BOOST_PYTHON_MODULE_INIT(name)
+#  if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(BOOST_PYTHON_STATIC_MODULE)
+
+#   define BOOST_PYTHON_MODULE_INIT(name)                           \
+  void BOOST_PP_CAT(init_module_,name)();                           \
+extern "C" __declspec(dllexport) _BOOST_PYTHON_MODULE_INIT(name)
+
+#  elif BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY
+
+#   define BOOST_PYTHON_MODULE_INIT(name)                               \
+  void BOOST_PP_CAT(init_module_,name)();                               \
+extern "C" __attribute__ ((__visibility__("default"))) _BOOST_PYTHON_MODULE_INIT(name)
+
+#  else
+
+#   define BOOST_PYTHON_MODULE_INIT(name)                               \
+  void BOOST_PP_CAT(init_module_,name)();                               \
+extern "C" _BOOST_PYTHON_MODULE_INIT(name)
+
+#  endif

 # endif

--- a/include/boost/python/numpy/config.hpp
+++ b/include/boost/python/numpy/config.hpp
@@ -62,9 +62,11 @@
 // Set the name of our library, this will get undef'ed by auto_link.hpp
 // once it's done with it:
 //
-#define _BOOST_PYTHON_CONCAT(N, M, m) N ## M ## m
-#define BOOST_PYTHON_CONCAT(N, M, m) _BOOST_PYTHON_CONCAT(N, M, m)
-#define BOOST_LIB_NAME BOOST_PYTHON_CONCAT(boost_numpy, PY_MAJOR_VERSION, PY_MINOR_VERSION)
+#if PY_MAJOR_VERSION == 2
+#  define BOOST_LIB_NAME boost_numpy
+#elif PY_MAJOR_VERSION == 3
+#  define BOOST_LIB_NAME boost_numpy3
+#endif
 //
 // If we're importing code from a dll, then tell auto_link.hpp about it:
 //
@@ -77,9 +79,6 @@
 #include <boost/config/auto_link.hpp>
 #endif  // auto-linking disabled

-#undef BOOST_PYTHON_CONCAT
-#undef _BOOST_PYTHON_CONCAT
-
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION

 #endif // CONFIG_NUMPY20170215_H_
--- a/include/boost/python/numpy/ndarray.hpp
+++ b/include/boost/python/numpy/ndarray.hpp
@@ -86,11 +86,11 @@ public:
  /// @brief Copy the scalar (deep for all non-object fields).
  ndarray copy() const;

-  /// @brief Return the size of the nth dimension. raises IndexError if k not in [-get_nd() : get_nd()-1 ]
-  Py_intptr_t shape(int n) const;
+  /// @brief Return the size of the nth dimension.
+  Py_intptr_t shape(int n) const { return get_shape()[n]; }

-  /// @brief Return the stride of the nth dimension. raises IndexError if k not in [-get_nd() : get_nd()-1]
-  Py_intptr_t strides(int n) const;
+  /// @brief Return the stride of the nth dimension.
+  Py_intptr_t strides(int n) const { return get_strides()[n]; }
    
  /**
   *  @brief Return the array's raw data pointer.
--- a/include/boost/python/numpy/ufunc.hpp
+++ b/include/boost/python/numpy/ufunc.hpp
@@ -106,7 +106,7 @@ struct unary_ufunc
    dtype in_dtype = dtype::get_builtin<TArgument>();
    dtype out_dtype = dtype::get_builtin<TResult>();
    ndarray in_array = from_object(input, in_dtype, ndarray::ALIGNED);
-    ndarray out_array = ! output.is_none() ?
+    ndarray out_array = (output != object()) ?
      from_object(output, out_dtype, ndarray::ALIGNED | ndarray::WRITEABLE)
      : zeros(in_array.get_nd(), in_array.get_shape(), out_dtype);
    multi_iter iter = make_multi_iter(in_array, out_array);
@@ -171,7 +171,7 @@ struct binary_ufunc
    ndarray in1_array = from_object(input1, in1_dtype, ndarray::ALIGNED);
    ndarray in2_array = from_object(input2, in2_dtype, ndarray::ALIGNED);
    multi_iter iter = make_multi_iter(in1_array, in2_array);
-    ndarray out_array = !output.is_none()
+    ndarray out_array = (output != object())
      ? from_object(output, out_dtype, ndarray::ALIGNED | ndarray::WRITEABLE)
      : zeros(iter.get_nd(), iter.get_shape(), out_dtype);
    iter = make_multi_iter(in1_array, in2_array, out_array);
--- a/include/boost/python/object.hpp
+++ b/include/boost/python/object.hpp
--- a/include/boost/python/object/class_metadata.hpp
+++ b/include/boost/python/object/class_metadata.hpp
@@ -83,7 +83,7 @@ inline void register_shared_ptr_from_python_and_casts(T*, Bases)
 {
  // Constructor performs registration
  python::detail::force_instantiate(converter::shared_ptr_from_python<T, boost::shared_ptr>());
-#if !defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus >= 201103L
  python::detail::force_instantiate(converter::shared_ptr_from_python<T, std::shared_ptr>());
 #endif

--- a/include/boost/python/object/function_doc_signature.hpp
+++ b/include/boost/python/object/function_doc_signature.hpp
--- a/include/boost/python/object/inheritance_query.hpp
+++ b/include/boost/python/object/inheritance_query.hpp
--- a/include/boost/python/object/make_ptr_instance.hpp
+++ b/include/boost/python/object/make_ptr_instance.hpp
@@ -21,7 +21,7 @@ struct make_ptr_instance
    template <class Arg>
    static inline Holder* construct(void* storage, PyObject*, Arg& x)
    {
-#if defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus < 201103L
      return new (storage) Holder(x);
 #else
      return new (storage) Holder(std::move(x));
@@ -58,7 +58,7 @@ struct make_ptr_instance
    static inline PyTypeObject* get_derived_class_object(boost::python::detail::true_, U const volatile* x)
    {
        converter::registration const* r = converter::registry::query(
-            type_info(typeid(*x))
+            type_info(typeid(*get_pointer(x)))
        );
        return r ? r->m_class_object : 0;
    }
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -106,7 +106,7 @@ struct pointer_holder_back_reference : instance_holder

 template <class Pointer, class Value>
 inline pointer_holder<Pointer,Value>::pointer_holder(Pointer p)
-#if defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus < 201103L
    : m_p(p)
 #else
    : m_p(std::move(p))
@@ -116,7 +116,7 @@ inline pointer_holder<Pointer,Value>::pointer_holder(Pointer p)

 template <class Pointer, class Value>
 inline pointer_holder_back_reference<Pointer,Value>::pointer_holder_back_reference(Pointer p)
-#if defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus < 201103L
    : m_p(p)
 #else
    : m_p(std::move(p))
--- a/include/boost/python/object/py_function.hpp
+++ b/include/boost/python/object/py_function.hpp
@@ -135,7 +135,7 @@ struct py_function
    {}

    py_function(py_function const& rhs)
-#if defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus < 201103L
      : m_impl(rhs.m_impl)
 #else
      : m_impl(std::move(rhs.m_impl))
@@ -168,7 +168,7 @@ struct py_function
    }
    
 private:
-#if defined(BOOST_NO_CXX11_SMART_PTR)
+#if __cplusplus < 201103L
    mutable std::auto_ptr<py_function_impl_base> m_impl;
 #else
    mutable std::unique_ptr<py_function_impl_base> m_impl;
--- a/include/boost/python/object/stl_iterator_core.hpp
+++ b/include/boost/python/object/stl_iterator_core.hpp
--- a/include/boost/python/object_protocol_core.hpp
+++ b/include/boost/python/object_protocol_core.hpp
--- a/include/boost/python/other.hpp
+++ b/include/boost/python/other.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_PYTHON_OTHER_HPP
-# define BOOST_PYTHON_OTHER_HPP
+#ifndef OTHER_DWA20020601_HPP
+# define OTHER_DWA20020601_HPP

 # include <boost/python/detail/prefix.hpp>
 // Copyright David Abrahams 2002.
@@ -7,6 +7,8 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

+# pragma once
+
 # include <boost/config.hpp>

 namespace boost { namespace python {
@@ -49,4 +51,4 @@ namespace detail

 }} // namespace boost::python

-#endif
+#endif // #ifndef OTHER_DWA20020601_HPP
--- a/include/boost/python/ptr.hpp
+++ b/include/boost/python/ptr.hpp
@@ -1,5 +1,5 @@
-#ifndef BOOST_PYTHON_PTR_HPP
-# define BOOST_PYTHON_PTR_HPP
+#ifndef PTR_DWA20020601_HPP
+# define PTR_DWA20020601_HPP

 # include <boost/python/detail/prefix.hpp>
 // Copyright David Abrahams 2002.
@@ -11,6 +11,8 @@
 //  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001 Peter Dimov

+# pragma once
+
 # include <boost/config.hpp>
 # include <boost/mpl/bool.hpp>

@@ -62,4 +64,4 @@ class unwrap_pointer<pointer_wrapper<T> >

 }} // namespace boost::python

-#endif
+#endif // #ifndef PTR_DWA20020601_HPP
--- a/include/boost/python/raw_function.hpp
+++ b/include/boost/python/raw_function.hpp
--- a/include/boost/python/refcount.hpp
+++ b/include/boost/python/refcount.hpp
--- a/include/boost/python/self.hpp
+++ b/include/boost/python/self.hpp
--- a/include/boost/python/signature.hpp
+++ b/include/boost/python/signature.hpp
@@ -111,6 +111,7 @@ struct most_derived
 // 'default' calling convention

 #  define BOOST_PYTHON_FN_CC
+#  define BOOST_PYTHON_FN_CC_IS_DEFAULT

 #  define BOOST_PP_ITERATION_PARAMS_1                                   \
    (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/signature.hpp>))
@@ -118,6 +119,7 @@ struct most_derived
 #  include BOOST_PP_ITERATE()

 #  undef BOOST_PYTHON_FN_CC
+#  undef BOOST_PYTHON_FN_CC_IS_DEFAULT

 // __cdecl calling convention

@@ -141,6 +143,7 @@ struct most_derived
 #  if defined(BOOST_PYTHON_ENABLE_STDCALL)

 #   define BOOST_PYTHON_FN_CC __stdcall
+#   define BOOST_PYTHON_FN_CC_IS_STDCALL

 #   define BOOST_PP_ITERATION_PARAMS_1                                   \
     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/signature.hpp>))
@@ -148,6 +151,7 @@ struct most_derived
 #   include BOOST_PP_ITERATE()

 #   undef BOOST_PYTHON_FN_CC
+#   undef BOOST_PYTHON_FN_CC_IS_STDCALL

 #  endif // defined(BOOST_PYTHON_ENABLE_STDCALL)

@@ -156,12 +160,14 @@ struct most_derived
 #  if defined(BOOST_PYTHON_ENABLE_FASTCALL)

 #   define BOOST_PYTHON_FN_CC __fastcall
+#   define BOOST_PYTHON_FN_CC_IS_FASTCALL

 #   define BOOST_PP_ITERATION_PARAMS_1                                   \
     (3, (0, BOOST_PYTHON_MAX_ARITY, <boost/python/signature.hpp>))

 #   include BOOST_PP_ITERATE()

+#   undef BOOST_PYTHON_FN_CC_IS_FASTCALL
 #   undef BOOST_PYTHON_FN_CC

 #  endif // defined(BOOST_PYTHON_ENABLE_FASTCALL)
@@ -184,8 +190,8 @@ struct most_derived

   // as 'get_signature(RT(*)(T0...TN), void* = 0)' is the same
   // function as 'get_signature(RT(__cdecl *)(T0...TN), void* = 0)',
-   // we don't define it twice
-#  if !defined(BOOST_PYTHON_FN_CC_IS_CDECL)
+   // we don't define it multiple times (i.e. for __cdecl, __stdcall ...)
+#  if defined(BOOST_PYTHON_FN_CC_IS_DEFAULT)

 template <
    class RT BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class T)>
@@ -198,7 +204,7 @@ get_signature(RT(BOOST_PYTHON_FN_CC *)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)), void* =
        >();
 }

-#  endif // !defined(BOOST_PYTHON_FN_CC_IS_CDECL)
+#  endif  // BOOST_PYTHON_FN_CC_IS_DEFAULT

 # undef N

@@ -206,11 +212,13 @@ get_signature(RT(BOOST_PYTHON_FN_CC *)(BOOST_PP_ENUM_PARAMS_Z(1, N, T)), void* =
    (3, (0, 3, <boost/python/signature.hpp>))
 # include BOOST_PP_ITERATE()

-#else
+#else  // BOOST_PP_ITERATION_DEPTH() != 1

 # define N BOOST_PP_RELATIVE_ITERATION(1)
 # define Q BOOST_PYTHON_CV_QUALIFIER(BOOST_PP_ITERATION())

+#  if defined(BOOST_PYTHON_FN_CC_IS_DEFAULT)
+
 template <
    class RT, class ClassT BOOST_PP_ENUM_TRAILING_PARAMS_Z(1, N, class T)>
 inline BOOST_PYTHON_LIST_INC(BOOST_PP_INC(N))<
@@ -245,6 +253,8 @@ get_signature(
    >();
 }

+#  endif  // BOOST_PYTHON_FN_CC_IS_DEFAULT
+
 # undef Q
 # undef N

--- a/include/boost/python/stl_iterator.hpp
+++ b/include/boost/python/stl_iterator.hpp
--- a/include/boost/python/to_python_indirect.hpp
+++ b/include/boost/python/to_python_indirect.hpp
@@ -83,7 +83,7 @@ namespace detail
          // copy constructor.
 # if defined(__ICL) && __ICL < 600 
          typedef boost::shared_ptr<T> smart_pointer;
-# elif defined(BOOST_NO_CXX11_SMART_PTR)
+# elif __cplusplus < 201103L
          typedef std::auto_ptr<T> smart_pointer;
 # else
          typedef std::unique_ptr<T> smart_pointer;
--- a/include/boost/python/to_python_value.hpp
+++ b/include/boost/python/to_python_value.hpp
@@ -118,7 +118,7 @@ struct object_manager_get_pytype<true>
    PyTypeObject const* get_pytype(boost::type<shared_ptr<U> &> *) const {return converter::registered<U>::converters.to_python_target_type();}
    template <class U>
    PyTypeObject const* get_pytype(boost::type<const shared_ptr<U> &> *) const {return converter::registered<U>::converters.to_python_target_type();}
-# if !defined(BOOST_NO_CXX11_SMART_PTR)
+# if __cplusplus >= 201103L
    template <class U>
    PyTypeObject const* get_pytype(boost::type<std::shared_ptr<U> &> *) const {return converter::registered<U>::converters.to_python_target_type();}
    template <class U>
--- a/include/boost/python/wrapper.hpp
+++ b/include/boost/python/wrapper.hpp
--- a/src/SConscript
+++ b/src/SConscript
@@ -0,0 +1,61 @@
+# -*- python -*-
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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('env')
+
+env.AppendUnique(CPPDEFINES = ["${LINK_DYNAMIC and 'BOOST_PYTHON_DYN_LINK=1' or ''}"])
+
+env1 = env.Clone()
+env1.AppendUnique(CPPDEFINES = ['BOOST_PYTHON_SOURCE'])
+
+env1.BoostLibrary(
+    'python',
+    ['list.cpp',
+     'long.cpp',
+     'dict.cpp',
+     'tuple.cpp',
+     'str.cpp',
+     'slice.cpp',
+     'converter/from_python.cpp',
+     'converter/registry.cpp',
+     'converter/type_id.cpp',
+     'object/enum.cpp',
+     'object/class.cpp',
+     'object/function.cpp',
+     'object/inheritance.cpp',
+     'object/life_support.cpp',
+     'object/pickle_support.cpp',
+     'errors.cpp',
+     'module.cpp',
+     'converter/builtin_converters.cpp',
+     'converter/arg_to_python_base.cpp',
+     'object/iterator.cpp',
+     'object/stl_iterator.cpp',
+     'object_protocol.cpp',
+     'object_operators.cpp',
+     'wrapper.cpp',
+     'import.cpp',
+     'exec.cpp',
+     'object/function_doc_signature.cpp'])
+
+if env['NUMPY']:
+    env2 = env.Clone()
+    env2.Append(CPPPATH=env['NUMPY_CPPPATH'])
+    build_dir = env.Dir('$BOOST_CURRENT_VARIANT_DIR/src')
+    env2.AppendUnique(CPPDEFINES = ['BOOST_NUMPY_SOURCE'],
+                      LIBPATH = [build_dir],
+                      LIBS='boost_python' + env["BOOST_SUFFIX"])
+    env2.BoostLibrary(
+        'numpy',
+        ['numpy/dtype.cpp',
+         'numpy/matrix.cpp',
+         'numpy/ndarray.cpp',
+         'numpy/numpy.cpp',
+         'numpy/scalars.cpp',
+         'numpy/ufunc.cpp'])
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -45,15 +45,10 @@ namespace
  {
      return PyString_Check(obj) ? PyString_AsString(obj) : 0;
  }
-#elif PY_VERSION_HEX < 0x03070000
-  void* convert_to_cstring(PyObject* obj)
-  {
-      return PyUnicode_Check(obj) ? _PyUnicode_AsString(obj) : 0;
-  }
 #else
  void* convert_to_cstring(PyObject* obj)
  {
-      return PyUnicode_Check(obj) ? const_cast<void*>(reinterpret_cast<const void*>(_PyUnicode_AsString(obj))) : 0;
+      return PyUnicode_Check(obj) ? _PyUnicode_AsString(obj) : 0;
  }
 #endif

--- a/src/exec.cpp
+++ b/src/exec.cpp
@@ -16,7 +16,7 @@ namespace python

 object BOOST_PYTHON_DECL eval(str string, object global, object local)
 {
-    return eval(python::extract<char const *>(string), global, local);
+    return eval(python::extract<char const *>(string));
 }

 object BOOST_PYTHON_DECL eval(char const *string, object global, object local)
@@ -39,7 +39,7 @@ object BOOST_PYTHON_DECL eval(char const *string, object global, object local)

 object BOOST_PYTHON_DECL exec(str string, object global, object local)
 {
-    return exec(python::extract<char const *>(string), global, local);
+    return exec(python::extract<char const *>(string));
 }

 object BOOST_PYTHON_DECL exec(char const *string, object global, object local)
--- a/src/fabscript
+++ b/src/fabscript
@@ -1,58 +0,0 @@
-# -*- python -*-
-#
-# Copyright (c) 2016 Stefan Seefeld
-# All rights reserved.
-#
-# 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)
-
-from faber.feature import set
-from faber.artefacts.library import library
-from faber.tools.compiler import define
-
-root = module('..')
-
-bpl = library('boost_python' + root.py_suffix,
-              ['list.cpp',
-               'long.cpp',
-               'dict.cpp',
-               'tuple.cpp',
-               'str.cpp',
-               'slice.cpp',
-               'converter/from_python.cpp',
-               'converter/registry.cpp',
-               'converter/type_id.cpp',
-               'object/enum.cpp',
-               'object/class.cpp',
-               'object/function.cpp',
-               'object/inheritance.cpp',
-               'object/life_support.cpp',
-               'object/pickle_support.cpp',
-               'errors.cpp',
-               'module.cpp',
-               'converter/builtin_converters.cpp',
-               'converter/arg_to_python_base.cpp',
-               'object/iterator.cpp',
-               'object/stl_iterator.cpp',
-               'object_protocol.cpp',
-               'object_operators.cpp',
-               'wrapper.cpp',
-               'import.cpp',
-               'exec.cpp',
-               'object/function_doc_signature.cpp'],
-              dependencies=root.config,
-              features=features + define('BOOST_PYTHON_SOURCE'))
-
-bnl = library('boost_numpy' + root.py_suffix,
-              ['numpy/dtype.cpp',
-               'numpy/matrix.cpp',
-               'numpy/ndarray.cpp',
-               'numpy/numpy.cpp',
-               'numpy/scalars.cpp',
-               'numpy/ufunc.cpp',
-               bpl],
-              dependencies=root.config,
-              features=features + define('BOOST_NUMPY_SOURCE'),
-              condition=set.define.contains('HAS_NUMPY'))
-default = [bpl, bnl]
--- a/src/numpy/dtype.cpp
+++ b/src/numpy/dtype.cpp
--- a/src/numpy/ndarray.cpp
+++ b/src/numpy/ndarray.cpp
@@ -138,30 +138,6 @@ ndarray from_data_impl(void * data,

 } // namespace detail

-namespace {
-    int normalize_index(int n,int nlim) // wraps [-nlim:nlim) into [0:nlim), throw IndexError otherwise
-    {
-        if (n<0)
-            n += nlim; // negative indices work backwards from end
-        if (n < 0 || n >= nlim)
-        {
-            PyErr_SetObject(PyExc_IndexError, Py_None);
-            throw_error_already_set();
-        }
-        return n;
-    }
-}
-
-Py_intptr_t ndarray::shape(int n) const
-{
-    return get_shape()[normalize_index(n,get_nd())];
-}
-
-Py_intptr_t ndarray::strides(int n) const
-{
-    return get_strides()[normalize_index(n,get_nd())];
-}
-
 ndarray ndarray::view(dtype const & dt) const
 {
  return ndarray(python::detail::new_reference
@@ -194,7 +170,7 @@ python::object ndarray::get_base() const
 void ndarray::set_base(object const & base) 
 {
  Py_XDECREF(get_struct()->base);
-  if (base.ptr())
+  if (base != object()) 
  {
    Py_INCREF(base.ptr());
    get_struct()->base = base.ptr();
--- a/src/numpy/numpy.cpp
+++ b/src/numpy/numpy.cpp
@@ -19,7 +19,6 @@ static void wrap_import_array()
 static void * wrap_import_array()
 {
  import_array();
-  return NULL;
 }
 #endif

--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -618,7 +618,7 @@ namespace objects
  {
      object property(
          (python::detail::new_reference)
-          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("Osss"), fget.ptr(), (char*)NULL, (char*)NULL, docstr));
+          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("Osss"), fget.ptr(), 0, 0, docstr));
      
      this->setattr(name, property);
  }
@@ -628,7 +628,7 @@ namespace objects
  {
      object property(
          (python::detail::new_reference)
-          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("OOss"), fget.ptr(), fset.ptr(), (char*)NULL, docstr));
+          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("OOss"), fget.ptr(), fset.ptr(), 0, docstr));
      
      this->setattr(name, property);
  }
--- a/src/object/enum.cpp
+++ b/src/object/enum.cpp
@@ -34,17 +34,11 @@ static PyMemberDef enum_members[] = {

 extern "C"
 {
-    static void
-    enum_dealloc(enum_object* self)
-    {
-        Py_XDECREF(self->name);
-        Py_TYPE(self)->tp_free((PyObject*)self);
-    }
-
    static PyObject* enum_repr(PyObject* self_)
    {
+        // XXX(bhy) Potentional memory leak here since PyObject_GetAttrString returns a new reference
+        // const char *mod = PyString_AsString(PyObject_GetAttrString( self_, const_cast<char*>("__module__")));
        PyObject *mod = PyObject_GetAttrString( self_, "__module__");
-        object auto_free = object(handle<>(mod));
        enum_object* self = downcast<enum_object>(self_);
        if (!self->name)
        {
@@ -94,7 +88,7 @@ static PyTypeObject enum_type_object = {
    const_cast<char*>("Boost.Python.enum"),
    sizeof(enum_object),                    /* tp_basicsize */
    0,                                      /* tp_itemsize */
-    (destructor) enum_dealloc,              /* tp_dealloc */
+    0,                                      /* tp_dealloc */
    0,                                      /* tp_print */
    0,                                      /* tp_getattr */
    0,                                      /* tp_setattr */
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -158,6 +158,11 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
                    {
                        // no argument preprocessing
                    }
+                    else if (n_actual > max_arity)
+                    {
+                        // too many arguments
+                        inner_args = handle<>();
+                    }
                    else
                    {
                        // build a new arg tuple, will adjust its size later
--- a/src/wrapper.cpp
+++ b/src/wrapper.cpp
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -50,8 +50,6 @@ rule require-windows ( properties * )
    }
 }

-if [ python.configured ]
-{
 test-suite python
  :

@@ -99,16 +97,12 @@ bpl-test crossmod_exception

 [ bpl-test polymorphism2_auto_ptr 
  : polymorphism2_auto_ptr.py polymorphism2.py polymorphism2_auto_ptr.cpp 
-  : [ requires auto_ptr ]
 ]

 [ bpl-test polymorphism ]
 [ bpl-test polymorphism2 ]

-[ bpl-test auto_ptr
-  : # files
-  : [ requires auto_ptr ]
-]
+[ bpl-test auto_ptr ]

 [ bpl-test minimal ]
 [ bpl-test args ]
@@ -254,4 +248,3 @@ bpl-test crossmod_opaque


  ;
-}
--- a/test/SConscript
+++ b/test/SConscript
@@ -0,0 +1,169 @@
+# -*- python -*-
+#
+# Copyright (c) 2016 Stefan Seefeld
+# All rights reserved.
+#
+# 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 platform
+import sys
+
+Import('env')
+
+if sys.platform == 'win32':
+    # HACK: This works around a bug in SCons.
+    #       subprocess.check_output will complain unless all environment
+    #       variables are strings.
+    system_root = env['ENV']['SystemRoot']
+    env['ENV']['SystemRoot'] = str(system_root)
+
+
+# libs needed for embedding
+ELIBS=env['LIBS'] + env['PYTHONLIBS']
+
+def BPLTest(env, name, sources = None, deps = None):
+    run = env.BoostRunPythonScript(name + '.py')
+    if sources:
+        for source in sources:
+            Depends(run,
+                    env.PythonExtension(source != name and source or (source + '_ext'), source + '.cpp')
+            )
+    else:
+        Depends(run, env.PythonExtension(name + '_ext', name + '.cpp'))
+    if deps:
+        Depends(run, deps)
+    return run
+        
+env.AddMethod(BPLTest)
+
+env.AppendENVPath('PYTHONPATH', Dir('.').path)
+
+tests=[]
+tests+=env.BPLTest('crossmod_exception', ['crossmod_exception_a', 'crossmod_exception_b'])
+
+for test in [('injected',),
+             ('properties',),
+             ('return_arg',),
+             ('staticmethod',),
+             ('boost_shared_ptr',),
+             ('enable_shared_from_this',),
+             ('andreas_beyer',),
+             ('polymorphism',),
+             ('polymorphism2',),
+             ('wrapper_held_type',),
+             ('minimal',),
+             ('args',),
+             ('raw_ctor',),
+             ('exception_translator',),
+             ('test_enum', ['enum_ext']),
+             ('test_cltree', ['cltree']),
+             ('newtest', ['m1', 'm2']),
+             ('const_argument',),
+             ('keywords_test', ['keywords']),
+             ('test_pointer_adoption',),
+             ('operators',),
+             ('operators_wrapper',),
+             ('callbacks',),
+             ('defaults',),
+             ('object',),
+             ('list',),
+             ('long',),
+             ('dict',),
+             ('tuple',),
+             ('str',),
+             ('slice',),
+             ('virtual_functions',),
+             ('back_reference',),
+             ('implicit',),
+             ('data_members',),
+             ('ben_scott1',),
+             ('bienstman1',),
+             ('bienstman2',),
+             ('bienstman3',),
+             ('multi_arg_constructor',),
+             ('iterator', ['iterator', 'input_iterator']),
+             ('stl_iterator',),
+             ('extract',),
+             ('crossmod_opaque', ['crossmod_opaque_a', 'crossmod_opaque_b']),
+             ('opaque',),
+#             ('voidptr',),
+             ('pickle1',),
+             ('pickle2',),
+             ('pickle3',),
+             ('pickle4',),
+             ('nested',),
+             ('docstring',),
+             ('pytype_function',),
+             ('vector_indexing_suite',),
+             ('pointer_vector',)]:
+    tests+=env.BPLTest(*test)
+
+if env['CXX11']:
+    for test in [
+        ('shared_ptr',),
+    ]:
+        tests+=env.BPLTest(*test)
+else:
+    for test in [
+        ('polymorphism2_auto_ptr',),
+        ('auto_ptr',),
+    ]:
+        tests+=env.BPLTest(*test)
+
+
+test = env.BoostRunPythonScript('test_builtin_converters.py')
+Depends(
+    test,
+    env.PythonExtension('builtin_converters_ext', ['builtin_converters.cpp'])
+    )
+tests+=test
+test = env.BoostRunPythonScript('map_indexing_suite.py')
+Depends(
+    test,
+    env.PythonExtension('map_indexing_suite_ext', [
+        'map_indexing_suite.cpp',
+        'int_map_indexing_suite.cpp',
+        'a_map_indexing_suite.cpp'])
+    )
+tests+=test
+
+tests+=env.BoostRunTest('import_', 'import_.cpp', '${SOURCES[0]} ${SOURCES[1]}', 'import_.py', LIBS=ELIBS)
+
+tests+=env.BoostCompileTest('indirect_traits_test')
+tests+=env.BoostRunTests(['destroy_test',
+                          'pointer_type_id_test',
+                          'bases',
+                          'if_else',
+                          'pointee',
+                          'result'], LIBS=ELIBS)
+
+tests+=env.BoostCompileTests(['string_literal',
+                              'borrowed',
+                              'object_manager',
+                              'copy_ctor_mutates_rhs'])
+
+tests+=env.BoostRunTest('upcast', LIBS=ELIBS)
+tests+=env.BoostCompileTest('select_holder')
+tests+=env.BoostRunTest('select_from_python_test', LIBS=ELIBS)
+tests+=env.BoostCompileTest('select_arg_to_python_test')
+
+if platform.system() == 'Windows':
+    tests+=env.BPLTest('calling_conventions')
+    tests+=env.BPLTest('calling_conventions_mf')
+
+if env['NUMPY']:
+    numpy_env = env.Clone()
+    numpy_env.BoostUseLib('numpy')
+    for test in [('numpy/dtype',),
+                 ('numpy/ufunc',),
+                 ('numpy/templates',),
+                 ('numpy/ndarray',),
+                 ('numpy/indexing',),
+                 ('numpy/shapes',),]:
+        tests+=numpy_env.BPLTest(*test)
+
+
+env.BoostTestSummary(tests)
+AlwaysBuild(tests)
--- a/test/borrowed.cpp
+++ b/test/borrowed.cpp
--- a/test/calling_conventions.cpp
+++ b/test/calling_conventions.cpp
@@ -17,11 +17,9 @@
 //------------------------------------------------------------------------------
 // this section is the main body of the test extension module

-#if defined(_WIN32) && !defined(_WIN64)
-# define BOOST_PYTHON_ENABLE_CDECL
-# define BOOST_PYTHON_ENABLE_STDCALL
-# define BOOST_PYTHON_ENABLE_FASTCALL
-#endif
+#define BOOST_PYTHON_ENABLE_CDECL
+#define BOOST_PYTHON_ENABLE_STDCALL
+#define BOOST_PYTHON_ENABLE_FASTCALL
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/stringize.hpp>
 #include <boost/python.hpp>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Stefan Seefeld	fed4f0d0f9	Fix version number.	2017-08-19 11:57:56 -04:00
Stefan Seefeld	39edfd45cf	Fix traits qualification.	2017-08-19 11:57:39 -04:00
Stefan Seefeld	8c2a808cbe	Remove 'numeric' documentation.	2017-07-31 11:38:40 -04:00
Stefan Seefeld	aeedea409a	Merge branch 'develop'	2017-07-20 13:04:44 -04:00
Stefan Seefeld	df6926551e	Merge branch 'develop'	2017-06-25 18:27:19 -04:00
Stefan Seefeld	7d3df3d3a7	Merge branch 'develop'	2017-03-28 12:57:32 -04:00
Stefan Seefeld	ae747521b0	Merge branch 'develop'	2017-03-24 15:53:30 -04:00
Rene Rivera	5e4b44e0af	Don't build numpy if there's no python version to target.	2017-03-06 10:39:01 -06:00
Rene Rivera	07b1489f3b	BPL builds targets need to always be defined.	2017-03-05 15:17:26 -06:00
Rene Rivera	44ea0562b2	Fix no pynumpy target when no numpy configured.	2017-03-05 09:00:27 -06:00
Rene Rivera	60fba03e99	Fix libs from referencing BPL when there is no python configured.	2017-03-05 09:00:10 -06:00
Stefan Seefeld	e3c9dd78aa	Merge branch 'develop'	2017-03-03 18:07:49 -05:00
Stefan Seefeld	aaf9022770	Merge branch 'develop'	2016-11-02 14:12:45 -04:00
Rene Rivera	88ea1f9626	Fix syntax error caused by merging.	2016-10-10 12:22:25 -05:00
Rene Rivera	731ba745ca	Add, and update, documentation build targets.	2016-10-10 12:22:10 -05:00