diff --git a/.ci/azp-linux-test.yml b/.ci/azp-linux-test.yml
new file mode 100644
index 0000000000..a49f3afcce
--- /dev/null
+++ b/.ci/azp-linux-test.yml
@@ -0,0 +1,41 @@
+steps:
+- bash: |
+    set -e
+    uname -a
+    ./.ci/linux-cxx-install.sh
+  displayName: Install
+- bash: |
+    set -e
+    cd src/engine
+    set PATH=${PATH};${CXX_PATH}
+    ./build.sh ${TOOLSET} --cxx=${CXX}
+    ./b2 -v
+    cd ../..
+  displayName: Build
+- bash: |
+    set -e
+    CXX_PATH=`which ${CXX}`
+    cd test
+    echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
+    python test_all.py ${TEST_TOOLSET}
+    cd ..
+  displayName: Test
+- bash: |
+    set -e
+    CXX_PATH=`which ${CXX}`
+    echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
+    ./src/engine/b2 b2 warnings-as-errors=on variant=debug,release address-model=32,64 toolset=${TEST_TOOLSET}
+  displayName: "No Warnings"
+- bash: |
+    set -e
+    CXX_PATH=`which ${CXX}`
+    echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
+    ./bootstrap.sh ${TOOLSET}
+    ./b2 --prefix=$HOME/temp/.b2 install ${TEST_TOOLSET}
+    rm ./b2
+    export PATH=$HOME/temp/.b2/bin:$PATH
+    cd $HOME
+    touch build.jam
+    b2 -v
+    b2 -n --debug-configuration
+  displayName: Bootstrap
diff --git a/.ci/azp-macos-test.yml b/.ci/azp-macos-test.yml
new file mode 100644
index 0000000000..2841b83e09
--- /dev/null
+++ b/.ci/azp-macos-test.yml
@@ -0,0 +1,41 @@
+steps:
+- bash: |
+    set -e
+    uname -a
+    sudo xcode-select -switch ${XCODE_APP}
+    which clang++
+  displayName: Install
+- bash: |
+    set -e
+    cd src/engine
+    ./build.sh ${TOOLSET} --cxx=${CXX}
+    ./b2 -v
+    cd ../..
+  displayName: Build
+- bash: |
+    set -e
+    CXX_PATH=`which ${CXX}`
+    cd test
+    echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
+    python test_all.py ${TEST_TOOLSET}
+    cd ..
+  displayName: Test
+- bash: |
+    set -e
+    CXX_PATH=`which ${CXX}`
+    echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
+    ./src/engine/b2 b2 warnings-as-errors=on variant=debug,release address-model=32,64 toolset=${TEST_TOOLSET}
+  displayName: "No Warnings"
+- bash: |
+    set -e
+    CXX_PATH=`which ${CXX}`
+    echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
+    ./bootstrap.sh ${TOOLSET}
+    ./b2 --prefix=$HOME/temp/.b2 install ${TEST_TOOLSET}
+    rm ./b2
+    export PATH=$HOME/temp/.b2/bin:$PATH
+    cd $HOME
+    touch build.jam
+    b2 -v
+    b2 -n --debug-configuration
+  displayName: Bootstrap
diff --git a/.ci/azp-windows-test.yml b/.ci/azp-windows-test.yml
new file mode 100644
index 0000000000..25aaf8f837
--- /dev/null
+++ b/.ci/azp-windows-test.yml
@@ -0,0 +1,34 @@
+steps:
+- powershell: |
+    cd src/engine
+    $env:path += ';' + $env:CXX_PATH
+    cmd /c build.bat $env:TOOLSET
+    ./b2.exe -v
+    cd ../..
+  displayName: Build
+- powershell: |
+    $env:HOME = $env:HOMEDRIVE + $env:HOMEPATH
+    cd test
+    echo "using" $env:TEST_TOOLSET ":" ":" $env:CXX ";" > ${env:HOME}/user-config.jam
+    python test_all.py $env:TEST_TOOLSET
+    cd ..
+  displayName: Test
+- powershell: |
+    $env:HOME = $env:HOMEDRIVE + $env:HOMEPATH
+    $env:path += ';' + $env:CXX_PATH
+    echo "using" $env:TEST_TOOLSET ":" ":" $env:CXX ";" > ${env:HOME}/user-config.jam
+    ./src/engine/b2.exe --debug-configuration b2 warnings-as-errors=on variant=debug,release toolset=$env:TEST_TOOLSET
+  displayName: "No Warnings"
+- powershell: |
+    $env:HOME = $env:HOMEDRIVE + $env:HOMEPATH
+    $env:path += ';' + $env:CXX_PATH
+    echo "using" $env:TEST_TOOLSET ":" ":" $env:CXX ";" > ${env:HOME}/user-config.jam
+    ./bootstrap.bat $env:TOOLSET
+    ./b2.exe --debug-configuration --prefix=${env:HOME}/temp/.b2 install toolset=$env:TEST_TOOLSET
+    Remove-Item ./b2.exe
+    $env:path += $env:HOME + '/temp/.b2/bin' + ';' + $env:PATH
+    cd $env:HOME
+    echo $null >> build.jam
+    b2 -v
+    b2 -n --debug-configuration
+  displayName: Bootstrap
diff --git a/.ci/linux-cxx-install.sh b/.ci/linux-cxx-install.sh
new file mode 100755
index 0000000000..c92a333882
--- /dev/null
+++ b/.ci/linux-cxx-install.sh
@@ -0,0 +1,30 @@
+#!/bin/sh
+
+# Usage:
+# LLVM_OS: LLVM OS release to obtain clang binaries. Only needed for clang install.
+# LLVM_VER: The LLVM toolset version to point the repo at.
+# PACKAGES: Compiler packages to install.
+
+set -e
+echo ">>>>>"
+echo ">>>>> APT: REPO.."
+echo ">>>>>"
+sudo -E apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+if test -n "${LLVM_OS}" ; then
+	wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+	sudo -E apt-add-repository "deb http://apt.llvm.org/${LLVM_OS}/ llvm-toolchain-${LLVM_OS}-${LLVM_VER} main"
+fi
+echo ">>>>>"
+echo ">>>>> APT: UPDATE.."
+echo ">>>>>"
+sudo -E apt-get -o Acquire::Retries=3 update
+echo ">>>>>"
+echo ">>>>> APT: INSTALL ${PACKAGES}.."
+echo ">>>>>"
+sudo -E apt-get -o Acquire::Retries=3 -yq --no-install-suggests --no-install-recommends install ${PACKAGES}
+
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright Rene Rivera 2020.
diff --git a/.cirrus.yml b/.cirrus.yml
new file mode 100644
index 0000000000..d90f76c488
--- /dev/null
+++ b/.cirrus.yml
@@ -0,0 +1,44 @@
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright René Ferdinand Rivera Morell 2020.
+
+freebsd_task:
+  # All the GCC's and Clang's currently supported by FreeBSD ports.
+  matrix:
+    - { name: 'FreeBSD, GCC 11', env: { TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: 'g++11', PACKAGE: 'gcc11-devel' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, GCC 10', env: { TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: 'g++10', PACKAGE: 'gcc10-devel' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, GCC 9', env: { TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: 'g++9', PACKAGE: 'gcc9-devel' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, GCC 8', env: { TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: 'g++8', PACKAGE: 'gcc8-devel' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, GCC 7', env: { TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: 'g++7', PACKAGE: 'gcc7' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, Clang 10', env: { TOOLSET: clang, TEST_TOOLSET: clang, CXX: 'clang++10', PACKAGE: 'llvm10' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, Clang 9', env: { TOOLSET: clang, TEST_TOOLSET: clang, CXX: 'clang++90', PACKAGE: 'llvm90' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, Clang 8', env: { TOOLSET: clang, TEST_TOOLSET: clang, CXX: 'clang++80', PACKAGE: 'llvm80' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, Clang 7', env: { TOOLSET: clang, TEST_TOOLSET: clang, CXX: 'clang++70', PACKAGE: 'llvm70' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+    - { name: 'FreeBSD, Clang 6', env: { TOOLSET: clang, TEST_TOOLSET: clang, CXX: 'clang++60', PACKAGE: 'llvm60' }, freebsd_instance: { image_family: 'freebsd-13-0-snap' } }
+  # To install with ports we need to initialize the package manager. To avoid
+  # confirmation prompts we need to set an env var.
+  install_script: [
+    "uname -a",
+    "env ASSUME_ALWAYS_YES=YES pkg bootstrap",
+    "env ASSUME_ALWAYS_YES=YES pkg install ${PACKAGE}"
+    ]
+  # Build the engine.
+  build_script: [
+    "set -e",
+    "cd src/engine",
+    "set PATH=${PATH};${CXX_PATH}",
+    "./build.sh ${TOOLSET}",
+    "./b2 -v",
+    "cd ../.."
+  ]
+  # Run the core tests.
+  test_script: [
+    "set -e",
+    "CXX_PATH=`which ${CXX}`",
+    "cd test",
+    "echo \"using ${TEST_TOOLSET} : : ${CXX_PATH} ;\" > ${HOME}/user-config.jam",
+    "python2 test_all.py ${TEST_TOOLSET}",
+    "cd ..",
+  ]
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 608af29b10..227e0c62d2 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -16,5 +16,43 @@
             "externalConsole": true,
             "MIMode": "lldb"
         },
+        {
+            "name": "(gdb) Launch: example/hello",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/.build/clang-linux-10.0.0/debug/cxxstd-11-iso/b2",
+            "args": ["-n", "toolset=clang"],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}/example/hello",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "(gdb) Launch: home/tmp/prebuild",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/.build/gcc-10.1.0/debug/cxxstd-11-iso/b2",
+            "args": ["-n","-sBOOST_BUILD_PATH=/home/grafik/Sync/DevRoots/B2/mainline/test/..","debug","release","-j1","-d2","toolset=gcc"],
+            "stopAtEntry": false,
+            "cwd": "/home/grafik/tmp/prebuilt-1",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
     ]
 }
\ No newline at end of file
diff --git a/README.adoc b/README.adoc
index 2ca949fcb3..35650f2a47 100644
--- a/README.adoc
+++ b/README.adoc
@@ -14,9 +14,9 @@ file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 Continuously tested on:
 
-* Linux Clang 3.5, 3.6, 3.7, 3.8, 3.9, 4, 5, 6, 7, 8
-* Linux GCC 4.7, 4.8, 4.9, 5, 6, 7, 8, 9
-* macOS Xcode 8.3.3, 9.0, 9.0.1, 9.1, 9.2, 9.3, 9.3.1, 9.4, 9.4.1, 10.0, 10.1, 10.2, 10.2.1, 11.0, 11.1, 11.2, 11.3, 11.3.1
+* Linux Clang 3.5, 3.6, 3.7, 3.8, 3.9, 4, 5, 6, 7, 8, 9, 10
+* Linux GCC 4.7, 4.8, 4.9, 5, 6, 7, 8, 9, 10
+* macOS Xcode 10.0, 10.1, 10.2, 10.2.1, 11.2.1, 11.3, 11.3.1, 11.4.1, 11.5, 11.6, 11.7
 * Windows MinGW 8.1.0
 * Windows VS 2013, 2015, 2017, 2019
 
diff --git a/appveyor.yml b/appveyor.yml
index 4e175514b6..078e5fa667 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -22,6 +22,12 @@ environment:
     TOOLSET: vc12
     TEST_TOOLSET: msvc
     APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+  # - job_name: 'Cygwin 3.1.7, Test'
+  #   job_group: 'Test'
+  #   TOOLSET:
+  #   TEST_TOOLSET: gcc
+  #   APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+  #   CXX_PATH: C:/cygwin/bin
 
 build_script:
   - cmd: |
@@ -55,7 +61,7 @@ for:
           echo ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
           echo ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NO WARNINGS"
           echo ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
-          src\engine\b2.exe --debug-configuration b2 warnings-as-errors=on toolset=%TEST_TOOLSET%
+          src\engine\b2.exe --debug-configuration b2 warnings-as-errors=on variant=debug,release address-model=32,64 toolset=%TEST_TOOLSET%
       - cmd: |
           echo ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
           echo ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BOOTSTRAP"
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index fc67c0a7c5..3594abd433 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -2,7 +2,7 @@
 # subject to the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #
-# Copyright Rene Rivera 2015-2019.
+# Copyright Rene Rivera 2015-2020.
 
 trigger:
   branches:
@@ -13,6 +13,7 @@ trigger:
   paths:
     exclude:
     - appveyor.yml
+    - .cirrus.yml
 pr:
   branches:
     include:
@@ -23,429 +24,193 @@ pr:
 
 stages:
 
-- stage: Test
+- stage: Core
   jobs:
 
-  - job: 'Linux'
-    pool:
-      vmImage: 'ubuntu-16.04'
+  - job: 'Linux_Default_Build'
     strategy:
       matrix:
-        GCC 9:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        GCC 8:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-8
-          PACKAGES: g++-8
-        GCC 7:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-7
-          PACKAGES: g++-7
-        GCC 6:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-6
-          PACKAGES: g++-6
-        GCC 5:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-5
-          PACKAGES: g++-5
-        GCC 4.9:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-4.9
-          PACKAGES: g++-4.9
-        GCC 4.8:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-4.8
-          PACKAGES: g++-4.8
-        GCC 4.7:
-          TOOLSET: gcc
-          TEST_TOOLSET: gcc
-          CXX: g++-4.7
-          PACKAGES: g++-4.7
-        Clang 9:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-9
-          PACKAGES: clang-9
-          LLVM_REPO: llvm-toolchain-xenial-9
-        Clang 8:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-8
-          PACKAGES: clang-8
-          LLVM_REPO: llvm-toolchain-xenial-8
-        Clang 7:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-7
-          PACKAGES: clang-7
-          LLVM_REPO: llvm-toolchain-xenial-7
-        Clang 6:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-6.0
-          PACKAGES: clang-6.0
-          LLVM_REPO: llvm-toolchain-xenial-6.0
-        Clang 5:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-5.0
-          PACKAGES: clang-5.0
-          LLVM_REPO: llvm-toolchain-xenial-5.0
-        Clang 4:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-4.0
-          PACKAGES: clang-4.0
-          LLVM_REPO: llvm-toolchain-xenial-4.0
-        Clang 3.9:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-3.9
-          PACKAGES: clang-3.9
-        Clang 3.8:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-3.8
-          PACKAGES: clang-3.8
-        Clang 3.7:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-3.7
-          PACKAGES: clang-3.7
-        Clang 3.6:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-3.6
-          PACKAGES: clang-3.6
-        Clang 3.5:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++-3.5
-          PACKAGES: clang-3.5
+        Clang 10: {PACKAGES: clang-10, LLVM_OS: bionic, LLVM_VER: 10, VM_IMAGE: 'ubuntu-18.04'}
+    pool:
+      vmImage: $(VM_IMAGE)
     steps:
     - bash: |
-          set -e
-          uname -a
-          sudo -E apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
-          if test -n "${LLVM_REPO}" ; then
-            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-            sudo -E apt-add-repository "deb http://apt.llvm.org/xenial/ ${LLVM_REPO} main"
-          fi
-          sudo -E apt-get -o Acquire::Retries=3 update
-          sudo -E apt-get -o Acquire::Retries=3 -yq --no-install-suggests --no-install-recommends install ${PACKAGES}
+        set -e
+        uname -a
+        ./.ci/linux-cxx-install.sh
       displayName: Install
     - bash: |
-          set -e
-          cd src/engine
-          set PATH=${PATH};${CXX_PATH}
-          ./build.sh ${TOOLSET}
-          ./b2 -v
-          cd ../..
+        set -e
+        ./src/engine/build.sh --verbose
       displayName: Build
+
+  - job: 'Linux_Clang_Only_Build'
+    strategy:
+      matrix:
+        Clang 10: {PACKAGES: clang-10, LLVM_OS: bionic, LLVM_VER: 10, VM_IMAGE: 'ubuntu-18.04'}
+    pool:
+      vmImage: $(VM_IMAGE)
+    steps:
     - bash: |
-          set -e
-          CXX_PATH=`which ${CXX}`
-          cd test
-          echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
-          python test_all.py ${TEST_TOOLSET}
-          cd ..
-      displayName: Test
-    - bash: |
-          set -e
-          CXX_PATH=`which ${CXX}`
-          echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
-          ./src/engine/b2 b2 warnings-as-errors=on toolset=${TEST_TOOLSET}
-      displayName: "No Warnings"
+        set -e
+        uname -a
+        ./.ci/linux-cxx-install.sh
+        sudo apt remove gcc g++
+      displayName: Install
     - bash: |
-          set -e
-          CXX_PATH=`which ${CXX}`
-          echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
-          ./bootstrap.sh ${TOOLSET}
-          ./b2 --prefix=./.b2 install ${TEST_TOOLSET}
-      displayName: Bootstrap
+        set -e
+        ./src/engine/build.sh --verbose
+      displayName: Build
+
+  - job: 'Linux_Latest'
+    strategy:
+      matrix:
+        GCC 10: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10, VM_IMAGE: 'ubuntu-18.04'}
+    pool:
+      vmImage: $(VM_IMAGE)
+    steps:
+    - template: .ci/azp-linux-test.yml
+
+  - job: 'Windows_Latest'
+    strategy:
+      matrix:
+        VS 2019: {TOOLSET: vc142, TEST_TOOLSET: msvc, VM_IMAGE: 'windows-2019'}
+    pool:
+      vmImage: $(VM_IMAGE)
+    steps:
+    - template: .ci/azp-windows-test.yml
+
+  - job: 'macOS'
+    strategy:
+      matrix:
+        Xcode 12.3: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_12.3.app, VM_IMAGE: 'macOS-10.15'}
+    pool:
+      vmImage: $(VM_IMAGE)
+    steps:
+    - template: .ci/azp-macos-test.yml
+
+- stage: Compilers
+  dependsOn: [Core]
+  jobs:
+
+  - job: 'Linux'
+    strategy:
+      matrix:
+        GCC 9: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-9, PACKAGES: g++-9, VM_IMAGE: 'ubuntu-18.04'}
+        GCC 8: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-8, PACKAGES: g++-8, VM_IMAGE: 'ubuntu-18.04'}
+        GCC 7: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-7, PACKAGES: g++-7, VM_IMAGE: 'ubuntu-18.04'}
+        GCC 6: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-6, PACKAGES: g++-6, VM_IMAGE: 'ubuntu-18.04'}
+        GCC 5: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-5,  PACKAGES: g++-5, VM_IMAGE: 'ubuntu-18.04'}
+        GCC 4.9: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-4.9, PACKAGES: g++-4.9, VM_IMAGE: 'ubuntu-16.04'}
+        GCC 4.8: {TOOLSET: gcc, TEST_TOOLSET: gcc,  CXX: g++-4.8, PACKAGES: g++-4.8, VM_IMAGE: 'ubuntu-16.04'}
+        GCC 4.7: {TOOLSET: gcc, TEST_TOOLSET: gcc, CXX: g++-4.7, PACKAGES: g++-4.7, VM_IMAGE: 'ubuntu-16.04'}
+        Clang 10: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-10, PACKAGES: clang-10, LLVM_OS: bionic, LLVM_VER: 10, VM_IMAGE: 'ubuntu-18.04'}
+        Clang 9: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-9, PACKAGES: clang-9, LLVM_OS: bionic, LLVM_VER: 9, VM_IMAGE: 'ubuntu-18.04'}
+        Clang 8: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-8, PACKAGES: clang-8, LLVM_OS: bionic, LLVM_VER: 8, VM_IMAGE: 'ubuntu-18.04'}
+        Clang 7: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-7, PACKAGES: clang-7, LLVM_OS: bionic, LLVM_VER: 7, VM_IMAGE: 'ubuntu-18.04'}
+        Clang 6: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-6.0, PACKAGES: clang-6.0, LLVM_OS: bionic, LLVM_VER: 6.0, VM_IMAGE: 'ubuntu-18.04'}
+        Clang 5: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-5.0, PACKAGES: clang-5.0, LLVM_OS: bionic, LLVM_VER: 5.0, VM_IMAGE: 'ubuntu-18.04'}
+        Clang 4: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-4.0, PACKAGES: clang-4.0, LLVM_OS: xenial, LLVM_VER: 4.0, VM_IMAGE: 'ubuntu-16.04'}
+        Clang 3.9: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-3.9, PACKAGES: clang-3.9, VM_IMAGE: 'ubuntu-16.04'}
+        Clang 3.8: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-3.8, PACKAGES: clang-3.8, VM_IMAGE: 'ubuntu-16.04'}
+        Clang 3.7: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-3.7, PACKAGES: clang-3.7, VM_IMAGE: 'ubuntu-16.04'}
+        Clang 3.6: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-3.6, PACKAGES: clang-3.6, VM_IMAGE: 'ubuntu-16.04'}
+        Clang 3.5: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++-3.5, PACKAGES: clang-3.5, VM_IMAGE: 'ubuntu-16.04'}
+    pool:
+      vmImage: $(VM_IMAGE)
+    steps:
+    - template: .ci/azp-linux-test.yml
 
   - job: 'Windows'
     strategy:
       matrix:
-        VS 2019:
-          TOOLSET: vc142
-          TEST_TOOLSET: msvc
-          VM_IMAGE: 'windows-2019'
-        VS 2017:
-          TOOLSET: vc141
-          TEST_TOOLSET: msvc
-          VM_IMAGE: 'vs2017-win2016'
-        MinGW 8.1.0:
-          TOOLSET: mingw
-          TEST_TOOLSET: gcc
-          VM_IMAGE: 'vs2017-win2016'
+        VS 2017: {TOOLSET: vc141, TEST_TOOLSET: msvc, VM_IMAGE: 'vs2017-win2016'}
+        MinGW 8.1.0: {TOOLSET: mingw, TEST_TOOLSET: gcc, VM_IMAGE: 'vs2017-win2016'}
     pool:
       vmImage: $(VM_IMAGE)
     steps:
-    - powershell: |
-          cd src/engine
-          $env:path += ';' + $env:CXX_PATH
-          cmd /c build.bat $env:TOOLSET
-          ./b2.exe -v
-          cd ../..
-      displayName: Build
-    - powershell: |
-          $env:HOME = $env:HOMEDRIVE + $env:HOMEPATH
-          cd test
-          echo "using" $env:TEST_TOOLSET ":" ":" $env:CXX ";" > $env:HOME/user-config.jam
-          python test_all.py $env:TEST_TOOLSET
-          cd ..
-      displayName: Test
-    - powershell: |
-          $env:HOME = $env:HOMEDRIVE + $env:HOMEPATH
-          $env:path += ';' + $env:CXX_PATH
-          echo "using" $env:TEST_TOOLSET ":" ":" $env:CXX ";" > $env:HOME/user-config.jam
-          ./src/engine/b2.exe --debug-configuration b2 warnings-as-errors=on toolset=$env:TEST_TOOLSET
-      displayName: "No Warnings"
-    - powershell: |
-          $env:HOME = $env:HOMEDRIVE + $env:HOMEPATH
-          $env:path += ';' + $env:CXX_PATH
-          echo "using" $env:TEST_TOOLSET ":" ":" $env:CXX ";" > $env:HOME/user-config.jam
-          ./bootstrap.bat $env:TOOLSET
-          ./b2.exe --debug-configuration --prefix=./.b2 install toolset=$env:TEST_TOOLSET
-      displayName: Bootstrap
+    - template: .ci/azp-windows-test.yml
 
   - job: 'macOS'
     strategy:
       matrix:
-        Xcode 11.4:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.4_beta.app
-          VM_IMAGE: 'macOS-10.15'
-        Xcode 11.3.1:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
-          VM_IMAGE: 'macOS-10.15'
-        Xcode 11.3:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.app
-          VM_IMAGE: 'macOS-10.15'
-        Xcode 11.2:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.2.app
-          VM_IMAGE: 'macOS-10.15'
-        Xcode 11.1:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.1.app
-          VM_IMAGE: 'macOS-10.15'
-        Xcode 11.0:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.app
-          VM_IMAGE: 'macOS-10.15'
-        Xcode 10.2.1:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_10.2.1.app
-          VM_IMAGE: 'macOS-10.14'
-        Xcode 10.2:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_10.2.app
-          VM_IMAGE: 'macOS-10.14'
-        Xcode 10.1:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_10.1.app
-          VM_IMAGE: 'macOS-10.14'
-        Xcode 10.0:
-          TOOLSET: clang
-          TEST_TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_10.app
-          VM_IMAGE: 'macOS-10.14'
+        Xcode 12.2: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_12.2.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 12.1.1: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_12.1.1.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 12.0.1: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_12.0.1.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 11.7: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 11.6: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.6.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 11.5: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.5.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 11.4.1: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.4.1.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 11.3.1: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.3.1.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 11.3: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.3.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 11.2.1: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.2.1.app, VM_IMAGE: 'macOS-10.15'}
+        Xcode 10.2.1: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_10.2.1.app, VM_IMAGE: 'macOS-10.14'}
+        Xcode 10.2: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_10.2.app, VM_IMAGE: 'macOS-10.14'}
+        Xcode 10.1: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_10.1.app, VM_IMAGE: 'macOS-10.14'}
+        Xcode 10.0: {TOOLSET: clang, TEST_TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_10.app, VM_IMAGE: 'macOS-10.14'}
     pool:
       vmImage: $(VM_IMAGE)
     steps:
-    - bash: |
-        set -e
-        uname -a
-        sudo xcode-select -switch ${XCODE_APP}
-        which clang++
-      displayName: Install
-    - bash: |
-        set -e
-        cd src/engine
-        ./build.sh ${TOOLSET}
-        ./b2 -v
-        cd ../..
-      displayName: Build
-    - bash: |
-        set -e
-        CXX_PATH=`which ${CXX}`
-        cd test
-        echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
-        python test_all.py ${TEST_TOOLSET}
-        cd ..
-      displayName: Test
-    - bash: |
-        set -e
-        CXX_PATH=`which ${CXX}`
-        echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
-        ./src/engine/b2 b2 warnings-as-errors=on toolset=${TEST_TOOLSET}
-      displayName: "No Warnings"
-    - bash: |
-        set -e
-        CXX_PATH=`which ${CXX}`
-        echo "using ${TEST_TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
-        ./bootstrap.sh ${TOOLSET}
-        ./b2 --prefix=./.b2 install ${TEST_TOOLSET}
-      displayName: Bootstrap
+    - template: .ci/azp-macos-test.yml
 
-- stage: Boost
+- stage: Boost_Dev
+  dependsOn: [Core]
   jobs:
 
-  - job: 'Release_Linux'
-    displayName: 'Release Linux'
+  - job: 'Dev_Linux'
+    displayName: 'Dev Linux'
     pool:
       vmImage: 'ubuntu-latest'
     strategy:
       matrix:
-        1.72.0 .. GCC 9:
-          BOOST_VERSION: 1.72.0
-          BOOST_VERSION_U: 1_72_0
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        1.71.0 .. GCC 9:
-          BOOST_VERSION: 1.71.0
-          BOOST_VERSION_U: 1_71_0
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        1.70.0 .. GCC 9:
-          BOOST_VERSION: 1.70.0
-          BOOST_VERSION_U: 1_70_0
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        1.69.0 .. GCC 9:
-          BOOST_VERSION: 1.69.0
-          BOOST_VERSION_U: 1_69_0
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        1.68.0 .. GCC 9:
-          BOOST_VERSION: 1.68.0
-          BOOST_VERSION_U: 1_68_0
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        1.67.0 .. GCC 9:
-          BOOST_VERSION: 1.67.0
-          BOOST_VERSION_U: 1_67_0
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        1.66.0 .. GCC 9:
-          BOOST_VERSION: 1.66.0
-          BOOST_VERSION_U: 1_66_0
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
+        Master .. GCC 10: {BOOST_BRANCH: master, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        Master .. Clang 10: {BOOST_BRANCH: master, TOOLSET: clang, CXX: clang++-10, PACKAGES: clang-10, LLVM_OS: bionic, LLVM_VER: 10}
+        Develop .. GCC 10: {BOOST_BRANCH: develop, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        Develop .. Clang 10: {BOOST_BRANCH: develop, TOOLSET: clang, CXX: clang++-10, PACKAGES: clang-10, LLVM_OS: bionic, LLVM_VER: 10}
     steps:
     - bash: |
-          set -e
-          uname -a
-          sudo -E apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
-          if test -n "${LLVM_REPO}" ; then
-            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-            sudo -E apt-add-repository "deb http://apt.llvm.org/xenial/ ${LLVM_REPO} main"
-          fi
-          sudo -E apt-get -o Acquire::Retries=3 update
-          sudo -E apt-get -o Acquire::Retries=3 -yq --no-install-suggests --no-install-recommends install ${PACKAGES}
+        set -e
+        uname -a
+        ./.ci/linux-cxx-install.sh
       displayName: Install
     - bash: |
-          set -e
-          cd src/engine
-          ./build.sh ${TOOLSET}
-          ./b2 -v
+        set -e
+        cd src/engine
+        ./build.sh ${TOOLSET} --cxx=${CXX}
+        ./b2 -v
       displayName: Build
     - bash: |
-          set -e
-          pushd ${HOME}
-          git clone -b boost-${BOOST_VERSION} --single-branch --recurse-submodules https://github.com/boostorg/boost.git boost_${BOOST_VERSION_U}
-          cd boost_${BOOST_VERSION_U}
-          CXX_PATH=`which ${CXX}`
-          echo "using ${TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
-          "${BUILD_SOURCESDIRECTORY}/src/engine/b2" "--boost-build=${BUILD_SOURCESDIRECTORY}/src" --debug-configuration --build-type=complete --layout=versioned -n -d1 toolset=${TOOLSET} install
-          popd
+        set -e
+        pushd ${HOME}
+        git clone --recursive https://github.com/boostorg/boost.git
+        cd boost
+        git checkout ${BOOST_BRANCH}
+        CXX_PATH=`which ${CXX}`
+        echo "using ${TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
+        "${BUILD_SOURCESDIRECTORY}/src/engine/b2" "--boost-build=${BUILD_SOURCESDIRECTORY}/src" --debug-configuration --build-type=complete --layout=versioned -n -d1 toolset=${TOOLSET} install
+        popd
       displayName: Test
 
-  - job: 'Dev_Linux'
-    displayName: 'Dev Linux'
+  - job: 'Dev_macOS'
+    displayName: 'Dev macOS'
     pool:
-      vmImage: 'ubuntu-latest'
+      vmImage: 'macOS-latest'
     strategy:
       matrix:
-        Master .. GCC 9:
-          BOOST_BRANCH: master
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        Master .. Clang 8:
-          BOOST_BRANCH: master
-          TOOLSET: clang
-          CXX: clang++-8
-          PACKAGES: clang-8
-          LLVM_REPO: llvm-toolchain-xenial-8
-        Develop .. GCC 9:
-          BOOST_BRANCH: develop
-          TOOLSET: gcc
-          CXX: g++-9
-          PACKAGES: g++-9
-        Develop .. Clang 8:
-          BOOST_BRANCH: develop
-          TOOLSET: clang
-          CXX: clang++-8
-          PACKAGES: clang-8
-          LLVM_REPO: llvm-toolchain-xenial-8
+        Master .. Xcode 11.7: {BOOST_BRANCH: master, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        Develop .. Xcode 11.7: {BOOST_BRANCH: develop, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
     steps:
     - bash: |
-          set -e
-          uname -a
-          sudo -E apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
-          if test -n "${LLVM_REPO}" ; then
-            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-            sudo -E apt-add-repository "deb http://apt.llvm.org/xenial/ ${LLVM_REPO} main"
-          fi
-          sudo -E apt-get -o Acquire::Retries=3 update
-          sudo -E apt-get -o Acquire::Retries=3 -yq --no-install-suggests --no-install-recommends install ${PACKAGES}
+        set -e
+        uname -a
+        sudo xcode-select -switch ${XCODE_APP}
+        which clang++
       displayName: Install
     - bash: |
-          set -e
-          cd src/engine
-          ./build.sh ${TOOLSET}
-          ./b2 -v
+        set -e
+        cd src/engine
+        ./build.sh ${TOOLSET} --cxx=${CXX}
+        ./b2 -v
       displayName: Build
     - bash: |
         set -e
@@ -459,65 +224,65 @@ stages:
         popd
       displayName: Test
 
-  - job: 'Release_macOS'
-    displayName: 'Release macOS'
+  - job: 'Dev_Windows'
+    displayName: 'Dev Windows'
     pool:
-      vmImage: 'macOS-latest'
+      vmImage: 'windows-latest'
+    strategy:
+      matrix:
+        Master .. VS 2019: {BOOST_BRANCH: master, TOOLSET: vc142}
+        Develop .. VS 2019: {BOOST_BRANCH: develop, TOOLSET: vc142}
+    steps:
+    - powershell: |
+        cd src/engine
+        $env:path += ';' + ${env:CXX_PATH}
+        cmd /c build.bat ${env:TOOLSET}
+        ./b2.exe -v
+        cd ../..
+      displayName: Build
+    - powershell: |
+        $env:HOME = "$env:HOMEDRIVE" + "$env:HOMEPATH"
+        cd "${env:HOME}"
+        git clone --recursive https://github.com/boostorg/boost.git
+        cd boost
+        $OriginalErrorActionPreference = $ErrorActionPreference
+        $ErrorActionPreference= 'silentlycontinue'
+        git checkout "${env:BOOST_BRANCH}"
+        $ErrorActionPreference = $OriginalErrorActionPreference
+        echo "using" "msvc" ";" > "${env:HOME}/user-config.jam"
+        & "${env:BUILD_SOURCESDIRECTORY}\src\engine\b2.exe" "--boost-build=${env:BUILD_SOURCESDIRECTORY}/src" --debug-configuration --build-type=complete --layout=versioned -n -d1 toolset=msvc install
+      displayName: Test
+
+- stage: Boost_Release
+  dependsOn: [Boost_Dev]
+  jobs:
+
+  - job: 'Release_Linux'
+    displayName: 'Release Linux'
+    pool:
+      vmImage: 'ubuntu-latest'
     strategy:
       matrix:
-        1.72.0 .. Xcode 11.3.1:
-          BOOST_VERSION: 1.72.0
-          BOOST_VERSION_U: 1_72_0
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
-        1.71.0 .. Xcode 11.3.1:
-          BOOST_VERSION: 1.71.0
-          BOOST_VERSION_U: 1_71_0
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
-        1.70.0 .. Xcode 11.3.1:
-          BOOST_VERSION: 1.70.0
-          BOOST_VERSION_U: 1_70_0
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
-        1.69.0 .. Xcode 11.3.1:
-          BOOST_VERSION: 1.69.0
-          BOOST_VERSION_U: 1_69_0
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
-        1.68.0 .. Xcode 11.3.1:
-          BOOST_VERSION: 1.68.0
-          BOOST_VERSION_U: 1_68_0
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.2.app
-        1.67.0 .. Xcode 11.3.1:
-          BOOST_VERSION: 1.67.0
-          BOOST_VERSION_U: 1_67_0
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
-        1.66.0 .. Xcode 11.3.1:
-          BOOST_VERSION: 1.66.0
-          BOOST_VERSION_U: 1_66_0
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
+        1.75.0 .. GCC 10: {BOOST_VERSION: 1.75.0, BOOST_VERSION_U: 1_75_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.74.0 .. GCC 10: {BOOST_VERSION: 1.74.0, BOOST_VERSION_U: 1_74_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.73.0 .. GCC 10: {BOOST_VERSION: 1.73.0, BOOST_VERSION_U: 1_73_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.72.0 .. GCC 10: {BOOST_VERSION: 1.72.0, BOOST_VERSION_U: 1_72_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.71.0 .. GCC 10: {BOOST_VERSION: 1.71.0, BOOST_VERSION_U: 1_71_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.70.0 .. GCC 10: {BOOST_VERSION: 1.70.0, BOOST_VERSION_U: 1_70_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.69.0 .. GCC 10: {BOOST_VERSION: 1.69.0, BOOST_VERSION_U: 1_69_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.68.0 .. GCC 10: {BOOST_VERSION: 1.68.0, BOOST_VERSION_U: 1_68_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.67.0 .. GCC 10: {BOOST_VERSION: 1.67.0, BOOST_VERSION_U: 1_67_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
+        1.66.0 .. GCC 10: {BOOST_VERSION: 1.66.0, BOOST_VERSION_U: 1_66_0, TOOLSET: gcc, CXX: g++-10, PACKAGES: g++-10}
     steps:
     - bash: |
         set -e
         uname -a
-        sudo xcode-select -switch ${XCODE_APP}
-        which clang++
+        ./.ci/linux-cxx-install.sh
       displayName: Install
     - bash: |
         set -e
         cd src/engine
-        ./build.sh ${TOOLSET}
+        ./build.sh ${TOOLSET} --cxx=${CXX}
         ./b2 -v
       displayName: Build
     - bash: |
@@ -531,22 +296,22 @@ stages:
         popd
       displayName: Test
 
-  - job: 'Dev_macOS'
-    displayName: 'Dev macOS'
+  - job: 'Release_macOS'
+    displayName: 'Release macOS'
     pool:
       vmImage: 'macOS-latest'
     strategy:
       matrix:
-        Master .. Xcode 11.3.1:
-          BOOST_BRANCH: master
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
-        Develop .. Xcode 11.3.1:
-          BOOST_BRANCH: develop
-          TOOLSET: clang
-          CXX: clang++
-          XCODE_APP: /Applications/Xcode_11.3.1.app
+        1.75.0 .. Xcode 11.7: {BOOST_VERSION: 1.75.0, BOOST_VERSION_U: 1_75_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.74.0 .. Xcode 11.7: {BOOST_VERSION: 1.74.0, BOOST_VERSION_U: 1_74_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.73.0 .. Xcode 11.7: {BOOST_VERSION: 1.73.0, BOOST_VERSION_U: 1_73_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.72.0 .. Xcode 11.7: {BOOST_VERSION: 1.72.0, BOOST_VERSION_U: 1_72_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.71.0 .. Xcode 11.7: {BOOST_VERSION: 1.71.0, BOOST_VERSION_U: 1_71_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.70.0 .. Xcode 11.7: {BOOST_VERSION: 1.70.0, BOOST_VERSION_U: 1_70_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.69.0 .. Xcode 11.7: {BOOST_VERSION: 1.69.0, BOOST_VERSION_U: 1_69_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.68.0 .. Xcode 11.7: {BOOST_VERSION: 1.68.0, BOOST_VERSION_U: 1_68_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.67.0 .. Xcode 11.7: {BOOST_VERSION: 1.67.0, BOOST_VERSION_U: 1_67_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
+        1.66.0 .. Xcode 11.7: {BOOST_VERSION: 1.66.0, BOOST_VERSION_U: 1_66_0, TOOLSET: clang, CXX: clang++, XCODE_APP: /Applications/Xcode_11.7.app}
     steps:
     - bash: |
         set -e
@@ -557,15 +322,14 @@ stages:
     - bash: |
         set -e
         cd src/engine
-        ./build.sh ${TOOLSET}
+        ./build.sh ${TOOLSET} --cxx=${CXX}
         ./b2 -v
       displayName: Build
     - bash: |
         set -e
         pushd ${HOME}
-        git clone --recursive https://github.com/boostorg/boost.git
-        cd boost
-        git checkout ${BOOST_BRANCH}
+        git clone -b boost-${BOOST_VERSION} --single-branch --recurse-submodules https://github.com/boostorg/boost.git boost_${BOOST_VERSION_U}
+        cd boost_${BOOST_VERSION_U}
         CXX_PATH=`which ${CXX}`
         echo "using ${TOOLSET} : : ${CXX_PATH} ;" > ${HOME}/user-config.jam
         "${BUILD_SOURCESDIRECTORY}/src/engine/b2" "--boost-build=${BUILD_SOURCESDIRECTORY}/src" --debug-configuration --build-type=complete --layout=versioned -n -d1 toolset=${TOOLSET} install
@@ -578,38 +342,16 @@ stages:
       vmImage: 'windows-latest'
     strategy:
       matrix:
-        1.73.0 .. VS 2019:
-          BOOST_VERSION: 1.73.0
-          BOOST_VERSION_U: 1_73_0
-          TOOLSET: vc142
-        1.72.0 .. VS 2019:
-          BOOST_VERSION: 1.72.0
-          BOOST_VERSION_U: 1_72_0
-          TOOLSET: vc142
-        1.71.0 .. VS 2019:
-          BOOST_VERSION: 1.71.0
-          BOOST_VERSION_U: 1_71_0
-          TOOLSET: vc142
-        1.70.0 .. VS 2019:
-          BOOST_VERSION: 1.70.0
-          BOOST_VERSION_U: 1_70_0
-          TOOLSET: vc142
-        1.69.0 .. VS 2019:
-          BOOST_VERSION: 1.69.0
-          BOOST_VERSION_U: 1_69_0
-          TOOLSET: vc142
-        1.68.0 .. VS 2019:
-          BOOST_VERSION: 1.68.0
-          BOOST_VERSION_U: 1_68_0
-          TOOLSET: vc142
-        1.67.0 .. VS 2019:
-          BOOST_VERSION: 1.67.0
-          BOOST_VERSION_U: 1_67_0
-          TOOLSET: vc142
-        1.66.0 .. VS 2019:
-          BOOST_VERSION: 1.66.0
-          BOOST_VERSION_U: 1_66_0
-          TOOLSET: vc142
+        1.75.0 .. VS 2019: {BOOST_VERSION: 1.75.0, BOOST_VERSION_U: 1_75_0, TOOLSET: vc142}
+        1.74.0 .. VS 2019: {BOOST_VERSION: 1.74.0, BOOST_VERSION_U: 1_74_0, TOOLSET: vc142}
+        1.73.0 .. VS 2019: {BOOST_VERSION: 1.73.0, BOOST_VERSION_U: 1_73_0, TOOLSET: vc142}
+        1.72.0 .. VS 2019: {BOOST_VERSION: 1.72.0, BOOST_VERSION_U: 1_72_0, TOOLSET: vc142}
+        1.71.0 .. VS 2019: {BOOST_VERSION: 1.71.0, BOOST_VERSION_U: 1_71_0, TOOLSET: vc142}
+        1.70.0 .. VS 2019: {BOOST_VERSION: 1.70.0, BOOST_VERSION_U: 1_70_0, TOOLSET: vc142}
+        1.69.0 .. VS 2019: {BOOST_VERSION: 1.69.0, BOOST_VERSION_U: 1_69_0, TOOLSET: vc142}
+        1.68.0 .. VS 2019: {BOOST_VERSION: 1.68.0, BOOST_VERSION_U: 1_68_0, TOOLSET: vc142}
+        1.67.0 .. VS 2019: {BOOST_VERSION: 1.67.0, BOOST_VERSION_U: 1_67_0, TOOLSET: vc142}
+        1.66.0 .. VS 2019: {BOOST_VERSION: 1.66.0, BOOST_VERSION_U: 1_66_0, TOOLSET: vc142}
     steps:
     - powershell: |
         cd src/engine
@@ -627,51 +369,19 @@ stages:
         & "${env:BUILD_SOURCESDIRECTORY}\src\engine\b2.exe" "--boost-build=${env:BUILD_SOURCESDIRECTORY}/src" --debug-configuration --build-type=complete --layout=versioned -n -d1 toolset=msvc install
       displayName: Test
 
-  - job: 'Dev_Windows'
-    displayName: 'Dev Windows'
-    pool:
-      vmImage: 'windows-latest'
-    strategy:
-      matrix:
-        Master .. VS 2019:
-          BOOST_BRANCH: master
-          TOOLSET: vc142
-        Develop .. VS 2019:
-          BOOST_BRANCH: develop
-          TOOLSET: vc142
-    steps:
-    - powershell: |
-        cd src/engine
-        $env:path += ';' + ${env:CXX_PATH}
-        cmd /c build.bat ${env:TOOLSET}
-        ./b2.exe -v
-        cd ../..
-      displayName: Build
-    - powershell: |
-        $env:HOME = "$env:HOMEDRIVE" + "$env:HOMEPATH"
-        cd "${env:HOME}"
-        git clone --recursive https://github.com/boostorg/boost.git
-        cd boost
-        $OriginalErrorActionPreference = $ErrorActionPreference
-        $ErrorActionPreference= 'silentlycontinue'
-        git checkout "${env:BOOST_BRANCH}"
-        $ErrorActionPreference = $OriginalErrorActionPreference
-        echo "using" "msvc" ";" > "${env:HOME}/user-config.jam"
-        & "${env:BUILD_SOURCESDIRECTORY}\src\engine\b2.exe" "--boost-build=${env:BUILD_SOURCESDIRECTORY}/src" --debug-configuration --build-type=complete --layout=versioned -n -d1 toolset=msvc install
-      displayName: Test
-
-- stage: WebsiteUpdate
+- stage: Website_Update
+  dependsOn: [Core]
   displayName: 'Website Update'
   condition: in(variables['Build.SourceBranch'], 'refs/heads/master', 'refs/heads/develop')
   jobs:
 
   - job: Documentation
     pool:
-      vmImage: 'ubuntu-16.04'
+      vmImage: 'ubuntu-latest'
     steps:
     - task: UsePythonVersion@0
       inputs:
-        versionSpec: '2.x'
+        versionSpec: '3.x'
     - task: UseRubyVersion@0
     - bash: |
         pip install --user Pygments
diff --git a/bootstrap.sh b/bootstrap.sh
index 37bc9502f6..b0b22f2e95 100755
--- a/bootstrap.sh
+++ b/bootstrap.sh
@@ -10,7 +10,7 @@
 # Build b2
 echo "Building the B2 engine.."
 pwd=`pwd`
-( cd "./src/engine" && ./build.sh "$*" )
+"${pwd}/src/engine/build.sh" "$*"
 if [ $? -ne 0 ]; then
     echo
     echo "Failed to build the B2 engine." 1>&2
diff --git a/doc/jamfile.jam b/doc/jamfile.jam
index 2583d3f02a..579650ca58 100644
--- a/doc/jamfile.jam
+++ b/doc/jamfile.jam
@@ -35,6 +35,7 @@ project b2doc
     ;
 
 path-constant PYGMENTS_DIR : src/pygments ;
+path-constant STYLES_DIR : src/styles ;
 
 doc-dir = [ MATCH "--doc-dir=(.*)" : [ modules.peek : ARGV ] ] ;
 doc-dir ?= html ;
@@ -56,12 +57,28 @@ html index : src/standalone.adoc :
         <flags>--trace
         <flags>--verbose
         <dependency>$(PYGMENTS_DIR)/pygments_init.rb
+        # <flags>"-a stylesheet=amber.css"
+        # <flags>"-a stylesdir=$(STYLES_DIR)"
+        # <asciidoctor-attribute>linkcss
     ;
 explicit index ;
 
 install html : index : <location>$(doc-dir) <dependency>website-html ;
 explicit html ;
 
+make index.html : : @make_redir_html : <location>.. ;
+REDIR_HTML = "
+<html><head><meta http-equiv=\"refresh\" content=\"0; URL=doc/html/index.html\"></head><body>
+Automatic redirection failed, please go to <a href=\"doc/html/index.html\">doc/html/index.html</a>.
+<!-- 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\) -->
+</body></html>
+" ;
+actions make_redir_html
+{
+    echo @($(<):O=F:E=$(REDIR_HTML))
+}
+explicit index.html ;
+
 alias standalone-html : html ;
 
 if $(website)
@@ -117,5 +134,5 @@ actions website-publish
 alias boostdoc ;
 explicit boostdoc ;
 
-alias boostrelease : standalone-html ;
+alias boostrelease : standalone-html index.html ;
 explicit boostrelease ;
diff --git a/doc/src/bjam.adoc b/doc/src/bjam.adoc
index 2404c20dbc..5505f05dd0 100644
--- a/doc/src/bjam.adoc
+++ b/doc/src/bjam.adoc
@@ -59,209 +59,179 @@ The supported toolsets, and whether they are auto-detected, are:
 |===
 |Script |Platform |Toolset |Detection and Notes
 
-|`build.bat`
-|Windows NT, 2000, and XP
-|http://www.codegear.com/downloads/free/cppbuilder[`borland`],
-http://www.borland.com/[Borland] {CPP}Builder (BCC 5.5)
+h|`build.bat` 3+h|Windows
+
+| | |`vc142`
 a|
-* Common install location: `C:\Borland\BCC55`
-* `BCC32.EXE` in `PATH`
+Microsoft Visual Studio {CPP} 2019
 
-| | |http://www.comeaucomputing.com/[`como`], Comeau Computing C/{CPP} |
+* Uses `vswhere` utility.
 
-| | |http://gcc.gnu.org/[`gcc`], GNU GCC |
+| | |`vc141`
+a|
+Microsoft Visual Studio {CPP} 2017
 
-| | |http://gcc.gnu.org/[`gcc-nocygwin`], GNU GCC |
+* Uses `vswhere` utility.
+* Common install location: `%ProgramFiles%\Microsoft Visual Studio\2017\Enterprise\VC\`
+* Common install location: `%ProgramFiles%\Microsoft Visual Studio\2017\Professional\VC\`
+* Common install location: `%ProgramFiles%\Microsoft Visual Studio\2017\Community\VC\`
 
-| |
-|http://www.intel.com/software/products/compilers/c60[`intel-win32`],
-Intel {CPP} Compiler for Windows
+| | |`vc14`
 a|
-* `ICL.EXE` in `PATH`
+Microsoft Visual Studio {CPP} 2015
 
-| | |http://www.metrowerks.com/[`metrowerks`], MetroWerks CodeWarrior
-C/{CPP} 7.x, 8.x, 9.x
-a|
-* `CWFolder` variable configured
-* `MWCC.EXE` in PATH
+* Env var `%VS140COMNTOOLS%`
+* Common install location: `%ProgramFiles%\Microsoft Visual Studio 14.0\VC\`
 
-| | |http://www.mingw.org/[`mingw`], GNU http://gcc.gnu.org/[GCC] as the
-http://www.mingw.org/[MinGW] configuration
+| | |`vc12`
 a|
-* Common install location: `C:\MinGW`
+Microsoft Visual Studio {CPP} 2013
 
-| | |http://msdn.microsoft.com/visualc/[`msvc`], Microsoft Visual {CPP}
-6.x
+* Env var `%VS120COMNTOOLS%`
+* Common install location: `%ProgramFiles%\Microsoft Visual Studio 12.0\VC\`
+
+| | |`borland`
 a|
-* `VCVARS32.BAT` already configured
-* `%MSVCDir%` is present in environment
-* Common install locations: `%ProgramFiles%\Microsoft Visual Studio`,
-`%ProgramFiles%\Microsoft Visual {CPP}`
-* `CL.EXE` in `PATH`
+Embarcadero {CPP}Builder
+
+* `bcc32c.exe` in `PATH`
 
-| | |http://msdn.microsoft.com/visualc/[`vc7`], Microsoft Visual {CPP} 7.x
+| |
+|`intel-win32`
 a|
-* `VCVARS32.BAT` or `VSVARS32.BAT` already configured
-* `%VS71COMNTOOLS%` is present in environment
-* `%VCINSTALLDIR%` is present in environment
-* Common install locations: `%ProgramFiles%\Microsoft Visual Studio .NET`,
-  `%ProgramFiles%\Microsoft Visual Studio .NET 2003`
-* `CL.EXE` in `PATH`
-
-| | |http://msdn.microsoft.com/visualc/[`vc8` and `vc9`], Microsoft
-Visual {CPP} 8.x and 9.x
+Intel {CPP} Compiler for Windows
+
+* `icl.exe` in `PATH`
+
+| | |`mingw`
 a|
-Detection:
+GNU GCC as the MinGW configuration
 
-* `VCVARSALL.BAT` already configured
-* `%VS90COMNTOOLS%` is present in environment
-* Common install location: `%ProgramFiles%\Microsoft Visual Studio 9`
-* `%VS80COMNTOOLS%` is present in environment
-* Common install location: `%ProgramFiles%\Microsoft Visual Studio 8`
-* `CL.EXE` in `PATH`
+* Common install location: `C:\MinGW`
 
-Notes:
+| | |`como` | Comeau Computing C/{CPP}
 
-* If `VCVARSALL.BAT`
-is called to set up the toolset, it is passed all the extra arguments,
-see below for what those arguments are. This can be used to build, for
-example, a Win64 specific version of `b2`. Consult the VisualStudio
-documentation for what the possible argument values to the `VCVARSALL.BAT`
-are.
+| | |`gcc`, | GNU GCC
 
-|`build.sh` |Unix, Linux, Cygwin, etc. |http://www.hp.com/go/c++[`acc`],
-HP-UX aCC
+| | |`clang` | Clang LLVM
+
+| | |`gcc-nocygwin` | GNU GCC
+
+h|`build.sh` 3+h|Unix, Linux, Cygwin, Windows Bash, etc.
+
+| | |`gcc`
 a|
-* `aCC` in `PATH`
-* `uname` is "HP-UX"
+GNU GCC
+
+* `g++` in `PATH`
 
-| | |http://www.comeaucomputing.com/[`como`], Comeau Computing C/{CPP}
+| | |`clang`
 a|
-* `como` in `PATH`
+Clang LLVM
 
-| | |http://gcc.gnu.org/[`gcc`], GNU GCC
+* `clang++` in `PATH`
+
+| | |`intel-linux`
 a|
-* `gcc` in `PATH`
+Intel {CPP} (oneAPI) for Linux
+
+* `icpx` in `PATH`
+* `icc` in `PATH`
+* `icpc` in `PATH`
+* `setvars.sh` in common install locations: `$HOME/intel/oneapi`,
+  `/opt/intel/oneapi`, `/opt/intel/inteloneapi`
+* `iccvars.sh` in common install locations: `/opt/intel/cc/9.0/bin`,
+  `/opt/intel_cc_80/bin`
 
 | |
-|http://www.intel.com/software/products/compilers/c60l/[`intel-linux`],
-Intel {CPP} for Linux
+|`mipspro`
 a|
-* `icc` in `PATH`
-* Common install locations: `/opt/intel/cc/9.0`, `/opt/intel_cc_80`,
-  `/opt/intel/compiler70`, `/opt/intel/compiler60`, `/opt/intel/compiler50`
+SGI MIPSpro {CPP}
+
+* `uname` is "IRIX" or "IRIX64" and `CC` in `PATH`
 
-| | |`kcc`, Intel KAI {CPP}
+| | |`true64cxx`
 a|
-* `KCC` in `PATH`
+Compaq {CPP} Compiler for True64 UNIX
 
-| | |http://www.codegear.com/downloads/free/cppbuilder[`kylix`],
-http://www.borland.com/[Borland] {CPP}Builder
+* `uname` is "OSF1" and `cc` in `PATH`
+
+| | |`qcc`
 a|
-* `bc++` in `PATH`
+QNX Neutrino
 
-| |
-|http://www.sgi.com/developers/devtools/languages/mipspro.html[`mipspro`],
-SGI MIPSpro C
+* `uname` is "QNX" and `QCC` in `PATH`
+
+| | |`xlcpp` and `vacpp`
 a|
-* `uname` is "IRIX" or "IRIX64"
+IBM VisualAge {CPP}
 
-| | |`sunpro`, Sun Workshop 6 {CPP}
+* `uname` is "Linux" and `xlC_r` in `PATH` (`xlcpp` or `vacpp` depending on
+  machine endian)
+* `uname` is "AIX" and `xlC_r` in `PATH` (`vacpp`)
+
+| | |`pgi`
 a|
-* Standard install location: `/opt/SUNWspro`
+PGI Compilers
+
+* `pgc++` in `PATH`
 
-| | |`qcc`, http://www.qnx.com/[QNX Neutrino]
+| | |`pathscale`
 a|
-* `uname` is "QNX" and `qcc` in `PATH`
+Pathscale {CPP}
+
+* `pathCC` in `PATH`
 
-| | |http://www.tru64unix.compaq.com/cplus/[`true64cxx`], Compaq {CPP}
-Compiler for True64 UNIX
+| | |`como`
 a|
-* `uname` is "OSF1"
+Comeau Computing C/{CPP}
+
+* `como` in `PATH`
 
-| | |http://www.ibm.com/software/awdtools/vacpp/[`vacpp`], IBM VisualAge
-{CPP}
+| | |`kylix`
 a|
-* `xlc` in `PATH`
+Borland {CPP}
 
-| |MacOS X |http://developer.apple.com/tools/compilers.html[`darwin`],
-Apple MacOS X GCC
+* `bc++` in `PATH` (`kylix`)
+
+| | |`acc`
 a|
-* `uname` is "Darwin"
+HP-UX aCC
+
+* `aCC` in `PATH`
 
-| |Windows NT, 2000, and XP |http://www.mingw.org/[`mingw`], GNU
-http://gcc.gnu.org/[GCC] as the http://www.mingw.org/[MinGW]
-configuration with the MSYS shell
+| | |`sunpro`
 a|
-* Common install location: `/mingw`
+Sun Workshop 6 {CPP}
 
-|===
+* Standard install location: `/opt/SUNWspro/bin/CC`
 
-The built executables are placed in a subdirectory specific to your
-platform. For example, in Linux running on an Intel x86 compatible chip,
-the executables are placed in: `bin.linuxx86`. The `b2[.exe]`
-executable can be used to invoke B2.
+|===
 
-The build scripts support additional invocation arguments for use by
-developers of Boost.Jam and for additional setup of the toolset. The
-extra arguments come after the toolset:
+The built executables are placed in the `src/engine` directory.
 
-* Arguments not in the form of an option, before option arguments, are
-used for extra setup to toolset configuration scripts.
-* Arguments of the form `--option`, which are passed to the
-`build.jam` build script.
-* Arguments not in the form of an option, after the options, which are
-targets for the `build.jam` script.
+The `build.sh` script supports additional invocation options used to
+control the the build and custom compilers:
 
 ----
-build [toolset] [setup*] [--option+ target*]
+build.sh [--option|--option=x] [toolset]
 ----
 
-The arguments immediately after the toolset are passed directly to the
-setup script of the toolset, if available and if it needs to be invoked.
-This allows one to configure the toolset ass needed to do non-default
-builds of `b2`. For example to build a Win64 version with `vc8`. See the
-toolset description above for when particular toolsets support this.
-
-The arguments starting with the `--option` forms are passed to the
-`build.jam` script and are used to further customize what gets built.
-Options and targets supported by the `build.jam` script:
-
-`---`::
-  Empty option when one wants to only specify a target.
-`--release`::
-  The default, builds the optimized executable.
+`--help`::
+  Shows some help information, including these options.
+`--verbose`::
+  Show messages about what this script is doing.
 `--debug`::
-  Builds debugging versions of the executable. When built they are
-  placed in their own directory `bin./platform/.debug`.
-`--grammar`::
-  Normally the Jam language grammar parsing files are not regenerated.
-  This forces building of the grammar, although it may not force the
-  regeneration of the grammar parser. If the parser is out of date it
-  will be regenerated and subsequently built.
-`--with-python=path`::
-  Enables Python integration, given a path to the Python libraries.
-`--gc`::
-  Enables use of the Boehm Garbage Collector. The build will look for
-  the Boehm-GC source in a "boehm_gc" subdirectory from the `b2`
-  sources.
-`--duma`::
-  Enables use of the DUMA (Detect Unintended Memory Access) debugging
-  memory allocator. The build expects to find the DUMA source files in a
-  "duma" subdirectory from the `b2` sources.
-`--toolset-root=path`::
-  Indicates where the toolset used to build is located. This option is
-  passed in by the bootstrap (`build.bat` or `build.sh`) script.
-`--show-locate-target`::
-  For information, prints out where it will put the built executable.
-`--noassert`::
-  Disable debug assertions, even if building the debug version of the
-  executable.
-`dist`::
-  Generate packages (compressed archives) as appropriate for
-  distribution in the platform, if possible.
-`clean`::
-  Remove all the built executables and objects.
+  Builds debugging versions of the executable. The default is to build an
+  optimized executable.
+`--guess-toolset`::
+  Print the toolset we can detect for building. This is used by external
+  scripts, like the Boost Libraries main bootstrap script.
+`--cxx=CXX`::
+  The compiler exec to use instead of the detected compiler exec.
+`--cxxflags=CXXFLAGS`::
+  The compiler flags to use in addition to the flags for the detected
+  compiler.
 
 [[jam.language]]
 == Language
@@ -1355,8 +1325,20 @@ Assign _value_ to the variable if it is unset.
 Concatenate list elements into single element, separated by
 _joinval_.
 
+`:O=value`::
+Sets semantic options for the evaluation of the variable. The format of the
+_value_ is specific to either variable or generated file expansion.
+
 On VMS, `$(var:P)` is the parent directory of `$(var:D)`.
 
+`:<=value`::
+After evaluating the expansion of the variable prefixes the given _value_
+to the elements of the expanded expression values.
+
+`:>=value`::
+After evaluating the expansion of the variable postfixes the given _value_
+to the elements of the expanded expression values.
+
 [[jam.language.variables.local_for_loop_variables]]
 ==== Local For Loop Variables
 
@@ -1383,7 +1365,22 @@ the form `@(filename:E=filecontents)` and replaces the expression with
 `filecontents`. This is useful for creating compiler response files, and
 other "internal" files. The expansion works both during parsing and
 action execution. Hence it is possible to create files during any of the
-three build phases.
+three build phases. This expansion follows the same modifiers as variable
+expansion. The generated file expansion accepts these (`:O=`) expansion
+option values:
+
+`F`::
+Always replace the `@()` reference with the name of the file generated.
+
+`C`::
+Always replace the `@()` reference with the contents, i.e. the _value_
+in the `:E=value` expression.
+
+`FC` or `CF`::
+Replace with either the file or contents depending on the length of the
+contents (`:E=value`). It will replace with the contents in an action
+if the length of the command is shorter than the allowed command length
+limit. Otherwise the reference is replaced with the filename.
 
 [[jam.language.variables.builtins]]
 ==== Built-in Variables
diff --git a/doc/src/history.adoc b/doc/src/history.adoc
index 68105bad45..1d6e16299d 100644
--- a/doc/src/history.adoc
+++ b/doc/src/history.adoc
@@ -1,6 +1,75 @@
 [[b2.history]]
 = History
 
+== Version 4.4.1
+
+Minor patch to correct missing fix for macOS default engine compiler.
+
+* Fix engine build defaulting to gcc instead of clang on macOX/Xcode.
+  -- _René Ferdinand Rivera Morell_
+
+== Version 4.4.0
+
+Along with a variety of fixes this version introduces "dynamic" response file
+support for some toolsets. This means that under most circumtances, if
+supported by the toolset, response files are not generated. Instead the
+command is expanded to include the options directly.
+
+* *New:* Add `response-file` feature to control the kind of response file usage in
+  toolset action.
+  -- _René Ferdinand Rivera Morell_
+* *New:* Add `:O=value` variable modifier for `@()` expansion.
+  -- _René Ferdinand Rivera Morell_
+* *New:* Add `:<=value` and `:>=value` variable modifiers for prefix and postfix
+  values *after* the complete expansion of variable references.
+  -- _René Ferdinand Rivera Morell_
+* *New:* Implement PCH on clang-win and clang-darwin.
+  -- _Nikita Kniazev_
+* *New:* Add support for Intel oneAPI release to intel-linux toolset.
+  -- _René Ferdinand Rivera Morell_
+* *New:* Add support for Intel oneAPI release to intel-windows toolset.
+  -- _Edward Diener_
+* Remove one at time linking limit. Once upon a time this was a performance
+  tweak as hardware and software was not up to doing multiple links at once.
+  Common setups are better equipped.
+  -- _René Ferdinand Rivera Morell_
+* Fix building engine with GCC on AIX.
+  -- _René Ferdinand Rivera Morell_
+* Support building engine as either 32 or 64 bit addressing model.
+  -- _René Ferdinand Rivera Morell_
+* Basic support for building b2 engine on GNU/Hurd.
+  -- _Pino Toscano_
+* Update "borland" toolset to bcc32c for building B2.
+  -- _Tanzinul Islam_
+* Ensure Embarcadero toolset name is only "embtc".
+  -- _Tanzinul Islam_
+* Adapt for Emscripten 2.0 change of default behaviour for archives.
+  -- _Basil Fierz_
+* Fix path to bootstrap for back compat.
+  -- _René Ferdinand Rivera Morell_
+* Add missing BOOST_ROOT to boot strap search.
+  -- _René Ferdinand Rivera Morell_
+* Fix for engine compile on FreeBSD.
+  -- _René Ferdinand Rivera Morell_
+* Default MSVC to a native platform, and remove ambiguous implicit
+  address-model ARM/ARM64 values.
+  -- _Nikita Kniazev_
+* Fix detection of MIPS32 for b2 engine build.
+  -- _Ivan Melnikov_
+* Enable building b2 engine with clang on Windows.
+  -- _Gei0r_
+* Fix building b2 engine with Intel Linux icpc.
+  -- _Alain Miniussi_
+* Rework `build.sh` to fix many bugs and to avoid use of common env vars.
+  -- _René Ferdinand Rivera Morell_
+* Remove limitation of relevant features for configure checks.
+  -- _René Ferdinand Rivera Morell_
+* Reformat configure check output to inform the variants of the checks in a
+  reasonably brief form.
+  -- _René Ferdinand Rivera Morell_
+* Support building engine on Windows Bash with Mingw.
+  -- _René Ferdinand Rivera Morell_
+
 == Version 4.3.0
 
 There are many invidual fixes in this release. Many thanks for the
diff --git a/doc/src/howto.adoc b/doc/src/howto.adoc
index 38a31f3c7c..4310f405d5 100644
--- a/doc/src/howto.adoc
+++ b/doc/src/howto.adoc
@@ -13,9 +13,3 @@ If there's anything you find unclear in this documentation, report the
 problem directly in the https://github.com/boostorg/build/issues[issue
 tracker]. For more general questions, please post them to our mailing
 list (http://boost.org/more/mailing_lists.htm#jamboost[]).
-
-****
-Copyright 2006, 2014 http://vladimirprus.com[Vladimir Prus]. 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)
-****
\ No newline at end of file
diff --git a/doc/src/reference.adoc b/doc/src/reference.adoc
index dc646d9dfd..15098317bd 100644
--- a/doc/src/reference.adoc
+++ b/doc/src/reference.adoc
@@ -277,6 +277,7 @@ include::../../src/tools/features/visibility-feature.jam[tag=doc]
 include::../../src/tools/features/warnings-feature.jam[tag=doc]
 include::../../src/tools/features/translate-path-feature.jam[tag=doc]
 include::../../src/tools/features/lto-feature.jam[tag=doc]
+include::../../src/tools/features/response-file-feature.jam[tag=doc]
 
 [[bbv2.reference.tools]]
 == Builtin tools
diff --git a/doc/src/standalone.adoc b/doc/src/standalone.adoc
index 9b7c0b4b1c..147dc2ec39 100644
--- a/doc/src/standalone.adoc
+++ b/doc/src/standalone.adoc
@@ -1,14 +1,17 @@
 = B2 User Manual
-:copyright: Copyright 2018 Rene Rivera; Copyright 2006, 2014 Vladimir Prus
-:author: Rene Rivera, Vladimir Prus, Steven Watanabe
+:copyright: Copyright 2018-2021 René Ferdinand Rivera Morell; Copyright 2006, 2014 Vladimir Prus
+:author: René Ferdinand Rivera Morell, Vladimir Prus, Steven Watanabe
 :toc: left
-:toclevels: 3
+:toclevels: 2
 :sectanchors:
 :sectnums:
 :nofooter:
+// :source-highlighter: rouge
 :source-highlighter: pygments
 :source-language: jam
 :highlightjsdir: hljs
+:pygments-style: native
+// :rouge-style: native
 :pygments-style: friendly
 :caution-caption: ⚑
 :important-caption: ‼
@@ -17,6 +20,8 @@
 :warning-caption: ⚠
 :CPP: C++
 
+== Introduction
+
 ifdef::backend-html5[]
 ++++
 <style>
@@ -27,6 +32,13 @@ endif::[]
 
 include::howto.adoc[]
 
+****
+Copyright 2018-2021 René Ferdinand Rivera Morell;
+Copyright 2006, 2014 Vladimir Prus.
+Distributed under the Boost Software License, Version 1.0. (See accompanying
+file `LICENSE.txt` or copy at http://www.boost.org/LICENSE_1_0.txt)
+****
+
 toc::[]
 
 :leveloffset: +1
diff --git a/doc/src/tutorial.adoc b/doc/src/tutorial.adoc
index 761fdb8538..ef9d0da82d 100644
--- a/doc/src/tutorial.adoc
+++ b/doc/src/tutorial.adoc
@@ -284,8 +284,8 @@ as-is to the compiler flags for `a.cpp`, but won't affect `foo`.
 
 Let's improve this project further. The library probably has some
 headers that must be used when compiling `app.cpp`. We could manually
-add the necessary `#include` paths to `app`'s requirements as values of
-the `<include>  ` feature, but then this work will be repeated for all
+add the necessary `#include` paths to the `app` requirements as values of
+the `<include>` feature, but then this work will be repeated for all
 programs that use `foo`. A better solution is to modify
 `util/foo/Jamfile` in this way:
 
diff --git a/src/build/ac.jam b/src/build/ac.jam
index 09eb26ea98..db02b72882 100644
--- a/src/build/ac.jam
+++ b/src/build/ac.jam
@@ -1,5 +1,6 @@
 # Copyright (c) 2010 Vladimir Prus.
 # Copyright (c) 2013 Steven Watanabe
+# Copyright (c) 2021 Rene Ferdinand Rivera Morell
 #
 # Use, modification and distribution is subject to the Boost Software
 # License Version 1.0. (See accompanying file LICENSE_1_0.txt or
@@ -227,6 +228,7 @@ class ac-library : basic-target
 
             local relevant = [ property.select [ configure.get-relevant-features ] <link> :
                 [ $(property-set).raw ] ] ;
+            local min = [ property.as-path [ SORT [ feature.minimize $(relevant) ] ] ] ;
 
             local key = ac-library-$(name)-$(relevant:J=-) ;
             local lookup = [ config-cache.get $(key) ] ;
@@ -235,7 +237,7 @@ class ac-library : basic-target
             {
                 if $(lookup) = missing
                 {
-                    configure.log-library-search-result $(name) : "no  (cached)" ;
+                    configure.log-library-search-result $(name) : "no  (cached)" $(min) ;
                     return [ property-set.empty ] ;
                 }
                 else
@@ -247,7 +249,7 @@ class ac-library : basic-target
                     }
                     local library = [ ac.construct-library $(lookup[2]) :
                         [ $(property-set).refine [ property-set.create $(lookup[3]) ] ] : $(library-path) ] ;
-                    configure.log-library-search-result $(name) : "yes (cached)" ;
+                    configure.log-library-search-result $(name) : "yes (cached)" $(min) ;
                     return [ $(library[1]).add-raw <include>$(includes) ] $(library[2-]) ;
                 }
             }
@@ -264,13 +266,13 @@ class ac-library : basic-target
                     }
                     library = [ ac.construct-library $(library[1]) :
                         [ $(property-set).refine [ property-set.create $(library[2]) ] ]  : $(library-path) ] ;
-                    configure.log-library-search-result $(name) : "yes" ;
+                    configure.log-library-search-result $(name) : "yes" $(min) ;
                     return [ $(library[1]).add-raw <include>$(includes) ] $(library[2-]) ;
                 }
                 else
                 {
                     config-cache.set $(key) : missing ;
-                    configure.log-library-search-result $(name) : "no" ;
+                    configure.log-library-search-result $(name) : "no" $(min) ;
                     return [ property-set.empty ] ;
                 }
             }
diff --git a/src/build/configure.jam b/src/build/configure.jam
index 646b05a035..e1541b3447 100644
--- a/src/build/configure.jam
+++ b/src/build/configure.jam
@@ -1,5 +1,5 @@
 # Copyright (c) 2010 Vladimir Prus.
-# Copyright 2017 Rene Rivera.
+# Copyright 2017-2021 Rene Ferdinand Rivera Morell
 #
 # Use, modification and distribution is subject to the Boost Software
 # License Version 1.0. (See accompanying file LICENSE_1_0.txt or
@@ -27,23 +27,6 @@ import utility ;
 import virtual-target ;
 
 
-# The configure feature allows external definition of what features are
-# relevant for doing configuration builds. One can add additional relevant
-# features by using:
-#
-#   import feature ;
-#   import configure ;
-#   feature.compose <configure> : <threading> ;
-#
-feature.feature configure : : composite optional ;
-
-# This is the initial set of relevant features. Note that subfeature of all
-# relevant features are also considered relevant.
-#
-feature.compose <configure> :
-    <target-os> <toolset> <address-model> <architecture> <cxxstd> ;
-
-
 rule log-summary ( )
 {
 }
@@ -83,7 +66,12 @@ rule log-component-configuration ( component : message )
 }
 
 
-rule log-check-result ( result )
+.variant_index = 0 ;
+.nl = "\n" ;
+
+.check_notes = ;
+
+rule log-check-result ( result variant ? )
 {
     if ! $(.announced-checks)
     {
@@ -91,16 +79,35 @@ rule log-check-result ( result )
         .announced-checks = 1 ;
     }
 
+    if $(variant)
+    {
+        if $(.variant_index.$(variant))
+        {
+            result = "$(result) [$(.variant_index.$(variant))]" ;
+        }
+        else
+        {
+            .variant_index = [ CALC $(.variant_index) + 1 ] ;
+            .variant_index.$(variant) = $(.variant_index) ;
+            result = "$(result) [$(.variant_index.$(variant))]" ;
+            .check_notes += "[$(.variant_index.$(variant))] $(variant)" ;
+        }
+    }
+    # else
+    # {
+    #     result = "$(result) [?]" ;
+    # }
+
     ECHO $(result) ;
     # FIXME: Unfinished code. Nothing seems to set .check-results at the moment.
     #.check-results += $(result) ;
 }
 
 
-rule log-library-search-result ( library : result )
+rule log-library-search-result ( library : result variant ? )
 {
     local x = [ PAD "    - $(library)" : $(.width) ] ;
-    log-check-result "$(x) : $(result)" ;
+    log-check-result "$(x) : $(result)" $(variant) ;
 }
 
 
@@ -134,6 +141,12 @@ rule print-component-configuration ( )
 
 rule print-configure-checks-summary ( )
 {
+    if $(.check_notes)
+    {
+        ECHO ;
+        for local l in $(.check_notes) { ECHO $(l) ; }
+    }
+
     # FIXME: The problem with this approach is that the user sees the checks
     # summary when all checks are done, and has no progress reporting while the
     # checks are being executed.
@@ -173,9 +186,11 @@ rule maybe-force-rebuild ( targets * )
 # Attempts to build a set of virtual targets
 rule try-build ( targets * : ps : what : retry ? )
 {
-   local cache-name = $(what) [ $(ps).raw ] ;
-   cache-name = $(cache-name:J=-) ;
-   local value = [ config-cache.get $(cache-name) ] ;
+    local cache-props = [ $(ps).raw ] ;
+    local cache-name = $(what) $(cache-props) ;
+    cache-name = $(cache-name:J=-) ;
+    local value = [ config-cache.get $(cache-name) ] ;
+    local cache-min = [ property.as-path [ SORT [ feature.minimize $(cache-props) ] ] ] ;
 
     local result ;
     local jam-targets ;
@@ -187,18 +202,19 @@ rule try-build ( targets * : ps : what : retry ? )
         jam-targets += [ $(t).actualize ] ;
     }
 
+    local x ;
     if $(value)
     {
-        local x = [ PAD "    - $(what)" : $(.width) ] ;
+        x = [ PAD "    - $(what)" : $(.width) ] ;
         if $(value) = true
         {
             .$(what)-supported.$(ps) = yes ;
             result = true ;
-            log-check-result "$(x) : yes (cached)" ;
+            x = "$(x) : yes (cached)" ;
         }
         else
         {
-            log-check-result "$(x) : no  (cached)" ;
+            x = "$(x) : no  (cached)" ;
         }
     }
     else if ! UPDATE_NOW in [ RULENAMES ]
@@ -207,19 +223,23 @@ rule try-build ( targets * : ps : what : retry ? )
     }
     else
     {
-        local x = [ PAD "    - $(what)" : $(.width) ] ;
+        x = [ PAD "    - $(what)" : $(.width) ] ;
         if [ UPDATE_NOW $(jam-targets) :
              $(.log-fd) : ignore-minus-n : ignore-minus-q ]
         {
             .$(what)-supported.$(ps) = yes ;
             result = true ;
-            log-check-result "$(x) : yes" ;
+            x = "$(x) : yes" ;
         }
         else
         {
-            log-check-result "$(x) : no" ;
+            x = "$(x) : no" ;
         }
     }
+    if $(x)
+    {
+        log-check-result "$(x)" "$(cache-min:J= )" ;
+    }
     if ! $(value)
     {
         if $(result)
@@ -242,9 +262,11 @@ rule try-find-build ( ps : what : * )
     # The outer layer only needs to check $(what), but we
     # also need to check the individual elements, in case
     # the set of targets has changed since the last build.
-    local cache-name = $(what) $($(args)[1]) [ $(ps).raw ] ;
+    local cache-props = [ $(ps).raw ] ;
+    local cache-name = $(what) $($(args)[1]) $(cache-props) ;
     cache-name = $(cache-name:J=-) ;
     local value = [ config-cache.get $(cache-name) ] ;
+    local cache-min = [ property.as-path [ SORT [ feature.minimize $(cache-props) ] ] ] ;
 
     local result ;
     local jam-targets ;
@@ -271,7 +293,7 @@ rule try-find-build ( ps : what : * )
         local x = [ PAD "    - $(what)" : $(.width) ] ;
         local y = [ PAD $($(name)[1]) : 3 ] ;
         result = $(value) ;
-        log-check-result "$(x) : $(y) (cached)" ;
+        log-check-result "$(x) : $(y) (cached)" "$(cache-min:J= )" ;
     }
     else
     {
@@ -291,13 +313,13 @@ rule try-find-build ( ps : what : * )
                 $(.log-fd) : ignore-minus-n : ignore-minus-q ]
             {
                 result = [ CALC $(i) - 2 ] ;
-                log-check-result "$(x) : $($(i)[1])" ;
+                log-check-result "$(x) : $($(i)[1])" "$(cache-min:J= )" ;
                 break ;
             }
         }
         if ! $(result)
         {
-            log-check-result "$(x) : none" ;
+            log-check-result "$(x) : none" "$(cache-min:J= )" ;
             result = none ;
         }
     }
@@ -406,29 +428,20 @@ rule find-builds-raw ( project : ps : what : * )
     }
 }
 
-rule get-relevant-features ( )
+rule get-relevant-features ( properties * )
 {
-    local relevant = [ feature.expand <configure> ] ;
-    local result = ;
-    for local f in $(relevant)
-    {
-        if $(f) != <configure>
-        {
-            local sub = [ modules.peek feature : $(f).subfeatures ] ;
-            local name = [ utility.ungrist $(f) ] ;
-            result += $(f) <$(name)-$(sub)> ;
-        }
-    }
-    return $(result) ;
+    local ps-full = [ property-set.create $(properties) ] ;
+    local ps-base = [ property-set.create [ $(ps-full).base ] ] ;
+    local ps-min = [ feature.expand-subfeatures [ feature.minimize
+        [ $(ps-base).raw ] ] ] ;
+    local ps-relevant = [ property-set.create $(ps-min) ] ;
+
+    return [ $(ps-relevant).raw ] ;
 }
 
 rule builds ( metatarget-reference : properties * : what ? : retry ? )
 {
-    local toolset-subfeatures = [ modules.peek feature : <toolset>.subfeatures ] ;
-    toolset-subfeatures = <toolset-$(toolset-subfeatures)> ;
-    # FIXME: This should not be hardcoded. Other checks might want to consider a
-    # different set of features as relevant.
-    local relevant = [ property.select [ get-relevant-features ] : $(properties) ] ;
+    local relevant = [ get-relevant-features $(properties) ] ;
     local ps = [ property-set.create $(relevant) ] ;
     local t = [ targets.current ] ;
     local p = [ $(t).project ] ;
@@ -446,7 +459,7 @@ rule builds ( metatarget-reference : properties * : what ? : retry ? )
 
 rule find-builds ( what : properties * : * )
 {
-    local relevant = [ property.select [ get-relevant-features ] : $(properties) ] ;
+    local relevant = [ get-relevant-features $(properties) ] ;
     local ps = [ property-set.create $(relevant) ] ;
     local t = [ targets.current ] ;
     local p = [ $(t).project ] ;
@@ -594,8 +607,7 @@ rule check-target-builds ( target message ? : true-properties * :
     local rulename = [ indirect.make check : $(instance) ] ;
     return <conditional>@$(rulename)
         [ property.evaluate-conditional-relevance
-            $(true-properties) $(false-properties)
-          : [ configure.get-relevant-features ] ] ;
+            $(true-properties) $(false-properties) ] ;
 }
 
 # Usage:
@@ -612,8 +624,7 @@ rule choose ( message : * )
     local rulename = [ indirect.make check : $(instance) ] ;
     return <conditional>@$(rulename)
         [ property.evaluate-conditional-relevance
-            [ $(instance).all-properties ]
-          : [ configure.get-relevant-features ]  ] ;
+            [ $(instance).all-properties ] ] ;
 }
 
 
diff --git a/src/build/property-set.jam b/src/build/property-set.jam
index eea8bf6a36..e729f5792c 100644
--- a/src/build/property-set.jam
+++ b/src/build/property-set.jam
@@ -6,6 +6,7 @@
 
 import "class" : new ;
 import feature ;
+import indirect ;
 import path ;
 import project ;
 import property ;
@@ -549,8 +550,11 @@ rule refine-from-user-input ( parent-requirements : specification * :
                 $(remove-requirements) : $(project-module) $(location) ] ;
 
             parent-requirements = [ property-set.create
-                [ set.difference [ $(parent-requirements).raw ]
-                : [ $(ps).raw ] ] ] ;
+                [ set.difference
+                    [ indirect.difference
+                        [ $(parent-requirements).raw ] : [ $(ps).raw ] ]
+                    : [ $(ps).raw ]
+                ] ] ;
             specification = $(add-requirements) ;
         }
 
diff --git a/src/build/version.jam b/src/build/version.jam
index 14f22b0ec8..2aa8dcfef5 100644
--- a/src/build/version.jam
+++ b/src/build/version.jam
@@ -8,7 +8,7 @@ import numbers ;
 
 # Mirror engine JAM_VERSION
 .major = "4" ;
-.minor = "3" ;
+.minor = "4" ;
 
 
 rule boost-build ( )
diff --git a/src/engine/build.bat b/src/engine/build.bat
index 4360c31ccf..b466609b10 100644
--- a/src/engine/build.bat
+++ b/src/engine/build.bat
@@ -28,7 +28,7 @@ ECHO ### You can specify the toolset as the argument, i.e.:
 ECHO ###     .\build.bat msvc
 ECHO ###
 ECHO ### Toolsets supported by this script are: borland, como, gcc,
-ECHO ###     gcc-nocygwin, intel-win32, metrowerks, mingw,
+ECHO ###     gcc-nocygwin, intel-win32, mingw,
 ECHO ###     vc12, vc14, vc141, vc142
 ECHO ###
 ECHO ### If you have Visual Studio 2017 installed you will need to either update
diff --git a/src/engine/build.sh b/src/engine/build.sh
index 565a9c4a69..58f41cb4af 100755
--- a/src/engine/build.sh
+++ b/src/engine/build.sh
@@ -1,22 +1,56 @@
 #!/bin/sh
 
-#~ Copyright 2002-2019 Rene Rivera.
+#~ Copyright 2002-2020 Rene Rivera.
 #~ 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)
 
+FALSE=1
+TRUE=0
+
 # Reset the toolset.
 B2_TOOLSET=
-B2_OS=
+B2_SETUP=
+
+# Internal options.
+B2_VERBOSE_OPT=${B2_VERBOSE_OPT:=${FALSE}}
+B2_DEBUG_OPT=${B2_DEBUG_OPT:=${FALSE}}
+B2_GUESS_TOOLSET_OPT=${FALSE}
+B2_HELP_OPT=${FALSE}
+B2_CXX_OPT=
+B2_CXXFLAGS_OPT=
+
+# We need to calculate and set SCRIPT_PATH and SCRIPT_DIR to reference this
+# script so that we can refer to file relative to it.
+SCRIPT_PATH=""
+if test "${BASH_SOURCE}" ; then
+    SCRIPT_PATH=${BASH_SOURCE[0]}
+fi
+if test "${SCRIPT_PATH}" = "" ; then
+    SCRIPT_PATH=$0
+fi
+SCRIPT_DIR="$( cd "$( dirname "${SCRIPT_PATH}" )" && pwd )"
+
+# This script needs to operate at engine source directory.
+SAVED_PWD="${PWD}"
+cd "${SCRIPT_DIR}"
+
+test_true ()
+{
+    if test $1 -eq ${TRUE} ; then
+        return ${TRUE}
+    fi
+    return ${FALSE}
+}
 
 # Run a command, and echo before doing so. Also checks the exit status and quits
 # if there was an error.
 echo_run ()
 {
-    echo "> $@"
+    if test_true ${B2_VERBOSE_OPT} ; then echo "> $@" ; fi
     $@
     r=$?
-    if test $r -ne 0 ; then
+    if test $r -ne ${TRUE} ; then
         exit $r
     fi
 }
@@ -28,24 +62,31 @@ error_exit ()
 ${@}
 
 You can specify the toolset as the argument, i.e.:
-    ./build.sh gcc
+    ./build.sh [options] gcc
 
 Toolsets supported by this script are:
     acc, clang, como, gcc, intel-darwin, intel-linux, kcc, kylix, mipspro,
     pathscale, pgi, qcc, sun, sunpro, tru64cxx, vacpp
 
-For any toolset you can override the path to the compiler with the CXX
-environment variable. You can also use additional flags for the compiler
-with the CXXFLAGS environment variable.
+For any toolset you can override the path to the compiler with the '--cxx'
+option. You can also use additional flags for the compiler with the
+'--cxxflags' option.
 
 A special toolset; cxx, is available which is used as a fallback when a more
 specific toolset is not found and the cxx command is detected. The 'cxx'
-toolset will use the CXX, CXXFLAGS, and LIBS environment variables, if present.
+toolset will use the '--cxx' and '--cxxflags' options, if present.
+
+Options:
+    --help                  Show this help message.
+    --verbose               Show messages about what this script is doing.
+    --debug                 Build b2 with debug information, and no
+                            optimizations.
+    --guess-toolset         Print the toolset we can detect for building.
+    --cxx=CXX               The compiler exec to use instead of the detected
+                            compiler exec.
+    --cxxflags=CXXFLAGS     The compiler flags to use in addition to the
+                            flags for the detected compiler.
 
-Similarly, the cross-cxx toolset is available for cross-compiling by using the
-BUILD_CXX, BUILD_CXXFLAGS, and BUILD_LDFLAGS environment variables to compile
-binaries that will be executed on the build system. This allows CXX etc. to be
-set for cross-compilers to be propagated to subprocesses.
 " 1>&2
     exit 1
 }
@@ -68,429 +109,405 @@ test_uname ()
     fi
 }
 
-# Check that the given command runs.
-test_exec ()
+test_compiler ()
 {
-    "$*" 1>/dev/null 2>/dev/null
+    local EXE="${B2_CXX_OPT:-$1}"
+    local CMD
+    local SETUP
+    shift
+    CMD="${EXE} $@ ${B2_CXXFLAGS_OPT:-}"
+    SETUP=${B2_SETUP:-true}
+    if test_true ${B2_VERBOSE_OPT} ; then
+        echo "> ${CMD} check_cxx11.cpp"
+        ( ${SETUP} ; ${CMD} check_cxx11.cpp )
+    else
+        ( ${SETUP} ; ${CMD} check_cxx11.cpp ) 1>/dev/null 2>/dev/null
+    fi
+    local CHECK_RESULT=$?
+    if test_true ${CHECK_RESULT} ; then
+        B2_CXX=${CMD}
+    fi
+    rm -rf check_cxx11.o* a.out a.exe 1>/dev/null 2>/dev/null
+    return ${CHECK_RESULT}
 }
 
-# Check that the compiler can do C++11.
-test_cxx11 ()
+test_toolset ()
 {
-    if ! test $NO_CXX11_CHECK ; then
-        case $1 in
-            gcc) ( ${CXX:=g++} -x c++ -std=c++11 check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            intel-darwin) ( ${CXX:=icc} -xc++ check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            intel-linux) ( ${CXX:=icc} -xc++ check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            vacpp) ( ${CXX:=xlC_r} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            xlcpp) ( ${CXX:=xlC_r} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            como) ( ${CXX:=como} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            kcc) ( ${CXX:=KCC} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            kylix) ( ${CXX:=bc++} -tC -q check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            mipspro) ( ${CXX:=CC} -FE:template_in_elf_section -ptused check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            pathscale) ( ${CXX:=pathCC} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            pgi) ( ${CXX:=pgc++} -std=c++11 check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            sun*) ( ${CXX:=CC} -std=c++11 check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            clang*) ( ${CXX:=clang++} -x c++ -std=c++11 check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            tru64cxx) ( ${CXX:=cc} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            acc) ( ${CXX:=aCC} -AA check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            qcc) ( ${CXX:=QCC} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            cxx) ( ${CXX:=cxx} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            cross-cxx) ( ${CXX:=cxx} check_cxx11.cpp && rm -f a.out ) 1>/dev/null 2>/dev/null ;;
-            *) test "0" = "1" ;;
-        esac
-    else
-        test $NO_CXX11_CHECK
-    fi
+    if test "${B2_TOOLSET}" = "" ; then return ${TRUE} ; fi
+    if test "${B2_TOOLSET}" = "$1" -o "${B2_TOOLSET}" = "$2" -o "${B2_TOOLSET}" = "$3" ; then return ${TRUE} ; fi
+    return 1
 }
 
-# Try and guess the toolset to bootstrap the build with...
-guess_toolset ()
+# Check the toolset to bootstrap the build with. The one optional argument to
+# the function is a toolset name. This operates as follows based on these
+# contextual vars, if set, and if an arg is given:
+#
+# No vars set:
+#   Checks, in some priority order, possible toolset commands. Upon finding the
+#   first working command sets B2_TOOLSET to the toolset and B2_CXX to the
+#   compile command with any base options.
+#
+# B2_TOOLSET set:
+#   Checks that toolset for possible compile commands and sets B2_CXX to the
+#   command that works for the toolset.
+#
+check_toolset ()
 {
-    if test_uname Darwin && test_cxx11 clang ; then B2_TOOLSET=clang
-    elif test_uname IRIX && test_cxx11 mipspro ; then B2_TOOLSET=mipspro
-    elif test_uname IRIX64 && test_cxx11 mipspro ; then B2_TOOLSET=mipspro
-    elif test_uname OSF1 && test_cxx11 tru64cxx ; then B2_TOOLSET=tru64cxx
-    elif test_uname QNX && test_path QCC && test_cxx11 qcc ; then B2_TOOLSET=qcc
-    elif test_uname Linux && test_path xlC_r ; then
-       if /usr/bin/lscpu | grep Byte | grep Little > /dev/null 2>&1 ; then
-          # Little endian linux
-          B2_TOOLSET=xlcpp
-       else
-          #Big endian linux
-          B2_TOOLSET=vacpp
-       fi
-    elif test_uname AIX && test_path xlC_r && test_cxx11 vacpp ; then B2_TOOLSET=vacpp
-    elif test_uname FreeBSD && test_path freebsd-version && test_path clang++ && test_cxx11 clang ; then B2_TOOLSET=clang
-    elif test_path g++ && test_cxx11 gcc ; then B2_TOOLSET=gcc
-    elif test_path clang++ && test_cxx11 clang ; then B2_TOOLSET=clang
-    elif test_path icc && test_cxx11 intel-linux ; then B2_TOOLSET=intel-linux
-    elif test -r /opt/intel/cc/9.0/bin/iccvars.sh && test_cxx11 intel-linux ; then
-        B2_TOOLSET=intel-linux
-        B2_TOOLSET_ROOT=/opt/intel/cc/9.0
-    elif test -r /opt/intel_cc_80/bin/iccvars.sh && test_cxx11 intel-linux ; then
-        B2_TOOLSET=intel-linux
-        B2_TOOLSET_ROOT=/opt/intel_cc_80
-    elif test -r /opt/intel/compiler70/ia32/bin/iccvars.sh && test_cxx11 intel-linux ; then
-        B2_TOOLSET=intel-linux
-        B2_TOOLSET_ROOT=/opt/intel/compiler70/ia32/
-    elif test -r /opt/intel/compiler60/ia32/bin/iccvars.sh && test_cxx11 intel-linux ; then
-        B2_TOOLSET=intel-linux
-        B2_TOOLSET_ROOT=/opt/intel/compiler60/ia32/
-    elif test -r /opt/intel/compiler50/ia32/bin/iccvars.sh && test_cxx11 intel-linux ; then
-        B2_TOOLSET=intel-linux
-        B2_TOOLSET_ROOT=/opt/intel/compiler50/ia32/
-    elif test_path pgc++ && test_cxx11 pgi ; then B2_TOOLSET=pgi
-    elif test_path pathCC && test_cxx11 pathscale ; then B2_TOOLSET=pathscale
-    elif test_path como && test_cxx11 como ; then B2_TOOLSET=como
-    elif test_path KCC && test_cxx11 kcc ; then B2_TOOLSET=kcc
-    elif test_path bc++ && test_cxx11 kylix ; then B2_TOOLSET=kylix
-    elif test_path aCC && test_cxx11 acc ; then B2_TOOLSET=acc
-    elif test_uname HP-UX ; then B2_TOOLSET=acc
-    elif test -r /opt/SUNWspro/bin/cc && test_cxx11 sunpro ; then
-        B2_TOOLSET=sunpro
-        B2_TOOLSET_ROOT=/opt/SUNWspro/
-    # Test for some common compile command as the default fallback.
-    elif test_path $CXX ; then B2_TOOLSET=cxx
-    elif test_path cxx ; then
-        B2_TOOLSET=cxx
-        CXX=cxx
-    elif test_path cpp ; then
-        B2_TOOLSET=cxx
-        CXX=cpp
-    elif test_path CC ; then
-        B2_TOOLSET=cxx
-        CXX=CC
+    # Prefer Clang (clang) on macOS..
+    if test_toolset clang && test_uname Darwin && test_compiler clang++ -x c++ -std=c++11 ; then B2_TOOLSET=clang ; return ${TRUE} ; fi
+    # GCC (gcc)..
+    if test_toolset gcc && test_compiler g++ -x c++ -std=c++11 ; then B2_TOOLSET=gcc ; return ${TRUE} ; fi
+    # Clang (clang)..
+    if test_toolset clang && test_compiler clang++ -x c++ -std=c++11 ; then B2_TOOLSET=clang ; return ${TRUE} ; fi
+    # Intel macOS (intel-darwin)
+    if test_toolset intel-darwin && test -r "${HOME}/intel/oneapi/setvars.sh" && test_uname Darwin ; then
+        B2_SETUP="source ${HOME}/intel/oneapi/setvars.sh"
+        if test_toolset intel-darwin && test_compiler icpx -x c++ -std=c++11 ; then B2_TOOLSET=intel-darwin ; return ${TRUE} ; fi
+        if test_toolset intel-darwin && test_compiler icc -x c++ -std=c++11 ; then B2_TOOLSET=intel-darwin ; return ${TRUE} ; fi
+        B2_SETUP=
+    fi
+    if test_toolset intel-darwin && test -r "/opt/intel/oneapi/setvars.sh" && test_uname Darwin ; then
+        B2_SETUP="source /opt/intel/oneapi/setvars.sh"
+        if test_toolset intel-darwin && test_compiler icpx -x c++ -std=c++11 ; then B2_TOOLSET=intel-darwin ; return ${TRUE} ; fi
+        if test_toolset intel-darwin && test_compiler icc -x c++ -std=c++11 ; then B2_TOOLSET=intel-darwin ; return ${TRUE} ; fi
+        B2_SETUP=
+    fi
+    # Intel oneAPI (intel-linux)
+    if test_toolset intel-linux && test_path icpx ; then
+        if test_compiler icpx -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+    fi
+    if test_toolset xyz && test_path icc ; then
+        if test_compiler icc -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
     fi
-    if test "$B2_TOOLSET" = "" ; then
+    if test_toolset intel-linux && test -r "${HOME}/intel/oneapi/setvars.sh" ; then
+        B2_SETUP="source ${HOME}/intel/oneapi/setvars.sh"
+        if test_toolset intel-linux && test_compiler icpx -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+        if test_toolset intel-linux && test_compiler icc -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+        B2_SETUP=
+    fi
+    if test_toolset intel-linux && test -r "/opt/intel/oneapi/setvars.sh" ; then
+        B2_SETUP="source /opt/intel/oneapi/setvars.sh"
+        if test_toolset intel-linux && test_compiler icpx -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+        if test_toolset intel-linux && test_compiler icc -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+        B2_SETUP=
+    fi
+    # Intel Pro (intel-linux)
+    if test_toolset intel-linux && test_path icpc ; then
+        if test_compiler icpc -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+    fi
+    if test_toolset intel-linux && test -r "/opt/intel/inteloneapi/setvars.sh" ; then
+        B2_SETUP="source /opt/intel/inteloneapi/setvars.sh"
+        if test_compiler icpc -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+        B2_SETUP=
+    fi
+    if test_toolset intel-linux && test -r "/opt/intel/cc/9.0/bin/iccvars.sh" ; then
+        B2_SETUP="source /opt/intel/cc/9.0/bin/iccvars.sh"
+        if test_compiler icpc -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+        B2_SETUP=
+    fi
+    if test_toolset intel-linux && test -r "/opt/intel_cc_80/bin/iccvars.sh" ; then
+        B2_SETUP="source /opt/intel_cc_80/bin/iccvars.sh"
+        if test_compiler icpc -x c++ -std=c++11 ; then B2_TOOLSET=intel-linux ; return ${TRUE} ; fi
+        B2_SETUP=
+    fi
+    # Mips Pro (mipspro)
+    if test_toolset mipspro && test_uname IRIX && test_compiler CC -FE:template_in_elf_section -ptused ; then B2_TOOLSET=mipspro ; return ${TRUE} ; fi
+    if test_toolset mipspro && test_uname IRIX64 && test_compiler CC -FE:template_in_elf_section -ptused ; then B2_TOOLSET=mipspro ; return ${TRUE} ; fi
+    # OSF Tru64 C++ (tru64cxx)
+    if test_toolset tru64cxx && test_uname OSF1 && test_compiler cc ; then B2_TOOLSET=mipspro ; return ${TRUE} ; fi
+    # QNX (qcc)
+    if test_toolset qcc && test_uname QNX && test_compiler QCC ; then B2_TOOLSET=mipspro ; return ${TRUE} ; fi
+    # Linux XL/VA C++ (xlcpp, vacpp)
+    if test_toolset xlcpp vacpp && test_uname Linux && test_compiler xlC_r ; then
+        if /usr/bin/lscpu | grep Byte | grep Little > /dev/null 2>&1 ; then
+            # Little endian linux
+            B2_TOOLSET=xlcpp
+            return ${TRUE}
+        else
+            # Big endian linux
+            B2_TOOLSET=vacpp
+            return ${TRUE}
+        fi
+    fi
+    # AIX VA C++ (vacpp)
+    if test_toolset vacpp && test_uname AIX && test_compiler xlC_r ; then B2_TOOLSET=vacpp ; return ${TRUE} ; fi
+    # PGI (pgi)
+    if test_toolset pgi && test_compiler pgc++ -std=c++11 ; then B2_TOOLSET=pgi ; return ${TRUE} ; fi
+    # Pathscale C++ (pathscale)
+    if test_toolset pathscale && test_compiler pathCC ; then B2_TOOLSET=pathscale ; return ${TRUE} ; fi
+    # Como (como)
+    if test_toolset como && test_compiler como ; then B2_TOOLSET=como ; return ${TRUE} ; fi
+    # Borland C++ (kylix)
+    if test_toolset kylix && test_compiler bc++ -tC -q ; then B2_TOOLSET=kylix ; return ${TRUE} ; fi
+    # aCC (acc)
+    if test_toolset acc && test_compiler aCC -AA ; then B2_TOOLSET=acc ; return ${TRUE} ; fi
+    # Sun Pro C++ (sunpro)
+    if test_toolset sunpro && test_compiler /opt/SUNWspro/bin/CC -std=c++11 ; then B2_TOOLSET=sunpro ; return ${TRUE} ; fi
+    # Generic (cxx)
+    if test_toolset cxx && test_compiler cxx ; then B2_TOOLSET=cxx ; return ${TRUE} ; fi
+    if test_toolset cxx && test_compiler cpp ; then B2_TOOLSET=cxx ; return ${TRUE} ; fi
+    if test_toolset cxx && test_compiler CC ; then B2_TOOLSET=cxx ; return ${TRUE} ; fi
+
+    # Nothing found.
+    if test "${B2_TOOLSET}" = "" ; then
         error_exit "Could not find a suitable toolset."
     fi
+    return ${FALSE}
 }
 
-check_debug_build ()
-{
-    while test $# -gt 0
-    do
-        case "$1" in
-            --debug) return 0 ;;
-        esac
-        shift
-    done
-    return 1
-}
+# Handle command options and args.
+while test $# -gt 0
+do
+    case "$1" in
+        --verbose) B2_VERBOSE_OPT=${TRUE} ;;
+        --debug) B2_DEBUG_OPT=${TRUE} ;;
+        --guess-toolset) B2_GUESS_TOOLSET_OPT=${TRUE} ;;
+        --help) B2_HELP_OPT=${TRUE} ;;
+        --cxx=*) B2_CXX_OPT=`expr "x$1" : "x--cxx=\(.*\)"` ;;
+        --cxxflags=*) B2_CXXFLAGS_OPT=`expr "x$1" : "x--cxxflags=\(.*\)"` ;;
+        -*) ;;
+        ?*) B2_TOOLSET=$1 ;;
+    esac
+    shift
+done
+
+# Show some help, if requested.
+if test_true ${B2_HELP_OPT} ; then
+    error_exit
+fi
 
-# The one option we support in the invocation
-# is the name of the toolset to force building
-# with.
-case "$1" in
-    --guess-toolset) NO_CXX11_CHECK=1 ; guess_toolset ; echo "$B2_TOOLSET" ; exit 1 ;;
-    -*) guess_toolset ;;
-    ?*) B2_TOOLSET=$1 ; shift ;;
-    *) guess_toolset ;;
-esac
+# If we have a CXX but no B2_TOLSET specified by the user we assume they meant
+# "cxx" as the toolset.
+if test "${B2_CXX_OPT}" != "" -a "${B2_TOOLSET}" = "" ; then
+    B2_TOOLSET=cxx
+fi
 
-# We need a C++11 compiler. Check here and given some feedback about it.
-if ! test_cxx11 $B2_TOOLSET ; then
-    error_exit "
-A C++11 capable compiler is required for building the B2 engine.
-Toolset '$B2_TOOLSET' does not appear to support C++11.
+# Guess toolset, or toolset commands.
+check_toolset
+TOOLSET_CHECK=$?
 
+# We can bail from the rest of the checks and build if we are just guessing
+# the toolset.
+if test_true ${B2_GUESS_TOOLSET_OPT} ; then
+    echo "${B2_TOOLSET}"
+    exit 0
+fi
+
+# We need a viable compiler. Check here and give some feedback about it.
+if ! test_true ${TOOLSET_CHECK} ; then
+    echo "
+A C++11 capable compiler is required for building the B2 engine.
+Toolset '${B2_TOOLSET}' does not appear to support C++11.
+"
+    (B2_VERBOSE_OPT=${TRUE} check_toolset)
+    error_exit "
 ** Note, the C++11 capable compiler is _only_ required for building the B2
 ** engine. The B2 build system allows for using any C++ level and any other
 ** supported language and resource in your projects.
 "
 fi
 
-case $B2_TOOLSET in
+# Set the additional options needed to build the engine based on the toolset.
+case "${B2_TOOLSET}" in
 
     gcc)
-        CXX=${CXX:=g++}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        # Check whether it's MinGW GCC, which has Windows headers and none of POSIX ones.
-        machine=$(${CXX} -dumpmachine 2>/dev/null)
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
+        # Check for machine specific options.
+        machine=$(${B2_CXX} -dumpmachine 2>/dev/null)
         if test $? -ne 0 ; then
             echo "B2_TOOLSET is gcc, but the 'gcc' command cannot be executed."
             echo "Make sure 'gcc' is in PATH, or use a different toolset."
             exit 1
         fi
         case $machine in
-        *mingw*)
-        # MinGW insists that its bin directory be in PATH.
-        if test -r ${B2_TOOLSET_ROOT}bin/gcc ; then
-            export PATH=${B2_TOOLSET_ROOT}bin:$PATH
-        fi
-        B2_CXX="${CXX} -x c++ -std=c++11"
-        B2_CXXFLAGS_RELEASE="-O2 -s"
-        B2_CXXFLAGS_DEBUG="-O0 -g"
-        B2_OS="NT"
-        ;;
-
-        *cygwin*)
-        B2_CXX="${CXX} -x c++ -std=gnu++11"
-        B2_CXXFLAGS_RELEASE="-O2 -s"
-        B2_CXXFLAGS_DEBUG="-O0 -g"
-        ;;
-
-        *)
-        B2_CXX="${CXX} -x c++ -std=c++11"
+            *ibm-aix*)
+            # AIX needs threading option to use std::thread, it seems.
+            B2_CXX="${B2_CXX} -pthread"
+            ;;
+        esac
         B2_CXXFLAGS_RELEASE="-O2 -s"
         B2_CXXFLAGS_DEBUG="-O0 -g"
-        esac
-    ;;
-
-    intel-darwin)
-        CXX=${CXX:=icc}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX} -xc++"
-        B2_CXXFLAGS_RELEASE="-O3 -s"
-        B2_CXXFLAGS_DEBUG="-O0 -g -p"
     ;;
 
-    intel-linux)
-        CXX=${CXX:=icc}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        test_path ${CXX} >/dev/null 2>&1
-        if test $? ; then
-            echo "Found ${CXX} in environment"
-            B2_TOOLSET_ROOT=`echo ${CXX}| sed -e 's/bin.*\/icc//'`
-            # probably the most widespread
-            ARCH=intel64
-        else
-            echo "No intel compiler in current path"
-            echo "Look in a few old place for legacy reason"
-            if test -r /opt/intel/cc/9.0/bin/iccvars.sh ; then
-                B2_TOOLSET_ROOT=/opt/intel/cc/9.0/
-            elif test -r /opt/intel_cc_80/bin/iccvars.sh ; then
-                B2_TOOLSET_ROOT=/opt/intel_cc_80/
-            elif test -r /opt/intel/compiler70/ia32/bin/iccvars.sh ; then
-                B2_TOOLSET_ROOT=/opt/intel/compiler70/ia32/
-            elif test -r /opt/intel/compiler60/ia32/bin/iccvars.sh ; then
-                B2_TOOLSET_ROOT=/opt/intel/compiler60/ia32/
-            elif test -r /opt/intel/compiler50/ia32/bin/iccvars.sh ; then
-                B2_TOOLSET_ROOT=/opt/intel/compiler50/ia32/
-            fi
-        fi
-        if test -r ${B2_TOOLSET_ROOT}bin/iccvars.sh ; then
-            # iccvars does not change LD_RUN_PATH. We adjust LD_RUN_PATH here in
-            # order not to have to rely on ld.so.conf knowing the icc library
-            # directory. We do this before running iccvars.sh in order to allow a
-            # user to add modifications to LD_RUN_PATH in iccvars.sh.
-            if test -z "${LD_RUN_PATH}"; then
-                LD_RUN_PATH="${B2_TOOLSET_ROOT}lib"
-            else
-                LD_RUN_PATH="${B2_TOOLSET_ROOT}lib:${LD_RUN_PATH}"
-            fi
-            export LD_RUN_PATH
-            . ${B2_TOOLSET_ROOT}bin/iccvars.sh $ARCH
-        fi
-        B2_CXX="${CXX} -xc++"
-        B2_CXXFLAGS_RELEASE="-O3 -s"
-        B2_CXXFLAGS_DEBUG="-O0 -g -p"
+    intel-*)
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
+        B2_CXXFLAGS_RELEASE="-O3 -s -static"
+        B2_CXXFLAGS_DEBUG="-O0 -g -p -static"
     ;;
 
     vacpp)
-        CXX=${CXX:=xlC_r}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=-qversion}
-        B2_CXX="${CXX}"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:--qversion}
         B2_CXXFLAGS_RELEASE="-O3 -s -qstrict -qinline"
         B2_CXXFLAGS_DEBUG="-g -qNOOPTimize -qnoinline -pg"
     ;;
 
     xlcpp)
-        CXX=${CXX:=xlC_r}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=-qversion}
-        B2_CXX="${CXX}"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:--qversion}
         B2_CXXFLAGS_RELEASE="-s -O3 -qstrict -qinline"
         B2_CXXFLAGS_DEBUG="-g -qNOOPTimize -qnoinline -pg"
     ;;
 
     como)
-        CXX=${CXX:=como}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX}"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-O3 --inlining"
         B2_CXXFLAGS_DEBUG="-O0 -g --no_inlining --long_long"
     ;;
 
     kcc)
-        CXX=${CXX:=KCC}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="KCC"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="+K2 -s"
         B2_CXXFLAGS_DEBUG="+K0 -g"
     ;;
 
     kylix)
-        CXX=${CXX:=bc++}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="bc++ -tC -q"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-O2 -vi -w-inl -s"
         B2_CXXFLAGS_DEBUG="-Od -v -vi-"
     ;;
 
     mipspro)
-        CXX=${CXX:=CC}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX} -FE:template_in_elf_section -ptused"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-Ofast -g0 \"-INLINE:none\" -s"
         B2_CXXFLAGS_DEBUG="-O0 -INLINE -g"
     ;;
 
     pathscale)
-        CXX=${CXX:=pathCC}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX}"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-O3 -inline -s"
         B2_CXXFLAGS_DEBUG="-O0 -noinline -ggdb"
     ;;
 
     pgi)
-        CXX=${CXX:=pgc++}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX} -std=c++11"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-fast -s"
         B2_CXXFLAGS_DEBUG="-O0 -gopt"
     ;;
 
     sun*)
-        CXX=${CXX:=CC}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=-V}
-        if test -z "${B2_TOOLSET_ROOT}" -a -r /opt/SUNWspro/bin/CC ; then
-            B2_TOOLSET_ROOT=/opt/SUNWspro/
-        fi
-        if test -r "${B2_TOOLSET_ROOT}/bin/CC" ; then
-            PATH=${B2_TOOLSET_ROOT}bin:${PATH}
-            export PATH
-        fi
-        B2_CXX="${CXX} -std=c++11"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:--V}
         B2_CXXFLAGS_RELEASE="-xO4 -s"
         B2_CXXFLAGS_DEBUG="-g"
     ;;
 
     clang*)
-        CXX=${CXX:=clang++}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX} -x c++ -std=c++11"
-        B2_TOOLSET=clang
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-O3 -s"
         B2_CXXFLAGS_DEBUG="-O0 -fno-inline -g"
     ;;
 
     tru64cxx)
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="cc"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-O5 -inline speed -s"
         B2_CXXFLAGS_DEBUG="-O0 -pg -g"
     ;;
 
     acc)
-        CXX=${CXX:=aCC}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX} -AA"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-O3 -s"
         B2_CXXFLAGS_DEBUG="+d -g"
     ;;
 
     qcc)
-        CXX=${CXX:=QCC}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX}"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
         B2_CXXFLAGS_RELEASE="-O3 -Wc,-finline-functions"
         B2_CXXFLAGS_DEBUG="O0 -Wc,-fno-inline -gstabs+"
     ;;
 
     cxx)
-        CXX=${CXX:=cxx}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX}"
-    ;;
-
-    cross-cxx)
-        CXX=${BUILD_CXX:=cxx}
-        CXXFLAGS=${BUILD_CXXFLAGS}
-        CXX_VERSION_OPT=${CXX_VERSION_OPT:=--version}
-        B2_CXX="${CXX}"
+        CXX_VERSION_OPT=${CXX_VERSION_OPT:---version}
     ;;
 
     *)
-        error_exit "Unknown toolset: $B2_TOOLSET"
+        error_exit "Unknown toolset: ${B2_TOOLSET}"
     ;;
 esac
 
-echo "
+build_b2 ()
+{
+    echo "
 ###
 ###
-### Using '$B2_TOOLSET' toolset.
+### Using '${B2_TOOLSET}' toolset.
 ###
 ###
 "
-echo_run ${CXX} ${CXX_VERSION_OPT}
+    echo_run ${B2_CXX} ${CXX_VERSION_OPT}
 echo "
 ###
 ###
 "
-B2_SOURCES="\
- builtins.cpp \
- class.cpp \
- command.cpp \
- compile.cpp \
- constants.cpp \
- cwd.cpp \
- debug.cpp \
- debugger.cpp \
- execcmd.cpp \
- filesys.cpp \
- frames.cpp \
- function.cpp \
- glob.cpp\
- hash.cpp \
- hcache.cpp \
- hdrmacro.cpp \
- headers.cpp \
- jam.cpp \
- jamgram.cpp \
- lists.cpp \
- make.cpp \
- make1.cpp \
- md5.cpp \
- mem.cpp \
- modules.cpp \
- native.cpp \
- object.cpp \
- option.cpp \
- output.cpp \
- parse.cpp \
- pathsys.cpp \
- regexp.cpp \
- rules.cpp \
- scan.cpp \
- search.cpp \
- jam_strings.cpp \
- startup.cpp \
- subst.cpp \
- sysinfo.cpp \
- timestamp.cpp \
- variable.cpp \
- w32_getreg.cpp \
- modules/order.cpp \
- modules/path.cpp \
- modules/property-set.cpp \
- modules/regex.cpp \
- modules/sequence.cpp \
- modules/set.cpp \
- "
-case $B2_OS in
-    NT)
-    B2_SOURCES="${B2_SOURCES} execnt.cpp filent.cpp pathnt.cpp"
-    ;;
+    B2_SOURCES="\
+builtins.cpp \
+class.cpp \
+command.cpp \
+compile.cpp \
+constants.cpp \
+cwd.cpp \
+debug.cpp \
+debugger.cpp \
+execcmd.cpp \
+execnt.cpp \
+execunix.cpp \
+filesys.cpp \
+filent.cpp \
+fileunix.cpp \
+frames.cpp \
+function.cpp \
+glob.cpp \
+hash.cpp \
+hcache.cpp \
+hdrmacro.cpp \
+headers.cpp \
+jam_strings.cpp \
+jam.cpp \
+jamgram.cpp \
+lists.cpp \
+make.cpp \
+make1.cpp \
+md5.cpp \
+mem.cpp \
+modules.cpp \
+native.cpp \
+object.cpp \
+option.cpp \
+output.cpp \
+parse.cpp \
+pathnt.cpp \
+pathsys.cpp \
+pathunix.cpp \
+regexp.cpp \
+rules.cpp \
+scan.cpp \
+search.cpp \
+startup.cpp \
+subst.cpp \
+sysinfo.cpp \
+timestamp.cpp \
+variable.cpp \
+w32_getreg.cpp \
+modules/order.cpp \
+modules/path.cpp \
+modules/property-set.cpp \
+modules/regex.cpp \
+modules/sequence.cpp \
+modules/set.cpp \
+"
 
-    *)
-    B2_SOURCES="${B2_SOURCES} execunix.cpp fileunix.cpp pathunix.cpp"
-    ;;
-esac
+    if test_true ${B2_DEBUG_OPT} ; then B2_CXXFLAGS="${B2_CXXFLAGS_DEBUG}"
+    else B2_CXXFLAGS="${B2_CXXFLAGS_RELEASE} -DNDEBUG"
+    fi
+    ( B2_VERBOSE_OPT=${TRUE} echo_run ${B2_CXX} ${B2_CXXFLAGS} ${B2_SOURCES} -o b2 )
+    ( B2_VERBOSE_OPT=${TRUE} echo_run cp b2 bjam )
+}
 
-if check_debug_build "$@" ; then B2_CXXFLAGS="${B2_CXXFLAGS_DEBUG}"
-else B2_CXXFLAGS="${B2_CXXFLAGS_RELEASE} -DNDEBUG"
+if test_true ${B2_VERBOSE_OPT} ; then
+    (
+        ${B2_SETUP}
+        build_b2
+    )
+else
+    (
+        ${B2_SETUP} 1>/dev/null 2>/dev/null
+        build_b2
+    )
 fi
-echo_run ${B2_CXX} ${CXXFLAGS} ${B2_CXXFLAGS} ${B2_SOURCES} -o b2
-echo_run cp b2 bjam
diff --git a/src/engine/builtins.cpp b/src/engine/builtins.cpp
index cf3971621e..86706a65b1 100644
--- a/src/engine/builtins.cpp
+++ b/src/engine/builtins.cpp
@@ -30,6 +30,7 @@
 #include "output.h"
 
 #include <ctype.h>
+#include <stdlib.h>
 
 #ifdef OS_NT
 #include <windows.h>
@@ -911,7 +912,7 @@ LIST * glob_recursive( char const * pattern )
                 {
                     OBJECT * p;
                     path->f_dir.ptr = object_str( list_item( iter ) );
-                    path->f_dir.len = strlen( object_str( list_item( iter ) ) );
+                    path->f_dir.len = int32_t(strlen( object_str( list_item( iter ) ) ));
                     path_build( path, file_string );
 
                     p = object_new( file_string->value );
@@ -1749,14 +1750,14 @@ LIST * builtin_pad( FRAME * frame, int flags )
     OBJECT * string = list_front( lol_get( frame->args, 0 ) );
     char const * width_s = object_str( list_front( lol_get( frame->args, 1 ) ) );
 
-    int current = strlen( object_str( string ) );
-    int desired = atoi( width_s );
+    int32_t current = int32_t(strlen( object_str( string ) ));
+    int32_t desired = atoi( width_s );
     if ( current >= desired )
         return list_new( object_copy( string ) );
     else
     {
         char * buffer = (char *)BJAM_MALLOC( desired + 1 );
-        int i;
+        int32_t i;
         LIST * result;
 
         strcpy( buffer, object_str( string ) );
@@ -1886,7 +1887,7 @@ LIST *builtin_readlink( FRAME * frame, int flags )
 #else
     char static_buf[256];
     char * buf = static_buf;
-    size_t bufsize = 256;
+    int32_t bufsize = 256;
     LIST * result = 0;
     while (1) {
         ssize_t len = readlink( path, buf, bufsize );
@@ -1894,7 +1895,7 @@ LIST *builtin_readlink( FRAME * frame, int flags )
         {
             break;
         }
-        else if ( size_t(len) < bufsize )
+        else if ( int32_t(len) < bufsize )
         {
             buf[ len ] = '\0';
             result = list_new( object_new( buf ) );
@@ -2400,7 +2401,7 @@ LIST * builtin_shell( FRAME * frame, int flags )
     LIST   * command = lol_get( frame->args, 0 );
     LIST   * result = L0;
     string   s;
-    int      ret;
+    int32_t ret;
     char     buffer[ 1024 ];
     FILE   * p = NULL;
     int      exit_status = -1;
@@ -2435,7 +2436,7 @@ LIST * builtin_shell( FRAME * frame, int flags )
 
     string_new( &s );
 
-    while ( ( ret = fread( buffer, sizeof( char ), sizeof( buffer ) - 1, p ) ) >
+    while ( ( ret = int32_t(fread( buffer, sizeof( char ), sizeof( buffer ) - 1, p )) ) >
         0 )
     {
         buffer[ ret ] = 0;
diff --git a/src/engine/config.h b/src/engine/config.h
index 9ff147d8e5..1df3501e5d 100644
--- a/src/engine/config.h
+++ b/src/engine/config.h
@@ -31,4 +31,21 @@ Distributed under the Boost Software License, Version 1.0.
     #endif
 #endif
 
+// Correct missing types in some earlier compilers..
+
+#include <stdint.h>
+#ifndef INT32_MIN
+
+// VS 2013 is barely C++11/C99. And opts to not provide specific sized int types.
+// Provide a generic implementation of the sizes we use.
+#if UINT_MAX == 0xffffffff
+typedef int int32_t;
+#elif (USHRT_MAX == 0xffffffff)
+typedef short int32_t;
+#elif ULONG_MAX == 0xffffffff
+typedef long int32_t;
+#endif
+
+#endif
+
 #endif
diff --git a/src/engine/config_toolset.bat b/src/engine/config_toolset.bat
index d13fcc667f..f717e7800f 100644
--- a/src/engine/config_toolset.bat
+++ b/src/engine/config_toolset.bat
@@ -14,6 +14,7 @@ if "_%B2_TOOLSET%_" == "_vc142_" call :Config_VC142
 if "_%B2_TOOLSET%_" == "_borland_" call :Config_BORLAND
 if "_%B2_TOOLSET%_" == "_como_" call :Config_COMO
 if "_%B2_TOOLSET%_" == "_gcc_" call :Config_GCC
+if "_%B2_TOOLSET%_" == "_clang_" call :Config_CLANG
 if "_%B2_TOOLSET%_" == "_gcc-nocygwin_" call :Config_GCC_NOCYGWIN
 if "_%B2_TOOLSET%_" == "_intel-win32_" call :Config_INTEL_WIN32
 if "_%B2_TOOLSET%_" == "_mingw_" call :Config_MINGW
@@ -33,7 +34,7 @@ call :Call_If_Exists "%B2_TOOLSET_ROOT%bin\VCVARS32.BAT"
 if not "_%B2_TOOLSET_ROOT%_" == "__" (
     set "PATH=%B2_TOOLSET_ROOT%bin;%PATH%"
     )
-set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL"
+set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL /EHsc"
 set "B2_CXX_LINK=/link kernel32.lib advapi32.lib user32.lib"
 set "_known_=1"
 goto :eof
@@ -48,7 +49,7 @@ if NOT "_%B2_TOOLSET_ROOT%_" == "__" (
     if "_%VCINSTALLDIR%_" == "__" (
         set "PATH=%B2_TOOLSET_ROOT%bin;%PATH%"
         ) )
-set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL"
+set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL /EHsc"
 set "B2_CXX_LINK=/link kernel32.lib advapi32.lib user32.lib"
 set "_known_=1"
 goto :eof
@@ -67,7 +68,7 @@ if NOT "_%B2_TOOLSET_ROOT%_" == "__" (
     if "_%VCINSTALLDIR%_" == "__" (
         set "PATH=%B2_TOOLSET_ROOT%bin;%PATH%"
         ) )
-set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL"
+set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL /EHsc"
 set "B2_CXX_LINK=/link kernel32.lib advapi32.lib user32.lib"
 set "_known_=1"
 goto :eof
@@ -87,7 +88,7 @@ if NOT "_%B2_TOOLSET_ROOT%_" == "__" (
     if "_%VCINSTALLDIR%_" == "__" (
         set "PATH=%B2_TOOLSET_ROOT%bin;%PATH%"
         ) )
-set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL"
+set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL /EHsc"
 set "B2_CXX_LINK=/link kernel32.lib advapi32.lib user32.lib"
 set "_known_=1"
 goto :eof
@@ -109,7 +110,7 @@ REM return to current directory as vsdevcmd_end.bat switches to %USERPROFILE%\So
 pushd %CD%
 if "_%VSINSTALLDIR%_" == "__" call :Call_If_Exists "%B2_TOOLSET_ROOT%Auxiliary\Build\vcvarsall.bat" %B2_BUILD_ARGS%
 popd
-set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL"
+set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL /EHsc"
 set "B2_CXX_LINK=/link kernel32.lib advapi32.lib user32.lib"
 set "_known_=1"
 goto :eof
@@ -131,7 +132,7 @@ REM return to current directory as vsdevcmd_end.bat switches to %USERPROFILE%\So
 pushd %CD%
 if "_%VSINSTALLDIR%_" == "__" call :Call_If_Exists "%B2_TOOLSET_ROOT%Auxiliary\Build\vcvarsall.bat" %B2_BUILD_ARGS%
 popd
-set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL"
+set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL /EHsc"
 set "B2_CXX_LINK=/link kernel32.lib advapi32.lib user32.lib"
 set "_known_=1"
 goto :eof
@@ -153,15 +154,15 @@ REM return to current directory as vsdevcmd_end.bat switches to %USERPROFILE%\So
 pushd %CD%
 if "_%VSINSTALLDIR%_" == "__" call :Call_If_Exists "%B2_TOOLSET_ROOT%Auxiliary\Build\vcvarsall.bat" %B2_BUILD_ARGS%
 popd
-set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL"
+set "B2_CXX=%CXX% /nologo /MP /MT /TP /Feb2 /wd4996 /O2 /GL /EHsc"
 set "B2_CXX_LINK=/link kernel32.lib advapi32.lib user32.lib"
 set "_known_=1"
 goto :eof
 
 :Config_BORLAND
-if not defined CXX ( set "CXX=bcc32" )
+if not defined CXX ( set "CXX=bcc32c" )
 if "_%B2_TOOLSET_ROOT%_" == "__" (
-    call guess_toolset.bat test_path bcc32.exe )
+    call guess_toolset.bat test_path bcc32c.exe )
 if "_%B2_TOOLSET_ROOT%_" == "__" (
     if not errorlevel 1 (
         set "B2_TOOLSET_ROOT=%FOUND_PATH%..\"
@@ -169,7 +170,7 @@ if "_%B2_TOOLSET_ROOT%_" == "__" (
 if not "_%B2_TOOLSET_ROOT%_" == "__" (
     set "PATH=%B2_TOOLSET_ROOT%Bin;%PATH%"
     )
-set "B2_CXX=%CXX% -tC -P -O2 -w- -I"%B2_TOOLSET_ROOT%Include" -L"%B2_TOOLSET_ROOT%Lib" -Nd -eb2"
+set "B2_CXX=%CXX% -tC -P -O2 -w- -I"%B2_TOOLSET_ROOT%Include" -L"%B2_TOOLSET_ROOT%Lib" -eb2"
 set "_known_=1"
 goto :eof
 
@@ -185,6 +186,12 @@ set "B2_CXX=%CXX% -x c++ -std=c++11 -s -O3 -o b2.exe"
 set "_known_=1"
 goto :eof
 
+:Config_CLANG
+if not defined CXX ( set "CXX=clang++" )
+set "B2_CXX=%CXX% -x c++ -std=c++11 -s -O3 -o b2.exe"
+set "_known_=1"
+goto :eof
+
 :Config_GCC_NOCYGWIN
 if not defined CXX ( set "CXX=g++" )
 set "B2_CXX=%CXX% -x c++ -std=c++11 -s -O3 -mno-cygwin -o b2.exe"
diff --git a/src/engine/constants.cpp b/src/engine/constants.cpp
index ce4e3d7e47..c64ea3b634 100644
--- a/src/engine/constants.cpp
+++ b/src/engine/constants.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright 2011 Steven Watanabe
+ * Copyright 2020 René Ferdinand Rivera Morell
  *
  * This file is part of Jam - see jam.c for Copyright information.
  */
@@ -74,6 +75,8 @@ void constants_init( void )
     constant_MAIN_PYTHON              = object_new( "MAIN_PYTHON" );
     constant_BUILTIN_GLOB_ARCHIVE_BACK= object_new( "BUILTIN_GLOB_ARCHIVE_BACK" );
     constant_FILE_ARCHIVESCAN         = object_new( "FILE_ARCHIVESCAN" );
+
+    constant_RESPONSE_FILE_SUB = object_new( "RESPONSE_FILE_SUB" );
 }
 
 void constants_done( void )
@@ -133,6 +136,8 @@ void constants_done( void )
     object_free( constant_MAIN_PYTHON );
     object_free( constant_FILE_ARCHIVESCAN );
     object_free( constant_BUILTIN_GLOB_ARCHIVE_BACK );
+
+    object_free( constant_RESPONSE_FILE_SUB );
 }
 
 OBJECT * constant_empty;
@@ -190,3 +195,5 @@ OBJECT * constant_extra_pythonpath;
 OBJECT * constant_MAIN_PYTHON;
 OBJECT * constant_FILE_ARCHIVESCAN;
 OBJECT * constant_BUILTIN_GLOB_ARCHIVE_BACK;
+
+OBJECT * constant_RESPONSE_FILE_SUB;
diff --git a/src/engine/constants.h b/src/engine/constants.h
index ec112080d6..675b665791 100644
--- a/src/engine/constants.h
+++ b/src/engine/constants.h
@@ -73,4 +73,6 @@ extern OBJECT * constant_MAIN_PYTHON;               /* "MAIN_PYTHON" */
 extern OBJECT * constant_FILE_ARCHIVESCAN;          /* "FILE_ARCHIVESCAN" */
 extern OBJECT * constant_BUILTIN_GLOB_ARCHIVE_BACK; /* "BUILTIN_GLOB_ARCHIVE_BACK" */
 
+extern OBJECT * constant_RESPONSE_FILE_SUB; // "RESPONSE_FILE_SUB"
+
 #endif
diff --git a/src/engine/debug.cpp b/src/engine/debug.cpp
index 2a19e072bb..8fcf7e362e 100644
--- a/src/engine/debug.cpp
+++ b/src/engine/debug.cpp
@@ -73,7 +73,7 @@ void profile_enter( OBJECT * rulename, profile_frame * frame )
 }
 
 
-void profile_memory( long mem )
+void profile_memory( size_t mem )
 {
     if ( DEBUG_PROFILE )
         if ( profile_stack && profile_stack->info )
diff --git a/src/engine/debug.h b/src/engine/debug.h
index d61faf450c..20824577e3 100644
--- a/src/engine/debug.h
+++ b/src/engine/debug.h
@@ -45,7 +45,7 @@ typedef struct profile_frame
 
 profile_frame * profile_init( OBJECT * rulename, profile_frame * );
 void profile_enter( OBJECT * rulename, profile_frame * );
-void profile_memory( long mem );
+void profile_memory( size_t mem );
 void profile_exit( profile_frame * );
 void profile_dump();
 double profile_clock();
diff --git a/src/engine/debugger.cpp b/src/engine/debugger.cpp
index 051166699b..f3b2f042da 100644
--- a/src/engine/debugger.cpp
+++ b/src/engine/debugger.cpp
@@ -160,14 +160,16 @@ static LIST * debug_list_read( FILE * in )
 {
     int len;
     int i;
-    int ch;
     LIST * result = L0;
-    fscanf( in, "%d", &len );
-    ch = fgetc( in );
-    assert( ch == '\n' );
-    for ( i = 0; i < len; ++i )
+    int ret = fscanf( in, "%d", &len );
+    if (ret == 1)
     {
-        result = list_push_back( result, debug_object_read( in ) );
+        int ch = fgetc( in );
+        if (ch > 0) assert( ch == '\n' );
+        for ( i = 0; i < len; ++i )
+        {
+            result = list_push_back( result, debug_object_read( in ) );
+        }
     }
     return result;
 }
@@ -328,7 +330,7 @@ static OBJECT * make_absolute_path( OBJECT * filename )
     const char * root = object_str( cwd() );
     path_parse( object_str( filename ), path1 );
     path1->f_root.ptr = root;
-    path1->f_root.len = strlen( root );
+    path1->f_root.len = int32_t(strlen( root ));
     string_new( buf );
     path_build( path1, buf );
     result = object_new( buf->value );
@@ -580,7 +582,7 @@ static int debug_add_breakpoint( const char * name )
         long line = strtoul( ptr + 1, &end, 10 );
         if ( line > 0 && line <= INT_MAX && end != ptr + 1 && *end == 0 )
         {
-            OBJECT * file = object_new_range( file_ptr,  ptr - file_ptr );
+            OBJECT * file = object_new_range( file_ptr, int32_t(ptr - file_ptr) );
             return add_line_breakpoint( file, line );
         }
         else
@@ -615,7 +617,7 @@ static int get_breakpoint_by_name( const char * name )
         long line = strtoul( ptr + 1, &end, 10 );
         if ( line > 0 && line <= INT_MAX && end != ptr + 1 && *end == 0 )
         {
-            OBJECT * file = object_new_range( file_ptr,  ptr - file_ptr );
+            OBJECT * file = object_new_range( file_ptr, int32_t(ptr - file_ptr) );
             result = handle_line_breakpoint( file, line );
             object_free( file );
         }
@@ -772,7 +774,7 @@ static int get_module_filename( string * out )
     DWORD result;
     string_reserve( out, 256 + 1 );
     string_truncate( out, 256 );
-    while( ( result = GetModuleFileNameA( NULL, out->value, out->size ) ) == out->size )
+    while( ( result = GetModuleFileNameA( NULL, out->value, DWORD(out->size) ) ) == DWORD(out->size) )
     {
         string_reserve( out, out->size * 2 + 1);
         string_truncate( out, out->size * 2 );
@@ -2690,7 +2692,7 @@ static int process_command( char * line )
             *iter++ = '\0';
         }
     }
-    result = run_command( current - buffer, (const char **)buffer );
+    result = run_command( int(current - buffer), (const char **)buffer );
     free( (void *)buffer );
     return result;
 }
diff --git a/src/engine/execcmd.cpp b/src/engine/execcmd.cpp
index 8e6ec4f504..dfbd5a7f8a 100644
--- a/src/engine/execcmd.cpp
+++ b/src/engine/execcmd.cpp
@@ -41,9 +41,9 @@ static int intr;
  */
 
 void argv_from_shell( char const * * argv, LIST * shell, char const * command,
-    int const slot )
+    int32_t const slot )
 {
-    static char jobno[ 4 ];
+    static char jobno[ 12 ];
 
     int i;
     int gotpercent = 0;
@@ -74,12 +74,12 @@ void argv_from_shell( char const * * argv, LIST * shell, char const * command,
 /* Returns whether the given command string contains lines longer than the given
  * maximum.
  */
-int check_cmd_for_too_long_lines( char const * command, size_t max,
-    int * const error_length, int * const error_max_length )
+int check_cmd_for_too_long_lines( char const * command, int32_t max,
+    int32_t * const error_length, int32_t * const error_max_length )
 {
     while ( *command )
     {
-        size_t const l = strcspn( command, "\n" );
+        int32_t const l = int32_t(strcspn( command, "\n" ));
         if ( l > max )
         {
             *error_length = l;
diff --git a/src/engine/execcmd.h b/src/engine/execcmd.h
index b39e8ae2dc..293822b308 100644
--- a/src/engine/execcmd.h
+++ b/src/engine/execcmd.h
@@ -54,8 +54,8 @@ int exec_check
 (
     string const * command,
     LIST * * pShell,
-    int * error_length,
-    int * error_max_length
+    int32_t * error_length,
+    int32_t * error_max_length
 );
 
 /* exec_check() return codes. */
@@ -91,7 +91,7 @@ void exec_wait();
  * given shell list.
  */
 void argv_from_shell( char const * * argv, LIST * shell, char const * command,
-    int const slot );
+    int32_t const slot );
 
 /* Interrupt routine bumping the internal interrupt counter. Needs to be
  * registered by platform specific exec*.c modules.
@@ -109,7 +109,11 @@ int is_raw_command_request( LIST * shell );
 /* Utility worker for exec_check() checking whether all the given command lines
  * are under the specified length limit.
  */
-int check_cmd_for_too_long_lines( char const * command, size_t max,
-    int * const error_length, int * const error_max_length );
+int check_cmd_for_too_long_lines( char const * command, int32_t max,
+    int32_t * const error_length, int32_t * const error_max_length );
+
+/* Maximum shell command line length.
+ */
+int32_t shell_maxline();
 
 #endif
diff --git a/src/engine/execnt.cpp b/src/engine/execnt.cpp
index 0b28087fe3..5eb77ec7ac 100644
--- a/src/engine/execnt.cpp
+++ b/src/engine/execnt.cpp
@@ -37,8 +37,10 @@
  */
 
 #include "jam.h"
-#include "output.h"
+
 #ifdef USE_EXECNT
+
+#include "output.h"
 #include "execcmd.h"
 
 #include "lists.h"
@@ -69,9 +71,9 @@
 
 
 /* get the maximum shell command line length according to the OS */
-static int maxline();
+static int32_t maxline();
 /* valid raw command string length */
-static long raw_command_length( char const * command );
+static int32_t raw_command_length( char const * command );
 /* add two 64-bit unsigned numbers, h1l1 and h2l2 */
 static FILETIME add_64(
     unsigned long h1, unsigned long l1,
@@ -87,33 +89,33 @@ static double running_time( HANDLE const );
 /* terminate the given process, after terminating all its children first */
 static void kill_process_tree( DWORD const procesdId, HANDLE const );
 /* waits for a command to complete or time out */
-static int try_wait( int const timeoutMillis );
+static int32_t try_wait( int32_t const timeoutMillis );
 /* reads any pending output for running commands */
 static void read_output();
 /* checks if a command ran out of time, and kills it */
-static int try_kill_one();
+static int32_t try_kill_one();
 /* is the first process a parent (direct or indirect) to the second one */
-static int is_parent_child( DWORD const parent, DWORD const child );
+static int32_t is_parent_child( DWORD const parent, DWORD const child );
 /* */
 static void close_alert( PROCESS_INFORMATION const * const );
 /* close any alerts hanging around */
 static void close_alerts();
 /* prepare a command file to be executed using an external shell */
-static char const * prepare_command_file( string const * command, int slot );
+static char const * prepare_command_file( string const * command, int32_t slot );
 /* invoke the actual external process using the given command line */
-static void invoke_cmd( char const * const command, int const slot );
+static void invoke_cmd( char const * const command, int32_t const slot );
 /* find a free slot in the running commands table */
-static int get_free_cmdtab_slot();
+static int32_t get_free_cmdtab_slot();
 /* put together the final command string we are to run */
 static void string_new_from_argv( string * result, char const * const * argv );
 /* frees and renews the given string */
 static void string_renew( string * const );
 /* reports the last failed Windows API related error message */
-static void reportWindowsError( char const * const apiName, int slot );
+static void reportWindowsError( char const * const apiName, int32_t slot );
 /* closes a Windows HANDLE and resets its variable to 0. */
 static void closeWinHandle( HANDLE * const handle );
 /* Adds the job index to the list of currently active jobs. */
-static void register_wait( int job_id );
+static void register_wait( int32_t job_id );
 
 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
 
@@ -132,7 +134,7 @@ static void register_wait( int job_id );
 #define EXECCMD_PIPE_READ 0
 #define EXECCMD_PIPE_WRITE 1
 
-static int intr_installed;
+static int32_t intr_installed;
 
 
 /* The list of commands we run. */
@@ -154,7 +156,7 @@ static struct _cmdtab_t
 
     HANDLE wait_handle;
 
-    int flags;
+    int32_t flags;
 
     /* Function called when the command completes. */
     ExecCmdCallback func;
@@ -162,14 +164,14 @@ static struct _cmdtab_t
     /* Opaque data passed back to the 'func' callback. */
     void * closure;
 } * cmdtab = NULL;
-static int cmdtab_size = 0;
+static int32_t cmdtab_size = 0;
 
 /* A thread-safe single element queue.  Used by the worker threads
  * to signal the main thread that a process is completed.
  */
 struct
 {
-    int job_index;
+    int32_t job_index;
     HANDLE read_okay;
     HANDLE write_okay;
 } process_queue;
@@ -185,7 +187,7 @@ void execnt_unit_test()
      * Use a table instead.
      */
     {
-        typedef struct test { const char * command; int result; } test;
+        typedef struct test { const char * command; int32_t result; } test;
         test tests[] = {
             { "", 0 },
             { "  ", 0 },
@@ -218,9 +220,9 @@ void execnt_unit_test()
     }
 
     {
-        int const length = maxline() + 9;
-        char * const cmd = (char *)BJAM_MALLOC_ATOMIC( length + 1 );
-        memset( cmd, 'x', length );
+        int32_t const length = maxline() + 9;
+        char * const cmd = (char *)BJAM_MALLOC_ATOMIC( size_t(length) + 1 );
+        memset( cmd, 'x', size_t(length) );
         cmd[ length ] = 0;
         assert( raw_command_length( cmd ) == length );
         BJAM_FREE( cmd );
@@ -266,12 +268,12 @@ void exec_done( void )
  * exec_check() - preprocess and validate the command
  */
 
-int exec_check
+int32_t exec_check
 (
     string const * command,
     LIST * * pShell,
-    int * error_length,
-    int * error_max_length
+    int32_t * error_length,
+    int32_t * error_max_length
 )
 {
     /* Default shell does nothing when triggered with an empty or a
@@ -290,7 +292,7 @@ int exec_check
     /* Check prerequisites for executing raw commands. */
     if ( is_raw_command_request( *pShell ) )
     {
-        long const raw_cmd_length = raw_command_length( command->value );
+        int32_t const raw_cmd_length = raw_command_length( command->value );
         if ( raw_cmd_length < 0 )
         {
             /* Invalid characters detected - fallback to default shell. */
@@ -318,7 +320,7 @@ int exec_check
      */
 
     /* Check for too long command lines. */
-    return check_cmd_for_too_long_lines( command->value, maxline(),
+    return check_cmd_for_too_long_lines( command->value, shell_maxline(),
         error_length, error_max_length );
 }
 
@@ -333,14 +335,14 @@ int exec_check
 void exec_cmd
 (
     string const * cmd_orig,
-    int flags,
+    int32_t flags,
     ExecCmdCallback func,
     void * closure,
     LIST * shell
 )
 {
-    int const slot = get_free_cmdtab_slot();
-    int const is_raw_cmd = is_raw_command_request( shell );
+    int32_t const slot = get_free_cmdtab_slot();
+    int32_t const is_raw_cmd = is_raw_command_request( shell );
     string cmd_local[ 1 ];
 
     /* Initialize default shell - anything more than /Q/C is non-portable. */
@@ -380,7 +382,7 @@ void exec_cmd
                 end = p;
         string_new( cmd_local );
         string_append_range( cmd_local, start, end );
-        assert( long(cmd_local->size) == raw_command_length( cmd_orig->value ) );
+        assert( int32_t(cmd_local->size) == raw_command_length( cmd_orig->value ) );
     }
     /* If we are not running a raw command directly, prepare a command file to
      * be executed using an external shell and the actual command string using
@@ -424,8 +426,8 @@ void exec_cmd
 
 void exec_wait()
 {
-    int i = -1;
-    int exit_reason;  /* reason why a command completed */
+    int32_t i = -1;
+    int32_t exit_reason;  /* reason why a command completed */
 
     /* Wait for a command to complete, while snarfing up any output. */
     while ( 1 )
@@ -447,7 +449,7 @@ void exec_wait()
     {
         DWORD exit_code;
         timing_info time;
-        int rstat;
+        int32_t rstat;
 
         /* The time data for the command. */
         record_times( cmdtab[ i ].pi.hProcess, &time );
@@ -494,7 +496,7 @@ void exec_wait()
  * process in our running commands table.
  */
 
-static void invoke_cmd( char const * const command, int const slot )
+static void invoke_cmd( char const * const command, int32_t const slot )
 {
     SECURITY_ATTRIBUTES sa = { sizeof( SECURITY_ATTRIBUTES ), 0, 0 };
     SECURITY_DESCRIPTOR sd;
@@ -577,16 +579,16 @@ static void invoke_cmd( char const * const command, int const slot )
  *     http://support.microsoft.com/default.aspx?scid=kb;en-us;830473
  */
 
-static int raw_maxline()
+static int32_t raw_maxline()
 {
     if ( IsWindowsVersionOrGreater(5,0,0) == TRUE ) return 8191;  /* XP       */
     if ( IsWindowsVersionOrGreater(4,0,0) == TRUE ) return 2047;  /* NT 4.x   */
     return 996;                                      /* NT 3.5.1 */
 }
 
-static int maxline()
+static int32_t maxline()
 {
-    static int result;
+    static int32_t result;
     if ( !result ) result = raw_maxline();
     return result;
 }
@@ -632,7 +634,7 @@ static void string_renew( string * const s )
  *     affect the executed command).
  */
 
-static long raw_command_length( char const * command )
+static int32_t raw_command_length( char const * command )
 {
     char const * p;
     char const * escape = 0;
@@ -688,7 +690,7 @@ static long raw_command_length( char const * command )
     while ( *p );
 
     /* Return the number of characters the command will occupy. */
-    return ( newline ? newline : p ) - command;
+    return int32_t(( newline ? newline : p ) - command);
 }
 
 
@@ -771,7 +773,7 @@ static void read_pipe
 (
     HANDLE   in,  /* the pipe to read from */
     string * out,
-    int      forwarding_mode
+    int32_t      forwarding_mode
 )
 {
     DWORD bytesInBuffer = 0;
@@ -820,7 +822,7 @@ static void read_pipe
 
 static void read_output()
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < globs.jobs; ++i )
         if ( cmdtab[ i ].pi.hProcess )
         {
@@ -839,17 +841,17 @@ static void CALLBACK try_wait_callback( void * data, BOOLEAN is_timeout )
 {
     struct _cmdtab_t * slot = ( struct _cmdtab_t * )data;
     WaitForSingleObject( process_queue.write_okay, INFINITE );
-    process_queue.job_index = slot - cmdtab;
+    process_queue.job_index = int32_t(slot - cmdtab);
     assert( !is_timeout );
     SetEvent( process_queue.read_okay );
     /* Okay.  Non-blocking. */
     UnregisterWait( slot->wait_handle );
 }
 
-static int try_wait_impl( DWORD timeout )
+static int32_t try_wait_impl( DWORD timeout )
 {
-    int job_index;
-    int res = WaitForSingleObject( process_queue.read_okay, timeout );
+    int32_t job_index;
+    int32_t res = WaitForSingleObject( process_queue.read_okay, timeout );
     if ( res != WAIT_OBJECT_0 )
         return -1;
     job_index = process_queue.job_index;
@@ -857,7 +859,7 @@ static int try_wait_impl( DWORD timeout )
     return job_index;
 }
 
-static void register_wait( int job_id )
+static void register_wait( int32_t job_id )
 {
     if ( globs.jobs > MAXIMUM_WAIT_OBJECTS )
     {
@@ -874,13 +876,13 @@ static void register_wait( int job_id )
  * cmdtab array, or -1.
  */
 
-static int try_wait( int const timeoutMillis )
+static int32_t try_wait( int32_t const timeoutMillis )
 {
     if ( globs.jobs <= MAXIMUM_WAIT_OBJECTS )
     {
-        int i;
+        int32_t i;
         HANDLE active_handles[ MAXIMUM_WAIT_OBJECTS ];
-        int job_ids[ MAXIMUM_WAIT_OBJECTS ];
+        int32_t job_ids[ MAXIMUM_WAIT_OBJECTS ];
         DWORD num_handles = 0;
         DWORD wait_api_result;
         for ( i = 0; i < globs.jobs; ++i )
@@ -910,12 +912,12 @@ static int try_wait( int const timeoutMillis )
 }
 
 
-static int try_kill_one()
+static int32_t try_kill_one()
 {
     /* Only need to check if a timeout was specified with the -l option. */
     if ( globs.timeout > 0 )
     {
-        int i;
+        int32_t i;
         for ( i = 0; i < globs.jobs; ++i )
             if ( cmdtab[ i ].pi.hProcess )
             {
@@ -946,7 +948,7 @@ static void close_alerts()
      */
     if ( ( (float)clock() / (float)( CLOCKS_PER_SEC * 5 ) ) < ( 1.0 / 5.0 ) )
     {
-        int i;
+        int32_t i;
         for ( i = 0; i < globs.jobs; ++i )
             if ( cmdtab[ i ].pi.hProcess )
                 close_alert( &cmdtab[ i ].pi );
@@ -1034,7 +1036,7 @@ static double creation_time( HANDLE const process )
  * process is System (first argument is ignored).
  */
 
-static int is_parent_child( DWORD const parent, DWORD const child )
+static int32_t is_parent_child( DWORD const parent, DWORD const child )
 {
     HANDLE process_snapshot_h = INVALID_HANDLE_VALUE;
 
@@ -1202,7 +1204,7 @@ static void close_alert( PROCESS_INFORMATION const * const pi )
  * function.
  */
 
-static FILE * open_command_file( int const slot )
+static FILE * open_command_file( int32_t const slot )
 {
     string * const command_file = cmdtab[ slot ].command_file;
 
@@ -1234,13 +1236,13 @@ static FILE * open_command_file( int const slot )
     {
         char * const index1 = command_file->value + command_file->size - 6;
         char * const index2 = index1 + 1;
-        int waits_remaining;
+        int32_t waits_remaining;
         assert( command_file->value < index1 );
         assert( index2 + 1 < command_file->value + command_file->size );
         assert( index2[ 1 ] == '.' );
         for ( waits_remaining = 3; ; --waits_remaining )
         {
-            int index;
+            int32_t index;
             for ( index = 0; index != 20; ++index )
             {
                 FILE * f;
@@ -1262,7 +1264,7 @@ static FILE * open_command_file( int const slot )
  * Prepare a command file to be executed using an external shell.
  */
 
-static char const * prepare_command_file( string const * command, int slot )
+static char const * prepare_command_file( string const * command, int32_t slot )
 {
     FILE * const f = open_command_file( slot );
     if ( !f )
@@ -1280,9 +1282,9 @@ static char const * prepare_command_file( string const * command, int slot )
  * Find a free slot in the running commands table.
  */
 
-static int get_free_cmdtab_slot()
+static int32_t get_free_cmdtab_slot()
 {
-    int slot;
+    int32_t slot;
     for ( slot = 0; slot < globs.jobs; ++slot )
         if ( !cmdtab[ slot ].pi.hProcess )
             return slot;
@@ -1314,7 +1316,7 @@ static void string_new_from_argv( string * result, char const * const * argv )
  * Reports the last failed Windows API related error message.
  */
 
-static void reportWindowsError( char const * const apiName, int slot )
+static void reportWindowsError( char const * const apiName, int32_t slot )
 {
     char * errorMessage;
     char buf[24];
@@ -1376,5 +1378,10 @@ static void reportWindowsError( char const * const apiName, int slot )
     string_renew( cmdtab[ slot ].buffer_err );
 }
 
+int32_t shell_maxline()
+{
+    return maxline();
+}
+
 
 #endif /* USE_EXECNT */
diff --git a/src/engine/execunix.cpp b/src/engine/execunix.cpp
index 2740743c71..207677998c 100644
--- a/src/engine/execunix.cpp
+++ b/src/engine/execunix.cpp
@@ -6,6 +6,9 @@
  */
 
 #include "jam.h"
+
+#ifdef USE_EXECUNIX
+
 #include "execcmd.h"
 
 #include "lists.h"
@@ -26,8 +29,6 @@
     #include <wait.h>
 #endif
 
-#ifdef USE_EXECUNIX
-
 #include <sys/times.h>
 
 #if defined(__APPLE__)
@@ -140,8 +141,8 @@ int exec_check
 (
     string const * command,
     LIST * * pShell,
-    int * error_length,
-    int * error_max_length
+    int32_t * error_length,
+    int32_t * error_max_length
 )
 {
     int const is_raw_cmd = is_raw_command_request( *pShell );
@@ -154,7 +155,7 @@ int exec_check
 
     return is_raw_cmd
         ? EXEC_CHECK_OK
-        : check_cmd_for_too_long_lines( command->value, MAXLINE, error_length,
+        : check_cmd_for_too_long_lines( command->value, shell_maxline(), error_length,
             error_max_length );
 }
 
@@ -603,4 +604,9 @@ static int get_free_cmdtab_slot()
     exit( EXITBAD );
 }
 
+int32_t shell_maxline()
+{
+    return MAXLINE;
+}
+
 # endif /* USE_EXECUNIX */
diff --git a/src/engine/execvms.cpp b/src/engine/execvms.cpp
index b4b0618455..2c516326c2 100644
--- a/src/engine/execvms.cpp
+++ b/src/engine/execvms.cpp
@@ -75,8 +75,8 @@ int exec_check
 (
     string const * command,
     LIST * * pShell,
-    int * error_length,
-    int * error_max_length
+    int32_t * error_length,
+    int32_t * error_max_length
 )
 {
     int const is_raw_cmd = 1;
@@ -89,7 +89,7 @@ int exec_check
 
     return is_raw_cmd
         ? EXEC_CHECK_OK
-        : check_cmd_for_too_long_lines( command->value, MAXLINE, error_length,
+        : check_cmd_for_too_long_lines( command->value, shell_maxline(), error_length,
             error_max_length );
 }
 
@@ -415,6 +415,11 @@ clock_t get_cpu_time()
     return result;
 }
 
+int32_t shell_maxline()
+{
+    return MAXLINE;
+}
+
 
 # endif /* VMS */
 
diff --git a/src/engine/filent.cpp b/src/engine/filent.cpp
index af89d5ef22..551f71c757 100644
--- a/src/engine/filent.cpp
+++ b/src/engine/filent.cpp
@@ -62,13 +62,13 @@ int file_collect_dir_content_( file_info_t * const d )
     string pathspec[ 1 ];
     string pathname[ 1 ];
     LIST * files = L0;
-    int d_length;
+    int32_t d_length;
 
     assert( d );
     assert( d->is_dir );
     assert( list_empty( d->files ) );
 
-    d_length = strlen( object_str( d->name ) );
+    d_length = int32_t(strlen( object_str( d->name ) ));
 
     memset( (char *)&f, '\0', sizeof( f ) );
     f.f_dir.ptr = object_str( d->name );
@@ -112,7 +112,7 @@ int file_collect_dir_content_( file_info_t * const d )
             OBJECT * pathname_obj;
 
             f.f_base.ptr = finfo.cFileName;
-            f.f_base.len = strlen( finfo.cFileName );
+            f.f_base.len = int32_t(strlen( finfo.cFileName ));
 
             string_truncate( pathname, 0 );
             path_build( &f, pathname );
@@ -276,7 +276,7 @@ void file_query_( file_info_t * const info )
 
     if ( ( dir = strrchr( pathstr, '\\' ) ) )
     {
-        parent = object_new_range( pathstr, dir - pathstr );
+        parent = object_new_range( pathstr, int32_t(dir - pathstr) );
     }
     else
     {
diff --git a/src/engine/fileunix.cpp b/src/engine/fileunix.cpp
index 4c1b6adf34..9d8dc17faf 100644
--- a/src/engine/fileunix.cpp
+++ b/src/engine/fileunix.cpp
@@ -307,7 +307,7 @@ int file_collect_archive_content_( file_archive_info_t * const archive )
         char * src;
         char * dest;
 
-        size_t ar_hdr_name_size = sizeof( ar_hdr.ar_name ); // Workaround for sizeof strncpy warning.
+        int32_t ar_hdr_name_size = sizeof( ar_hdr.ar_name ); // Workaround for sizeof strncpy warning.
         strncpy( lar_name, ar_hdr.ar_name, ar_hdr_name_size );
 
         sscanf( ar_hdr.ar_date, "%ld", &lar_date );
diff --git a/src/engine/filevms.cpp b/src/engine/filevms.cpp
index ab038d065b..03f980a1e3 100644
--- a/src/engine/filevms.cpp
+++ b/src/engine/filevms.cpp
@@ -229,7 +229,7 @@ file_cvttime(
     unsigned int *curtime,
     time_t *unixtime )
 {
-    static const size_t divisor = 10000000;
+    static const int32_t divisor = 10000000;
     static unsigned int bastim[2] = { 0x4BEB4000, 0x007C9567 }; /* 1/1/1970 */
     int delta[2], remainder;
 
diff --git a/src/engine/function.cpp b/src/engine/function.cpp
index 295192d158..056949d9ef 100644
--- a/src/engine/function.cpp
+++ b/src/engine/function.cpp
@@ -13,6 +13,7 @@
 #include "compile.h"
 #include "constants.h"
 #include "debugger.h"
+#include "execcmd.h"
 #include "filesys.h"
 #include "frames.h"
 #include "lists.h"
@@ -29,6 +30,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <string>
+
 /*
 #define FUNCTION_DEBUG_PROFILE
 */
@@ -40,7 +43,7 @@
 #define PROFILE_EXIT_LOCAL(x)
 #endif
 
-int glob( char const * s, char const * c );
+int32_t glob( char const * s, char const * c );
 void backtrace( FRAME * );
 void backtrace_line( FRAME * );
 
@@ -130,22 +133,22 @@ void backtrace_line( FRAME * );
 
 typedef struct instruction
 {
-    unsigned int op_code;
-    int arg;
+    uint32_t op_code;
+    int32_t arg;
 } instruction;
 
 typedef struct _subfunction
 {
     OBJECT * name;
     FUNCTION * code;
-    int local;
+    int32_t local;
 } SUBFUNCTION;
 
 typedef struct _subaction
 {
     OBJECT * name;
     FUNCTION * command;
-    int flags;
+    int32_t flags;
 } SUBACTION;
 
 #define FUNCTION_BUILTIN    0
@@ -153,7 +156,7 @@ typedef struct _subaction
 
 struct argument
 {
-    int flags;
+    int32_t flags;
 #define ARG_ONE 0
 #define ARG_OPTIONAL 1
 #define ARG_PLUS 2
@@ -161,45 +164,45 @@ struct argument
 #define ARG_VARIADIC 4
     OBJECT * type_name;
     OBJECT * arg_name;
-    int index;
+    int32_t index;
 };
 
 struct arg_list
 {
-    int size;
+    int32_t size;
     struct argument * args;
 };
 
 struct _function
 {
-    int type;
-    int reference_count;
+    int32_t type;
+    int32_t reference_count;
     OBJECT * rulename;
     struct arg_list * formal_arguments;
-    int num_formal_arguments;
+    int32_t num_formal_arguments;
 };
 
 typedef struct _builtin_function
 {
     FUNCTION base;
-    LIST * ( * func )( FRAME *, int flags );
-    int flags;
+    LIST * ( * func )( FRAME *, int32_t flags );
+    int32_t flags;
 } BUILTIN_FUNCTION;
 
 typedef struct _jam_function
 {
     FUNCTION base;
-    int code_size;
+    int32_t code_size;
     instruction * code;
-    int num_constants;
+    int32_t num_constants;
     OBJECT * * constants;
-    int num_subfunctions;
+    int32_t num_subfunctions;
     SUBFUNCTION * functions;
-    int num_subactions;
+    int32_t num_subactions;
     SUBACTION * actions;
     FUNCTION * generic;
     OBJECT * file;
-    int line;
+    int32_t line;
 } JAM_FUNCTION;
 
 
@@ -230,7 +233,7 @@ STACK * stack_global()
     static STACK result;
     if ( !stack )
     {
-        int const size = 1 << 21;
+        int32_t const size = 1 << 21;
         stack = BJAM_MALLOC( size );
         result.data = (char *)stack + size;
     }
@@ -251,7 +254,7 @@ static void check_alignment( STACK * s )
     assert( (size_t)s->data % LISTPTR_ALIGN == 0 );
 }
 
-void * stack_allocate( STACK * s, int size )
+void * stack_allocate( STACK * s, int32_t size )
 {
     check_alignment( s );
     s->data = (char *)s->data - size;
@@ -259,7 +262,7 @@ void * stack_allocate( STACK * s, int size )
     return s->data;
 }
 
-void stack_deallocate( STACK * s, int size )
+void stack_deallocate( STACK * s, int32_t size )
 {
     check_alignment( s );
     s->data = (char *)s->data + size;
@@ -284,13 +287,13 @@ LIST * stack_top( STACK * s )
     return *(LIST * *)s->data;
 }
 
-LIST * stack_at( STACK * s, int n )
+LIST * stack_at( STACK * s, int32_t n )
 {
     check_alignment( s );
     return *( (LIST * *)s->data + n );
 }
 
-void stack_set( STACK * s, int n, LIST * value )
+void stack_set( STACK * s, int32_t n, LIST * value )
 {
     check_alignment( s );
     *((LIST * *)s->data + n) = value;
@@ -302,56 +305,56 @@ void * stack_get( STACK * s )
     return s->data;
 }
 
-LIST * frame_get_local( FRAME * frame, int idx )
+LIST * frame_get_local( FRAME * frame, int32_t idx )
 {
     /* The only local variables are the arguments. */
     return list_copy( lol_get( frame->args, idx ) );
 }
 
-static OBJECT * function_get_constant( JAM_FUNCTION * function, int idx )
+static OBJECT * function_get_constant( JAM_FUNCTION * function, int32_t idx )
 {
     return function->constants[ idx ];
 }
 
 static LIST * function_get_variable( JAM_FUNCTION * function, FRAME * frame,
-    int idx )
+    int32_t idx )
 {
     return list_copy( var_get( frame->module, function->constants[ idx ] ) );
 }
 
 static void function_set_variable( JAM_FUNCTION * function, FRAME * frame,
-    int idx, LIST * value )
+    int32_t idx, LIST * value )
 {
     var_set( frame->module, function->constants[ idx ], value, VAR_SET );
 }
 
 static LIST * function_swap_variable( JAM_FUNCTION * function, FRAME * frame,
-    int idx, LIST * value )
+    int32_t idx, LIST * value )
 {
     return var_swap( frame->module, function->constants[ idx ], value );
 }
 
 static void function_append_variable( JAM_FUNCTION * function, FRAME * frame,
-    int idx, LIST * value )
+    int32_t idx, LIST * value )
 {
     var_set( frame->module, function->constants[ idx ], value, VAR_APPEND );
 }
 
 static void function_default_variable( JAM_FUNCTION * function, FRAME * frame,
-    int idx, LIST * value )
+    int32_t idx, LIST * value )
 {
     var_set( frame->module, function->constants[ idx ], value, VAR_DEFAULT );
 }
 
 static void function_set_rule( JAM_FUNCTION * function, FRAME * frame,
-    STACK * s, int idx )
+    STACK * s, int32_t idx )
 {
     SUBFUNCTION * sub = function->functions + idx;
     new_rule_body( frame->module, sub->name, sub->code, !sub->local );
 }
 
 static void function_set_actions( JAM_FUNCTION * function, FRAME * frame,
-    STACK * s, int idx )
+    STACK * s, int32_t idx )
 {
     SUBACTION * sub = function->actions + idx;
     LIST * bindlist = stack_pop( s );
@@ -365,7 +368,7 @@ static void function_set_actions( JAM_FUNCTION * function, FRAME * frame,
  * returns -1.
  */
 
-static int get_argument_index( char const * s )
+static int32_t get_argument_index( char const * s )
 {
     if ( s[ 0 ] != '\0')
     {
@@ -412,7 +415,7 @@ static int get_argument_index( char const * s )
 static LIST * function_get_named_variable( JAM_FUNCTION * function,
     FRAME * frame, OBJECT * name )
 {
-    int const idx = get_argument_index( object_str( name ) );
+    int32_t const idx = get_argument_index( object_str( name ) );
     return idx == -1
         ? list_copy( var_get( frame->module, name ) )
         : list_copy( lol_get( frame->args, idx ) );
@@ -443,10 +446,10 @@ static void function_default_named_variable( JAM_FUNCTION * function,
 }
 
 static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame,
-    STACK * s, int n_args, char const * unexpanded, OBJECT * file, int line )
+    STACK * s, int32_t n_args, char const * unexpanded, OBJECT * file, int32_t line )
 {
     FRAME inner[ 1 ];
-    int i;
+    int32_t i;
     LIST * first = stack_pop( s );
     LIST * result = L0;
     OBJECT * rulename;
@@ -497,10 +500,10 @@ static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame,
     return result;
 }
 
-static LIST * function_call_member_rule( JAM_FUNCTION * function, FRAME * frame, STACK * s, int n_args, OBJECT * rulename, OBJECT * file, int line )
+static LIST * function_call_member_rule( JAM_FUNCTION * function, FRAME * frame, STACK * s, int32_t n_args, OBJECT * rulename, OBJECT * file, int32_t line )
 {
     FRAME   inner[ 1 ];
-    int i;
+    int32_t i;
     LIST * first = stack_pop( s );
     LIST * result = L0;
     RULE * rule;
@@ -613,27 +616,39 @@ static LIST * function_call_member_rule( JAM_FUNCTION * function, FRAME * frame,
 
 typedef struct
 {
-    int sub1;
-    int sub2;
+    int32_t sub1;
+    int32_t sub2;
 } subscript_t;
 
 typedef struct
 {
-    PATHNAME f;           /* :GDBSMR -- pieces */
-    char     parent;      /* :P -- go to parent directory */
-    char     filemods;    /* one of the above applied */
-    char     downshift;   /* :L -- downshift result */
-    char     upshift;     /* :U -- upshift result */
-    char     to_slashes;  /* :T -- convert "\" to "/" */
-    char     to_windows;  /* :W -- convert cygwin to native paths */
-    PATHPART empty;       /* :E -- default for empties */
-    PATHPART join;        /* :J -- join list with char */
+    PATHNAME f;             /* :GDBSMR -- pieces */
+    PATHPART empty;         /* :E -- default for empties */
+    PATHPART join;          /* :J -- join list with char */
+    PATHPART prefix;        /* :< */
+    PATHPART postfix;       /* :> */
+    bool     parent:1;      /* :P -- go to parent directory */
+    bool     filemods:1;    /* one of the above applied */
+    bool     downshift:1;   /* :L -- downshift result */
+    bool     upshift:1;     /* :U -- upshift result */
+    bool     to_slashes:1;  /* :T -- convert "\" to "/" */
+    bool     to_windows:1;  /* :W -- convert cygwin to native paths */
+    bool     opt_file:1;    /* :O=F -- replace @() with the file part */
+    bool     opt_content:1; /* :O=C -- repalce @() with the content (E) part */
 } VAR_EDITS;
 
-static LIST * apply_modifiers_impl( LIST * result, string * buf,
-    VAR_EDITS * edits, int n, LISTITER iter, LISTITER end );
+struct VAR_EXPANDED
+{
+    LIST * value = L0;
+    LIST * inner = L0;
+    bool opt_file:1;
+    bool  opt_content:1;
+};
+
+static VAR_EXPANDED apply_modifiers_impl( LIST * result, string * buf,
+    VAR_EDITS * edits, int32_t n, LISTITER iter, LISTITER end );
 static void get_iters( subscript_t const subscript, LISTITER * const first,
-    LISTITER * const last, int const length );
+    LISTITER * const last, int32_t const length );
 
 
 /*
@@ -671,12 +686,13 @@ static void get_iters( subscript_t const subscript, LISTITER * const first,
  * var_edit_file() below and path_build() obligingly follow this convention.
  */
 
-static int var_edit_parse( char const * mods, VAR_EDITS * edits, int havezeroed
+static int32_t var_edit_parse( char const * mods, VAR_EDITS * edits, int32_t havezeroed
     )
 {
     while ( *mods )
     {
         PATHPART * fp;
+        bool opt = false;
 
         switch ( *mods++ )
         {
@@ -693,6 +709,9 @@ static int var_edit_parse( char const * mods, VAR_EDITS * edits, int havezeroed
             case 'M': fp = &edits->f.f_member; goto fileval;
             case 'T': edits->to_slashes = 1; continue;
             case 'W': edits->to_windows = 1; continue;
+            case '<': fp = &edits->prefix; goto strval;
+            case '>': fp = &edits->postfix; goto strval;
+            case 'O': opt = true; goto strval;
             default:
                 continue;  /* Should complain, but so what... */
         }
@@ -709,7 +728,7 @@ static int var_edit_parse( char const * mods, VAR_EDITS * edits, int havezeroed
         {
             if ( !havezeroed++ )
             {
-                int i;
+                int32_t i;
                 for ( i = 0; i < 6; ++i )
                 {
                     edits->f.part[ i ].len = 0;
@@ -722,17 +741,35 @@ static int var_edit_parse( char const * mods, VAR_EDITS * edits, int havezeroed
         }
 
     strval:
-        /* Handle :X=value, or :X */
-        if ( *mods != '=' )
+        /* Handle :O=??? */
+        if ( opt )
         {
-            fp->ptr = "";
-            fp->len = 0;
+            if ( *mods == '=' )
+            {
+                for (++mods; *mods; ++mods)
+                {
+                    switch ( *mods )
+                    {
+                        case 'F': edits->opt_file = true; break;
+                        case 'C': edits->opt_content = true; break;
+                    }
+                }
+            }
         }
         else
         {
-            fp->ptr = ++mods;
-            fp->len = strlen( mods );
-            mods += fp->len;
+            /* Handle :X=value, or :X */
+            if ( *mods != '=' )
+            {
+                fp->ptr = "";
+                fp->len = 0;
+            }
+            else
+            {
+                fp->ptr = ++mods;
+                fp->len = int32_t(strlen( mods ));
+                mods += fp->len;
+            }
         }
     }
 
@@ -779,12 +816,12 @@ static void var_edit_file( char const * in, string * out, VAR_EDITS * edits )
  * var_edit_translate_path() - translate path to os native format.
  */
 
-static void var_edit_translate_path( string * out, size_t pos, VAR_EDITS * edits )
+static void var_edit_translate_path( string * out, int32_t pos, VAR_EDITS * edits )
 {
     if ( edits->to_windows )
     {
         string result[ 1 ];
-        int translated;
+        int32_t translated;
 
         /* Translate path to os native format. */
         translated = path_translate_to_os( out->value + pos, result );
@@ -806,7 +843,7 @@ static void var_edit_translate_path( string * out, size_t pos, VAR_EDITS * edits
  * var_edit_shift() - do upshift/downshift & other mods.
  */
 
-static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits )
+static void var_edit_shift( string * out, int32_t pos, VAR_EDITS * edits )
 {
 #if defined( OS_CYGWIN ) || defined( OS_VMS )
     var_edit_translate_path( out, pos, edits );
@@ -834,10 +871,10 @@ static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits )
  * Returns the number of VAR_EDITS pushed onto the STACK.
  */
 
-static int expand_modifiers( STACK * s, int n )
+static int32_t expand_modifiers( STACK * s, int32_t n )
 {
-    int i;
-    int total = 1;
+    int32_t i;
+    int32_t total = 1;
     LIST * * args = (LIST**)stack_get( s );
     for ( i = 0; i < n; ++i )
         total *= list_length( args[ i ] );
@@ -850,7 +887,7 @@ static int expand_modifiers( STACK * s, int n )
             iter[ i ] = list_begin( args[ i ] );
         i = 0;
         {
-            int havezeroed;
+            int32_t havezeroed;
         loop:
             memset( out, 0, sizeof( *out ) );
             havezeroed = 0;
@@ -873,19 +910,37 @@ static int expand_modifiers( STACK * s, int n )
     return total;
 }
 
-static LIST * apply_modifiers( STACK * s, int n )
+static VAR_EXPANDED apply_modifiers( STACK * s, int32_t n )
 {
     LIST * value = stack_top( s );
-    LIST * result = L0;
+    VAR_EXPANDED result;
     VAR_EDITS * const edits = (VAR_EDITS *)( (LIST * *)stack_get( s ) + 1 );
     string buf[ 1 ];
     string_new( buf );
-    result = apply_modifiers_impl( result, buf, edits, n, list_begin( value ),
+    result = apply_modifiers_impl( L0, buf, edits, n, list_begin( value ),
         list_end( value ) );
     string_free( buf );
     return result;
 }
 
+// STACK: LIST * modifiers[modifier_count]
+static VAR_EXPANDED eval_modifiers( STACK * s, LIST * value, int32_t modifier_count )
+{
+    // Convert modifiers to value edits.
+    int32_t edits = expand_modifiers( s, modifier_count );
+    // Edit the value on the stack.
+    stack_push( s, value );
+    VAR_EXPANDED result = apply_modifiers( s, edits );
+    list_free( stack_pop( s ) );
+    // Clean up the value edits on the stack.
+    stack_deallocate( s, edits * sizeof( VAR_EDITS ) );
+    // Clean up the filename modifiers.
+    for ( int32_t i = 0; i < modifier_count; ++i )
+        list_free( stack_pop( s ) );
+    // Done.
+    return result;
+}
+
 
 /*
  * Parse a string of the form "1-2", "-2--1", "2-" and return the two
@@ -953,7 +1008,7 @@ static LIST * apply_subscript( STACK * s )
     LIST * value = stack_top( s );
     LIST * indices = stack_at( s, 1 );
     LIST * result = L0;
-    int length = list_length( value );
+    int32_t length = list_length( value );
     string buf[ 1 ];
     LISTITER indices_iter = list_begin( indices );
     LISTITER const indices_end = list_end( indices );
@@ -980,10 +1035,10 @@ static LIST * apply_subscript( STACK * s )
  */
 
 static void get_iters( subscript_t const subscript, LISTITER * const first,
-    LISTITER * const last, int const length )
+    LISTITER * const last, int32_t const length )
 {
-    int start;
-    int size;
+    int32_t start;
+    int32_t size;
     LISTITER iter;
     LISTITER end;
     {
@@ -1027,10 +1082,36 @@ static void get_iters( subscript_t const subscript, LISTITER * const first,
     *last = end;
 }
 
+static LIST * apply_modifiers_prepost( LIST * result, string * buf,
+    VAR_EDITS * edits, int32_t n, LISTITER begin, LISTITER end )
+{
+    for ( LISTITER iter = begin; iter != end; iter = list_next( iter ) )
+    {
+        for ( int32_t i = 0; i < n; ++i )
+        {
+            if ( edits[ i ].prefix.ptr )
+            {
+                string_append( buf, edits[ i ].prefix.ptr );
+            }
+        }
+        string_append( buf, object_str( list_item( iter ) ) );
+        for ( int32_t i = 0; i < n; ++i )
+        {
+            if ( edits[ i ].postfix.ptr )
+            {
+                string_append( buf, edits[ i ].postfix.ptr );
+            }
+        }
+        result = list_push_back( result, object_new( buf->value ) );
+        string_truncate( buf, 0 );
+    }
+    return result;
+}
+
 static LIST * apply_modifiers_empty( LIST * result, string * buf,
-    VAR_EDITS * edits, int n )
+    VAR_EDITS * edits, int32_t n )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < n; ++i )
     {
         if ( edits[ i ].empty.ptr )
@@ -1046,9 +1127,9 @@ static LIST * apply_modifiers_empty( LIST * result, string * buf,
 }
 
 static LIST * apply_modifiers_non_empty( LIST * result, string * buf,
-    VAR_EDITS * edits, int n, LISTITER begin, LISTITER end )
+    VAR_EDITS * edits, int32_t n, LISTITER begin, LISTITER end )
 {
-    int i;
+    int32_t i;
     LISTITER iter;
     for ( i = 0; i < n; ++i )
     {
@@ -1059,7 +1140,7 @@ static LIST * apply_modifiers_non_empty( LIST * result, string * buf,
             for ( iter = list_next( begin ); iter != end; iter = list_next( iter
                 ) )
             {
-                size_t size;
+                int32_t size;
                 string_append( buf, edits[ i ].join.ptr );
                 size = buf->size;
                 var_edit_file( object_str( list_item( iter ) ), buf, edits + i
@@ -1083,21 +1164,33 @@ static LIST * apply_modifiers_non_empty( LIST * result, string * buf,
     return result;
 }
 
-static LIST * apply_modifiers_impl( LIST * result, string * buf,
-    VAR_EDITS * edits, int n, LISTITER iter, LISTITER end )
+static VAR_EXPANDED apply_modifiers_impl( LIST * result, string * buf,
+    VAR_EDITS * edits, int32_t n, LISTITER iter, LISTITER end )
 {
-    return iter == end
+    LIST * modified = iter == end
         ? apply_modifiers_empty( result, buf, edits, n )
         : apply_modifiers_non_empty( result, buf, edits, n, iter, end );
+    VAR_EXPANDED expanded;
+    expanded.value = apply_modifiers_prepost(
+        L0, buf, edits, n, list_begin( modified ), list_end( modified ) );
+    expanded.inner = modified;
+    expanded.opt_file = false;
+    expanded.opt_content = false;
+    for ( int32_t i = 0; i < n; ++i )
+    {
+        expanded.opt_file |= edits[i].opt_file;
+        expanded.opt_content |= edits[i].opt_content;
+    }
+    return expanded;
 }
 
-static LIST * apply_subscript_and_modifiers( STACK * s, int n )
+static LIST * apply_subscript_and_modifiers( STACK * s, int32_t n )
 {
     LIST * const value = stack_top( s );
     LIST * const indices = stack_at( s, 1 );
     LIST * result = L0;
     VAR_EDITS * const edits = (VAR_EDITS *)((LIST * *)stack_get( s ) + 2);
-    int const length = list_length( value );
+    int32_t const length = list_length( value );
     string buf[ 1 ];
     LISTITER indices_iter = list_begin( indices );
     LISTITER const indices_end = list_end( indices );
@@ -1110,7 +1203,10 @@ static LIST * apply_subscript_and_modifiers( STACK * s, int n )
         subscript_t const sub = parse_subscript( object_str( list_item(
             indices_iter ) ) );
         get_iters( sub, &iter, &end, length );
-        result = apply_modifiers_impl( result, buf, edits, n, iter, end );
+        VAR_EXPANDED modified
+            = apply_modifiers_impl( result, buf, edits, n, iter, end );
+        result = modified.value;
+        list_free( modified.inner );
     }
     string_free( buf );
     return result;
@@ -1158,17 +1254,17 @@ typedef struct expansion_item
 
     /* Internal data initialized and used inside expand(). */
     LISTITER current;  /* Currently used value. */
-    int size;          /* Concatenated string length prior to concatenating the
+    int32_t size;     /* Concatenated string length prior to concatenating the
                         * item's current value.
                         */
 } expansion_item;
 
-static LIST * expand( expansion_item * items, int const length )
+static LIST * expand( expansion_item * items, int32_t const length )
 {
     LIST * result = L0;
     string buf[ 1 ];
-    int size = 0;
-    int i;
+    int32_t size = 0;
+    int32_t i;
 
     assert( length > 0 );
     for ( i = 0; i < length; ++i )
@@ -1190,10 +1286,10 @@ static LIST * expand( expansion_item * items, int const length )
          * strings.
          */
         {
-            int max = 0;
+            int32_t max = 0;
             for ( ; iter != end; iter = list_next( iter ) )
             {
-                int const len = strlen( object_str( list_item( iter ) ) );
+                int32_t const len = int32_t(strlen( object_str( list_item( iter ) ) ));
                 if ( len > max ) max = len;
             }
             size += max;
@@ -1230,9 +1326,9 @@ static LIST * expand( expansion_item * items, int const length )
     return result;
 }
 
-static void combine_strings( STACK * s, int n, string * out )
+static void combine_strings( STACK * s, int32_t n, string * out )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < n; ++i )
     {
         LIST * const values = stack_pop( s );
@@ -1254,8 +1350,9 @@ static void combine_strings( STACK * s, int n, string * out )
 
 struct dynamic_array
 {
-    int size;
-    int capacity;
+    int32_t size;
+    int32_t capacity;
+    int32_t unit_size;
     void * data;
 };
 
@@ -1263,6 +1360,7 @@ static void dynamic_array_init( struct dynamic_array * array )
 {
     array->size = 0;
     array->capacity = 0;
+    array->unit_size = 0;
     array->data = 0;
 }
 
@@ -1272,8 +1370,16 @@ static void dynamic_array_free( struct dynamic_array * array )
 }
 
 static void dynamic_array_push_impl( struct dynamic_array * const array,
-    void const * const value, int const unit_size )
+    void const * const value, int32_t const unit_size )
 {
+    if ( array->unit_size == 0 )
+    {
+        array->unit_size = unit_size;
+    }
+    else
+    {
+        assert( array->unit_size == unit_size );
+    }
     if ( array->capacity == 0 )
     {
         array->capacity = 2;
@@ -1293,7 +1399,7 @@ static void dynamic_array_push_impl( struct dynamic_array * const array,
 }
 
 #define dynamic_array_push( array, value ) (dynamic_array_push_impl(array, &value, sizeof(value)))
-#define dynamic_array_at( type, array, idx ) (((type *)(array)->data)[idx])
+#define dynamic_array_at( type, array, idx ) ( (assert( array->unit_size == sizeof(type) )) , (((type *)(array)->data)[idx]) )
 #define dynamic_array_pop( array ) (--(array)->size)
 
 /*
@@ -1302,7 +1408,7 @@ static void dynamic_array_push_impl( struct dynamic_array * const array,
 
 struct label_info
 {
-    int absolute_position;
+    int32_t absolute_position;
     struct dynamic_array uses[ 1 ];
 };
 
@@ -1311,18 +1417,18 @@ struct label_info
 
 struct loop_info
 {
-    int type;
-    int label;
-    int cleanup_depth;
+    int32_t type;
+    int32_t label;
+    int32_t cleanup_depth;
 };
 
 struct stored_rule
 {
     OBJECT * name;
     PARSE * parse;
-    int num_arguments;
+    int32_t num_arguments;
     struct arg_list * arguments;
-    int local;
+    int32_t local;
 };
 
 typedef struct compiler
@@ -1349,7 +1455,7 @@ static void compiler_init( compiler * c )
 
 static void compiler_free( compiler * c )
 {
-    int i;
+    int32_t i;
     dynamic_array_free( c->actions );
     dynamic_array_free( c->rules );
     for ( i = 0; i < c->labels->size; ++i )
@@ -1367,9 +1473,9 @@ static void compile_emit_instruction( compiler * c, instruction instr )
     dynamic_array_push( c->code, instr );
 }
 
-static int compile_new_label( compiler * c )
+static int32_t compile_new_label( compiler * c )
 {
-    int result = c->labels->size;
+    int32_t result = c->labels->size;
     struct label_info info;
     info.absolute_position = -1;
     dynamic_array_init( info.uses );
@@ -1377,23 +1483,23 @@ static int compile_new_label( compiler * c )
     return result;
 }
 
-static void compile_set_label( compiler * c, int label )
+static void compile_set_label( compiler * c, int32_t label )
 {
     struct label_info * const l = &dynamic_array_at( struct label_info,
         c->labels, label );
-    int const pos = c->code->size;
-    int i;
+    int32_t const pos = c->code->size;
+    int32_t i;
     assert( l->absolute_position == -1 );
     l->absolute_position = pos;
     for ( i = 0; i < l->uses->size; ++i )
     {
-        int id = dynamic_array_at( int, l->uses, i );
-        int offset = (int)( pos - id - 1 );
+        int32_t id = dynamic_array_at( int32_t, l->uses, i );
+        int32_t offset = (int32_t)( pos - id - 1 );
         dynamic_array_at( instruction, c->code, id ).arg = offset;
     }
 }
 
-static void compile_emit( compiler * c, unsigned int op_code, int arg )
+static void compile_emit( compiler * c, uint32_t op_code, int32_t arg )
 {
     instruction instr;
     instr.op_code = op_code;
@@ -1401,11 +1507,11 @@ static void compile_emit( compiler * c, unsigned int op_code, int arg )
     compile_emit_instruction( c, instr );
 }
 
-static void compile_emit_branch( compiler * c, unsigned int op_code, int label )
+static void compile_emit_branch( compiler * c, uint32_t op_code, int32_t label )
 {
     struct label_info * const l = &dynamic_array_at( struct label_info,
         c->labels, label );
-    int const pos = c->code->size;
+    int32_t const pos = c->code->size;
     instruction instr;
     instr.op_code = op_code;
     if ( l->absolute_position == -1 )
@@ -1414,18 +1520,18 @@ static void compile_emit_branch( compiler * c, unsigned int op_code, int label )
         dynamic_array_push( l->uses, pos );
     }
     else
-        instr.arg = (int)( l->absolute_position - pos - 1 );
+        instr.arg = (int32_t)( l->absolute_position - pos - 1 );
     compile_emit_instruction( c, instr );
 }
 
-static int compile_emit_constant( compiler * c, OBJECT * value )
+static int32_t compile_emit_constant( compiler * c, OBJECT * value )
 {
     OBJECT * copy = object_copy( value );
     dynamic_array_push( c->constants, copy );
     return c->constants->size - 1;
 }
 
-static void compile_push_cleanup( compiler * c, unsigned int op_code, int arg )
+static void compile_push_cleanup( compiler * c, uint32_t op_code, int32_t arg )
 {
     instruction instr;
     instr.op_code = op_code;
@@ -1438,19 +1544,19 @@ static void compile_pop_cleanup( compiler * c )
     dynamic_array_pop( c->cleanups );
 }
 
-static void compile_emit_cleanups( compiler * c, int end )
+static void compile_emit_cleanups( compiler * c, int32_t end )
 {
-    int i;
+    int32_t i;
     for ( i = c->cleanups->size; --i >= end; )
     {
         compile_emit_instruction( c, dynamic_array_at( instruction, c->cleanups, i ) );
     }
 }
 
-static void compile_emit_loop_jump( compiler * c, int type )
+static void compile_emit_loop_jump( compiler * c, int32_t type )
 {
     struct loop_info * info = NULL;
-    int i;
+    int32_t i;
     for ( i = c->loop_scopes->size; --i >= 0; )
     {
         struct loop_info * elem = &dynamic_array_at( struct loop_info, c->loop_scopes, i );
@@ -1469,7 +1575,7 @@ static void compile_emit_loop_jump( compiler * c, int type )
     compile_emit_branch( c, INSTR_JUMP, info->label );
 }
 
-static void compile_push_break_scope( compiler * c, int label )
+static void compile_push_break_scope( compiler * c, int32_t label )
 {
     struct loop_info info;
     info.type = LOOP_INFO_BREAK;
@@ -1478,7 +1584,7 @@ static void compile_push_break_scope( compiler * c, int label )
     dynamic_array_push( c->loop_scopes, info );
 }
 
-static void compile_push_continue_scope( compiler * c, int label )
+static void compile_push_continue_scope( compiler * c, int32_t label )
 {
     struct loop_info info;
     info.type = LOOP_INFO_CONTINUE;
@@ -1501,8 +1607,8 @@ static void compile_pop_continue_scope( compiler * c )
     dynamic_array_pop( c->loop_scopes );
 }
 
-static int compile_emit_rule( compiler * c, OBJECT * name, PARSE * parse,
-    int num_arguments, struct arg_list * arguments, int local )
+static int32_t compile_emit_rule( compiler * c, OBJECT * name, PARSE * parse,
+    int32_t num_arguments, struct arg_list * arguments, int32_t local )
 {
     struct stored_rule rule;
     rule.name = object_copy( name );
@@ -1511,10 +1617,10 @@ static int compile_emit_rule( compiler * c, OBJECT * name, PARSE * parse,
     rule.arguments = arguments;
     rule.local = local;
     dynamic_array_push( c->rules, rule );
-    return (int)( c->rules->size - 1 );
+    return (int32_t)( c->rules->size - 1 );
 }
 
-static int compile_emit_actions( compiler * c, PARSE * parse )
+static int32_t compile_emit_actions( compiler * c, PARSE * parse )
 {
     SUBACTION a;
     a.name = object_copy( parse->string );
@@ -1522,13 +1628,13 @@ static int compile_emit_actions( compiler * c, PARSE * parse )
         parse->file, parse->line );
     a.flags = parse->num;
     dynamic_array_push( c->actions, a );
-    return (int)( c->actions->size - 1 );
+    return (int32_t)( c->actions->size - 1 );
 }
 
 static JAM_FUNCTION * compile_to_function( compiler * c )
 {
     JAM_FUNCTION * const result = (JAM_FUNCTION*)BJAM_MALLOC( sizeof( JAM_FUNCTION ) );
-    int i;
+    int32_t i;
     result->base.type = FUNCTION_JAM;
     result->base.reference_count = 1;
     result->base.formal_arguments = 0;
@@ -1594,7 +1700,7 @@ typedef struct VAR_PARSE_ACTIONS
 
 typedef struct _var_parse
 {
-    int type;  /* string, variable or file */
+    int32_t type;  /* string, variable or file */
 } VAR_PARSE;
 
 typedef struct
@@ -1611,14 +1717,54 @@ typedef struct
     OBJECT * s;
 } VAR_PARSE_STRING;
 
-typedef struct
+static void var_parse_free( VAR_PARSE * );
+
+static std::string var_parse_to_string( VAR_PARSE_STRING * string, bool debug = false );
+static std::string var_parse_to_string( VAR_PARSE_GROUP * group, bool debug = false );
+static std::string var_parse_to_string( VAR_PARSE_VAR const * parse, bool debug = false );
+
+static std::string var_parse_to_string( VAR_PARSE_STRING * string, bool debug )
 {
-    VAR_PARSE base;
-    struct dynamic_array filename[ 1 ];
-    struct dynamic_array contents[ 1 ];
-} VAR_PARSE_FILE;
+    std::string result;
+    if ( debug ) result += "'";
+    result += object_str( string->s ) ?  object_str( string->s ) : "";
+    if ( debug ) result += "'";
+    return result;
+}
+static std::string var_parse_to_string( VAR_PARSE_GROUP * group, bool debug )
+{
+    std::string result;
+    if ( debug ) result += "[";
+    for ( int32_t i = 0; i < group->elems->size; ++i )
+    {
+        switch ( dynamic_array_at( VAR_PARSE *, group->elems, i )->type )
+        {
+            case VAR_PARSE_TYPE_VAR:
+            result += var_parse_to_string( dynamic_array_at( VAR_PARSE_VAR *, group->elems, i ), debug );
+            break;
 
-static void var_parse_free( VAR_PARSE * );
+            case VAR_PARSE_TYPE_STRING:
+            result += var_parse_to_string( dynamic_array_at( VAR_PARSE_STRING *, group->elems, i ), debug );
+            break;
+        }
+    }
+    if ( debug ) result += "[";
+    return result;
+}
+static std::string var_parse_to_string( VAR_PARSE_VAR const * parse, bool debug )
+{
+    std::string result = "$(";
+    result += var_parse_to_string( parse->name, debug );
+    if ( parse->subscript )
+    {
+        result += "[" + var_parse_to_string( parse->subscript, debug ) + "]";
+    }
+    for ( int32_t i = 0; i < parse->modifiers->size; ++i )
+    {
+        result += ":" + var_parse_to_string( dynamic_array_at( VAR_PARSE_GROUP *, parse->modifiers, i ), debug );
+    }
+    return result + ")";
+}
 
 
 /*
@@ -1634,7 +1780,7 @@ static VAR_PARSE_GROUP * var_parse_group_new()
 
 static void var_parse_group_free( VAR_PARSE_GROUP * group )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < group->elems->size; ++i )
         var_parse_free( dynamic_array_at( VAR_PARSE *, group->elems, i ) );
     dynamic_array_free( group->elems );
@@ -1689,7 +1835,7 @@ static VAR_PARSE_ACTIONS * var_parse_actions_new()
 
 static void var_parse_actions_free( VAR_PARSE_ACTIONS * actions )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < actions->elems->size; ++i )
         var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *,
             actions->elems, i ) );
@@ -1714,7 +1860,7 @@ static VAR_PARSE_VAR * var_parse_var_new()
 
 static void var_parse_var_free( VAR_PARSE_VAR * var )
 {
-    int i;
+    int32_t i;
     var_parse_group_free( var->name );
     if ( var->subscript )
         var_parse_group_free( var->subscript );
@@ -1732,6 +1878,21 @@ static VAR_PARSE_GROUP * var_parse_var_new_modifier( VAR_PARSE_VAR * var )
     return result;
 }
 
+static int32_t var_parse_var_mod_index( VAR_PARSE_VAR const * var , char m)
+{
+    for ( int32_t i = 0; i < var->modifiers->size; ++i )
+    {
+        VAR_PARSE_GROUP * mod = dynamic_array_at( VAR_PARSE_GROUP *, var->modifiers, i );
+        VAR_PARSE_STRING * mod_val = dynamic_array_at( VAR_PARSE_STRING *, mod->elems, 0 );
+        const char * mod_str = object_str(mod_val->s);
+        if (mod_str && mod_str[0] == m)
+        {
+            return i;
+        }
+    }
+    return -1;
+}
+
 
 /*
  * VAR_PARSE_STRING
@@ -1744,35 +1905,6 @@ static void var_parse_string_free( VAR_PARSE_STRING * string )
 }
 
 
-/*
- * VAR_PARSE_FILE
- */
-
-static VAR_PARSE_FILE * var_parse_file_new( void )
-{
-    VAR_PARSE_FILE * const result = (VAR_PARSE_FILE *)BJAM_MALLOC( sizeof(
-        VAR_PARSE_FILE ) );
-    result->base.type = VAR_PARSE_TYPE_FILE;
-    dynamic_array_init( result->filename );
-    dynamic_array_init( result->contents );
-    return result;
-}
-
-static void var_parse_file_free( VAR_PARSE_FILE * file )
-{
-    int i;
-    for ( i = 0; i < file->filename->size; ++i )
-        var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *,
-            file->filename, i ) );
-    dynamic_array_free( file->filename );
-    for ( i = 0; i < file->contents->size; ++i )
-        var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *,
-            file->contents, i ) );
-    dynamic_array_free( file->contents );
-    BJAM_FREE( file );
-}
-
-
 /*
  * VAR_PARSE
  */
@@ -1782,6 +1914,7 @@ static void var_parse_free( VAR_PARSE * parse )
     switch ( parse->type )
     {
         case VAR_PARSE_TYPE_VAR:
+        case VAR_PARSE_TYPE_FILE:
             var_parse_var_free( (VAR_PARSE_VAR *)parse );
             break;
 
@@ -1789,10 +1922,6 @@ static void var_parse_free( VAR_PARSE * parse )
             var_parse_string_free( (VAR_PARSE_STRING *)parse );
             break;
 
-        case VAR_PARSE_TYPE_FILE:
-            var_parse_file_free( (VAR_PARSE_FILE *)parse );
-            break;
-
         default:
             assert( !"Invalid type" );
     }
@@ -1808,9 +1937,9 @@ static void var_parse_group_compile( VAR_PARSE_GROUP const * parse,
 
 static void var_parse_var_compile( VAR_PARSE_VAR const * parse, compiler * c )
 {
-    int expand_name = 0;
-    int is_get_grist = 0;
-    int has_modifiers = 0;
+    int32_t expand_name = 0;
+    int32_t is_get_grist = 0;
+    int32_t has_modifiers = 0;
     /* Special case common modifiers */
     if ( parse->modifiers->size == 1 )
     {
@@ -1831,7 +1960,7 @@ static void var_parse_var_compile( VAR_PARSE_VAR const * parse, compiler * c )
     /* If there are modifiers, emit them in reverse order. */
     if ( parse->modifiers->size > 0 && !is_get_grist )
     {
-        int i;
+        int32_t i;
         has_modifiers = 1;
         for ( i = 0; i < parse->modifiers->size; ++i )
             var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *,
@@ -1852,7 +1981,7 @@ static void var_parse_var_compile( VAR_PARSE_VAR const * parse, compiler * c )
     {
         OBJECT * const name = ( (VAR_PARSE_STRING *)dynamic_array_at(
             VAR_PARSE *, parse->name->elems, 0 ) )->s;
-        int const idx = get_argument_index( object_str( name ) );
+        int32_t const idx = get_argument_index( object_str( name ) );
         if ( idx != -1 )
             compile_emit( c, INSTR_PUSH_ARG, idx );
         else
@@ -1898,17 +2027,55 @@ static void var_parse_string_compile( VAR_PARSE_STRING const * parse,
         );
 }
 
-static void var_parse_file_compile( VAR_PARSE_FILE const * parse, compiler * c )
+static void parse_var_string( char const * first, char const * last,
+    struct dynamic_array * out );
+
+static void var_parse_file_compile( VAR_PARSE_VAR const * parse, compiler * c )
 {
-    int i;
-    for ( i = 0; i < parse->filename->size; ++i )
-        var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *,
-            parse->filename, parse->filename->size - i - 1 ), c );
-    compile_emit( c, INSTR_APPEND_STRINGS, parse->filename->size );
-    for ( i = 0; i < parse->contents->size; ++i )
-        var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *,
-            parse->contents, parse->contents->size - i - 1 ), c );
-    compile_emit( c, INSTR_WRITE_FILE, parse->contents->size );
+    std::string var = var_parse_to_string( parse, true );
+    int32_t empty_mod_index = var_parse_var_mod_index( parse, 'E' );
+    int32_t grist_mod_index = var_parse_var_mod_index( parse, 'G' );
+    int32_t modifier_count = 0;
+    // Push the contents, aka the edit modifier value.
+    {
+        assert( empty_mod_index >= 0 );
+        // We reparse the edit modifier as we do teh expansion differently than
+        // regular var expansion.
+        std::string contents_val = var_parse_to_string(
+            dynamic_array_at(
+                VAR_PARSE_GROUP *, parse->modifiers, empty_mod_index ), false );
+        dynamic_array contents_dyn_array;
+        dynamic_array_init( &contents_dyn_array );
+        parse_var_string(
+            contents_val.c_str() + 2, contents_val.c_str() + contents_val.size(),
+            &contents_dyn_array );
+        for ( int32_t i = contents_dyn_array.size - 1; i >= 0; --i )
+        {
+            auto group = dynamic_array_at(
+                VAR_PARSE_GROUP *, ( &contents_dyn_array ), i );
+            var_parse_group_compile( group, c );
+            var_parse_group_free( group );
+        }
+        dynamic_array_free( &contents_dyn_array );
+        compile_emit( c, INSTR_APPEND_STRINGS, contents_dyn_array.size );
+    }
+    // If there are modifiers, emit them in reverse order.
+    if ( parse->modifiers->size > 0 )
+    {
+        for ( int32_t i = parse->modifiers->size - 1; i >= 0; --i )
+        {
+            // Skip special modifiers.
+            if ( i == empty_mod_index || i == grist_mod_index ) continue;
+            modifier_count += 1;
+            var_parse_group_compile(
+                dynamic_array_at( VAR_PARSE_GROUP *, parse->modifiers, i ), c );
+        }
+    }
+    // Push the filename, aka var name.
+    var_parse_group_compile( parse->name, c );
+    // This instruction applies the modifiers and writes out the file and fills
+    // in the file name.
+    compile_emit( c, INSTR_WRITE_FILE, modifier_count );
 }
 
 static void var_parse_compile( VAR_PARSE const * parse, compiler * c )
@@ -1924,7 +2091,7 @@ static void var_parse_compile( VAR_PARSE const * parse, compiler * c )
             break;
 
         case VAR_PARSE_TYPE_FILE:
-            var_parse_file_compile( (VAR_PARSE_FILE const *)parse, c );
+            var_parse_file_compile( (VAR_PARSE_VAR const *)parse, c );
             break;
 
         default:
@@ -1936,7 +2103,7 @@ static void var_parse_group_compile( VAR_PARSE_GROUP const * parse, compiler * c
     )
 {
     /* Emit the elements in reverse order. */
-    int i;
+    int32_t i;
     for ( i = 0; i < parse->elems->size; ++i )
         var_parse_compile( dynamic_array_at( VAR_PARSE *, parse->elems,
             parse->elems->size - i - 1 ), c );
@@ -1952,7 +2119,7 @@ static void var_parse_group_compile( VAR_PARSE_GROUP const * parse, compiler * c
 static void var_parse_actions_compile( VAR_PARSE_ACTIONS const * actions,
     compiler * c )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < actions->elems->size; ++i )
         var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *,
             actions->elems, actions->elems->size - i - 1 ), c );
@@ -1964,10 +2131,8 @@ static void var_parse_actions_compile( VAR_PARSE_ACTIONS const * actions,
  * Parse VAR_PARSE_VAR
  */
 
-static VAR_PARSE * parse_at_file( char const * start, char const * mid,
-    char const * end );
 static VAR_PARSE * parse_variable( char const * * string );
-static int try_parse_variable( char const * * s_, char const * * string,
+static int32_t try_parse_variable( char const * * s_, char const * * string,
     VAR_PARSE_GROUP * out );
 static void balance_parentheses( char const * * s_, char const * * string,
     VAR_PARSE_GROUP * out );
@@ -2011,7 +2176,7 @@ static VAR_PARSE_ACTIONS * parse_actions( char const * string )
  * starts with a variable, 0 otherwise.
  */
 
-static int try_parse_variable( char const * * s_, char const * * string,
+static int32_t try_parse_variable( char const * * s_, char const * * string,
     VAR_PARSE_GROUP * out )
 {
     char const * s = *s_;
@@ -2026,43 +2191,29 @@ static int try_parse_variable( char const * * s_, char const * * string,
     }
     if ( s[ 0 ] == '@' && s[ 1 ] == '(' )
     {
-        int depth = 1;
-        char const * ine;
-        char const * split = 0;
         var_parse_group_maybe_add_constant( out, *string, s );
         s += 2;
-        ine = s;
-
-        /* Scan the content of the response file @() section. */
-        while ( *ine && ( depth > 0 ) )
+        VAR_PARSE_VAR *vp = (VAR_PARSE_VAR*)parse_variable( &s );
+        /* We at least need the empty (:E) modifier. */
+        if (var_parse_var_mod_index(vp, 'E') >= 0)
         {
-            switch ( *ine )
-            {
-            case '(': ++depth; break;
-            case ')': --depth; break;
-            case ':':
-                if ( ( depth == 1 ) && ( ine[ 1 ] == 'E' ) && ( ine[ 2 ] == '='
-                    ) )
-                    split = ine;
-                break;
-            }
-            ++ine;
+            vp->base.type = VAR_PARSE_TYPE_FILE;
+            var_parse_group_add( out, (VAR_PARSE*)vp );
+            *string = s;
+            *s_ = s;
+            return 1;
+        }
+        else
+        {
+            var_parse_var_free( vp );
         }
-
-        if ( !split || depth )
-            return 0;
-
-        var_parse_group_add( out, parse_at_file( s, split, ine - 1 ) );
-        *string = ine;
-        *s_ = ine;
-        return 1;
     }
     return 0;
 }
 
 
 static char const * current_file = "";
-static int current_line;
+static int32_t current_line;
 
 static void parse_error( char const * message )
 {
@@ -2221,20 +2372,6 @@ static void parse_var_string( char const * first, char const * last,
     }
 }
 
-/*
- * start should point to the character immediately following the opening "@(",
- * mid should point to the ":E=", and end should point to the closing ")".
- */
-
-static VAR_PARSE * parse_at_file( char const * start, char const * mid,
-    char const * end )
-{
-    VAR_PARSE_FILE * result = var_parse_file_new();
-    parse_var_string( start, mid, result->filename );
-    parse_var_string( mid + 3, end, result->contents );
-    return (VAR_PARSE *)result;
-}
-
 /*
  * Given that *s_ points to the character after a "(", parses up to the matching
  * ")". *string should point to the first unemitted character before *s_.
@@ -2247,7 +2384,7 @@ static VAR_PARSE * parse_at_file( char const * start, char const * mid,
 void balance_parentheses( char const * * s_, char const * * string,
     VAR_PARSE_GROUP * out)
 {
-    int depth = 1;
+    int32_t depth = 1;
     char const * s = *s_;
     for ( ; ; )
     {
@@ -2287,10 +2424,10 @@ void balance_parentheses( char const * * s_, char const * * string,
 #define RESULT_RETURN 1
 #define RESULT_NONE 2
 
-static void compile_parse( PARSE * parse, compiler * c, int result_location );
-static struct arg_list * arg_list_compile( PARSE * parse, int * num_arguments );
+static void compile_parse( PARSE * parse, compiler * c, int32_t result_location );
+static struct arg_list * arg_list_compile( PARSE * parse, int32_t * num_arguments );
 
-static void compile_condition( PARSE * parse, compiler * c, int branch_true, int label )
+static void compile_condition( PARSE * parse, compiler * c, int32_t branch_true, int32_t label )
 {
     assert( parse->type == PARSE_EVAL );
     switch ( parse->num )
@@ -2369,7 +2506,7 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int
         case EXPR_AND:
             if ( branch_true )
             {
-                int f = compile_new_label( c );
+                int32_t f = compile_new_label( c );
                 compile_condition( parse->left, c, 0, f );
                 compile_condition( parse->right, c, 1, label );
                 compile_set_label( c, f );
@@ -2389,7 +2526,7 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int
             }
             else
             {
-                int t = compile_new_label( c );
+                int32_t t = compile_new_label( c );
                 compile_condition( parse->left, c, 1, t );
                 compile_condition( parse->right, c, 0, label );
                 compile_set_label( c, t );
@@ -2402,8 +2539,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int
     }
 }
 
-static void adjust_result( compiler * c, int actual_location,
-    int desired_location )
+static void adjust_result( compiler * c, int32_t actual_location,
+    int32_t desired_location )
 {
     if ( actual_location == desired_location )
         ;
@@ -2442,7 +2579,7 @@ static void compile_append_chain( PARSE * parse, compiler * c )
     }
 }
 
-static void compile_emit_debug(compiler * c, int line)
+static void compile_emit_debug(compiler * c, int32_t line)
 {
 #ifdef JAM_DEBUGGER
     if ( debug_is_debugging() )
@@ -2450,7 +2587,7 @@ static void compile_emit_debug(compiler * c, int line)
 #endif
 }
 
-static void compile_parse( PARSE * parse, compiler * c, int result_location )
+static void compile_parse( PARSE * parse, compiler * c, int32_t result_location )
 {
     compile_emit_debug(c, parse->line);
     if ( parse->type == PARSE_APPEND )
@@ -2467,8 +2604,8 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
             compile_parse( parse->left, c, result_location );
         else
         {
-            int f = compile_new_label( c );
-            int end = compile_new_label( c );
+            int32_t f = compile_new_label( c );
+            int32_t end = compile_new_label( c );
 
             out_printf( "%s:%d: Conditional used as list (check operator "
                 "precedence).\n", object_str( parse->file ), parse->line );
@@ -2486,10 +2623,10 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     }
     else if ( parse->type == PARSE_FOREACH )
     {
-        int var = compile_emit_constant( c, parse->string );
-        int top = compile_new_label( c );
-        int end = compile_new_label( c );
-        int continue_ = compile_new_label( c );
+        int32_t var = compile_emit_constant( c, parse->string );
+        int32_t top = compile_new_label( c );
+        int32_t end = compile_new_label( c );
+        int32_t continue_ = compile_new_label( c );
 
         /*
          * Evaluate the list.
@@ -2536,7 +2673,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     }
     else if ( parse->type == PARSE_IF )
     {
-        int f = compile_new_label( c );
+        int32_t f = compile_new_label( c );
         /* Emit the condition */
         compile_condition( parse->left, c, 0, f );
         /* Emit the if block */
@@ -2544,7 +2681,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
         if ( parse->third->type != PARSE_NULL || result_location != RESULT_NONE )
         {
             /* Emit the else block */
-            int end = compile_new_label( c );
+            int32_t end = compile_new_label( c );
             compile_emit_branch( c, INSTR_JUMP, end );
             compile_set_label( c, f );
             compile_parse( parse->third, c, result_location );
@@ -2556,12 +2693,12 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     }
     else if ( parse->type == PARSE_WHILE )
     {
-        int nested_result = result_location == RESULT_NONE
+        int32_t nested_result = result_location == RESULT_NONE
             ? RESULT_NONE
             : RESULT_RETURN;
-        int test = compile_new_label( c );
-        int top = compile_new_label( c );
-        int end = compile_new_label( c );
+        int32_t test = compile_new_label( c );
+        int32_t top = compile_new_label( c );
+        int32_t end = compile_new_label( c );
         /* Make sure that we return an empty list if the loop runs zero times.
          */
         adjust_result( c, RESULT_NONE, nested_result );
@@ -2590,7 +2727,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     }
     else if ( parse->type == PARSE_MODULE )
     {
-        int const nested_result = result_location == RESULT_NONE
+        int32_t const nested_result = result_location == RESULT_NONE
             ? RESULT_NONE
             : RESULT_RETURN;
         compile_parse( parse->left, c, RESULT_STACK );
@@ -2633,7 +2770,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     }
     else if ( parse->type == PARSE_LOCAL )
     {
-        int nested_result = result_location == RESULT_NONE
+        int32_t nested_result = result_location == RESULT_NONE
             ? RESULT_NONE
             : RESULT_RETURN;
         /* This should be left recursive group of compile_appends. */
@@ -2658,7 +2795,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
             if ( group->elems->size == 1 && dynamic_array_at( VAR_PARSE *,
                 group->elems, 0 )->type == VAR_PARSE_TYPE_STRING )
             {
-                int const name = compile_emit_constant( c, (
+                int32_t const name = compile_emit_constant( c, (
                     (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *,
                     group->elems, 0 ) )->s );
                 var_parse_group_free( group );
@@ -2736,7 +2873,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
             else
             {
                 /* Too complex.  Fall back on push/pop. */
-                int end = compile_new_label( c );
+                int32_t end = compile_new_label( c );
                 compile_parse( parse->left, c, RESULT_STACK );
                 compile_emit_branch( c, INSTR_PUSH_ON, end );
                 compile_push_cleanup( c, INSTR_POP_ON, 0 );
@@ -2749,7 +2886,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
         }
         else
         {
-            int end = compile_new_label( c );
+            int32_t end = compile_new_label( c );
             compile_parse( parse->left, c, RESULT_STACK );
             compile_emit_branch( c, INSTR_PUSH_ON, end );
             compile_push_cleanup( c, INSTR_POP_ON, 0 );
@@ -2763,7 +2900,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     else if ( parse->type == PARSE_RULE )
     {
         PARSE * p;
-        int n = 0;
+        int32_t n = 0;
         VAR_PARSE_GROUP * group;
         char const * s = object_str( parse->string );
 
@@ -2811,8 +2948,8 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     else if ( parse->type == PARSE_SET )
     {
         PARSE * vars = parse->left;
-        unsigned int op_code;
-        unsigned int op_code_group;
+        uint32_t op_code;
+        uint32_t op_code_group;
 
         switch ( parse->num )
         {
@@ -2832,7 +2969,7 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
             if ( group->elems->size == 1 && dynamic_array_at( VAR_PARSE *,
                 group->elems, 0 )->type == VAR_PARSE_TYPE_STRING )
             {
-                int const name = compile_emit_constant( c, (
+                int32_t const name = compile_emit_constant( c, (
                     (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *,
                     group->elems, 0 ) )->s );
                 var_parse_group_free( group );
@@ -2875,16 +3012,16 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     }
     else if ( parse->type == PARSE_SETCOMP )
     {
-        int n_args;
+        int32_t n_args;
         struct arg_list * args = arg_list_compile( parse->right, &n_args );
-        int const rule_id = compile_emit_rule( c, parse->string, parse->left,
+        int32_t const rule_id = compile_emit_rule( c, parse->string, parse->left,
             n_args, args, parse->num );
         compile_emit( c, INSTR_RULE, rule_id );
         adjust_result( c, RESULT_NONE, result_location );
     }
     else if ( parse->type == PARSE_SETEXEC )
     {
-        int const actions_id = compile_emit_actions( c, parse );
+        int32_t const actions_id = compile_emit_actions( c, parse );
         compile_parse( parse->left, c, RESULT_STACK );
         compile_emit( c, INSTR_ACTIONS, actions_id );
         adjust_result( c, RESULT_NONE, result_location );
@@ -2907,13 +3044,13 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location )
     }
     else if ( parse->type == PARSE_SWITCH )
     {
-        int const switch_end = compile_new_label( c );
+        int32_t const switch_end = compile_new_label( c );
         compile_parse( parse->left, c, RESULT_STACK );
 
         for ( parse = parse->right; parse; parse = parse->right )
         {
-            int const id = compile_emit_constant( c, parse->left->string );
-            int const next_case = compile_new_label( c );
+            int32_t const id = compile_emit_constant( c, parse->left->string );
+            int32_t const next_case = compile_new_label( c );
             compile_emit( c, INSTR_PUSH_CONSTANT, id );
             compile_emit_branch( c, INSTR_JUMP_NOT_GLOB, next_case );
             compile_parse( parse->left->left, c, result_location );
@@ -2954,7 +3091,7 @@ void function_set_rulename( FUNCTION * function, OBJECT * rulename )
     function->rulename = rulename;
 }
 
-void function_location( FUNCTION * function_, OBJECT * * file, int * line )
+void function_location( FUNCTION * function_, OBJECT * * file, int32_t * line )
 {
     if ( function_->type == FUNCTION_BUILTIN )
     {
@@ -2978,10 +3115,10 @@ void function_location( FUNCTION * function_, OBJECT * * file, int * line )
 }
 
 static struct arg_list * arg_list_compile_builtin( char const * * args,
-    int * num_arguments );
+    int32_t * num_arguments );
 
-FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int flags ),
-    int flags, char const * * args )
+FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int32_t flags ),
+    int32_t flags, char const * * args )
 {
     BUILTIN_FUNCTION * result = (BUILTIN_FUNCTION*)BJAM_MALLOC( sizeof( BUILTIN_FUNCTION ) );
     result->base.type = FUNCTION_BUILTIN;
@@ -3009,7 +3146,7 @@ FUNCTION * function_compile( PARSE * parse )
 }
 
 FUNCTION * function_compile_actions( char const * actions, OBJECT * file,
-    int line )
+    int32_t line )
 {
     compiler c[ 1 ];
     JAM_FUNCTION * result;
@@ -3028,7 +3165,7 @@ FUNCTION * function_compile_actions( char const * actions, OBJECT * file,
     return (FUNCTION *)result;
 }
 
-static void argument_list_print( struct arg_list * args, int num_args );
+static void argument_list_print( struct arg_list * args, int32_t num_args );
 
 
 /* Define delimiters for type check elements in argument lists (and return type
@@ -3042,7 +3179,7 @@ static void argument_list_print( struct arg_list * args, int num_args );
  * specification.
  */
 
-int is_type_name( char const * s )
+int32_t is_type_name( char const * s )
 {
     return s[ 0 ] == TYPE_OPEN_DELIM && s[ strlen( s ) - 1 ] ==
         TYPE_CLOSE_DELIM;
@@ -3113,18 +3250,18 @@ static void type_check( OBJECT * type_name, LIST * values, FRAME * caller,
         caller, called, arg_name );
 }
 
-void argument_list_check( struct arg_list * formal, int formal_count,
+void argument_list_check( struct arg_list * formal, int32_t formal_count,
     FUNCTION * function, FRAME * frame )
 {
     LOL * all_actual = frame->args;
-    int i;
+    int32_t i;
 
     for ( i = 0; i < formal_count; ++i )
     {
         LIST * actual = lol_get( all_actual, i );
         LISTITER actual_iter = list_begin( actual );
         LISTITER const actual_end = list_end( actual );
-        int j;
+        int32_t j;
         for ( j = 0; j < formal[ i ].size; ++j )
         {
             struct argument * formal_arg = &formal[ i ].args[ j ];
@@ -3178,22 +3315,22 @@ void argument_list_check( struct arg_list * formal, int formal_count,
     }
 }
 
-void argument_list_push( struct arg_list * formal, int formal_count,
+void argument_list_push( struct arg_list * formal, int32_t formal_count,
     FUNCTION * function, FRAME * frame, STACK * s )
 {
     LOL * all_actual = frame->args;
-    int i;
+    int32_t i;
 
     for ( i = 0; i < formal_count; ++i )
     {
         LIST * actual = lol_get( all_actual, i );
         LISTITER actual_iter = list_begin( actual );
         LISTITER const actual_end = list_end( actual );
-        int j;
+        int32_t j;
         for ( j = 0; j < formal[ i ].size; ++j )
         {
             struct argument * formal_arg = &formal[ i ].args[ j ];
-            LIST * value;
+            LIST * value = L0;
 
             switch ( formal_arg->flags )
             {
@@ -3255,13 +3392,13 @@ void argument_list_push( struct arg_list * formal, int formal_count,
     }
 }
 
-void argument_list_pop( struct arg_list * formal, int formal_count,
+void argument_list_pop( struct arg_list * formal, int32_t formal_count,
     FRAME * frame, STACK * s )
 {
-    int i;
+    int32_t i;
     for ( i = formal_count - 1; i >= 0; --i )
     {
-        int j;
+        int32_t j;
         for ( j = formal[ i ].size - 1; j >= 0 ; --j )
         {
             struct argument * formal_arg = &formal[ i ].args[ j ];
@@ -3288,7 +3425,7 @@ struct argument_compiler
 {
     struct dynamic_array args[ 1 ];
     struct argument arg;
-    int state;
+    int32_t state;
 #define ARGUMENT_COMPILER_START         0
 #define ARGUMENT_COMPILER_FOUND_TYPE    1
 #define ARGUMENT_COMPILER_FOUND_OBJECT  2
@@ -3308,7 +3445,7 @@ static void argument_compiler_free( struct argument_compiler * c )
 }
 
 static void argument_compiler_add( struct argument_compiler * c, OBJECT * arg,
-    OBJECT * file, int line )
+    OBJECT * file, int32_t line )
 {
     switch ( c->state )
     {
@@ -3391,7 +3528,7 @@ static void argument_compiler_recurse( struct argument_compiler * c,
 }
 
 static struct arg_list arg_compile_impl( struct argument_compiler * c,
-    OBJECT * file, int line )
+    OBJECT * file, int32_t line )
 {
     struct arg_list result;
     switch ( c->state )
@@ -3458,7 +3595,7 @@ static void argument_list_compiler_recurse( struct argument_list_compiler * c,
     }
 }
 
-static struct arg_list * arg_list_compile( PARSE * parse, int * num_arguments )
+static struct arg_list * arg_list_compile( PARSE * parse, int32_t * num_arguments )
 {
     if ( parse )
     {
@@ -3478,7 +3615,7 @@ static struct arg_list * arg_list_compile( PARSE * parse, int * num_arguments )
 }
 
 static struct arg_list * arg_list_compile_builtin( char const * * args,
-    int * num_arguments )
+    int32_t * num_arguments )
 {
     if ( args )
     {
@@ -3518,14 +3655,14 @@ static struct arg_list * arg_list_compile_builtin( char const * * args,
     return 0;
 }
 
-static void argument_list_print( struct arg_list * args, int num_args )
+static void argument_list_print( struct arg_list * args, int32_t num_args )
 {
     if ( args )
     {
-        int i;
+        int32_t i;
         for ( i = 0; i < num_args; ++i )
         {
-            int j;
+            int32_t j;
             if ( i ) out_printf( " : " );
             for ( j = 0; j < args[ i ].size; ++j )
             {
@@ -3547,17 +3684,17 @@ static void argument_list_print( struct arg_list * args, int num_args )
 
 
 struct arg_list * argument_list_bind_variables( struct arg_list * formal,
-    int formal_count, module_t * module, int * counter )
+    int32_t formal_count, module_t * module, int32_t * counter )
 {
     if ( formal )
     {
         struct arg_list * result = (struct arg_list *)BJAM_MALLOC( sizeof(
             struct arg_list ) * formal_count );
-        int i;
+        int32_t i;
 
         for ( i = 0; i < formal_count; ++i )
         {
-            int j;
+            int32_t j;
             struct argument * args = (struct argument *)BJAM_MALLOC( sizeof(
                 struct argument ) * formal[ i ].size );
             for ( j = 0; j < formal[ i ].size; ++j )
@@ -3580,12 +3717,12 @@ struct arg_list * argument_list_bind_variables( struct arg_list * formal,
 }
 
 
-void argument_list_free( struct arg_list * args, int args_count )
+void argument_list_free( struct arg_list * args, int32_t args_count )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < args_count; ++i )
     {
-        int j;
+        int32_t j;
         for ( j = 0; j < args[ i ].size; ++j )
         {
             if ( args[ i ].args[ j ].type_name  )
@@ -3614,7 +3751,7 @@ FUNCTION * function_unbind_variables( FUNCTION * f )
 }
 
 FUNCTION * function_bind_variables( FUNCTION * f, module_t * module,
-    int * counter )
+    int32_t * counter )
 {
     if ( f->type == FUNCTION_BUILTIN )
         return f;
@@ -3626,7 +3763,7 @@ FUNCTION * function_bind_variables( FUNCTION * f, module_t * module,
         JAM_FUNCTION * func = (JAM_FUNCTION *)f;
         JAM_FUNCTION * new_func = (JAM_FUNCTION *)BJAM_MALLOC( sizeof( JAM_FUNCTION ) );
         instruction * code;
-        int i;
+        int32_t i;
         assert( f->type == FUNCTION_JAM );
         memcpy( new_func, func, sizeof( JAM_FUNCTION ) );
         new_func->base.reference_count = 1;
@@ -3640,7 +3777,7 @@ FUNCTION * function_bind_variables( FUNCTION * f, module_t * module,
         for ( i = 0; ; ++i )
         {
             OBJECT * key;
-            int op_code;
+            int32_t op_code;
             code = func->code + i;
             switch ( code->op_code )
             {
@@ -3657,7 +3794,7 @@ FUNCTION * function_bind_variables( FUNCTION * f, module_t * module,
             case INSTR_CALL_RULE: ++i; continue;
             case INSTR_PUSH_MODULE:
                 {
-                    int depth = 1;
+                    int32_t depth = 1;
                     ++i;
                     while ( depth > 0 )
                     {
@@ -3707,7 +3844,7 @@ LIST * function_get_variables( FUNCTION * f )
         JAM_FUNCTION * func = (JAM_FUNCTION *)f;
         LIST * result = L0;
         instruction * code;
-        int i;
+        int32_t i;
         assert( f->type == FUNCTION_JAM );
         if ( func->generic ) func = ( JAM_FUNCTION * )func->generic;
 
@@ -3723,7 +3860,7 @@ LIST * function_get_variables( FUNCTION * f )
             case INSTR_CALL_RULE: ++i; continue;
             case INSTR_PUSH_MODULE:
                 {
-                    int depth = 1;
+                    int32_t depth = 1;
                     ++i;
                     while ( depth > 0 )
                     {
@@ -3767,7 +3904,7 @@ void function_refer( FUNCTION * func )
 
 void function_free( FUNCTION * function_ )
 {
-    int i;
+    int32_t i;
 
     if ( --function_->reference_count != 0 )
         return;
@@ -3859,6 +3996,152 @@ void function_run_actions( FUNCTION * function, FRAME * frame, STACK * s,
     stack_deallocate( s, sizeof( string * ) );
 }
 
+// Result is either the filename or contents depending on:
+// 1. If the RESPONSE_FILE_SUB == f or not set (it's filename)
+// 2. If the RESPONSE_FILE_SUB == c (it's contents)
+// 3. If the RESPONSE_FILE_SUB == a (depends on the length of contents)
+// Note, returns a *copy* of the filename or contents.
+LIST * function_execute_write_file(
+    JAM_FUNCTION * function, FRAME * frame, STACK * s,
+    VAR_EXPANDED filename, LIST * contents )
+{
+    LIST * filename_or_contents_result = nullptr;
+
+    char response_file_sub_c = 'f';
+    if ( filename.opt_file && filename.opt_content )
+    {
+        LIST * response_file_sub = function_get_named_variable(
+            function, frame, constant_RESPONSE_FILE_SUB );
+        if ( response_file_sub && list_front( response_file_sub ) )
+            response_file_sub_c =  object_str( list_front( response_file_sub ) )[0];
+        list_free( response_file_sub );
+        const char * contents_str = object_str( list_front( contents ) );
+        if ( response_file_sub_c == 'a' )
+        {
+            if ( int32_t( strlen( contents_str ) + 256 ) > shell_maxline() )
+                response_file_sub_c = 'f';
+            else
+                response_file_sub_c = 'c';
+        }
+    }
+    else if ( filename.opt_file )
+        response_file_sub_c = 'f';
+    else if ( filename.opt_content )
+        response_file_sub_c = 'c';
+    if ( response_file_sub_c == 'c' )
+    {
+        filename_or_contents_result = list_copy( contents );
+    }
+    else
+    {
+        char const * out = object_str( list_front( filename.inner ) );
+        OBJECT * tmp_filename = nullptr;
+        FILE * out_file = nullptr;
+        bool out_debug = DEBUG_EXEC != 0;
+
+        /* For stdout/stderr we will create a temp file and generate a
+        * command that outputs the content as needed.
+        */
+        if ( ( strcmp( "STDOUT", out ) == 0 ) ||
+            ( strcmp( "STDERR", out ) == 0 ) )
+        {
+            int32_t err_redir = strcmp( "STDERR", out ) == 0;
+            string result[ 1 ];
+
+            tmp_filename = path_tmpfile();
+
+            /* Construct os-specific cat command. */
+            {
+                const char * command = "cat";
+                const char * quote = "\"";
+                const char * redirect = "1>&2";
+
+                #ifdef OS_NT
+                command = "type";
+                quote = "\"";
+                #elif defined( OS_VMS )
+                command = "pipe type";
+                quote = "";
+
+                /* Get tmp file name in os-format. */
+                {
+                    string os_filename[ 1 ];
+
+                    string_new( os_filename );
+                    path_translate_to_os( object_str( tmp_filename ), os_filename );
+                    object_free( tmp_filename );
+                    tmp_filename = object_new( os_filename->value );
+                    string_free( os_filename );
+                }
+                #endif
+
+                string_new( result );
+                string_append( result, command );
+                string_append( result, " " );
+                string_append( result, quote );
+                string_append( result, object_str( tmp_filename ) );
+                string_append( result, quote );
+                if ( err_redir )
+                {
+                    string_append( result, " " );
+                    string_append( result, redirect );
+                }
+            }
+
+            /* Replace STDXXX with the temporary file. */
+            filename_or_contents_result = list_new( object_new( result->value ) );
+            out = object_str( tmp_filename );
+
+            string_free( result );
+
+            /* Make sure temp files created by this get nuked eventually. */
+            file_remove_atexit( tmp_filename );
+        }
+        else
+        {
+            filename_or_contents_result = list_copy( filename.value );
+        }
+
+        if ( !globs.noexec )
+        {
+            string out_name[ 1 ];
+            /* Handle "path to file" filenames. */
+            if ( ( out[ 0 ] == '"' ) && ( out[ strlen( out ) - 1 ] == '"' )
+                )
+            {
+                string_copy( out_name, out + 1 );
+                string_truncate( out_name, out_name->size - 1 );
+            }
+            else
+                string_copy( out_name, out );
+            out_file = fopen( out_name->value, "w" );
+
+            if ( !out_file )
+            {
+                err_printf( "[errno %d] failed to write output file '%s': %s",
+                    errno, out_name->value, strerror(errno) );
+                exit( EXITBAD );
+            }
+            string_free( out_name );
+        }
+
+        if ( out_debug ) out_printf( "\nfile %s\n", out );
+        if ( out_file ) fputs( object_str( list_front( contents ) ), out_file );
+        if ( out_debug ) out_puts( object_str( list_front( contents ) ) );
+        if ( out_file )
+        {
+            fflush( out_file );
+            fclose( out_file );
+        }
+        if ( tmp_filename )
+            object_free( tmp_filename );
+
+        if ( out_debug ) out_putc( '\n' );
+    }
+
+    return filename_or_contents_result;
+}
+
 /*
  * WARNING: The instruction set is tuned for Jam and is not really generic. Be
  * especially careful about stack push/pop.
@@ -3871,7 +4154,9 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
     LIST * l;
     LIST * r;
     LIST * result = L0;
+#ifndef NDEBUG
     void * saved_stack = s->data;
+#endif
 
     PROFILE_ENTER_LOCAL(function_run);
 
@@ -4250,8 +4535,8 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
                 backtrace( frame );
                 assert( saved_stack == s->data );
             }
-#endif
             assert( saved_stack == s->data );
+#endif
             debug_on_exit_function( function->base.rulename );
             PROFILE_EXIT_LOCAL(function_run_INSTR_RETURN);
             PROFILE_EXIT_LOCAL(function_run);
@@ -4467,7 +4752,7 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
                 OBJECT * varname = function->constants[ code->arg ];
                 TARGET * t = bindtarget( list_front( targets ) );
                 SETTINGS * s = t->settings;
-                int found = 0;
+                int32_t found = 0;
                 for ( ; s != 0; s = s->next )
                 {
                     if ( object_equal( s->symbol, varname ) )
@@ -4653,12 +4938,14 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
         case INSTR_APPLY_MODIFIERS:
         {
             PROFILE_ENTER_LOCAL(function_run_INSTR_APPLY_MODIFIERS);
-            int n;
-            int i;
+            int32_t n;
+            int32_t i;
             l = stack_pop( s );
             n = expand_modifiers( s, code->arg );
             stack_push( s, l );
-            l = apply_modifiers( s, n );
+            VAR_EXPANDED m = apply_modifiers( s, n );
+            l = m.value;
+            list_free( m.inner );
             list_free( stack_pop( s ) );
             stack_deallocate( s, n * sizeof( VAR_EDITS ) );
             for ( i = 0; i < code->arg; ++i )
@@ -4682,8 +4969,8 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
         case INSTR_APPLY_INDEX_MODIFIERS:
         {
             PROFILE_ENTER_LOCAL(function_run_INSTR_APPLY_INDEX_MODIFIERS);
-            int i;
-            int n;
+            int32_t i;
+            int32_t n;
             l = stack_pop( s );
             r = stack_pop( s );
             n = expand_modifiers( s, code->arg );
@@ -4703,9 +4990,9 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
         case INSTR_APPLY_MODIFIERS_GROUP:
         {
             PROFILE_ENTER_LOCAL(function_run_INSTR_APPLY_MODIFIERS_GROUP);
-            int i;
+            int32_t i;
             LIST * const vars = stack_pop( s );
-            int const n = expand_modifiers( s, code->arg );
+            int32_t const n = expand_modifiers( s, code->arg );
             LIST * result = L0;
             LISTITER iter = list_begin( vars );
             LISTITER const end = list_end( vars );
@@ -4713,7 +5000,9 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
             {
                 stack_push( s, function_get_named_variable( function, frame,
                     list_item( iter ) ) );
-                result = list_append( result, apply_modifiers( s, n ) );
+                VAR_EXPANDED m = apply_modifiers( s, n );
+                result = m.value;
+                list_free( m.inner );
                 list_free( stack_pop( s ) );
             }
             list_free( vars );
@@ -4749,10 +5038,10 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
         case INSTR_APPLY_INDEX_MODIFIERS_GROUP:
         {
             PROFILE_ENTER_LOCAL(function_run_INSTR_APPLY_INDEX_MODIFIERS_GROUP);
-            int i;
+            int32_t i;
             LIST * const vars = stack_pop( s );
             LIST * const r = stack_pop( s );
-            int const n = expand_modifiers( s, code->arg );
+            int32_t const n = expand_modifiers( s, code->arg );
             LIST * result = L0;
             LISTITER iter = list_begin( vars );
             LISTITER const end = list_end( vars );
@@ -4778,11 +5067,11 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
         case INSTR_COMBINE_STRINGS:
         {
             PROFILE_ENTER_LOCAL(function_run_INSTR_COMBINE_STRINGS);
-            size_t const buffer_size = code->arg * sizeof( expansion_item );
+            int32_t const buffer_size = code->arg * sizeof( expansion_item );
             LIST * * const stack_pos = (LIST * * const)stack_get( s );
             expansion_item * items = (expansion_item *)stack_allocate( s, buffer_size );
             LIST * result;
-            int i;
+            int32_t i;
             for ( i = 0; i < code->arg; ++i )
                 items[ i ].values = stack_pos[ i ];
             result = expand( items, code->arg );
@@ -4809,7 +5098,7 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
                 if ( value[ 0 ] == '<' && ( p = strchr( value, '>' ) ) )
                 {
                     if( p[ 1 ] )
-                        new_object = object_new_range( value, p - value + 1 );
+                        new_object = object_new_range( value, int32_t(p - value + 1) );
                     else
                         new_object = object_copy( list_item( iter ) );
                 }
@@ -4930,114 +5219,27 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
             break;
         }
 
+        // WRITE_FILE( LIST*1 filename,  LIST*1 modifiers[N], LIST*1 contents )
         case INSTR_WRITE_FILE:
         {
             PROFILE_ENTER_LOCAL(function_run_INSTR_WRITE_FILE);
-            string buf[ 1 ];
-            char const * out;
-            OBJECT * tmp_filename = 0;
-            int out_debug = DEBUG_EXEC ? 1 : 0;
-            FILE * out_file = 0;
-            string_new( buf );
-            combine_strings( s, code->arg, buf );
-            out = object_str( list_front( stack_top( s ) ) );
-
-            /* For stdout/stderr we will create a temp file and generate a
-             * command that outputs the content as needed.
-             */
-            if ( ( strcmp( "STDOUT", out ) == 0 ) ||
-                ( strcmp( "STDERR", out ) == 0 ) )
-            {
-                int err_redir = strcmp( "STDERR", out ) == 0;
-                string result[ 1 ];
-
-                tmp_filename = path_tmpfile();
-
-                /* Construct os-specific cat command. */
-                {
-                    const char * command = "cat";
-                    const char * quote = "\"";
-                    const char * redirect = "1>&2";
-
-                #ifdef OS_NT
-                    command = "type";
-                    quote = "\"";
-                #elif defined( OS_VMS )
-                    command = "pipe type";
-                    quote = "";
-
-                    /* Get tmp file name is os-format. */
-                    {
-                        string os_filename[ 1 ];
-
-                        string_new( os_filename );
-                        path_translate_to_os( object_str( tmp_filename ), os_filename );
-                        object_free( tmp_filename );
-                        tmp_filename = object_new( os_filename->value );
-                        string_free( os_filename );
-                    }
-                #endif
-
-                    string_new( result );
-                    string_append( result, command );
-                    string_append( result, " " );
-                    string_append( result, quote );
-                    string_append( result, object_str( tmp_filename ) );
-                    string_append( result, quote );
-                    if ( err_redir )
-                    {
-                        string_append( result, " " );
-                        string_append( result, redirect );
-                    }
-                }
-
-                /* Replace STDXXX with the temporary file. */
-                list_free( stack_pop( s ) );
-                stack_push( s, list_new( object_new( result->value ) ) );
-                out = object_str( tmp_filename );
-
-                string_free( result );
-
-                /* Make sure temp files created by this get nuked eventually. */
-                file_remove_atexit( tmp_filename );
-            }
-
-            if ( !globs.noexec )
+            // Get expanded filename.
+            LIST * filename = nullptr;
             {
-                string out_name[ 1 ];
-                /* Handle "path to file" filenames. */
-                if ( ( out[ 0 ] == '"' ) && ( out[ strlen( out ) - 1 ] == '"' )
-                    )
-                {
-                    string_copy( out_name, out + 1 );
-                    string_truncate( out_name, out_name->size - 1 );
-                }
-                else
-                    string_copy( out_name, out );
-                out_file = fopen( out_name->value, "w" );
-
-                if ( !out_file )
-                {
-                    err_printf( "[errno %d] failed to write output file '%s': %s",
-                        errno, out_name->value, strerror(errno) );
-                    exit( EXITBAD );
-                }
-                string_free( out_name );
-            }
-
-            if ( out_debug ) out_printf( "\nfile %s\n", out );
-            if ( out_file ) fputs( buf->value, out_file );
-            if ( out_debug ) out_puts( buf->value );
-            if ( out_file )
-            {
-                fflush( out_file );
-                fclose( out_file );
+                expansion_item ei = { stack_pop( s ) };
+                filename = expand( &ei, 1 );
             }
-            string_free( buf );
-            if ( tmp_filename )
-                object_free( tmp_filename );
-
-            if ( out_debug ) out_putc( '\n' );
+            // Apply modifiers to "raw" filename.
+            VAR_EXPANDED filename_mod = eval_modifiers( s, filename, code->arg );
+            // Get contents.
+            LIST * contents = stack_pop( s );
+            // Write out the contents file, or expand the contents, as needed.
+            LIST * filename_or_contents = function_execute_write_file( function, frame, s, filename_mod, contents );
+            // The result that gets replaced into the @() space.
+            stack_push( s, filename_or_contents );
+            list_free( filename_mod.value );
+            list_free( filename_mod.inner );
+            list_free( contents );
             PROFILE_EXIT_LOCAL(function_run_INSTR_WRITE_FILE);
             break;
         }
@@ -5069,7 +5271,7 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s )
 #ifdef HAVE_PYTHON
 
 static struct arg_list * arg_list_compile_python( PyObject * bjam_signature,
-    int * num_arguments )
+    int32_t * num_arguments )
 {
     if ( bjam_signature )
     {
@@ -5127,18 +5329,18 @@ FUNCTION * function_python( PyObject * function, PyObject * bjam_signature )
 }
 
 
-static void argument_list_to_python( struct arg_list * formal, int formal_count,
+static void argument_list_to_python( struct arg_list * formal, int32_t formal_count,
     FUNCTION * function, FRAME * frame, PyObject * kw )
 {
     LOL * all_actual = frame->args;
-    int i;
+    int32_t i;
 
     for ( i = 0; i < formal_count; ++i )
     {
         LIST * actual = lol_get( all_actual, i );
         LISTITER actual_iter = list_begin( actual );
         LISTITER const actual_end = list_end( actual );
-        int j;
+        int32_t j;
         for ( j = 0; j < formal[ i ].size; ++j )
         {
             struct argument * formal_arg = &formal[ i ].args[ j ];
@@ -5259,7 +5461,7 @@ static LIST * call_python_function( PYTHON_FUNCTION * function, FRAME * frame )
     LIST * result = 0;
     PyObject * arguments = 0;
     PyObject * kw = NULL;
-    int i;
+    int32_t i;
     PyObject * py_result;
     FRAME * prev_frame_before_python_call;
 
@@ -5290,8 +5492,8 @@ static LIST * call_python_function( PYTHON_FUNCTION * function, FRAME * frame )
     {
         if ( PyList_Check( py_result ) )
         {
-            int size = PyList_Size( py_result );
-            int i;
+            int32_t size = PyList_Size( py_result );
+            int32_t i;
             for ( i = 0; i < size; ++i )
             {
                 OBJECT * s = python_to_string( PyList_GetItem( py_result, i ) );
diff --git a/src/engine/function.h b/src/engine/function.h
index 73c837f520..397487537e 100644
--- a/src/engine/function.h
+++ b/src/engine/function.h
@@ -22,18 +22,18 @@ void stack_push( STACK * s, LIST * l );
 LIST * stack_pop( STACK * s );
 
 FUNCTION * function_compile( PARSE * parse );
-FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int flags ), int flags, const char * * args );
+FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int32_t flags ), int32_t flags, const char * * args );
 void function_refer( FUNCTION * );
 void function_free( FUNCTION * );
 OBJECT * function_rulename( FUNCTION * );
 void function_set_rulename( FUNCTION *, OBJECT * );
-void function_location( FUNCTION *, OBJECT * *, int * );
+void function_location( FUNCTION *, OBJECT * *, int32_t * );
 LIST * function_run( FUNCTION * function, FRAME * frame, STACK * s );
 
-FUNCTION * function_compile_actions( const char * actions, OBJECT * file, int line );
+FUNCTION * function_compile_actions( const char * actions, OBJECT * file, int32_t line );
 void function_run_actions( FUNCTION * function, FRAME * frame, STACK * s, string * out );
 
-FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int * counter );
+FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int32_t * counter );
 FUNCTION * function_unbind_variables( FUNCTION * f );
 
 LIST * function_get_variables( FUNCTION * f );
diff --git a/src/engine/guess_toolset.bat b/src/engine/guess_toolset.bat
index 422e43d32e..7093327116 100644
--- a/src/engine/guess_toolset.bat
+++ b/src/engine/guess_toolset.bat
@@ -85,11 +85,7 @@ if not errorlevel 1 (
     call "%FOUND_PATH%VCVARS32.BAT"
     set "B2_TOOLSET_ROOT=%MSVCDir%\"
     exit /b 0)
-if EXIST "C:\Borland\BCC55\Bin\bcc32.exe" (
-    set "B2_TOOLSET=borland"
-    set "B2_TOOLSET_ROOT=C:\Borland\BCC55\"
-    exit /b 0)
-call :Test_Path bcc32.exe
+call :Test_Path bcc32c.exe
 if not errorlevel 1 (
     set "B2_TOOLSET=borland"
     set "B2_TOOLSET_ROOT=%FOUND_PATH%..\"
diff --git a/src/engine/hash.cpp b/src/engine/hash.cpp
index f3dcef88a5..9dcd5816bf 100644
--- a/src/engine/hash.cpp
+++ b/src/engine/hash.cpp
@@ -45,12 +45,12 @@ struct hash
      */
     struct
     {
-        int nel;
+        int32_t nel;
         ITEM * * base;
     } tab;
 
-    int bloat;  /* tab.nel / items.nel */
-    int inel;   /* initial number of elements */
+    int32_t bloat;  /* tab.nel / items.nel */
+    int32_t inel;   /* initial number of elements */
 
     /*
      * the array of records, maintained by these routines - essentially a
@@ -58,16 +58,16 @@ struct hash
      */
     struct
     {
-        int more;     /* how many more ITEMs fit in lists[ list ] */
+        int32_t more;     /* how many more ITEMs fit in lists[ list ] */
         ITEM * free;  /* free list of items */
         char * next;  /* where to put more ITEMs in lists[ list ] */
-        int size;     /* sizeof( ITEM ) + aligned datalen */
-        int nel;      /* total ITEMs held by all lists[] */
-        int list;     /* index into lists[] */
+        int32_t size;     /* sizeof( ITEM ) + aligned datalen */
+        int32_t nel;      /* total ITEMs held by all lists[] */
+        int32_t list;     /* index into lists[] */
 
         struct
         {
-            int nel;      /* total ITEMs held by this list */
+            int32_t nel;      /* total ITEMs held by this list */
             char * base;  /* base of ITEMs array */
         } lists[ MAX_LISTS ];
     } items;
@@ -78,7 +78,7 @@ struct hash
 static void hashrehash( struct hash * );
 static void hashstat( struct hash * );
 
-static unsigned int hash_keyval( OBJECT * key )
+static uint32_t hash_keyval( OBJECT * key )
 {
     return object_hash( key );
 }
@@ -96,7 +96,7 @@ static unsigned int hash_keyval( OBJECT * key )
  * hashinit() - initialize a hash table, returning a handle
  */
 
-struct hash * hashinit( int datalen, char const * name )
+struct hash * hashinit( int32_t datalen, char const * name )
 {
     struct hash * hp = (struct hash *)BJAM_MALLOC( sizeof( *hp ) );
 
@@ -123,7 +123,7 @@ struct hash * hashinit( int datalen, char const * name )
  * bucket or to 0 if our item is the first item in its bucket.
  */
 
-static ITEM * hash_search( struct hash * hp, unsigned int keyval,
+static ITEM * hash_search( struct hash * hp, uint32_t keyval,
     OBJECT * keydata, ITEM * * previous )
 {
     ITEM * i = *hash_bucket( hp, keyval );
@@ -146,10 +146,10 @@ static ITEM * hash_search( struct hash * hp, unsigned int keyval,
  * hash_insert() - insert a record in the table or return the existing one
  */
 
-HASHDATA * hash_insert( struct hash * hp, OBJECT * key, int * found )
+HASHDATA * hash_insert( struct hash * hp, OBJECT * key, int32_t * found )
 {
     ITEM * i;
-    unsigned int keyval = hash_keyval( key );
+    uint32_t keyval = hash_keyval( key );
 
     #ifdef HASH_DEBUG_PROFILE
     profile_frame prof[ 1 ];
@@ -201,7 +201,7 @@ HASHDATA * hash_insert( struct hash * hp, OBJECT * key, int * found )
 HASHDATA * hash_find( struct hash * hp, OBJECT * key )
 {
     ITEM * i;
-    unsigned int keyval = hash_keyval( key );
+    uint32_t keyval = hash_keyval( key );
 
     #ifdef HASH_DEBUG_PROFILE
     profile_frame prof[ 1 ];
@@ -235,7 +235,7 @@ HASHDATA * hash_find( struct hash * hp, OBJECT * key )
 
 static void hashrehash( struct hash * hp )
 {
-    int i = ++hp->items.list;
+    int32_t i = ++hp->items.list;
     hp->items.more = i ? 2 * hp->items.nel : hp->inel;
     hp->items.next = (char *)BJAM_MALLOC( hp->items.more * hp->items.size );
     hp->items.free = 0;
@@ -254,7 +254,7 @@ static void hashrehash( struct hash * hp )
 
     for ( i = 0; i < hp->items.list; ++i )
     {
-        int nel = hp->items.lists[ i ].nel;
+        int32_t nel = hp->items.lists[ i ].nel;
         char * next = hp->items.lists[ i ].base;
 
         for ( ; nel--; next += hp->items.size )
@@ -277,11 +277,11 @@ static void hashrehash( struct hash * hp )
 void hashenumerate( struct hash * hp, void (* f)( void *, void * ), void * data
     )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i <= hp->items.list; ++i )
     {
         char * next = hp->items.lists[ i ].base;
-        int nel = hp->items.lists[ i ].nel;
+        int32_t nel = hp->items.lists[ i ].nel;
         if ( i == hp->items.list )
             nel -= hp->items.more;
 
@@ -301,7 +301,7 @@ void hashenumerate( struct hash * hp, void (* f)( void *, void * ), void * data
 
 void hash_free( struct hash * hp )
 {
-    int i;
+    int32_t i;
     if ( !hp )
         return;
     if ( hp->tab.base )
diff --git a/src/engine/hash.h b/src/engine/hash.h
index 7ed633d731..5f69f97cb0 100644
--- a/src/engine/hash.h
+++ b/src/engine/hash.h
@@ -28,7 +28,7 @@ typedef struct hashdata HASHDATA;
  *   datalen - item size
  *   name    - used for debugging
  */
-struct hash * hashinit( int datalen, char const * name );
+struct hash * hashinit( int32_t datalen, char const * name );
 
 /*
  * hash_free() - free a hash table, given its handle
@@ -57,7 +57,7 @@ void hashenumerate( struct hash *, void (* f)( void *, void * ), void * data );
  *   - if the key is present then *found == 1 and the result is a pointer to the
  *     existing record.
  */
-HASHDATA * hash_insert( struct hash *, OBJECT * key, int * found );
+HASHDATA * hash_insert( struct hash *, OBJECT * key, int32_t * found );
 
 /*
  * hash_find() - find a record in the table or NULL if none exists
diff --git a/src/engine/jam.cpp b/src/engine/jam.cpp
index 07ed5e52c0..76acdb6f79 100644
--- a/src/engine/jam.cpp
+++ b/src/engine/jam.cpp
@@ -747,7 +747,7 @@ char * executable_path( char const * argv0 )
     sysctl( mib, 4, buf, &size, NULL, 0 );
     return ( !size || size == sizeof( buf ) ) ? NULL : strndup( buf, size );
 }
-#elif defined(__linux__)
+#elif defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__)
 # include <unistd.h>
 char * executable_path( char const * argv0 )
 {
diff --git a/src/engine/jam.h b/src/engine/jam.h
index 984a4a41bb..5d706dcb79 100644
--- a/src/engine/jam.h
+++ b/src/engine/jam.h
@@ -88,6 +88,7 @@
 #define SPLITPATH ';'
 #define MAXLINE (undefined__see_execnt_c)  /* max chars per command line */
 #define USE_EXECNT
+#define USE_PATHNT
 #define PATH_DELIM '\\'
 
 /* AS400 cross-compile from NT. */
@@ -131,6 +132,7 @@
 #define SPLITPATH ';'
 #define MAXLINE 996  /* max chars per command line */
 #define USE_EXECUNIX
+#define USE_PATHNT
 #define PATH_DELIM '\\'
 
 #endif  /* #ifdef MINGW */
@@ -145,6 +147,7 @@
 #define OSMAJOR "UNIX=true"
 #define USE_EXECUNIX
 #define USE_FILEUNIX
+#define USE_PATHUNIX
 #define PATH_DELIM '/'
 
 #ifdef _AIX
@@ -189,6 +192,10 @@
     #define OSMINOR "OS=DGUX"
     #define OS_DGUX
 #endif
+#ifdef __GNU__
+    #define OSMINOR "OS=HURD"
+    #define OS_HURD
+#endif
 #ifdef __hpux
     #define OSMINOR "OS=HPUX"
     #define OS_HPUX
@@ -412,9 +419,9 @@
 #endif
 
 #ifdef __mips__
-  #if defined(_ABI64)
+  #if _MIPS_SIM == _MIPS_SIM_ABI64
     #define OSPLAT "OSPLAT=MIPS64"
-  #elif defined(_ABIO32)
+  #elif _MIPS_SIM == _MIPS_SIM_ABI32
     #define OSPLAT "OSPLAT=MIPS32"
   #endif
 #endif
diff --git a/src/engine/jam_strings.cpp b/src/engine/jam_strings.cpp
index c9ed8a17f0..b5aef5f1cd 100644
--- a/src/engine/jam_strings.cpp
+++ b/src/engine/jam_strings.cpp
@@ -26,12 +26,12 @@ static void assert_invariants( string * self )
     }
 
     assert( self->size < self->capacity );
-    assert( ( self->capacity <= sizeof( self->opt ) ) == ( self->value == self->opt ) );
+    assert( ( self->capacity <= int32_t(sizeof( self->opt )) ) == ( self->value == self->opt ) );
     assert( self->value[ self->size ] == 0 );
     /* String objects modified manually after construction to contain embedded
      * '\0' characters are considered structurally valid.
      */
-    assert( strlen( self->value ) <= self->size );
+    assert( strlen( self->value ) <= size_t(self->size) );
 
     for ( i = 0; i < 4; ++i )
     {
@@ -67,20 +67,20 @@ void string_free( string * s )
 }
 
 
-static void string_reserve_internal( string * self, size_t capacity )
+static void string_reserve_internal( string * self, int32_t capacity )
 {
     if ( self->value == self->opt )
     {
-        self->value = (char *)BJAM_MALLOC_ATOMIC( capacity +
+        self->value = (char *)BJAM_MALLOC_ATOMIC( size_t(capacity) +
             JAM_STRING_MAGIC_SIZE );
         self->value[ 0 ] = 0;
         size_t opt_size = sizeof(self->opt); // Workaround sizeof in strncat warning.
         strncat( self->value, self->opt, opt_size );
-        assert( strlen( self->value ) <= self->capacity && "Regression test" );
+        assert( strlen( self->value ) <= size_t(self->capacity) && "Regression test" );
     }
     else
     {
-        self->value = (char *)BJAM_REALLOC( self->value, capacity +
+        self->value = (char *)BJAM_REALLOC( self->value, size_t(capacity) +
             JAM_STRING_MAGIC_SIZE );
     }
 #ifndef NDEBUG
@@ -90,7 +90,7 @@ static void string_reserve_internal( string * self, size_t capacity )
 }
 
 
-void string_reserve( string * self, size_t capacity )
+void string_reserve( string * self, int32_t capacity )
 {
     assert_invariants( self );
     if ( capacity <= self->capacity )
@@ -100,12 +100,12 @@ void string_reserve( string * self, size_t capacity )
 }
 
 
-static void maybe_reserve( string * self, size_t new_size )
+static void maybe_reserve( string * self, int32_t new_size )
 {
-    size_t capacity = self->capacity;
+    int32_t capacity = self->capacity;
     if ( capacity <= new_size )
     {
-        size_t new_capacity = capacity;
+        int32_t new_capacity = capacity;
         while ( new_capacity <= new_size )
             new_capacity <<= 1;
         string_reserve_internal( self, new_capacity );
@@ -115,13 +115,13 @@ static void maybe_reserve( string * self, size_t new_size )
 
 void string_append( string * self, char const * rhs )
 {
-    size_t rhs_size = strlen( rhs );
-    size_t new_size = self->size + rhs_size;
+    int32_t rhs_size = int32_t(strlen( rhs ));
+    int32_t new_size = self->size + rhs_size;
     assert_invariants( self );
 
     maybe_reserve( self, new_size );
 
-    memcpy( self->value + self->size, rhs, rhs_size + 1 );
+    memcpy( self->value + self->size, rhs, size_t(rhs_size) + 1 );
     self->size = new_size;
 
     assert_invariants( self );
@@ -130,14 +130,14 @@ void string_append( string * self, char const * rhs )
 
 void string_append_range( string * self, char const * start, char const * finish )
 {
-    size_t rhs_size = finish - start;
-    size_t new_size = self->size + rhs_size;
+    int32_t rhs_size = int32_t(finish - start);
+    int32_t new_size = self->size + rhs_size;
     assert_invariants( self );
 
     maybe_reserve( self, new_size );
 
     if ( start != finish )
-        memcpy( self->value + self->size, start, rhs_size );
+        memcpy( self->value + self->size, start, size_t(rhs_size) );
     self->size = new_size;
     self->value[ new_size ] = 0;
 
@@ -151,7 +151,7 @@ void string_copy( string * s, char const * rhs )
     string_append( s, rhs );
 }
 
-void string_truncate( string * self, size_t n )
+void string_truncate( string * self, int32_t n )
 {
     assert_invariants( self );
     assert( n <= self->capacity );
@@ -198,9 +198,9 @@ void string_unit_test()
         for ( i = 0; i < limit; ++i )
         {
             string_push_back( s, (char)( i + 1 ) );
-            assert( s->size == i + 1 );
+            assert( s->size == int32_t(i + 1) );
         }
-        assert( s->size == limit );
+        assert( s->size == int32_t(limit) );
         assert( s->value != s->opt );
         for ( i = 0; i < limit; ++i )
             assert( s->value[ i ] == (char)( i + 1 ) );
@@ -212,7 +212,7 @@ void string_unit_test()
         string copy[ 1 ];
         string_copy( copy, original );
         assert( !strcmp( copy->value, original ) );
-        assert( copy->size == strlen( original ) );
+        assert( copy->size == int32_t(strlen( original )) );
         string_free( copy );
     }
 
diff --git a/src/engine/jam_strings.h b/src/engine/jam_strings.h
index f47db10af7..02b744a654 100644
--- a/src/engine/jam_strings.h
+++ b/src/engine/jam_strings.h
@@ -14,8 +14,8 @@
 typedef struct string
 {
     char * value;
-    unsigned long size;
-    unsigned long capacity;
+    int32_t size;
+    int32_t capacity;
     char opt[ 32 ];
 #ifndef NDEBUG
     char magic[ 4 ];
@@ -28,8 +28,8 @@ void string_free( string * );
 void string_append( string *, char const * );
 void string_append_range( string *, char const *, char const * );
 void string_push_back( string * s, char x );
-void string_reserve( string *, size_t );
-void string_truncate( string *, size_t );
+void string_reserve( string *, int32_t );
+void string_truncate( string *, int32_t );
 void string_pop_back( string * );
 char string_back( string * );
 void string_rtrim( string * );
diff --git a/src/engine/jamgram.cpp b/src/engine/jamgram.cpp
index 163428b1d3..4f3de0615f 100644
--- a/src/engine/jamgram.cpp
+++ b/src/engine/jamgram.cpp
@@ -1,4 +1,4 @@
-/* A Bison parser, made by GNU Bison 3.6.2.  */
+/* A Bison parser, made by GNU Bison 3.7.2.  */
 
 /* Bison implementation for Yacc-like parsers in C
 
@@ -49,7 +49,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "3.6.2"
+#define YYBISON_VERSION "3.7.2"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -135,144 +135,7 @@
 #  endif
 # endif
 
-/* Use api.header.include to #include this header
-   instead of duplicating it here.  */
-#ifndef YY_YY_SRC_ENGINE_JAMGRAM_HPP_INCLUDED
-# define YY_YY_SRC_ENGINE_JAMGRAM_HPP_INCLUDED
-/* Debug traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token kinds.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-  enum yytokentype
-  {
-    YYEMPTY = -2,
-    YYEOF = 0,                     /* "end of file"  */
-    YYerror = 256,                 /* error  */
-    YYUNDEF = 257,                 /* "invalid token"  */
-    _BANG_t = 258,                 /* _BANG_t  */
-    _BANG_EQUALS_t = 259,          /* _BANG_EQUALS_t  */
-    _AMPER_t = 260,                /* _AMPER_t  */
-    _AMPERAMPER_t = 261,           /* _AMPERAMPER_t  */
-    _LPAREN_t = 262,               /* _LPAREN_t  */
-    _RPAREN_t = 263,               /* _RPAREN_t  */
-    _PLUS_EQUALS_t = 264,          /* _PLUS_EQUALS_t  */
-    _COLON_t = 265,                /* _COLON_t  */
-    _SEMIC_t = 266,                /* _SEMIC_t  */
-    _LANGLE_t = 267,               /* _LANGLE_t  */
-    _LANGLE_EQUALS_t = 268,        /* _LANGLE_EQUALS_t  */
-    _EQUALS_t = 269,               /* _EQUALS_t  */
-    _RANGLE_t = 270,               /* _RANGLE_t  */
-    _RANGLE_EQUALS_t = 271,        /* _RANGLE_EQUALS_t  */
-    _QUESTION_EQUALS_t = 272,      /* _QUESTION_EQUALS_t  */
-    _LBRACKET_t = 273,             /* _LBRACKET_t  */
-    _RBRACKET_t = 274,             /* _RBRACKET_t  */
-    ACTIONS_t = 275,               /* ACTIONS_t  */
-    BIND_t = 276,                  /* BIND_t  */
-    BREAK_t = 277,                 /* BREAK_t  */
-    CASE_t = 278,                  /* CASE_t  */
-    CLASS_t = 279,                 /* CLASS_t  */
-    CONTINUE_t = 280,              /* CONTINUE_t  */
-    DEFAULT_t = 281,               /* DEFAULT_t  */
-    ELSE_t = 282,                  /* ELSE_t  */
-    EXISTING_t = 283,              /* EXISTING_t  */
-    FOR_t = 284,                   /* FOR_t  */
-    IF_t = 285,                    /* IF_t  */
-    IGNORE_t = 286,                /* IGNORE_t  */
-    IN_t = 287,                    /* IN_t  */
-    INCLUDE_t = 288,               /* INCLUDE_t  */
-    LOCAL_t = 289,                 /* LOCAL_t  */
-    MODULE_t = 290,                /* MODULE_t  */
-    ON_t = 291,                    /* ON_t  */
-    PIECEMEAL_t = 292,             /* PIECEMEAL_t  */
-    QUIETLY_t = 293,               /* QUIETLY_t  */
-    RETURN_t = 294,                /* RETURN_t  */
-    RULE_t = 295,                  /* RULE_t  */
-    SWITCH_t = 296,                /* SWITCH_t  */
-    TOGETHER_t = 297,              /* TOGETHER_t  */
-    UPDATED_t = 298,               /* UPDATED_t  */
-    WHILE_t = 299,                 /* WHILE_t  */
-    _LBRACE_t = 300,               /* _LBRACE_t  */
-    _BAR_t = 301,                  /* _BAR_t  */
-    _BARBAR_t = 302,               /* _BARBAR_t  */
-    _RBRACE_t = 303,               /* _RBRACE_t  */
-    ARG = 304,                     /* ARG  */
-    STRING = 305                   /* STRING  */
-  };
-  typedef enum yytokentype yytoken_kind_t;
-#endif
-/* Token kinds.  */
-#define YYEOF 0
-#define YYerror 256
-#define YYUNDEF 257
-#define _BANG_t 258
-#define _BANG_EQUALS_t 259
-#define _AMPER_t 260
-#define _AMPERAMPER_t 261
-#define _LPAREN_t 262
-#define _RPAREN_t 263
-#define _PLUS_EQUALS_t 264
-#define _COLON_t 265
-#define _SEMIC_t 266
-#define _LANGLE_t 267
-#define _LANGLE_EQUALS_t 268
-#define _EQUALS_t 269
-#define _RANGLE_t 270
-#define _RANGLE_EQUALS_t 271
-#define _QUESTION_EQUALS_t 272
-#define _LBRACKET_t 273
-#define _RBRACKET_t 274
-#define ACTIONS_t 275
-#define BIND_t 276
-#define BREAK_t 277
-#define CASE_t 278
-#define CLASS_t 279
-#define CONTINUE_t 280
-#define DEFAULT_t 281
-#define ELSE_t 282
-#define EXISTING_t 283
-#define FOR_t 284
-#define IF_t 285
-#define IGNORE_t 286
-#define IN_t 287
-#define INCLUDE_t 288
-#define LOCAL_t 289
-#define MODULE_t 290
-#define ON_t 291
-#define PIECEMEAL_t 292
-#define QUIETLY_t 293
-#define RETURN_t 294
-#define RULE_t 295
-#define SWITCH_t 296
-#define TOGETHER_t 297
-#define UPDATED_t 298
-#define WHILE_t 299
-#define _LBRACE_t 300
-#define _BAR_t 301
-#define _BARBAR_t 302
-#define _RBRACE_t 303
-#define ARG 304
-#define STRING 305
-
-/* Value type.  */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef int YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-extern YYSTYPE yylval;
-
-int yyparse (void);
-
-#endif /* !YY_YY_SRC_ENGINE_JAMGRAM_HPP_INCLUDED  */
+#include "jamgram.hpp"
 /* Symbol kind.  */
 enum yysymbol_kind_t
 {
@@ -716,6 +579,7 @@ union yyalloc
 /* YYNSTATES -- Number of states.  */
 #define YYNSTATES  207
 
+/* YYMAXUTOK -- Last valid token kind.  */
 #define YYMAXUTOK   305
 
 
@@ -764,7 +628,7 @@ static const yytype_int8 yytranslate[] =
 };
 
 #if YYDEBUG
-  /* YYRLINEYYN -- Source line where rule number YYN was defined.  */
+  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_int16 yyrline[] =
 {
        0,   145,   145,   147,   158,   160,   164,   166,   168,   168,
@@ -846,7 +710,7 @@ static const yytype_int16 yytoknum[] =
 #define yytable_value_is_error(Yyn) \
   0
 
-  /* YYPACTSTATE-NUM -- Index in YYTABLE of the portion describing
+  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
@@ -873,7 +737,7 @@ static const yytype_int16 yypact[] =
     -119,   115,  -119,  -119,  -119,   140,  -119
 };
 
-  /* YYDEFACTSTATE-NUM -- Default reduction number in state STATE-NUM.
+  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
      Performed when YYTABLE does not specify something else to do.  Zero
      means the default is an error.  */
 static const yytype_int8 yydefact[] =
@@ -901,7 +765,7 @@ static const yytype_int8 yydefact[] =
       60,     0,    19,    95,    37,    11,    96
 };
 
-  /* YYPGOTONTERM-NUM.  */
+  /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
     -119,  -119,  -118,    25,  -119,  -119,    96,  -119,  -119,  -119,
@@ -913,7 +777,7 @@ static const yytype_int16 yypgoto[] =
     -119,  -119,  -119,  -119,  -119,  -119,  -119,  -119
 };
 
-  /* YYDEFGOTONTERM-NUM.  */
+  /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
       -1,    17,    38,    39,    31,   168,    40,   109,   140,   175,
@@ -925,7 +789,7 @@ static const yytype_int16 yydefgoto[] =
       53,    84,   149,   148,    23,    61,    87,   121
 };
 
-  /* YYTABLEYYPACT[STATE-NUM] -- What to do in state STATE-NUM.  If
+  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
      positive, shift that token.  If negative, reduce the rule whose
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
@@ -986,7 +850,7 @@ static const yytype_int16 yycheck[] =
       14,    15,    16
 };
 
-  /* YYSTOSSTATE-NUM -- The (internal number of the) accessing
+  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
      symbol of state STATE-NUM.  */
 static const yytype_int8 yystos[] =
 {
@@ -1013,7 +877,7 @@ static const yytype_int8 yystos[] =
       48,    53,    63,    10,    48,   105,    53
 };
 
-  /* YYR1YYN -- Symbol number of symbol that rule YYN derives.  */
+  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_int8 yyr1[] =
 {
        0,    51,    52,    52,    53,    53,    54,    54,    55,    56,
@@ -1031,7 +895,7 @@ static const yytype_int8 yyr1[] =
      118,   117
 };
 
-  /* YYR2YYN -- Number of symbols on the right hand side of rule YYN.  */
+  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
 static const yytype_int8 yyr2[] =
 {
        0,     2,     0,     1,     1,     1,     1,     2,     0,     0,
@@ -1258,7 +1122,7 @@ yydestruct (const char *yymsg,
 }
 
 
-/* The lookahead symbol.  */
+/* Lookahead token kind.  */
 int yychar;
 
 /* The semantic value of the lookahead symbol.  */
@@ -1276,34 +1140,30 @@ int yynerrs;
 int
 yyparse (void)
 {
-    yy_state_fast_t yystate;
+    yy_state_fast_t yystate = 0;
     /* Number of tokens to shift before error messages enabled.  */
-    int yyerrstatus;
-
-    /* The stacks and their tools:
-       'yyss': related to states.
-       'yyvs': related to semantic values.
+    int yyerrstatus = 0;
 
-       Refer to the stacks through separate pointers, to allow yyoverflow
+    /* Refer to the stacks through separate pointers, to allow yyoverflow
        to reallocate them elsewhere.  */
 
     /* Their size.  */
-    YYPTRDIFF_T yystacksize;
+    YYPTRDIFF_T yystacksize = YYINITDEPTH;
 
-    /* The state stack.  */
+    /* The state stack: array, bottom, top.  */
     yy_state_t yyssa[YYINITDEPTH];
-    yy_state_t *yyss;
-    yy_state_t *yyssp;
+    yy_state_t *yyss = yyssa;
+    yy_state_t *yyssp = yyss;
 
-    /* The semantic value stack.  */
+    /* The semantic value stack: array, bottom, top.  */
     YYSTYPE yyvsa[YYINITDEPTH];
-    YYSTYPE *yyvs;
-    YYSTYPE *yyvsp;
+    YYSTYPE *yyvs = yyvsa;
+    YYSTYPE *yyvsp = yyvs;
 
   int yyn;
   /* The return value of yyparse.  */
   int yyresult;
-  /* Lookahead token as an internal (translated) token number.  */
+  /* Lookahead symbol kind.  */
   yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
   /* The variables used to return semantic value and location from the
      action routines.  */
@@ -1317,15 +1177,6 @@ yyparse (void)
      Keep to zero when no symbol should be popped.  */
   int yylen = 0;
 
-  yynerrs = 0;
-  yystate = 0;
-  yyerrstatus = 0;
-
-  yystacksize = YYINITDEPTH;
-  yyssp = yyss = yyssa;
-  yyvsp = yyvs = yyvsa;
-
-
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yychar = YYEMPTY; /* Cause a token to be read.  */
@@ -1526,722 +1377,722 @@ yyparse (void)
   YY_REDUCE_PRINT (yyn);
   switch (yyn)
     {
-  case 3:
+  case 3: /* run: rules  */
 #line 148 "src/engine/jamgram.y"
                 { parse_save( yyvsp[0].parse ); }
-#line 1533 "src/engine/jamgram.cpp"
+#line 1384 "src/engine/jamgram.cpp"
     break;
 
-  case 4:
+  case 4: /* block: null  */
 #line 159 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; }
-#line 1539 "src/engine/jamgram.cpp"
+#line 1390 "src/engine/jamgram.cpp"
     break;
 
-  case 5:
+  case 5: /* block: rules  */
 #line 161 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; }
-#line 1545 "src/engine/jamgram.cpp"
+#line 1396 "src/engine/jamgram.cpp"
     break;
 
-  case 6:
+  case 6: /* rules: rule  */
 #line 165 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; }
-#line 1551 "src/engine/jamgram.cpp"
+#line 1402 "src/engine/jamgram.cpp"
     break;
 
-  case 7:
+  case 7: /* rules: rule rules  */
 #line 167 "src/engine/jamgram.y"
                 { yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); }
-#line 1557 "src/engine/jamgram.cpp"
+#line 1408 "src/engine/jamgram.cpp"
     break;
 
-  case 8:
+  case 8: /* $@1: %empty  */
 #line 168 "src/engine/jamgram.y"
                   { yymode( SCAN_ASSIGN ); }
-#line 1563 "src/engine/jamgram.cpp"
+#line 1414 "src/engine/jamgram.cpp"
     break;
 
-  case 9:
+  case 9: /* $@2: %empty  */
 #line 168 "src/engine/jamgram.y"
                                                                            { yymode( SCAN_NORMAL ); }
-#line 1569 "src/engine/jamgram.cpp"
+#line 1420 "src/engine/jamgram.cpp"
     break;
 
-  case 10:
+  case 10: /* rules: LOCAL_t $@1 list assign_list_opt _SEMIC_t $@2 block  */
 #line 169 "src/engine/jamgram.y"
                 { yyval.parse = plocal( yyvsp[-4].parse, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1575 "src/engine/jamgram.cpp"
+#line 1426 "src/engine/jamgram.cpp"
     break;
 
-  case 11:
+  case 11: /* null: %empty  */
 #line 173 "src/engine/jamgram.y"
         { yyval.parse = pnull(); }
-#line 1581 "src/engine/jamgram.cpp"
+#line 1432 "src/engine/jamgram.cpp"
     break;
 
-  case 12:
+  case 12: /* $@3: %empty  */
 #line 176 "src/engine/jamgram.y"
                             { yymode( SCAN_PUNCT ); }
-#line 1587 "src/engine/jamgram.cpp"
+#line 1438 "src/engine/jamgram.cpp"
     break;
 
-  case 13:
+  case 13: /* assign_list_opt: _EQUALS_t $@3 list  */
 #line 177 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_SET; }
-#line 1593 "src/engine/jamgram.cpp"
+#line 1444 "src/engine/jamgram.cpp"
     break;
 
-  case 14:
+  case 14: /* assign_list_opt: null  */
 #line 179 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_APPEND; }
-#line 1599 "src/engine/jamgram.cpp"
+#line 1450 "src/engine/jamgram.cpp"
     break;
 
-  case 15:
+  case 15: /* arglist_opt: _LPAREN_t lol _RPAREN_t  */
 #line 183 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[-1].parse; }
-#line 1605 "src/engine/jamgram.cpp"
+#line 1456 "src/engine/jamgram.cpp"
     break;
 
-  case 16:
+  case 16: /* arglist_opt: %empty  */
 #line 185 "src/engine/jamgram.y"
                 { yyval.parse = P0; }
-#line 1611 "src/engine/jamgram.cpp"
+#line 1462 "src/engine/jamgram.cpp"
     break;
 
-  case 17:
+  case 17: /* local_opt: LOCAL_t  */
 #line 189 "src/engine/jamgram.y"
                 { yyval.number = 1; }
-#line 1617 "src/engine/jamgram.cpp"
+#line 1468 "src/engine/jamgram.cpp"
     break;
 
-  case 18:
+  case 18: /* local_opt: %empty  */
 #line 191 "src/engine/jamgram.y"
                 { yyval.number = 0; }
-#line 1623 "src/engine/jamgram.cpp"
+#line 1474 "src/engine/jamgram.cpp"
     break;
 
-  case 19:
+  case 19: /* else_opt: ELSE_t rule  */
 #line 195 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; }
-#line 1629 "src/engine/jamgram.cpp"
+#line 1480 "src/engine/jamgram.cpp"
     break;
 
-  case 20:
+  case 20: /* else_opt: %empty  */
 #line 197 "src/engine/jamgram.y"
                 { yyval.parse = pnull(); }
-#line 1635 "src/engine/jamgram.cpp"
+#line 1486 "src/engine/jamgram.cpp"
     break;
 
-  case 21:
+  case 21: /* rule: _LBRACE_t block _RBRACE_t  */
 #line 200 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[-1].parse; }
-#line 1641 "src/engine/jamgram.cpp"
+#line 1492 "src/engine/jamgram.cpp"
     break;
 
-  case 22:
+  case 22: /* $@4: %empty  */
 #line 201 "src/engine/jamgram.y"
                     { yymode( SCAN_PUNCT ); }
-#line 1647 "src/engine/jamgram.cpp"
+#line 1498 "src/engine/jamgram.cpp"
     break;
 
-  case 23:
+  case 23: /* rule: INCLUDE_t $@4 list _SEMIC_t  */
 #line 202 "src/engine/jamgram.y"
                 { yyval.parse = pincl( yyvsp[-1].parse ); yymode( SCAN_NORMAL ); }
-#line 1653 "src/engine/jamgram.cpp"
+#line 1504 "src/engine/jamgram.cpp"
     break;
 
-  case 24:
+  case 24: /* $@5: %empty  */
 #line 203 "src/engine/jamgram.y"
               { yymode( SCAN_PUNCT ); }
-#line 1659 "src/engine/jamgram.cpp"
+#line 1510 "src/engine/jamgram.cpp"
     break;
 
-  case 25:
+  case 25: /* rule: ARG $@5 lol _SEMIC_t  */
 #line 204 "src/engine/jamgram.y"
                 { yyval.parse = prule( yyvsp[-3].string, yyvsp[-1].parse ); yymode( SCAN_NORMAL ); }
-#line 1665 "src/engine/jamgram.cpp"
+#line 1516 "src/engine/jamgram.cpp"
     break;
 
-  case 26:
+  case 26: /* $@6: %empty  */
 #line 205 "src/engine/jamgram.y"
                      { yymode( SCAN_PUNCT ); }
-#line 1671 "src/engine/jamgram.cpp"
+#line 1522 "src/engine/jamgram.cpp"
     break;
 
-  case 27:
+  case 27: /* rule: arg assign $@6 list _SEMIC_t  */
 #line 206 "src/engine/jamgram.y"
                 { yyval.parse = pset( yyvsp[-4].parse, yyvsp[-1].parse, yyvsp[-3].number ); yymode( SCAN_NORMAL ); }
-#line 1677 "src/engine/jamgram.cpp"
+#line 1528 "src/engine/jamgram.cpp"
     break;
 
-  case 28:
+  case 28: /* $@7: %empty  */
 #line 207 "src/engine/jamgram.y"
                    { yymode( SCAN_ASSIGN ); }
-#line 1683 "src/engine/jamgram.cpp"
+#line 1534 "src/engine/jamgram.cpp"
     break;
 
-  case 29:
+  case 29: /* $@8: %empty  */
 #line 207 "src/engine/jamgram.y"
                                                           { yymode( SCAN_PUNCT ); }
-#line 1689 "src/engine/jamgram.cpp"
+#line 1540 "src/engine/jamgram.cpp"
     break;
 
-  case 30:
+  case 30: /* rule: arg ON_t $@7 list assign $@8 list _SEMIC_t  */
 #line 208 "src/engine/jamgram.y"
                 { yyval.parse = pset1( yyvsp[-7].parse, yyvsp[-4].parse, yyvsp[-1].parse, yyvsp[-3].number ); yymode( SCAN_NORMAL ); }
-#line 1695 "src/engine/jamgram.cpp"
+#line 1546 "src/engine/jamgram.cpp"
     break;
 
-  case 31:
+  case 31: /* $@9: %empty  */
 #line 209 "src/engine/jamgram.y"
                    { yymode( SCAN_PUNCT ); }
-#line 1701 "src/engine/jamgram.cpp"
+#line 1552 "src/engine/jamgram.cpp"
     break;
 
-  case 32:
+  case 32: /* rule: RETURN_t $@9 list _SEMIC_t  */
 #line 210 "src/engine/jamgram.y"
                 { yyval.parse = preturn( yyvsp[-1].parse ); yymode( SCAN_NORMAL ); }
-#line 1707 "src/engine/jamgram.cpp"
+#line 1558 "src/engine/jamgram.cpp"
     break;
 
-  case 33:
+  case 33: /* rule: BREAK_t _SEMIC_t  */
 #line 212 "src/engine/jamgram.y"
         { yyval.parse = pbreak(); }
-#line 1713 "src/engine/jamgram.cpp"
+#line 1564 "src/engine/jamgram.cpp"
     break;
 
-  case 34:
+  case 34: /* rule: CONTINUE_t _SEMIC_t  */
 #line 214 "src/engine/jamgram.y"
         { yyval.parse = pcontinue(); }
-#line 1719 "src/engine/jamgram.cpp"
+#line 1570 "src/engine/jamgram.cpp"
     break;
 
-  case 35:
+  case 35: /* $@10: %empty  */
 #line 215 "src/engine/jamgram.y"
                                    { yymode( SCAN_PUNCT ); }
-#line 1725 "src/engine/jamgram.cpp"
+#line 1576 "src/engine/jamgram.cpp"
     break;
 
-  case 36:
+  case 36: /* $@11: %empty  */
 #line 215 "src/engine/jamgram.y"
                                                                             { yymode( SCAN_NORMAL ); }
-#line 1731 "src/engine/jamgram.cpp"
+#line 1582 "src/engine/jamgram.cpp"
     break;
 
-  case 37:
+  case 37: /* rule: FOR_t local_opt ARG IN_t $@10 list _LBRACE_t $@11 block _RBRACE_t  */
 #line 216 "src/engine/jamgram.y"
                 { yyval.parse = pfor( yyvsp[-7].string, yyvsp[-4].parse, yyvsp[-1].parse, yyvsp[-8].number ); }
-#line 1737 "src/engine/jamgram.cpp"
+#line 1588 "src/engine/jamgram.cpp"
     break;
 
-  case 38:
+  case 38: /* $@12: %empty  */
 #line 217 "src/engine/jamgram.y"
                    { yymode( SCAN_PUNCT ); }
-#line 1743 "src/engine/jamgram.cpp"
+#line 1594 "src/engine/jamgram.cpp"
     break;
 
-  case 39:
+  case 39: /* $@13: %empty  */
 #line 217 "src/engine/jamgram.y"
                                                             { yymode( SCAN_NORMAL ); }
-#line 1749 "src/engine/jamgram.cpp"
+#line 1600 "src/engine/jamgram.cpp"
     break;
 
-  case 40:
+  case 40: /* rule: SWITCH_t $@12 list _LBRACE_t $@13 cases _RBRACE_t  */
 #line 218 "src/engine/jamgram.y"
                 { yyval.parse = pswitch( yyvsp[-4].parse, yyvsp[-1].parse ); }
-#line 1755 "src/engine/jamgram.cpp"
+#line 1606 "src/engine/jamgram.cpp"
     break;
 
-  case 41:
+  case 41: /* $@14: %empty  */
 #line 219 "src/engine/jamgram.y"
                { yymode( SCAN_CONDB ); }
-#line 1761 "src/engine/jamgram.cpp"
+#line 1612 "src/engine/jamgram.cpp"
     break;
 
-  case 42:
+  case 42: /* $@15: %empty  */
 #line 219 "src/engine/jamgram.y"
                                                         { yymode( SCAN_NORMAL ); }
-#line 1767 "src/engine/jamgram.cpp"
+#line 1618 "src/engine/jamgram.cpp"
     break;
 
-  case 43:
+  case 43: /* rule: IF_t $@14 expr _LBRACE_t $@15 block _RBRACE_t else_opt  */
 #line 220 "src/engine/jamgram.y"
                 { yyval.parse = pif( yyvsp[-5].parse, yyvsp[-2].parse, yyvsp[0].parse ); }
-#line 1773 "src/engine/jamgram.cpp"
+#line 1624 "src/engine/jamgram.cpp"
     break;
 
-  case 44:
+  case 44: /* $@16: %empty  */
 #line 221 "src/engine/jamgram.y"
                    { yymode( SCAN_PUNCT ); }
-#line 1779 "src/engine/jamgram.cpp"
+#line 1630 "src/engine/jamgram.cpp"
     break;
 
-  case 45:
+  case 45: /* $@17: %empty  */
 #line 221 "src/engine/jamgram.y"
                                                             { yymode( SCAN_NORMAL ); }
-#line 1785 "src/engine/jamgram.cpp"
+#line 1636 "src/engine/jamgram.cpp"
     break;
 
-  case 46:
+  case 46: /* rule: MODULE_t $@16 list _LBRACE_t $@17 block _RBRACE_t  */
 #line 222 "src/engine/jamgram.y"
                 { yyval.parse = pmodule( yyvsp[-4].parse, yyvsp[-1].parse ); }
-#line 1791 "src/engine/jamgram.cpp"
+#line 1642 "src/engine/jamgram.cpp"
     break;
 
-  case 47:
+  case 47: /* $@18: %empty  */
 #line 223 "src/engine/jamgram.y"
                   { yymode( SCAN_PUNCT ); }
-#line 1797 "src/engine/jamgram.cpp"
+#line 1648 "src/engine/jamgram.cpp"
     break;
 
-  case 48:
+  case 48: /* $@19: %empty  */
 #line 223 "src/engine/jamgram.y"
                                                           { yymode( SCAN_NORMAL ); }
-#line 1803 "src/engine/jamgram.cpp"
+#line 1654 "src/engine/jamgram.cpp"
     break;
 
-  case 49:
+  case 49: /* rule: CLASS_t $@18 lol _LBRACE_t $@19 block _RBRACE_t  */
 #line 224 "src/engine/jamgram.y"
                 { yyval.parse = pclass( yyvsp[-4].parse, yyvsp[-1].parse ); }
-#line 1809 "src/engine/jamgram.cpp"
+#line 1660 "src/engine/jamgram.cpp"
     break;
 
-  case 50:
+  case 50: /* $@20: %empty  */
 #line 225 "src/engine/jamgram.y"
                   { yymode( SCAN_CONDB ); }
-#line 1815 "src/engine/jamgram.cpp"
+#line 1666 "src/engine/jamgram.cpp"
     break;
 
-  case 51:
+  case 51: /* $@21: %empty  */
 #line 225 "src/engine/jamgram.y"
                                                  { yymode( SCAN_NORMAL ); }
-#line 1821 "src/engine/jamgram.cpp"
+#line 1672 "src/engine/jamgram.cpp"
     break;
 
-  case 52:
+  case 52: /* rule: WHILE_t $@20 expr $@21 _LBRACE_t block _RBRACE_t  */
 #line 226 "src/engine/jamgram.y"
                 { yyval.parse = pwhile( yyvsp[-4].parse, yyvsp[-1].parse ); }
-#line 1827 "src/engine/jamgram.cpp"
+#line 1678 "src/engine/jamgram.cpp"
     break;
 
-  case 53:
+  case 53: /* $@22: %empty  */
 #line 227 "src/engine/jamgram.y"
                         { yymode( SCAN_PUNCT ); }
-#line 1833 "src/engine/jamgram.cpp"
+#line 1684 "src/engine/jamgram.cpp"
     break;
 
-  case 54:
+  case 54: /* $@23: %empty  */
 #line 227 "src/engine/jamgram.y"
                                                       { yymode( SCAN_PARAMS ); }
-#line 1839 "src/engine/jamgram.cpp"
+#line 1690 "src/engine/jamgram.cpp"
     break;
 
-  case 55:
+  case 55: /* $@24: %empty  */
 #line 227 "src/engine/jamgram.y"
                                                                                              { yymode( SCAN_NORMAL ); }
-#line 1845 "src/engine/jamgram.cpp"
+#line 1696 "src/engine/jamgram.cpp"
     break;
 
-  case 56:
+  case 56: /* rule: local_opt RULE_t $@22 ARG $@23 arglist_opt $@24 rule  */
 #line 228 "src/engine/jamgram.y"
                 { yyval.parse = psetc( yyvsp[-4].string, yyvsp[0].parse, yyvsp[-2].parse, yyvsp[-7].number ); }
-#line 1851 "src/engine/jamgram.cpp"
+#line 1702 "src/engine/jamgram.cpp"
     break;
 
-  case 57:
+  case 57: /* rule: ON_t arg rule  */
 #line 230 "src/engine/jamgram.y"
                 { yyval.parse = pon( yyvsp[-1].parse, yyvsp[0].parse ); }
-#line 1857 "src/engine/jamgram.cpp"
+#line 1708 "src/engine/jamgram.cpp"
     break;
 
-  case 58:
+  case 58: /* $@25: %empty  */
 #line 232 "src/engine/jamgram.y"
                 { yymode( SCAN_STRING ); }
-#line 1863 "src/engine/jamgram.cpp"
+#line 1714 "src/engine/jamgram.cpp"
     break;
 
-  case 59:
+  case 59: /* $@26: %empty  */
 #line 234 "src/engine/jamgram.y"
                 { yymode( SCAN_NORMAL ); }
-#line 1869 "src/engine/jamgram.cpp"
+#line 1720 "src/engine/jamgram.cpp"
     break;
 
-  case 60:
+  case 60: /* rule: ACTIONS_t eflags ARG bindlist _LBRACE_t $@25 STRING $@26 _RBRACE_t  */
 #line 236 "src/engine/jamgram.y"
                 { yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); }
-#line 1875 "src/engine/jamgram.cpp"
+#line 1726 "src/engine/jamgram.cpp"
     break;
 
-  case 61:
+  case 61: /* assign: _EQUALS_t  */
 #line 244 "src/engine/jamgram.y"
                 { yyval.number = ASSIGN_SET; }
-#line 1881 "src/engine/jamgram.cpp"
+#line 1732 "src/engine/jamgram.cpp"
     break;
 
-  case 62:
+  case 62: /* assign: _PLUS_EQUALS_t  */
 #line 246 "src/engine/jamgram.y"
                 { yyval.number = ASSIGN_APPEND; }
-#line 1887 "src/engine/jamgram.cpp"
+#line 1738 "src/engine/jamgram.cpp"
     break;
 
-  case 63:
+  case 63: /* assign: _QUESTION_EQUALS_t  */
 #line 248 "src/engine/jamgram.y"
                 { yyval.number = ASSIGN_DEFAULT; }
-#line 1893 "src/engine/jamgram.cpp"
+#line 1744 "src/engine/jamgram.cpp"
     break;
 
-  case 64:
+  case 64: /* assign: DEFAULT_t _EQUALS_t  */
 #line 250 "src/engine/jamgram.y"
                 { yyval.number = ASSIGN_DEFAULT; }
-#line 1899 "src/engine/jamgram.cpp"
+#line 1750 "src/engine/jamgram.cpp"
     break;
 
-  case 65:
+  case 65: /* expr: arg  */
 #line 257 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_EXISTS, yyvsp[0].parse, pnull() ); yymode( SCAN_COND ); }
-#line 1905 "src/engine/jamgram.cpp"
+#line 1756 "src/engine/jamgram.cpp"
     break;
 
-  case 66:
+  case 66: /* $@27: %empty  */
 #line 258 "src/engine/jamgram.y"
                          { yymode( SCAN_CONDB ); }
-#line 1911 "src/engine/jamgram.cpp"
+#line 1762 "src/engine/jamgram.cpp"
     break;
 
-  case 67:
+  case 67: /* expr: expr _EQUALS_t $@27 expr  */
 #line 259 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_EQUALS, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1917 "src/engine/jamgram.cpp"
+#line 1768 "src/engine/jamgram.cpp"
     break;
 
-  case 68:
+  case 68: /* $@28: %empty  */
 #line 260 "src/engine/jamgram.y"
                               { yymode( SCAN_CONDB ); }
-#line 1923 "src/engine/jamgram.cpp"
+#line 1774 "src/engine/jamgram.cpp"
     break;
 
-  case 69:
+  case 69: /* expr: expr _BANG_EQUALS_t $@28 expr  */
 #line 261 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_NOTEQ, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1929 "src/engine/jamgram.cpp"
+#line 1780 "src/engine/jamgram.cpp"
     break;
 
-  case 70:
+  case 70: /* $@29: %empty  */
 #line 262 "src/engine/jamgram.y"
                          { yymode( SCAN_CONDB ); }
-#line 1935 "src/engine/jamgram.cpp"
+#line 1786 "src/engine/jamgram.cpp"
     break;
 
-  case 71:
+  case 71: /* expr: expr _LANGLE_t $@29 expr  */
 #line 263 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_LESS, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1941 "src/engine/jamgram.cpp"
+#line 1792 "src/engine/jamgram.cpp"
     break;
 
-  case 72:
+  case 72: /* $@30: %empty  */
 #line 264 "src/engine/jamgram.y"
                                 { yymode( SCAN_CONDB ); }
-#line 1947 "src/engine/jamgram.cpp"
+#line 1798 "src/engine/jamgram.cpp"
     break;
 
-  case 73:
+  case 73: /* expr: expr _LANGLE_EQUALS_t $@30 expr  */
 #line 265 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_LESSEQ, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1953 "src/engine/jamgram.cpp"
+#line 1804 "src/engine/jamgram.cpp"
     break;
 
-  case 74:
+  case 74: /* $@31: %empty  */
 #line 266 "src/engine/jamgram.y"
                          { yymode( SCAN_CONDB ); }
-#line 1959 "src/engine/jamgram.cpp"
+#line 1810 "src/engine/jamgram.cpp"
     break;
 
-  case 75:
+  case 75: /* expr: expr _RANGLE_t $@31 expr  */
 #line 267 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_MORE, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1965 "src/engine/jamgram.cpp"
+#line 1816 "src/engine/jamgram.cpp"
     break;
 
-  case 76:
+  case 76: /* $@32: %empty  */
 #line 268 "src/engine/jamgram.y"
                                 { yymode( SCAN_CONDB ); }
-#line 1971 "src/engine/jamgram.cpp"
+#line 1822 "src/engine/jamgram.cpp"
     break;
 
-  case 77:
+  case 77: /* expr: expr _RANGLE_EQUALS_t $@32 expr  */
 #line 269 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_MOREEQ, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1977 "src/engine/jamgram.cpp"
+#line 1828 "src/engine/jamgram.cpp"
     break;
 
-  case 78:
+  case 78: /* $@33: %empty  */
 #line 270 "src/engine/jamgram.y"
                         { yymode( SCAN_CONDB ); }
-#line 1983 "src/engine/jamgram.cpp"
+#line 1834 "src/engine/jamgram.cpp"
     break;
 
-  case 79:
+  case 79: /* expr: expr _AMPER_t $@33 expr  */
 #line 271 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_AND, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 1989 "src/engine/jamgram.cpp"
+#line 1840 "src/engine/jamgram.cpp"
     break;
 
-  case 80:
+  case 80: /* $@34: %empty  */
 #line 272 "src/engine/jamgram.y"
                              { yymode( SCAN_CONDB ); }
-#line 1995 "src/engine/jamgram.cpp"
+#line 1846 "src/engine/jamgram.cpp"
     break;
 
-  case 81:
+  case 81: /* expr: expr _AMPERAMPER_t $@34 expr  */
 #line 273 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_AND, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 2001 "src/engine/jamgram.cpp"
+#line 1852 "src/engine/jamgram.cpp"
     break;
 
-  case 82:
+  case 82: /* $@35: %empty  */
 #line 274 "src/engine/jamgram.y"
                       { yymode( SCAN_CONDB ); }
-#line 2007 "src/engine/jamgram.cpp"
+#line 1858 "src/engine/jamgram.cpp"
     break;
 
-  case 83:
+  case 83: /* expr: expr _BAR_t $@35 expr  */
 #line 275 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_OR, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 2013 "src/engine/jamgram.cpp"
+#line 1864 "src/engine/jamgram.cpp"
     break;
 
-  case 84:
+  case 84: /* $@36: %empty  */
 #line 276 "src/engine/jamgram.y"
                          { yymode( SCAN_CONDB ); }
-#line 2019 "src/engine/jamgram.cpp"
+#line 1870 "src/engine/jamgram.cpp"
     break;
 
-  case 85:
+  case 85: /* expr: expr _BARBAR_t $@36 expr  */
 #line 277 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_OR, yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 2025 "src/engine/jamgram.cpp"
+#line 1876 "src/engine/jamgram.cpp"
     break;
 
-  case 86:
+  case 86: /* $@37: %empty  */
 #line 278 "src/engine/jamgram.y"
                    { yymode( SCAN_PUNCT ); }
-#line 2031 "src/engine/jamgram.cpp"
+#line 1882 "src/engine/jamgram.cpp"
     break;
 
-  case 87:
+  case 87: /* expr: arg IN_t $@37 list  */
 #line 279 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_IN, yyvsp[-3].parse, yyvsp[0].parse ); yymode( SCAN_COND ); }
-#line 2037 "src/engine/jamgram.cpp"
+#line 1888 "src/engine/jamgram.cpp"
     break;
 
-  case 88:
+  case 88: /* $@38: %empty  */
 #line 280 "src/engine/jamgram.y"
                   { yymode( SCAN_CONDB ); }
-#line 2043 "src/engine/jamgram.cpp"
+#line 1894 "src/engine/jamgram.cpp"
     break;
 
-  case 89:
+  case 89: /* expr: _BANG_t $@38 expr  */
 #line 281 "src/engine/jamgram.y"
                 { yyval.parse = peval( EXPR_NOT, yyvsp[0].parse, pnull() ); }
-#line 2049 "src/engine/jamgram.cpp"
+#line 1900 "src/engine/jamgram.cpp"
     break;
 
-  case 90:
+  case 90: /* $@39: %empty  */
 #line 282 "src/engine/jamgram.y"
                     { yymode( SCAN_CONDB ); }
-#line 2055 "src/engine/jamgram.cpp"
+#line 1906 "src/engine/jamgram.cpp"
     break;
 
-  case 91:
+  case 91: /* expr: _LPAREN_t $@39 expr _RPAREN_t  */
 #line 283 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[-1].parse; }
-#line 2061 "src/engine/jamgram.cpp"
+#line 1912 "src/engine/jamgram.cpp"
     break;
 
-  case 92:
+  case 92: /* cases: %empty  */
 #line 294 "src/engine/jamgram.y"
                 { yyval.parse = P0; }
-#line 2067 "src/engine/jamgram.cpp"
+#line 1918 "src/engine/jamgram.cpp"
     break;
 
-  case 93:
+  case 93: /* cases: case cases  */
 #line 296 "src/engine/jamgram.y"
                 { yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); }
-#line 2073 "src/engine/jamgram.cpp"
+#line 1924 "src/engine/jamgram.cpp"
     break;
 
-  case 94:
+  case 94: /* $@40: %empty  */
 #line 299 "src/engine/jamgram.y"
                  { yymode( SCAN_CASE ); }
-#line 2079 "src/engine/jamgram.cpp"
+#line 1930 "src/engine/jamgram.cpp"
     break;
 
-  case 95:
+  case 95: /* $@41: %empty  */
 #line 299 "src/engine/jamgram.y"
                                                        { yymode( SCAN_NORMAL ); }
-#line 2085 "src/engine/jamgram.cpp"
+#line 1936 "src/engine/jamgram.cpp"
     break;
 
-  case 96:
+  case 96: /* case: CASE_t $@40 ARG _COLON_t $@41 block  */
 #line 300 "src/engine/jamgram.y"
                 { yyval.parse = psnode( yyvsp[-3].string, yyvsp[0].parse ); }
-#line 2091 "src/engine/jamgram.cpp"
+#line 1942 "src/engine/jamgram.cpp"
     break;
 
-  case 97:
+  case 97: /* lol: list  */
 #line 309 "src/engine/jamgram.y"
                 { yyval.parse = pnode( P0, yyvsp[0].parse ); }
-#line 2097 "src/engine/jamgram.cpp"
+#line 1948 "src/engine/jamgram.cpp"
     break;
 
-  case 98:
+  case 98: /* lol: list _COLON_t lol  */
 #line 311 "src/engine/jamgram.y"
                 { yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); }
-#line 2103 "src/engine/jamgram.cpp"
+#line 1954 "src/engine/jamgram.cpp"
     break;
 
-  case 99:
+  case 99: /* list: listp  */
 #line 321 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; }
-#line 2109 "src/engine/jamgram.cpp"
+#line 1960 "src/engine/jamgram.cpp"
     break;
 
-  case 100:
+  case 100: /* listp: %empty  */
 #line 325 "src/engine/jamgram.y"
                 { yyval.parse = pnull(); }
-#line 2115 "src/engine/jamgram.cpp"
+#line 1966 "src/engine/jamgram.cpp"
     break;
 
-  case 101:
+  case 101: /* listp: listp arg  */
 #line 327 "src/engine/jamgram.y"
                 { yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); }
-#line 2121 "src/engine/jamgram.cpp"
+#line 1972 "src/engine/jamgram.cpp"
     break;
 
-  case 102:
+  case 102: /* arg: ARG  */
 #line 331 "src/engine/jamgram.y"
                 { yyval.parse = plist( yyvsp[0].string ); }
-#line 2127 "src/engine/jamgram.cpp"
+#line 1978 "src/engine/jamgram.cpp"
     break;
 
-  case 103:
+  case 103: /* @42: %empty  */
 #line 332 "src/engine/jamgram.y"
                       { yyval.number = yymode( SCAN_CALL ); }
-#line 2133 "src/engine/jamgram.cpp"
+#line 1984 "src/engine/jamgram.cpp"
     break;
 
-  case 104:
+  case 104: /* arg: _LBRACKET_t @42 func _RBRACKET_t  */
 #line 333 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[-1].parse; yymode( yyvsp[-2].number ); }
-#line 2139 "src/engine/jamgram.cpp"
+#line 1990 "src/engine/jamgram.cpp"
     break;
 
-  case 105:
+  case 105: /* $@43: %empty  */
 #line 341 "src/engine/jamgram.y"
               { yymode( SCAN_PUNCT ); }
-#line 2145 "src/engine/jamgram.cpp"
+#line 1996 "src/engine/jamgram.cpp"
     break;
 
-  case 106:
+  case 106: /* func: ARG $@43 lol  */
 #line 342 "src/engine/jamgram.y"
                 { yyval.parse = prule( yyvsp[-2].string, yyvsp[0].parse ); }
-#line 2151 "src/engine/jamgram.cpp"
+#line 2002 "src/engine/jamgram.cpp"
     break;
 
-  case 107:
+  case 107: /* $@44: %empty  */
 #line 343 "src/engine/jamgram.y"
                        { yymode( SCAN_PUNCT ); }
-#line 2157 "src/engine/jamgram.cpp"
+#line 2008 "src/engine/jamgram.cpp"
     break;
 
-  case 108:
+  case 108: /* func: ON_t arg ARG $@44 lol  */
 #line 344 "src/engine/jamgram.y"
                 { yyval.parse = pon( yyvsp[-3].parse, prule( yyvsp[-2].string, yyvsp[0].parse ) ); }
-#line 2163 "src/engine/jamgram.cpp"
+#line 2014 "src/engine/jamgram.cpp"
     break;
 
-  case 109:
+  case 109: /* $@45: %empty  */
 #line 345 "src/engine/jamgram.y"
                             { yymode( SCAN_PUNCT ); }
-#line 2169 "src/engine/jamgram.cpp"
+#line 2020 "src/engine/jamgram.cpp"
     break;
 
-  case 110:
+  case 110: /* func: ON_t arg RETURN_t $@45 list  */
 #line 346 "src/engine/jamgram.y"
                 { yyval.parse = pon( yyvsp[-3].parse, yyvsp[0].parse ); }
-#line 2175 "src/engine/jamgram.cpp"
+#line 2026 "src/engine/jamgram.cpp"
     break;
 
-  case 111:
+  case 111: /* eflags: %empty  */
 #line 356 "src/engine/jamgram.y"
                 { yyval.number = 0; }
-#line 2181 "src/engine/jamgram.cpp"
+#line 2032 "src/engine/jamgram.cpp"
     break;
 
-  case 112:
+  case 112: /* eflags: eflags eflag  */
 #line 358 "src/engine/jamgram.y"
                 { yyval.number = yyvsp[-1].number | yyvsp[0].number; }
-#line 2187 "src/engine/jamgram.cpp"
+#line 2038 "src/engine/jamgram.cpp"
     break;
 
-  case 113:
+  case 113: /* eflag: UPDATED_t  */
 #line 362 "src/engine/jamgram.y"
                 { yyval.number = EXEC_UPDATED; }
-#line 2193 "src/engine/jamgram.cpp"
+#line 2044 "src/engine/jamgram.cpp"
     break;
 
-  case 114:
+  case 114: /* eflag: TOGETHER_t  */
 #line 364 "src/engine/jamgram.y"
                 { yyval.number = EXEC_TOGETHER; }
-#line 2199 "src/engine/jamgram.cpp"
+#line 2050 "src/engine/jamgram.cpp"
     break;
 
-  case 115:
+  case 115: /* eflag: IGNORE_t  */
 #line 366 "src/engine/jamgram.y"
                 { yyval.number = EXEC_IGNORE; }
-#line 2205 "src/engine/jamgram.cpp"
+#line 2056 "src/engine/jamgram.cpp"
     break;
 
-  case 116:
+  case 116: /* eflag: QUIETLY_t  */
 #line 368 "src/engine/jamgram.y"
                 { yyval.number = EXEC_QUIETLY; }
-#line 2211 "src/engine/jamgram.cpp"
+#line 2062 "src/engine/jamgram.cpp"
     break;
 
-  case 117:
+  case 117: /* eflag: PIECEMEAL_t  */
 #line 370 "src/engine/jamgram.y"
                 { yyval.number = EXEC_PIECEMEAL; }
-#line 2217 "src/engine/jamgram.cpp"
+#line 2068 "src/engine/jamgram.cpp"
     break;
 
-  case 118:
+  case 118: /* eflag: EXISTING_t  */
 #line 372 "src/engine/jamgram.y"
                 { yyval.number = EXEC_EXISTING; }
-#line 2223 "src/engine/jamgram.cpp"
+#line 2074 "src/engine/jamgram.cpp"
     break;
 
-  case 119:
+  case 119: /* bindlist: %empty  */
 #line 381 "src/engine/jamgram.y"
                 { yyval.parse = pnull(); }
-#line 2229 "src/engine/jamgram.cpp"
+#line 2080 "src/engine/jamgram.cpp"
     break;
 
-  case 120:
+  case 120: /* $@46: %empty  */
 #line 382 "src/engine/jamgram.y"
                  { yymode( SCAN_PUNCT ); }
-#line 2235 "src/engine/jamgram.cpp"
+#line 2086 "src/engine/jamgram.cpp"
     break;
 
-  case 121:
+  case 121: /* bindlist: BIND_t $@46 list  */
 #line 383 "src/engine/jamgram.y"
                 { yyval.parse = yyvsp[0].parse; }
-#line 2241 "src/engine/jamgram.cpp"
+#line 2092 "src/engine/jamgram.cpp"
     break;
 
 
-#line 2245 "src/engine/jamgram.cpp"
+#line 2096 "src/engine/jamgram.cpp"
 
       default: break;
     }
@@ -2401,13 +2252,13 @@ yyparse (void)
 yyexhaustedlab:
   yyerror (YY_("memory exhausted"));
   yyresult = 2;
-  /* Fall through.  */
+  goto yyreturn;
 #endif
 
 
-/*-----------------------------------------------------.
-| yyreturn -- parsing is finished, return the result.  |
-`-----------------------------------------------------*/
+/*-------------------------------------------------------.
+| yyreturn -- parsing is finished, clean up and return.  |
+`-------------------------------------------------------*/
 yyreturn:
   if (yychar != YYEMPTY)
     {
diff --git a/src/engine/jamgram.hpp b/src/engine/jamgram.hpp
index 6d19ae77b4..48e84c194f 100644
--- a/src/engine/jamgram.hpp
+++ b/src/engine/jamgram.hpp
@@ -1,4 +1,4 @@
-/* A Bison parser, made by GNU Bison 3.6.2.  */
+/* A Bison parser, made by GNU Bison 3.7.2.  */
 
 /* Bison interface for Yacc-like parsers in C
 
diff --git a/src/engine/lists.cpp b/src/engine/lists.cpp
index af602b504b..d646c6e22c 100644
--- a/src/engine/lists.cpp
+++ b/src/engine/lists.cpp
@@ -16,30 +16,30 @@
 
 static LIST * freelist[ 32 ];  /* junkpile for list_dealloc() */
 
-static unsigned get_bucket( unsigned size )
+static int32_t get_bucket( int32_t size )
 {
-    unsigned bucket = 0;
-    while ( size > ( 1u << bucket ) ) ++bucket;
+    int32_t bucket = 0;
+    while ( size > ( int32_t(1) << bucket ) ) ++bucket;
     return bucket;
 }
 
-static LIST * list_alloc( unsigned const size )
+static LIST * list_alloc( int32_t size )
 {
-    unsigned const bucket = get_bucket( size );
+    int32_t bucket = get_bucket( size );
     if ( freelist[ bucket ] )
     {
         LIST * result = freelist[ bucket ];
         freelist[ bucket ] = result->impl.next;
         return result;
     }
-    return (LIST *)BJAM_MALLOC( sizeof( LIST ) + ( 1u << bucket ) *
+    return (LIST *)BJAM_MALLOC( sizeof( LIST ) + ( size_t( 1 ) << bucket ) *
         sizeof( OBJECT * ) );
 }
 
 static void list_dealloc( LIST * l )
 {
-    unsigned size = list_length( l );
-    unsigned bucket;
+    int32_t size = list_length( l );
+    int32_t bucket;
     LIST * node = l;
 
     if ( size == 0 ) return;
@@ -64,13 +64,13 @@ LIST * list_append( LIST * l, LIST * nl )
         return nl;
     if ( !list_empty( nl ) )
     {
-        unsigned int const l_size = list_length( l );
-        int const nl_size = list_length( nl );
-        int const size = l_size + nl_size;
-        unsigned const bucket = get_bucket( size );
+        int32_t l_size = list_length( l );
+        int32_t nl_size = list_length( nl );
+        int32_t size = l_size + nl_size;
+        int32_t bucket = get_bucket( size );
 
         /* Do we need to reallocate? */
-        if ( l_size <= ( 1u << ( bucket - 1 ) ) )
+        if ( l_size <= ( int32_t(1) << ( bucket - 1 ) ) )
         {
             LIST * result = list_alloc( size );
             memcpy( list_begin( result ), list_begin( l ), l_size * sizeof(
@@ -111,7 +111,7 @@ LIST * list_new( OBJECT * value )
 
 LIST * list_push_back( LIST * head, OBJECT * value )
 {
-    unsigned int size = list_length( head );
+    int32_t size = list_length( head );
 
     if ( DEBUG_LISTS )
         out_printf( "list > %s <\n", object_str( value ) );
@@ -142,8 +142,8 @@ LIST * list_push_back( LIST * head, OBJECT * value )
 
 LIST * list_copy( LIST * l )
 {
-    int size = list_length( l );
-    int i;
+    int32_t size = list_length( l );
+    int32_t i;
     LIST * result;
 
     if ( size == 0 ) return L0;
@@ -162,7 +162,7 @@ LIST * list_copy_range( LIST * l, LISTITER first, LISTITER last )
         return L0;
     else
     {
-        int size = last - first;
+        int32_t size = int32_t( last - first );
         LIST * result = list_alloc( size );
         LISTITER dest = list_begin( result );
         result->impl.size = size;
@@ -177,17 +177,17 @@ LIST * list_copy_range( LIST * l, LISTITER first, LISTITER last )
  * list_sublist() - copy a subset of a list of strings.
  */
 
-LIST * list_sublist( LIST * l, int start, int count )
+LIST * list_sublist( LIST * l, int32_t start, int32_t count )
 {
-    int end = start + count;
-    int size = list_length( l );
+    int32_t end = start + count;
+    int32_t size = list_length( l );
     if ( start >= size ) return L0;
     if ( end > size ) end = size;
     return list_copy_range( l, list_begin( l ) + start, list_begin( l ) + end );
 }
 
 
-static int str_ptr_compare( void const * va, void const * vb )
+static int32_t str_ptr_compare( void const * va, void const * vb )
 {
     OBJECT * a = *( (OBJECT * *)va );
     OBJECT * b = *( (OBJECT * *)vb );
@@ -197,7 +197,7 @@ static int str_ptr_compare( void const * va, void const * vb )
 
 LIST * list_sort( LIST * l )
 {
-    int len;
+    int32_t len;
     LIST * result;
 
     if ( !l )
@@ -235,7 +235,7 @@ void list_free( LIST * head )
 
 LIST * list_pop_front( LIST * l )
 {
-    unsigned size = list_length( l );
+    int32_t size = list_length( l );
     assert( size );
     --size;
     object_free( list_front( l ) );
@@ -263,11 +263,11 @@ LIST * list_pop_front( LIST * l )
 
 LIST * list_reverse( LIST * l )
 {
-    int size = list_length( l );
+    int32_t size = list_length( l );
     if ( size == 0 ) return L0;
     {
         LIST * const result = list_alloc( size );
-        int i;
+        int32_t i;
         result->impl.size = size;
         for ( i = 0; i < size; ++i )
             list_begin( result )[ i ] = object_copy( list_begin( l )[ size - i -
@@ -276,9 +276,9 @@ LIST * list_reverse( LIST * l )
     }
 }
 
-int list_cmp( LIST * t, LIST * s )
+int32_t list_cmp( LIST * t, LIST * s )
 {
-    int status = 0;
+    int32_t status = 0;
     LISTITER t_it = list_begin( t );
     LISTITER const t_end = list_end( t );
     LISTITER s_it = list_begin( s );
@@ -298,7 +298,7 @@ int list_cmp( LIST * t, LIST * s )
     return status;
 }
 
-int list_is_sublist( LIST * sub, LIST * l )
+int32_t list_is_sublist( LIST * sub, LIST * l )
 {
     LISTITER iter = list_begin( sub );
     LISTITER const end = list_end( sub );
@@ -329,13 +329,13 @@ void list_print( LIST * l )
  * list_length() - return the number of items in the list
  */
 
-int list_length( LIST * l )
+int32_t list_length( LIST * l )
 {
     return l ? l->impl.size : 0;
 }
 
 
-int list_in( LIST * l, OBJECT * value )
+int32_t list_in( LIST * l, OBJECT * value )
 {
     LISTITER iter = list_begin( l );
     LISTITER end = list_end( l );
@@ -365,8 +365,7 @@ LIST * list_unique( LIST * sorted_list )
 
 void list_done()
 {
-    unsigned int i;
-    for ( i = 0; i < sizeof( freelist ) / sizeof( freelist[ 0 ] ); ++i )
+    for ( int32_t i = 0; i < int32_t(sizeof( freelist ) / sizeof( freelist[ 0 ] )); ++i )
     {
         LIST * l = freelist[ i ];
         while ( l )
@@ -406,7 +405,7 @@ void lol_add( LOL * lol, LIST * l )
 
 void lol_free( LOL * lol )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < lol->count; ++i )
         list_free( lol->list[ i ] );
     lol->count = 0;
@@ -417,7 +416,7 @@ void lol_free( LOL * lol )
  * lol_get() - return one of the LISTs in the LOL.
  */
 
-LIST * lol_get( LOL * lol, int i )
+LIST * lol_get( LOL * lol, int32_t i )
 {
     return i < lol->count ? lol->list[ i ] : L0;
 }
@@ -429,7 +428,7 @@ LIST * lol_get( LOL * lol, int i )
 
 void lol_print( LOL * lol )
 {
-    int i;
+    int32_t i;
     for ( i = 0; i < lol->count; ++i )
     {
         if ( i )
diff --git a/src/engine/lists.h b/src/engine/lists.h
index c26be620df..2f802b368a 100644
--- a/src/engine/lists.h
+++ b/src/engine/lists.h
@@ -54,7 +54,7 @@
 
 typedef struct _list {
     union {
-        int size;
+        int32_t size;
         struct _list * next;
         OBJECT * align;
     } impl;
@@ -68,7 +68,7 @@ typedef OBJECT * * LISTITER;
 
 #define LOL_MAX 19
 typedef struct _lol {
-    int count;
+    int32_t count;
     LIST * list[ LOL_MAX ];
 } LOL;
 
@@ -79,15 +79,15 @@ LIST * list_copy_range( LIST * destination, LISTITER first, LISTITER last );
 void   list_free( LIST * head );
 LIST * list_push_back( LIST * head, OBJECT * value );
 void   list_print( LIST * );
-int    list_length( LIST * );
-LIST * list_sublist( LIST *, int start, int count );
+int32_t list_length( LIST * );
+LIST * list_sublist( LIST *, int32_t start, int32_t count );
 LIST * list_pop_front( LIST * );
 LIST * list_sort( LIST * );
 LIST * list_unique( LIST * sorted_list );
-int    list_in( LIST *, OBJECT * value );
+int32_t list_in( LIST *, OBJECT * value );
 LIST * list_reverse( LIST * );
-int    list_cmp( LIST * lhs, LIST * rhs );
-int    list_is_sublist( LIST * sub, LIST * l );
+int32_t list_cmp( LIST * lhs, LIST * rhs );
+int32_t list_is_sublist( LIST * sub, LIST * l );
 void   list_done();
 
 LISTITER list_begin( LIST * );
@@ -159,7 +159,7 @@ namespace b2 { namespace jam {
         inline iterator begin() { return iterator(list_begin(list_obj)); }
         inline iterator end() { return iterator(list_end(list_obj)); }
         inline bool empty() const { return list_empty(list_obj) || length() == 0; }
-        inline int length() const { return list_length(list_obj); }
+        inline int32_t length() const { return list_length(list_obj); }
         inline list &append(const list &other)
         {
             list_obj = list_append(list_obj, list_copy(other.list_obj));
diff --git a/src/engine/make.cpp b/src/engine/make.cpp
index 470626e567..065adcaef4 100644
--- a/src/engine/make.cpp
+++ b/src/engine/make.cpp
@@ -56,7 +56,7 @@
 static TARGETS * make0sort( TARGETS * c );
 
 #ifdef OPT_GRAPH_DEBUG_EXT
-    static void dependGraphOutput( TARGET * t, int depth );
+    static void dependGraphOutput( TARGET * t, int32_t depth );
 #endif
 
 static char const * target_fate[] =
@@ -91,10 +91,10 @@ static char const * target_bind[] =
  * make() - make a target, given its name.
  */
 
-int make( LIST * targets, int anyhow )
+int32_t make( LIST * targets, int32_t anyhow )
 {
     COUNTS counts[ 1 ];
-    int status = 0;  /* 1 if anything fails */
+    int32_t status = 0;  /* 1 if anything fails */
 
 #ifdef OPT_HEADER_CACHE_EXT
     hcache_init();
@@ -188,7 +188,7 @@ static void update_dependants( TARGET * t )
             if ( DEBUG_FATE )
             {
                 out_printf( "fate change  %s from %s to %s (as dependent of %s)\n",
-                        object_str( p->name ), target_fate[ (int) fate0 ], target_fate[ (int) p->fate ], object_str( t->name ) );
+                        object_str( p->name ), target_fate[ (int32_t) fate0 ], target_fate[ (int32_t) p->fate ], object_str( t->name ) );
             }
 
             /* If we are done visiting it, go back and make sure its dependants
@@ -219,7 +219,7 @@ static void force_rebuilds( TARGET * t )
         {
             if ( DEBUG_FATE )
                 out_printf( "fate change  %s from %s to %s (by rebuild)\n",
-                        object_str( r->name ), target_fate[ (int) r->fate ], target_fate[ T_FATE_REBUILD ] );
+                        object_str( r->name ), target_fate[ (int32_t) r->fate ], target_fate[ T_FATE_REBUILD ] );
 
             /* Force rebuild it. */
             r->fate = T_FATE_REBUILD;
@@ -231,9 +231,9 @@ static void force_rebuilds( TARGET * t )
 }
 
 
-int make0rescan( TARGET * t, TARGET * rescanning )
+int32_t make0rescan( TARGET * t, TARGET * rescanning )
 {
-    int result = 0;
+    int32_t result = 0;
     TARGETS * c;
 
     /* Check whether we have already found a cycle. */
@@ -281,9 +281,9 @@ void make0
 (
     TARGET * t,
     TARGET * p,       /* parent */
-    int      depth,   /* for display purposes */
+    int32_t      depth,   /* for display purposes */
     COUNTS * counts,  /* for reporting */
-    int      anyhow,
+    int32_t      anyhow,
     TARGET * rescanning
 )  /* forcibly touch all (real) targets */
 {
@@ -293,13 +293,13 @@ void make0
     timestamp    last;
     timestamp    leaf;
     timestamp    hlast;
-    int          fate;
+    int32_t          fate;
     char const * flag = "";
     SETTINGS   * s;
 
 #ifdef OPT_GRAPH_DEBUG_EXT
-    int savedFate;
-    int oldTimeStamp;
+    int32_t savedFate;
+    int32_t oldTimeStamp;
 #endif
 
     if ( DEBUG_MAKEPROG )
@@ -392,7 +392,7 @@ void make0
         case T_BIND_MISSING:
         case T_BIND_PARENTS:
             out_printf( "time\t--\t%s%s: %s\n", spaces( depth ),
-                object_str( t->name ), target_bind[ (int)t->binding ] );
+                object_str( t->name ), target_bind[ (int32_t)t->binding ] );
             break;
 
         case T_BIND_EXISTS:
@@ -409,7 +409,7 @@ void make0
     /* Step 3a: Recursively make0() dependencies. */
     for ( c = t->depends; c; c = c->next )
     {
-        int const internal = t->flags & T_FLAG_INTERNAL;
+        int32_t const internal = t->flags & T_FLAG_INTERNAL;
 
         /* Warn about circular deps, except for includes, which include each
          * other alot.
@@ -453,7 +453,7 @@ void make0
 
     /* Step 3d: Detect cycles. */
     {
-        int cycle_depth = depth;
+        int32_t cycle_depth = depth;
         for ( c = t->depends; c; c = c->next )
         {
             TARGET * scc_root = target_scc( c->target );
@@ -512,8 +512,8 @@ void make0
         if ( DEBUG_FATE )
             if ( fate < c->target->fate )
                 out_printf( "fate change %s from %s to %s by dependency %s\n",
-                    object_str( t->name ), target_fate[ (int)fate ],
-                    target_fate[ (int)c->target->fate ], object_str(
+                    object_str( t->name ), target_fate[ (int32_t)fate ],
+                    target_fate[ (int32_t)c->target->fate ], object_str(
                     c->target->name ) );
 #endif
     }
@@ -760,7 +760,7 @@ void make0
         flag = "*";
 
     if ( DEBUG_MAKEPROG )
-        out_printf( "made%s\t%s\t%s%s\n", flag, target_fate[ (int)t->fate ],
+        out_printf( "made%s\t%s\t%s%s\n", flag, target_fate[ (int32_t)t->fate ],
             spaces( depth ), object_str( t->name ) );
 }
 
@@ -783,7 +783,7 @@ static char const * target_name( TARGET * t )
  * dependGraphOutput() - output the DG after make0 has run.
  */
 
-static void dependGraphOutput( TARGET * t, int depth )
+static void dependGraphOutput( TARGET * t, int32_t depth )
 {
     TARGETS * c;
 
@@ -864,7 +864,7 @@ static void dependGraphOutput( TARGET * t, int depth )
     for ( c = t->depends; c; c = c->next )
     {
         out_printf( "  %s       : Depends on %s (%s)", spaces( depth ),
-           target_name( c->target ), target_fate[ (int)c->target->fate ] );
+           target_name( c->target ), target_fate[ (int32_t)c->target->fate ] );
         if ( !timestamp_cmp( &c->target->time, &t->time ) )
             out_printf( " (max time)");
         out_printf( "\n" );
diff --git a/src/engine/make.h b/src/engine/make.h
index 537b9e98f7..5fcdb7a2e2 100644
--- a/src/engine/make.h
+++ b/src/engine/make.h
@@ -16,20 +16,20 @@
 #include "object.h"
 #include "rules.h"
 
-int make( LIST * targets, int anyhow );
-int make1( LIST * t );
+int32_t make( LIST * targets, int32_t anyhow );
+int32_t make1( LIST * t );
 
 typedef struct {
-    int temp;
-    int updating;
-    int cantfind;
-    int cantmake;
-    int targets;
-    int made;
+    int32_t temp;
+    int32_t updating;
+    int32_t cantfind;
+    int32_t cantmake;
+    int32_t targets;
+    int32_t made;
 } COUNTS ;
 
 
-void make0( TARGET * t, TARGET * p, int depth, COUNTS * counts, int anyhow,
+void make0( TARGET * t, TARGET * p, int32_t depth, COUNTS * counts, int32_t anyhow,
     TARGET * rescanning );
 
 
diff --git a/src/engine/make1.cpp b/src/engine/make1.cpp
index 61f0614a1a..0e6e49e6d1 100644
--- a/src/engine/make1.cpp
+++ b/src/engine/make1.cpp
@@ -59,24 +59,24 @@
 #endif
 
 static CMD      * make1cmds      ( TARGET * );
-static LIST     * make1list      ( LIST *, TARGETS *, int flags );
+static LIST     * make1list      ( LIST *, TARGETS *, int32_t flags );
 static SETTINGS * make1settings  ( struct module_t *, LIST * vars );
 static void       make1bind      ( TARGET * );
-static void       push_cmds( CMDLIST * cmds, int status );
-static int        cmd_sem_lock( TARGET * t );
+static void       push_cmds( CMDLIST * cmds, int32_t status );
+static int32_t    cmd_sem_lock( TARGET * t );
 static void       cmd_sem_unlock( TARGET * t );
 
-static int targets_contains( TARGETS * l, TARGET * t );
-static int targets_equal( TARGETS * l1, TARGETS * l2 );
+static int32_t targets_contains( TARGETS * l, TARGET * t );
+static int32_t targets_equal( TARGETS * l1, TARGETS * l2 );
 
 /* Ugly static - it is too hard to carry it through the callbacks. */
 
 static struct
 {
-    int failed;
-    int skipped;
-    int total;
-    int made;
+    int32_t failed;
+    int32_t skipped;
+    int32_t total;
+    int32_t made;
 } counts[ 1 ];
 
 /* Target state. */
@@ -90,16 +90,16 @@ struct _state
     state  * prev;      /* previous state on stack */
     TARGET * t;         /* current target */
     TARGET * parent;    /* parent argument necessary for MAKE1A */
-    int      curstate;  /* current state */
+    int32_t  curstate;  /* current state */
 };
 
 static void make1a( state * const );
 static void make1b( state * const );
 static void make1c( state const * const );
 
-static void make1c_closure( void * const closure, int status,
+static void make1c_closure( void * const closure, int32_t status,
     timing_info const * const, char const * const cmd_stdout,
-    char const * const cmd_stderr, int const cmd_exit_reason );
+    char const * const cmd_stderr, int32_t const cmd_exit_reason );
 
 typedef struct _stack
 {
@@ -111,7 +111,7 @@ static stack state_stack = { NULL };
 static state * state_freelist = NULL;
 
 /* Currently running command counter. */
-static int cmdsrunning;
+static int32_t cmdsrunning;
 
 
 static state * alloc_state()
@@ -163,7 +163,7 @@ static void pop_state( stack * const pStack )
 
 
 static state * push_state( stack * const pStack, TARGET * const t,
-    TARGET * const parent, int const curstate )
+    TARGET * const parent, int32_t const curstate )
 {
     state * const pState = alloc_state();
     pState->t = t;
@@ -194,13 +194,13 @@ static void push_stack_on_stack( stack * const pDest, stack * const pSrc )
  * make1() - execute commands to update a list of targets and all of their dependencies
  */
 
-static int intr = 0;
-static int quit = 0;
+static int32_t intr = 0;
+static int32_t quit = 0;
 
-int make1( LIST * targets )
+int32_t make1( LIST * targets )
 {
     state * pState;
-    int status = 0;
+    int32_t status = 0;
 
     memset( (char *)counts, 0, sizeof( *counts ) );
 
@@ -512,7 +512,7 @@ static void make1c( state const * const pState )
 {
     TARGET * const t = pState->t;
     CMD * const cmd = (CMD *)t->cmds;
-    int exec_flags = 0;
+    int32_t exec_flags = 0;
 
     if ( cmd )
     {
@@ -786,7 +786,7 @@ static void call_timing_rule( TARGET * target, timing_info const * const time )
 static void call_action_rule
 (
     TARGET * target,
-    int status,
+    int32_t status,
     timing_info const * time,
     char const * executed_command,
     char const * command_output
@@ -869,11 +869,11 @@ static void call_action_rule
 static void make1c_closure
 (
     void * const closure,
-    int status_orig,
+    int32_t status_orig,
     timing_info const * const time,
     char const * const cmd_stdout,
     char const * const cmd_stderr,
-    int const cmd_exit_reason
+    int32_t const cmd_exit_reason
 )
 {
     TARGET * const t = (TARGET *)closure;
@@ -984,7 +984,7 @@ static void make1c_closure
 }
 
 /* push the next MAKE1C state after a command is run. */
-static void push_cmds( CMDLIST * cmds, int status )
+static void push_cmds( CMDLIST * cmds, int32_t status )
 {
     CMDLIST * cmd_iter;
     for( cmd_iter = cmds; cmd_iter; cmd_iter = cmd_iter->next )
@@ -1065,12 +1065,12 @@ static void swap_settings
 static CMD * make1cmds( TARGET * t )
 {
     CMD * cmds = 0;
-    CMD * last_cmd;
+    CMD * last_cmd = 0;
     LIST * shell = L0;
     module_t * settings_module = 0;
     TARGET * settings_target = 0;
-    ACTIONS * a0;
-    int const running_flag = globs.noexec ? A_RUNNING_NOEXEC : A_RUNNING;
+    ACTIONS * a0 = 0;
+    int32_t const running_flag = globs.noexec ? A_RUNNING_NOEXEC : A_RUNNING;
 
     /* Step through actions.
      */
@@ -1168,21 +1168,21 @@ static CMD * make1cmds( TARGET * t )
          * Note that we loop through at least once, for sourceless actions.
          */
         {
-            int const length = list_length( ns );
-            int start = 0;
-            int chunk = length;
-            int cmd_count = 0;
+            int32_t const length = list_length( ns );
+            int32_t start = 0;
+            int32_t chunk = length;
+            int32_t cmd_count = 0;
             TARGETS * semaphores = NULL;
             TARGETS * targets_iter;
-            int unique_targets;
+            int32_t unique_targets;
             do
             {
                 CMD * cmd;
-                int cmd_check_result;
-                int cmd_error_length;
-                int cmd_error_max_length;
-                int retry = 0;
-                int accept_command = 0;
+                int32_t cmd_check_result;
+                int32_t cmd_error_length;
+                int32_t cmd_error_max_length;
+                int32_t retry = 0;
+                int32_t accept_command = 0;
 
                 /* Build cmd: cmd_new() takes ownership of its lists. */
                 cmd = cmd_new( rule, list_copy( nt ), list_sublist( ns, start,
@@ -1219,9 +1219,10 @@ static CMD * make1cmds( TARGET * t )
                             : "contains a line that is too long";
                     assert( cmd_check_result == EXEC_CHECK_TOO_LONG ||
                         cmd_check_result == EXEC_CHECK_LINE_TOO_LONG );
-                    out_printf( "%s action %s (%d, max %d):\n", object_str(
-                        rule->name ), error_message, cmd_error_length,
-                        cmd_error_max_length );
+                    out_printf(
+                        "%s action %s (%d, max %d):\n",
+                        object_str( rule->name ), error_message,
+                        cmd_error_length, cmd_error_max_length );
 
                     /* Tell the user what did not fit. */
                     out_puts( cmd->buf->value );
@@ -1314,7 +1315,7 @@ static CMD * make1cmds( TARGET * t )
  * make1list() - turn a list of targets into a LIST, for $(<) and $(>)
  */
 
-static LIST * make1list( LIST * l, TARGETS * targets, int flags )
+static LIST * make1list( LIST * l, TARGETS * targets, int32_t flags )
 {
     for ( ; targets; targets = targets->next )
     {
@@ -1417,7 +1418,7 @@ static void make1bind( TARGET * t )
 }
 
 
-static int targets_contains( TARGETS * l, TARGET * t )
+static int32_t targets_contains( TARGETS * l, TARGET * t )
 {
     for ( ; l; l = l->next )
     {
@@ -1429,7 +1430,7 @@ static int targets_contains( TARGETS * l, TARGET * t )
     return 0;
 }
 
-static int targets_equal( TARGETS * l1, TARGETS * l2 )
+static int32_t targets_equal( TARGETS * l1, TARGETS * l2 )
 {
     for ( ; l1 && l2; l1 = l1->next, l2 = l2->next )
     {
@@ -1442,7 +1443,7 @@ static int targets_equal( TARGETS * l1, TARGETS * l2 )
 
 #ifdef OPT_SEMAPHORE
 
-static int cmd_sem_lock( TARGET * t )
+static int32_t cmd_sem_lock( TARGET * t )
 {
     CMD * cmd = (CMD *)t->cmds;
     TARGETS * iter;
diff --git a/src/engine/md5.cpp b/src/engine/md5.cpp
index c35d96c5ef..2c53be85e9 100644
--- a/src/engine/md5.cpp
+++ b/src/engine/md5.cpp
@@ -320,25 +320,25 @@ md5_init(md5_state_t *pms)
 }
 
 void
-md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
+md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes)
 {
     const md5_byte_t *p = data;
-    int left = nbytes;
-    int offset = (pms->count[0] >> 3) & 63;
+    size_t left = nbytes;
+    size_t offset = (pms->count[0] >> 3) & 63;
     md5_word_t nbits = (md5_word_t)(nbytes << 3);
 
     if (nbytes <= 0)
 	return;
 
     /* Update the message length. */
-    pms->count[1] += nbytes >> 29;
+    pms->count[1] += md5_word_t(nbytes >> 29);
     pms->count[0] += nbits;
     if (pms->count[0] < nbits)
 	pms->count[1]++;
 
     /* Process an initial partial block. */
     if (offset) {
-	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+	size_t copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
 
 	memcpy(pms->buf + offset, p, copy);
 	if (offset + copy < 64)
diff --git a/src/engine/md5.h b/src/engine/md5.h
index 698c995d8f..cbfde59767 100644
--- a/src/engine/md5.h
+++ b/src/engine/md5.h
@@ -50,6 +50,8 @@
 #ifndef md5_INCLUDED
 #  define md5_INCLUDED
 
+#include <stddef.h>
+
 /*
  * This package supports both compile-time and run-time determination of CPU
  * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
@@ -71,7 +73,7 @@ typedef struct md5_state_s {
 } md5_state_t;
 
 #ifdef __cplusplus
-extern "C" 
+extern "C"
 {
 #endif
 
@@ -79,7 +81,7 @@ extern "C"
 void md5_init(md5_state_t *pms);
 
 /* Append a string to the message. */
-void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+void md5_append(md5_state_t *pms, const md5_byte_t *data, size_t nbytes);
 
 /* Finish the message and return the digest. */
 void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
diff --git a/src/engine/modules/order.cpp b/src/engine/modules/order.cpp
index 38209b889d..dcfee4343a 100644
--- a/src/engine/modules/order.cpp
+++ b/src/engine/modules/order.cpp
@@ -15,7 +15,7 @@
 /* Use quite klugy approach: when we add order dependency from 'a' to 'b', just
  * append 'b' to of value of variable 'a'.
  */
-LIST * add_pair( FRAME * frame, int flags )
+LIST * add_pair( FRAME * frame, int32_t flags )
 {
     LIST * arg = lol_get( frame->args, 0 );
     LISTITER iter = list_begin( arg );
@@ -29,9 +29,9 @@ LIST * add_pair( FRAME * frame, int flags )
 /* Given a list and a value, returns position of that value in the list, or -1
  * if not found.
  */
-int list_index( LIST * list, OBJECT * value )
+int32_t list_index( LIST * list, OBJECT * value )
 {
-    int result = 0;
+    int32_t result = 0;
     LISTITER iter = list_begin( list );
     LISTITER const end = list_end( list );
     for ( ; iter != end; iter = list_next( iter ), ++result )
@@ -47,15 +47,15 @@ enum colors { white, gray, black };
  * vertices which were not yet visited. After that, 'current_vertex' is added to
  * '*result_ptr'.
  */
-void do_ts( int * * graph, int current_vertex, int * colors, int * * result_ptr
+void do_ts( int32_t * * graph, int32_t current_vertex, int32_t * colors, int32_t * * result_ptr
     )
 {
-    int i;
+    int32_t i;
 
     colors[ current_vertex ] = gray;
     for ( i = 0; graph[ current_vertex ][ i ] != -1; ++i )
     {
-        int adjacent_vertex = graph[ current_vertex ][ i ];
+        int32_t adjacent_vertex = graph[ current_vertex ][ i ];
         if ( colors[ adjacent_vertex ] == white )
             do_ts( graph, adjacent_vertex, colors, result_ptr );
         /* The vertex is either black, in which case we do not have to do
@@ -70,10 +70,10 @@ void do_ts( int * * graph, int current_vertex, int * colors, int * * result_ptr
 }
 
 
-void topological_sort( int * * graph, int num_vertices, int * result )
+static void topological_sort( int32_t * * graph, int32_t num_vertices, int32_t * result )
 {
-    int i;
-    int * colors = ( int * )BJAM_CALLOC( num_vertices, sizeof( int ) );
+    int32_t i;
+    int32_t * colors = ( int32_t * )BJAM_CALLOC( num_vertices, sizeof( int32_t ) );
     for ( i = 0; i < num_vertices; ++i )
         colors[ i ] = white;
 
@@ -85,34 +85,34 @@ void topological_sort( int * * graph, int num_vertices, int * result )
 }
 
 
-LIST * order( FRAME * frame, int flags )
+LIST * order( FRAME * frame, int32_t flags )
 {
     LIST * arg = lol_get( frame->args, 0 );
     LIST * result = L0;
-    int src;
+    int32_t src;
     LISTITER iter = list_begin( arg );
     LISTITER const end = list_end( arg );
 
     /* We need to create a graph of order dependencies between the passed
      * objects. We assume there are no duplicates passed to 'add_pair'.
      */
-    int length = list_length( arg );
-    int * * graph = ( int * * )BJAM_CALLOC( length, sizeof( int * ) );
-    int * order = ( int * )BJAM_MALLOC( ( length + 1 ) * sizeof( int ) );
+    int32_t length = list_length( arg );
+    int32_t * * graph = ( int32_t * * )BJAM_CALLOC( length, sizeof( int32_t * ) );
+    int32_t * order = ( int32_t * )BJAM_MALLOC( ( length + 1 ) * sizeof( int32_t ) );
 
     for ( src = 0; iter != end; iter = list_next( iter ), ++src )
     {
         /* For all objects this one depends upon, add elements to 'graph'. */
         LIST * dependencies = var_get( frame->module, list_item( iter ) );
-        int index = 0;
+        int32_t index = 0;
         LISTITER dep_iter = list_begin( dependencies );
         LISTITER const dep_end = list_end( dependencies );
 
-        graph[ src ] = ( int * )BJAM_CALLOC( list_length( dependencies ) + 1,
-            sizeof( int ) );
+        graph[ src ] = ( int32_t * )BJAM_CALLOC( list_length( dependencies ) + 1,
+            sizeof( int32_t ) );
         for ( ; dep_iter != dep_end; dep_iter = list_next( dep_iter ) )
         {
-            int const dst = list_index( arg, list_item( dep_iter ) );
+            int32_t const dst = list_index( arg, list_item( dep_iter ) );
             if ( dst != -1 )
                 graph[ src ][ index++ ] = dst;
         }
@@ -122,10 +122,10 @@ LIST * order( FRAME * frame, int flags )
     topological_sort( graph, length, order );
 
     {
-        int index = length - 1;
+        int32_t index = length - 1;
         for ( ; index >= 0; --index )
         {
-            int i;
+            int32_t i;
             LISTITER iter = list_begin( arg );
             for ( i = 0; i < order[ index ]; ++i, iter = list_next( iter ) );
             result = list_push_back( result, object_copy( list_item( iter ) ) );
@@ -134,7 +134,7 @@ LIST * order( FRAME * frame, int flags )
 
     /* Clean up */
     {
-        int i;
+        int32_t i;
         for ( i = 0; i < length; ++i )
             BJAM_FREE( graph[ i ] );
         BJAM_FREE( graph );
diff --git a/src/engine/modules/property-set.cpp b/src/engine/modules/property-set.cpp
index 1f33941075..30236ee3ac 100644
--- a/src/engine/modules/property-set.cpp
+++ b/src/engine/modules/property-set.cpp
@@ -26,8 +26,8 @@ struct ps_map_entry
 struct ps_map
 {
     struct ps_map_entry * * table;
-    size_t table_size;
-    size_t num_elems;
+    int32_t table_size;
+    int32_t num_elems;
 };
 
 static unsigned list_hash(LIST * key)
@@ -63,10 +63,10 @@ static int list_equal( LIST * lhs, LIST * rhs )
 
 static void ps_map_init( struct ps_map * map )
 {
-    size_t i;
+    int32_t i;
     map->table_size = 2;
     map->num_elems = 0;
-    map->table = (struct ps_map_entry * *)BJAM_MALLOC( map->table_size * sizeof( struct ps_map_entry * ) );
+    map->table = (struct ps_map_entry * *)BJAM_MALLOC( size_t(map->table_size) * sizeof( struct ps_map_entry * ) );
     for ( i = 0; i < map->table_size; ++i )
     {
         map->table[ i ] = NULL;
@@ -75,7 +75,7 @@ static void ps_map_init( struct ps_map * map )
 
 static void ps_map_destroy( struct ps_map * map )
 {
-    size_t i;
+    int32_t i;
     for ( i = 0; i < map->table_size; ++i )
     {
         struct ps_map_entry * pos;
@@ -93,8 +93,8 @@ static void ps_map_destroy( struct ps_map * map )
 static void ps_map_rehash( struct ps_map * map )
 {
     struct ps_map old = *map;
-    size_t i;
-    map->table = (struct ps_map_entry * *)BJAM_MALLOC( map->table_size * 2 * sizeof( struct ps_map_entry * ) );
+    int32_t i;
+    map->table = (struct ps_map_entry * *)BJAM_MALLOC( size_t(map->table_size) * 2 * sizeof( struct ps_map_entry * ) );
     map->table_size *= 2;
     for ( i = 0; i < map->table_size; ++i )
     {
diff --git a/src/engine/modules/regex.cpp b/src/engine/modules/regex.cpp
index fa53558588..eae846d75e 100644
--- a/src/engine/modules/regex.cpp
+++ b/src/engine/modules/regex.cpp
@@ -48,7 +48,7 @@ LIST * regex_split( FRAME * frame, int flags )
     prev = pos = object_str( s );
     while ( regexec( re, pos ) )
     {
-        result = list_push_back( result, object_new_range( prev, re->startp[ 0 ] - prev ) );
+        result = list_push_back( result, object_new_range( prev, int32_t(re->startp[ 0 ] - prev) ) );
         prev = re->endp[ 0 ];
         /* Handle empty matches */
         if ( *pos == '\0' )
diff --git a/src/engine/native.cpp b/src/engine/native.cpp
index 68828aa315..0f80080f66 100644
--- a/src/engine/native.cpp
+++ b/src/engine/native.cpp
@@ -12,7 +12,7 @@
 
 
 void declare_native_rule( char const * module, char const * rule,
-    char const * * args, LIST * (*f)( FRAME *, int ), int version )
+    char const * * args, LIST * (*f)( FRAME *, int32_t ), int32_t version )
 {
     OBJECT * const module_obj = module ? object_new( module ) : 0 ;
     module_t * m = bindmodule( module_obj );
@@ -23,7 +23,7 @@ void declare_native_rule( char const * module, char const * rule,
 
     {
         OBJECT * const name = object_new( rule );
-        int found;
+        int32_t found;
         native_rule_t * const np = (native_rule_t *)hash_insert(
             m->native_rules, name, &found );
         np->name = name;
diff --git a/src/engine/native.h b/src/engine/native.h
index f80b0e0f04..5367552f5c 100644
--- a/src/engine/native.h
+++ b/src/engine/native.h
@@ -25,11 +25,11 @@ typedef struct native_rule_t
      *
      * Versions are numbered from 1.
     */
-    int version;
+    int32_t version;
 } native_rule_t;
 /* MSVC debugger gets confused unless the native_rule_t typedef is provided. */
 
 void declare_native_rule( char const * module, char const * rule,
-    char const * * args, LIST * (*f)( FRAME *, int ), int version );
+    char const * * args, LIST * (*f)( FRAME *, int32_t ), int32_t version );
 
 #endif
diff --git a/src/engine/object.cpp b/src/engine/object.cpp
index 07866baf46..069bc215ed 100644
--- a/src/engine/object.cpp
+++ b/src/engine/object.cpp
@@ -55,15 +55,15 @@ struct hash_item
 
 typedef struct string_set
 {
-    unsigned int num;
-    unsigned int size;
+    int32_t num;
+    int32_t size;
     struct hash_item * * data;
 } string_set;
 
 static string_set strhash;
-static int strtotal = 0;
-static int strcount_in = 0;
-static int strcount_out = 0;
+static int32_t strtotal = 0;
+static int32_t strcount_in = 0;
+static int32_t strcount_out = 0;
 
 
 /*
@@ -89,13 +89,13 @@ static char * storage_finish = 0;
  * allocate() - Allocate n bytes of immortal string storage.
  */
 
-static char * allocate( size_t n )
+static char * allocate( int32_t n )
 {
 #ifdef BJAM_NEWSTR_NO_ALLOCATE
     return (char *)BJAM_MALLOC( n );
 #else
     /* See if we can grab storage from an existing block. */
-    size_t remaining = storage_finish - storage_start;
+    int32_t remaining = int32_t(storage_finish - storage_start);
     n = ( ( n + ALLOC_ALIGNMENT - 1 ) / ALLOC_ALIGNMENT ) * ALLOC_ALIGNMENT;
     if ( remaining >= n )
     {
@@ -106,13 +106,13 @@ static char * allocate( size_t n )
     else  /* Must allocate a new block. */
     {
         strblock * new_block;
-        size_t nalloc = n;
+        int32_t nalloc = n;
         if ( nalloc < STRING_BLOCK )
             nalloc = STRING_BLOCK;
 
         /* Allocate a new block and link into the chain. */
         new_block = (strblock *)BJAM_MALLOC( offsetof( strblock, data[ 0 ] ) +
-            nalloc * sizeof( new_block->data[ 0 ] ) );
+            size_t(nalloc) * sizeof( new_block->data[ 0 ] ) );
         if ( new_block == 0 )
             return 0;
         new_block->next = strblock_chain;
@@ -130,7 +130,7 @@ static char * allocate( size_t n )
 }
 
 
-static unsigned int hash_keyval( char const * key, int const size )
+static unsigned int hash_keyval( char const * key, int32_t size )
 {
     unsigned int const magic = 2147059363;
     unsigned int hash = 0;
@@ -171,14 +171,13 @@ static void string_set_done( string_set * set )
 
 static void string_set_resize( string_set * set )
 {
-    unsigned i;
     string_set new_set;
     new_set.num = set->num * 2;
     new_set.size = set->size;
     new_set.data = (struct hash_item * *)BJAM_MALLOC( sizeof( struct hash_item *
         ) * new_set.num );
     memset( new_set.data, 0, sizeof( struct hash_item * ) * new_set.num );
-    for ( i = 0; i < set->num; ++i )
+    for ( int32_t i = 0; i < set->num; ++i )
     {
         while ( set->data[ i ] )
         {
@@ -195,7 +194,7 @@ static void string_set_resize( string_set * set )
 
 
 static char const * string_set_insert( string_set * set, char const * string,
-    int const size )
+    int32_t const size )
 {
     unsigned hash = hash_keyval( string, size );
     unsigned pos = hash % set->num;
@@ -230,25 +229,11 @@ static char const * string_set_insert( string_set * set, char const * string,
 }
 
 
-static struct hash_item * object_get_item( OBJECT * obj )
-{
-    return (struct hash_item *)( (char *)obj - offsetof( struct hash_item, data
-        ) );
-}
-
-
-static void object_validate( OBJECT * obj )
-{
-    assert( obj );
-    assert( object_get_item( obj )->header.magic == OBJECT_MAGIC );
-}
-
-
 /*
  * object_new_range() - create an object from a string of given length
  */
 
-OBJECT * object_new_range( char const * const string, int const size )
+OBJECT * object_new_range( char const * const string, int32_t size )
 {
     ++strcount_in;
 
@@ -278,12 +263,26 @@ OBJECT * object_new_range( char const * const string, int const size )
 
 OBJECT * object_new( char const * const string )
 {
-    return object_new_range( string, strlen( string ) );
+    return object_new_range( string, int32_t(strlen( string )) );
 }
 
 
 #ifndef object_copy
 
+static struct hash_item * object_get_item( OBJECT * obj )
+{
+    return (struct hash_item *)( (char *)obj - offsetof( struct hash_item, data
+        ) );
+}
+
+
+static void object_validate( OBJECT * obj )
+{
+    assert( obj );
+    assert( object_get_item( obj )->header.magic == OBJECT_MAGIC );
+}
+
+
 /*
  * object_copy() - return a copy of an object
  */
diff --git a/src/engine/object.h b/src/engine/object.h
index e53078d738..555e9851c6 100644
--- a/src/engine/object.h
+++ b/src/engine/object.h
@@ -18,7 +18,7 @@
 typedef struct _object OBJECT;
 
 OBJECT * object_new( char const * const );
-OBJECT * object_new_range( char const * const, int const size );
+OBJECT * object_new_range( char const * const, int32_t size );
 void object_done( void );
 
 #if defined(NDEBUG) && !defined(BJAM_NO_MEM_CACHE)
diff --git a/src/engine/patchlevel.h b/src/engine/patchlevel.h
index 69fe073d8e..7c3260183b 100644
--- a/src/engine/patchlevel.h
+++ b/src/engine/patchlevel.h
@@ -12,5 +12,5 @@ Distributed under the Boost Software License, Version 1.0.
 
 
 #define VERSION_MAJOR 4
-#define VERSION_MINOR 3
-#define VERSION_PATCH 0
+#define VERSION_MINOR 4
+#define VERSION_PATCH 1
diff --git a/src/engine/pathnt.cpp b/src/engine/pathnt.cpp
index 5b0cc4659e..a4cdc93c86 100644
--- a/src/engine/pathnt.cpp
+++ b/src/engine/pathnt.cpp
@@ -17,6 +17,8 @@
  */
 
 #include "jam.h"
+#ifdef USE_PATHNT
+
 #include "pathsys.h"
 #include "hash.h"
 
@@ -94,11 +96,11 @@ void path_get_temp_path_( string * buffer )
  *  - path_key_cache path/key mapping cache object already initialized
  */
 
-static int canonicWindowsPath( char const * const path, int const path_length,
+static int canonicWindowsPath( char const * const path, int32_t path_length,
     string * const out )
 {
     char const * last_element;
-    unsigned long saved_size;
+    int32_t saved_size;
     char const * p;
     int missing_parent;
 
@@ -138,7 +140,7 @@ static int canonicWindowsPath( char const * const path, int const path_length,
     if ( p >= path )
     {
         char const * const dir = path;
-        int const dir_length = p - path;
+        const int32_t dir_length = int32_t(p - path);
         OBJECT * const dir_obj = object_new_range( dir, dir_length );
         int found;
         path_key_entry * const result = (path_key_entry *)hash_insert(
@@ -170,7 +172,7 @@ static int canonicWindowsPath( char const * const path, int const path_length,
     if ( !missing_parent )
     {
         char const * const n = last_element;
-        int const n_length = path + path_length - n;
+        int32_t n_length = int32_t(path + path_length - n);
         if ( !( n_length == 1 && n[ 0 ] == '.' )
             && !( n_length == 2 && n[ 0 ] == '.' && n[ 1 ] == '.' ) )
         {
@@ -239,7 +241,7 @@ static path_key_entry * path_key( OBJECT * const path,
     if ( !found )
     {
         OBJECT * normalized;
-        int normalized_size;
+        int32_t normalized_size;
         path_key_entry * nresult;
         result->path = path;
         {
@@ -394,8 +396,8 @@ OBJECT * path_as_key( OBJECT * path )
 static void free_path_key_entry( void * xentry, void * const data )
 {
     path_key_entry * const entry = (path_key_entry *)xentry;
-    object_free( entry->path );
-    object_free( entry->key );
+    if (entry->path) object_free( entry->path );
+    if (entry->key) object_free( entry->key );
 }
 
 
@@ -407,3 +409,5 @@ void path_done( void )
         hashdone( path_key_cache );
     }
 }
+
+#endif // USE_PATHNT
diff --git a/src/engine/pathsys.cpp b/src/engine/pathsys.cpp
index 00687d1590..7e6d57a34f 100644
--- a/src/engine/pathsys.cpp
+++ b/src/engine/pathsys.cpp
@@ -64,7 +64,7 @@ void path_parse( char const * file, PATHNAME * f )
     if ( ( file[ 0 ] == '<' ) && ( p = strchr( file, '>' ) ) )
     {
         f->f_grist.ptr = file;
-        f->f_grist.len = p - file;
+        f->f_grist.len = int32_t(p - file);
         file = p + 1;
     }
 
@@ -83,7 +83,7 @@ void path_parse( char const * file, PATHNAME * f )
     if ( p )
     {
         f->f_dir.ptr = file;
-        f->f_dir.len = p - file;
+        f->f_dir.len = int32_t(p - file);
 
         /* Special case for / - dirname is /, not "" */
         if ( !f->f_dir.len )
@@ -104,7 +104,7 @@ void path_parse( char const * file, PATHNAME * f )
     if ( ( p = strchr( file, '(' ) ) && ( end[ -1 ] == ')' ) )
     {
         f->f_member.ptr = p + 1;
-        f->f_member.len = end - p - 2;
+        f->f_member.len = int32_t(end - p - 2);
         end = p;
     }
 
@@ -115,13 +115,13 @@ void path_parse( char const * file, PATHNAME * f )
     if ( p )
     {
         f->f_suffix.ptr = p;
-        f->f_suffix.len = end - p;
+        f->f_suffix.len = int32_t(end - p);
         end = p;
     }
 
     /* Leaves base. */
     f->f_base.ptr = file;
-    f->f_base.len = end - file;
+    f->f_base.len = int32_t(end - file);
 }
 
 
@@ -316,7 +316,7 @@ std::string b2::paths::normalize(const std::string &p)
     // want this function to obtain a canonic representation.
     std::replace(result.begin(), result.end(), '\\', '/');
 
-    size_t ellipsis = 0;
+    int32_t ellipsis = 0;
     for (auto end_pos = result.length(); end_pos > 0; )
     {
         auto path_pos = result.rfind('/', end_pos-1);
diff --git a/src/engine/pathsys.h b/src/engine/pathsys.h
index ffb62c18ef..272cae2145 100644
--- a/src/engine/pathsys.h
+++ b/src/engine/pathsys.h
@@ -38,7 +38,7 @@ Distributed under the Boost Software License, Version 1.0.
 typedef struct _pathpart
 {
     char const * ptr;
-    int len;
+    int32_t len;
 } PATHPART;
 
 typedef struct _pathname
diff --git a/src/engine/pathunix.cpp b/src/engine/pathunix.cpp
index 2b2347c871..b4aab23822 100644
--- a/src/engine/pathunix.cpp
+++ b/src/engine/pathunix.cpp
@@ -16,6 +16,9 @@
  * pathunix.c - UNIX specific path manipulation support
  */
 
+#include "jam.h"
+#ifdef USE_PATHUNIX
+
 #include "pathsys.h"
 
 #include <stdlib.h>
@@ -84,3 +87,5 @@ OBJECT * path_as_key( OBJECT * path )
 void path_done( void )
 {
 }
+
+#endif // USE_PATHUNIX
diff --git a/src/engine/regexp.cpp b/src/engine/regexp.cpp
index 537bc828dc..dacae62520 100644
--- a/src/engine/regexp.cpp
+++ b/src/engine/regexp.cpp
@@ -154,9 +154,9 @@
  * Utility definitions.
  */
 #ifndef CHARBITS
-#define UCHARAT(p)  ((int)*(const unsigned char *)(p))
+#define UCHARAT(p)  ((int32_t)*(const unsigned char *)(p))
 #else
-#define UCHARAT(p)  ((int)*(p)&CHARBITS)
+#define UCHARAT(p)  ((int32_t)*(p)&CHARBITS)
 #endif
 
 #define FAIL(m) { regerror(m); return(NULL); }
@@ -173,11 +173,11 @@
 /*
  * Global work variables for regcomp().
  */
-static char *regparse;      /* Input-scan pointer. */
-static int regnpar;     /* () count. */
+static char *regparse; /* Input-scan pointer. */
+static int32_t regnpar; /* () count. */
 static char regdummy;
-static char *regcode;       /* Code-emit pointer; &regdummy = don't. */
-static long regsize;        /* Code size. */
+static char *regcode; /* Code-emit pointer; &regdummy = don't. */
+static int32_t regsize; /* Code size. */
 
 /*
  * Forward declarations for regcomp()'s friends.
@@ -185,18 +185,18 @@ static long regsize;        /* Code size. */
 #ifndef STATIC
 #define STATIC  static
 #endif
-STATIC char *reg( int paren, int *flagp );
-STATIC char *regbranch( int *flagp );
-STATIC char *regpiece( int *flagp );
-STATIC char *regatom( int *flagp );
-STATIC char *regnode( int op );
+STATIC char *reg( int32_t paren, int32_t *flagp );
+STATIC char *regbranch( int32_t *flagp );
+STATIC char *regpiece( int32_t *flagp );
+STATIC char *regatom( int32_t *flagp );
+STATIC char *regnode( int32_t op );
 STATIC char *regnext( char *p );
-STATIC void regc( int b );
+STATIC void regc( int32_t b );
 STATIC void reginsert( char op, char *opnd );
 STATIC void regtail( char *p, char *val );
 STATIC void regoptail( char *p, char *val );
 #ifdef STRCSPN
-STATIC int strcspn();
+STATIC int32_t strcspn();
 #endif
 
 /*
@@ -220,8 +220,8 @@ regcomp( const char *exp )
     regexp *r;
     char *scan;
     char *longest;
-    unsigned len;
-    int flags;
+    int32_t len;
+    int32_t flags;
 
     if (exp == NULL)
         FAIL("NULL argument");
@@ -232,7 +232,7 @@ regcomp( const char *exp )
 #endif
     regparse = (char *)exp;
     regnpar = 1;
-    regsize = 0L;
+    regsize = 0;
     regcode = &regdummy;
     regc(MAGIC);
     if (reg(0, &flags) == NULL)
@@ -243,7 +243,7 @@ regcomp( const char *exp )
         FAIL("regexp too big");
 
     /* Allocate space. */
-    r = (regexp *)BJAM_MALLOC(sizeof(regexp) + (unsigned)regsize);
+    r = (regexp *)BJAM_MALLOC(sizeof(regexp) + regsize);
     if (r == NULL)
         FAIL("out of space");
 
@@ -282,9 +282,9 @@ regcomp( const char *exp )
             longest = NULL;
             len = 0;
             for (; scan != NULL; scan = regnext(scan))
-                if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
+                if (OP(scan) == EXACTLY && static_cast<int32_t>(strlen(OPERAND(scan))) >= len) {
                     longest = OPERAND(scan);
-                    len = strlen(OPERAND(scan));
+                    len = static_cast<int32_t>(strlen(OPERAND(scan)));
                 }
             r->regmust = longest;
             r->regmlen = len;
@@ -305,14 +305,14 @@ regcomp( const char *exp )
  */
 static char *
 reg(
-    int paren,          /* Parenthesized? */
-    int *flagp )
+    int32_t paren,          /* Parenthesized? */
+    int32_t *flagp )
 {
     char *ret;
     char *br;
     char *ender;
-    int parno = 0;
-    int flags;
+    int32_t parno = 0;
+    int32_t flags;
 
     *flagp = HASWIDTH;  /* Tentatively. */
 
@@ -376,12 +376,12 @@ reg(
  * Implements the concatenation operator.
  */
 static char *
-regbranch( int *flagp )
+regbranch( int32_t *flagp )
 {
     char *ret;
     char *chain;
     char *latest;
-    int flags;
+    int32_t flags;
 
     *flagp = WORST;     /* Tentatively. */
 
@@ -415,12 +415,12 @@ regbranch( int *flagp )
  * endmarker role is not redundant.
  */
 static char *
-regpiece( int *flagp )
+regpiece( int32_t *flagp )
 {
     char *ret;
     char op;
     char *next;
-    int flags;
+    int32_t flags;
 
     ret = regatom(&flags);
     if (ret == NULL)
@@ -478,10 +478,10 @@ regpiece( int *flagp )
  * separate node; the code is simpler that way and it's not worth fixing.
  */
 static char *
-regatom( int *flagp )
+regatom( int32_t *flagp )
 {
     char *ret;
-    int flags;
+    int32_t flags;
 
     *flagp = WORST;     /* Tentatively. */
 
@@ -498,8 +498,8 @@ regatom( int *flagp )
         *flagp |= HASWIDTH|SIMPLE;
         break;
     case '[': {
-            int classr;
-            int classend;
+            int32_t classr;
+            int32_t classend;
 
             if (*regparse == '^') { /* Complement of range. */
                 ret = regnode(ANYBUT);
@@ -655,7 +655,7 @@ regatom( int *flagp )
  - regnode - emit a node
  */
 static char *           /* Location. */
-regnode( int op )
+regnode( int32_t op )
 {
     char *ret;
     char *ptr;
@@ -679,7 +679,7 @@ regnode( int op )
  - regc - emit (if appropriate) a byte of code
  */
 static void
-regc( int b )
+regc( int32_t b )
 {
     if (regcode != &regdummy)
         *regcode++ = b;
@@ -728,7 +728,7 @@ regtail(
 {
     char *scan;
     char *temp;
-    int offset;
+    size_t offset;
 
     if (p == &regdummy)
         return;
@@ -780,12 +780,12 @@ static const char **regendp;      /* Ditto for endp. */
 /*
  * Forwards.
  */
-STATIC int regtry( regexp *prog, const char *string );
-STATIC int regmatch( char *prog );
-STATIC int regrepeat( char *p );
+STATIC int32_t regtry( regexp *prog, const char *string );
+STATIC int32_t regmatch( char *prog );
+STATIC int32_t regrepeat( char *p );
 
 #ifdef DEBUG
-int regnarrate = 0;
+int32_t regnarrate = 0;
 void regdump();
 STATIC char *regprop();
 #endif
@@ -793,7 +793,7 @@ STATIC char *regprop();
 /*
  - regexec - match a regexp against a string
  */
-int
+int32_t
 regexec(
     regexp *prog,
     const char *string )
@@ -858,12 +858,12 @@ regexec(
  * regtry() - try match at specific point.
  */
 
-static int          /* 0 failure, 1 success */
+static int32_t          /* 0 failure, 1 success */
 regtry(
     regexp *prog,
     const char *string )
 {
-    int i;
+    int32_t i;
     const char * * sp;
     const char * * ep;
 
@@ -899,7 +899,7 @@ regtry(
  * whether the rest of the match failed) by a loop instead of by recursion.
  */
 
-static int          /* 0 failure, 1 success */
+static int32_t          /* 0 failure, 1 success */
 regmatch( char * prog )
 {
     char * scan;  /* Current node. */
@@ -947,7 +947,7 @@ regmatch( char * prog )
             reginput++;
             break;
         case EXACTLY: {
-                int len;
+                size_t len;
                 char *opnd;
 
                 opnd = OPERAND(scan);
@@ -983,7 +983,7 @@ regmatch( char * prog )
         case OPEN+7:
         case OPEN+8:
         case OPEN+9: {
-                int no;
+                int32_t no;
                 const char *save;
 
                 no = OP(scan) - OPEN;
@@ -1011,7 +1011,7 @@ regmatch( char * prog )
         case CLOSE+7:
         case CLOSE+8:
         case CLOSE+9: {
-                int no;
+                int32_t no;
                 const char *save;
 
                 no = OP(scan) - CLOSE;
@@ -1051,9 +1051,9 @@ regmatch( char * prog )
         case STAR:
         case PLUS: {
                 char nextch;
-                int no;
+                int32_t no;
                 const char *save;
-                int min;
+                int32_t min;
 
                 /*
                  * Lookahead to avoid useless match attempts
@@ -1100,10 +1100,10 @@ regmatch( char * prog )
 /*
  - regrepeat - repeatedly match something simple, report how many
  */
-static int
+static int32_t
 regrepeat( char *p )
 {
-    int count = 0;
+    int32_t count = 0;
     const char *scan;
     char *opnd;
 
@@ -1111,7 +1111,7 @@ regrepeat( char *p )
     opnd = OPERAND(p);
     switch (OP(p)) {
     case ANY:
-        count = strlen(scan);
+        count = int32_t(strlen(scan));
         scan += count;
         break;
     case EXACTLY:
@@ -1148,7 +1148,7 @@ regrepeat( char *p )
 static char *
 regnext( char *p )
 {
-    int offset;
+    int32_t offset;
 
     if (p == &regdummy)
         return(NULL);
@@ -1309,14 +1309,14 @@ regprop( char *op )
  * of characters not from s2
  */
 
-static int
+static int32_t
 strcspn(
     char *s1,
     char *s2 )
 {
     char *scan1;
     char *scan2;
-    int count;
+    int32_t count;
 
     count = 0;
     for (scan1 = s1; *scan1 != '\0'; scan1++) {
diff --git a/src/engine/regexp.h b/src/engine/regexp.h
index 3a52ba3d6b..bbac95eeba 100644
--- a/src/engine/regexp.h
+++ b/src/engine/regexp.h
@@ -16,13 +16,13 @@ typedef struct regexp {
     char regstart;      /* Internal use only. */
     char reganch;       /* Internal use only. */
     char * regmust;     /* Internal use only. */
-    int regmlen;        /* Internal use only. */
+    int32_t regmlen;   /* Internal use only. */
     char program[ 1 ];  /* Unwarranted chumminess with compiler. */
 } regexp;
 
 
 regexp * regcomp( char const * exp );
-int regexec( regexp * prog, char const * string );
+int32_t regexec( regexp * prog, char const * string );
 void regerror( char const * s );
 
 
diff --git a/src/engine/search.cpp b/src/engine/search.cpp
index 7529e02dcb..7bafc2b6c4 100644
--- a/src/engine/search.cpp
+++ b/src/engine/search.cpp
@@ -98,7 +98,7 @@ void set_explicit_binding( OBJECT * target, OBJECT * locate )
 
     /* Root the target path at the given location. */
     f->f_root.ptr = object_str( locate );
-    f->f_root.len = strlen( object_str( locate ) );
+    f->f_root.len = int32_t(strlen( object_str( locate ) ));
 
     path_build( f, buf );
     boundname = object_new( buf->value );
@@ -164,7 +164,7 @@ OBJECT * search( OBJECT * target, timestamp * const time,
     {
         OBJECT * key;
         f->f_root.ptr = object_str( list_front( varlist ) );
-        f->f_root.len = strlen( object_str( list_front( varlist ) ) );
+        f->f_root.len = int32_t(strlen( object_str( list_front( varlist ) ) ));
 
         path_build( f, buf );
 
@@ -189,7 +189,7 @@ OBJECT * search( OBJECT * target, timestamp * const time,
             OBJECT * test_path;
 
             f->f_root.ptr = object_str( list_item( iter ) );
-            f->f_root.len = strlen( object_str( list_item( iter ) ) );
+            f->f_root.len = int32_t(strlen( object_str( list_item( iter ) ) ));
 
             string_truncate( buf, 0 );
             path_build( f, buf );
diff --git a/src/engine/startup.cpp b/src/engine/startup.cpp
index f58625408c..e0205bf59c 100644
--- a/src/engine/startup.cpp
+++ b/src/engine/startup.cpp
@@ -14,6 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include "output.h"
 #include "variable.h"
 
+#include <cstdlib>
 #include <string>
 #include <algorithm>
 
@@ -155,7 +156,12 @@ bool b2::startup::bootstrap(FRAME *frame)
         }
     }
 
-    const std::string b2_exe_path{executable_path(saved_argv0)};
+    char *b2_exe_path_pchar = executable_path(saved_argv0);
+    const std::string b2_exe_path{b2_exe_path_pchar};
+    if (b2_exe_path_pchar)
+    {
+        std::free(b2_exe_path_pchar);
+    }
     const std::string boost_build_jam{"boost-build.jam"};
     std::string b2_file_path;
 
@@ -195,15 +201,17 @@ bool b2::startup::bootstrap(FRAME *frame)
     {
         const std::string path{
             b2::paths::normalize(
-                b2_exe_path + "/../../share/boost-build/" + boost_build_jam)};
+                b2_exe_path + "/../../share/boost-build/src/kernel/" + boost_build_jam)};
         if (b2::filesys::is_file(path))
             b2_file_path = path;
     }
 
-    // Check the BOOST_BUILD_PATH paths.
+    // Check the BOOST_BUILD_PATH (and BOOST_ROOT) paths.
     if (b2_file_path.empty())
     {
         b2::jam::list BOOST_BUILD_PATH = b2::jam::variable{"BOOST_BUILD_PATH"};
+        // For back-compat with Boost we also search in the BOOST_ROOT location.
+        BOOST_BUILD_PATH.append(b2::jam::list(b2::jam::variable{"BOOST_ROOT"}));
         for (auto search_path: BOOST_BUILD_PATH)
         {
             std::string path = b2::jam::object{search_path};
diff --git a/src/engine/sysinfo.cpp b/src/engine/sysinfo.cpp
index c3257e71e0..fa2e3c1630 100644
--- a/src/engine/sysinfo.cpp
+++ b/src/engine/sysinfo.cpp
@@ -18,7 +18,7 @@
 #include <unistd.h>
 #endif
 
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(__GLIBC__)
 // Need to define this in case it's not as that's the only way to get the
 // sched_* APIs.
 #ifndef _GNU_SOURCE
diff --git a/src/engine/variable.cpp b/src/engine/variable.cpp
index 574c344ce6..b597c842ce 100644
--- a/src/engine/variable.cpp
+++ b/src/engine/variable.cpp
@@ -90,7 +90,7 @@ void var_defines( struct module_t * module, const char * const * e, int preproce
         )
         {
             LIST * l = L0;
-            size_t const len = strlen( val + 1 );
+            int32_t const len = int32_t(strlen( val + 1 ));
             int const quoted = ( val[ 1 ] == '"' ) && ( val[ len ] == '"' ) &&
                 ( len > 1 );
 
diff --git a/src/engine/vswhere_usability_wrapper.cmd b/src/engine/vswhere_usability_wrapper.cmd
index bc5c60528c..b9d9172311 100644
--- a/src/engine/vswhere_usability_wrapper.cmd
+++ b/src/engine/vswhere_usability_wrapper.cmd
@@ -32,7 +32,7 @@ for /f "usebackq tokens=*" %%i in (`vswhere %VSWHERE_ARGS%`) do (
 
 REM Visual Studio 2019 (16.X, toolset 14.2)
 set VSWHERE_LMT=-version "[16.0,17.0)"
-SET VSWHERE_ARGS=-latest -products * %VSWHERE_REQ% %VSWHERE_PRP% %VSWHERE_LMT%
+SET VSWHERE_ARGS=-latest -products * %VSWHERE_REQ% %VSWHERE_PRP% %VSWHERE_LMT% %VSWHERE_PRERELEASE%
 for /f "usebackq tokens=*" %%i in (`vswhere %VSWHERE_ARGS%`) do (
     endlocal
 	echo Found with vswhere %%i
@@ -57,4 +57,4 @@ for /f "usebackq tokens=*" %%i in (`vswhere %VSWHERE_ARGS%`) do (
 :no-vswhere
 endlocal
 echo could not find "vswhere"
-exit /B 1
\ No newline at end of file
+exit /B 1
diff --git a/src/engine/w32_getreg.cpp b/src/engine/w32_getreg.cpp
index 1ba06274b4..4df13c04fb 100644
--- a/src/engine/w32_getreg.cpp
+++ b/src/engine/w32_getreg.cpp
@@ -43,7 +43,7 @@ static HKEY get_key(char const** path)
 
     for (p = dlRootKeys; p->name; ++p)
     {
-        int n = strlen(p->name);
+        size_t n = strlen(p->name);
         if (!strncmp(*path,p->name,n))
         {
             if ((*path)[n] == '\\' || (*path)[n] == 0)
@@ -81,14 +81,14 @@ LIST * builtin_system_registry( FRAME * frame, int flags )
 
              case REG_EXPAND_SZ:
                  {
-                     unsigned long len;
+                     DWORD len;
                      string expanded[1];
                      string_new(expanded);
 
                      while (
                          (len = ExpandEnvironmentStringsA(
-                             (LPCSTR)data, expanded->value, expanded->capacity))
-                         > expanded->capacity
+                             (LPCSTR)data, expanded->value, (DWORD)expanded->capacity))
+                         > DWORD(expanded->capacity)
                      )
                          string_reserve(expanded, len);
 
diff --git a/src/tools/builtin.py b/src/tools/builtin.py
index 9eeaaf6976..ecec2c9e33 100644
--- a/src/tools/builtin.py
+++ b/src/tools/builtin.py
@@ -82,9 +82,9 @@ def variant (name, parents_or_properties, explicit_properties = []):
     feature.compose ("<variant>" + name, explicit_properties.all())
 
 __os_names = """
-    amiga aix appletv bsd cygwin darwin dos emx freebsd hpux iphone linux netbsd
-    openbsd osf qnx qnxnto sgi solaris sun sunos svr4 sysv ultrix unix unixware
-    vms windows
+    amiga aix appletv bsd cygwin darwin dos emx freebsd hpux hurd iphone linux
+    netbsd openbsd osf qnx qnxnto sgi solaris sun sunos svr4 sysv ultrix unix
+    unixware vms windows
 """.split()
 
 # Translates from bjam current OS to the os tags used in host-os and target-os,
diff --git a/src/tools/clang-darwin.jam b/src/tools/clang-darwin.jam
index 11f62d298b..834431b6fb 100644
--- a/src/tools/clang-darwin.jam
+++ b/src/tools/clang-darwin.jam
@@ -1,5 +1,6 @@
 # Copyright Vladimir Prus 2004.
 # Copyright Noel Belcourt 2007.
+# Copyright Nikita Kniazev 2020.
 # 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)
@@ -19,15 +20,17 @@ feature.extend-subfeature toolset clang : platform : darwin ;
 toolset.inherit-generators clang-darwin
   <toolset>clang <toolset-clang:platform>darwin
   : gcc
-  # Don't inherit PCH generators. They were not tested, and probably
-  # don't work for this compiler.
-  : gcc.mingw.link gcc.mingw.link.dll gcc.compile.c.pch gcc.compile.c++.pch
+  : gcc.mingw.link gcc.mingw.link.dll
   ;
 
 generators.override clang-darwin.prebuilt : builtin.lib-generator ;
 generators.override clang-darwin.prebuilt : builtin.prebuilt ;
 generators.override clang-darwin.searched-lib-generator : searched-lib-generator ;
 
+# Override default do-nothing generators.
+generators.override clang-darwin.compile.c.pch   : pch.default-c-pch-generator   ;
+generators.override clang-darwin.compile.c++.pch : pch.default-cpp-pch-generator ;
+
 generators.register-c-compiler clang-darwin.compile.m : OBJECTIVE_C : OBJ : <toolset>clang <toolset-clang:platform>darwin ;
 generators.register-c-compiler clang-darwin.compile.mm : OBJECTIVE_CPP : OBJ : <toolset>clang <toolset-clang:platform>darwin ;
 
@@ -106,14 +109,36 @@ toolset.flags clang-darwin.link OPTIONS <stdlib>gnu <stdlib>gnu11 : -stdlib=libs
 toolset.flags clang-darwin.compile OPTIONS <stdlib>libc++ : -stdlib=libc++ ;
 toolset.flags clang-darwin.link OPTIONS <stdlib>libc++ : -stdlib=libc++ ;
 
-actions compile.c
+rule compile.c ( targets * : sources * : properties * )
+{
+    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
+}
+
+rule compile.c++ ( targets * : sources * : properties * )
+{
+    DEPENDS $(<) : [ on $(<) return $(PCH_FILE) ] ;
+}
+
+.include-pch = "-include-pch " ;
+
+actions compile.c bind PCH_FILE
+{
+    "$(CONFIG_COMMAND)" -x c $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" $(.include-pch)"$(PCH_FILE)" -c -o "$(<)" "$(>)"
+}
+
+actions compile.c++ bind PCH_FILE
+{
+    "$(CONFIG_COMMAND)" -x c++ $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" $(.include-pch)"$(PCH_FILE)" -c -o "$(<)" "$(>)"
+}
+
+actions compile.c.pch
 {
-    "$(CONFIG_COMMAND)" -x c $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"
+    "$(CONFIG_COMMAND)" -x c-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -o "$(<)" "$(>)"
 }
 
-actions compile.c++
+actions compile.c++.pch
 {
-    "$(CONFIG_COMMAND)" -x c++ $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"
+    "$(CONFIG_COMMAND)" -c -x c++-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -o "$(<)" "$(>)"
 }
 
 actions compile.m
@@ -173,9 +198,6 @@ actions piecemeal archive
 rule link ( targets * : sources * : properties * )
 {
   SPACE on $(targets) = " " ;
-  # Serialize execution of the 'link' action, since
-  # running N links in parallel is just slower.
-  JAM_SEMAPHORE on $(targets) = <s>clang-darwin-link-semaphore ;
 }
 
 actions link bind LIBRARIES
diff --git a/src/tools/clang-linux.jam b/src/tools/clang-linux.jam
index d5c9ed744e..ca3bbcfd30 100644
--- a/src/tools/clang-linux.jam
+++ b/src/tools/clang-linux.jam
@@ -20,6 +20,7 @@ import type ;
 import numbers ;
 import os ;
 import property ;
+import set ;
 
 feature.extend-subfeature toolset clang : platform : linux ;
 
@@ -112,6 +113,8 @@ rule init ( version ? :  command * : options * ) {
 ###############################################################################
 # Flags
 
+local all-os = [ feature.values <target-os> ] ;
+
 # note: clang silently ignores some of these inlining options
 # For clang, 'on' and 'full' are identical.
 toolset.flags clang-linux.compile OPTIONS <inlining>full : -Wno-inline ;
@@ -133,6 +136,11 @@ toolset.flags clang-linux.link OPTIONS <stdlib>gnu <stdlib>gnu11 : -stdlib=libst
 toolset.flags clang-linux.compile OPTIONS <stdlib>libc++ : -stdlib=libc++ ;
 toolset.flags clang-linux.link OPTIONS <stdlib>libc++ : -stdlib=libc++ ;
 
+# Enable response file control
+toolset.flags clang-linux RESPONSE_FILE_SUB <response-file>auto : a ;
+toolset.flags clang-linux RESPONSE_FILE_SUB <response-file>file : f ;
+toolset.flags clang-linux RESPONSE_FILE_SUB <response-file>contents : c ;
+
 ###############################################################################
 # C and C++ compilation
 
@@ -203,87 +211,21 @@ actions compile.c.pch
 ###############################################################################
 # Linking
 
-SPACE = " " ;
+local soname-os = [ set.difference $(all-os) : windows ] ;
+toolset.flags clang-linux.link SONAME_OPT <target-os>$(soname-os) : "-Wl,-soname -Wl," ;
 
 rule link ( targets * : sources * : properties * ) {
-  SPACE on $(targets) = " " ;
-  JAM_SEMAPHORE on $(targets) = <s>clang-linux-link-semaphore ;
-  
-  local tosw ;
-  local pselect = [ property.select <target-os> : $(properties) ] ;
-  
-  if $(pselect)
-    {
-    
-    local tosv = [ feature.get-values <target-os> : $(pselect) ] ;
-    
-    if $(tosv) = windows
-        {
-        tosw = 1 ;
-        }
-    }
-  else if [ os.name ] in NT
-    {
-    tosw = 1 ;
-    }
-  if $(tosw)
-    {
-    link-w $(targets) : $(sources) ;
-    }
-  else
-    {
-    link-o $(targets) : $(sources) ;
-    }
+  _ on $(targets) = " " ;
 }
 
 rule link.dll ( targets * : sources * : properties * ) {
-  SPACE on $(targets) = " " ;
-  JAM_SEMAPHORE on $(targets) = <s>clang-linux-link-semaphore ;
-  
-  local tosw ;
-  local pselect = [ property.select <target-os> : $(properties) ] ;
-  
-  if $(pselect)
-    {
-    
-    local tosv = [ feature.get-values <target-os> : $(pselect) ] ;
-    
-    if $(tosv) = windows
-        {
-        tosw = 1 ;
-        }
-    }
-  else if [ os.name ] in NT
-    {
-    tosw = 1 ;
-    }
-  if $(tosw)
-    {
-    link.dll-w $(targets) : $(sources) ;
-    }
-  else
-    {
-    link.dll-o $(targets) : $(sources) ;
-    }
-}
-
-# Target OS is not Windows, needs the RPATH stuff
-actions link-o bind LIBRARIES {
-    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" @"@($(<[1]:T).rsp:E=-Wl,-R$(SPACE)-Wl,"$(RPATH)" -Wl,-rpath-link$(SPACE)-Wl,"$(RPATH_LINK)" $(START-GROUP) "$(>:T)" "$(LIBRARIES:T)" $(FINDLIBS-ST-PFX:T) -l$(FINDLIBS-ST:T) $(FINDLIBS-SA-PFX:T) -l$(FINDLIBS-SA:T) $(END-GROUP))" $(OPTIONS) $(USER_OPTIONS)
-}
-
-# Target OS is not Windows, needs the RPATH and SONAME stuff
-actions link.dll-o bind LIBRARIES {
-    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" @"@($(<[1]:T).rsp:E=-Wl,-R$(SPACE)-Wl,"$(RPATH)" -Wl,-soname$(SPACE)-Wl,$(<[1]:D=) -shared $(START-GROUP) "$(>:T)" "$(LIBRARIES:T)" $(FINDLIBS-ST-PFX:T) -l$(FINDLIBS-ST:T) $(FINDLIBS-SA-PFX:T) -l$(FINDLIBS-SA:T) $(END-GROUP))" $(OPTIONS) $(USER_OPTIONS)
+  _ on $(targets) = " " ;
 }
 
-# Target OS is Windows, does not need the RPATH stuff
-actions link-w bind LIBRARIES {
-    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" @"@($(<[1]:T).rsp:E=$(START-GROUP) "$(>:T)" "$(LIBRARIES:T)" $(FINDLIBS-ST-PFX:T) -l$(FINDLIBS-ST:T) $(FINDLIBS-SA-PFX:T) -l$(FINDLIBS-SA:T) $(END-GROUP))" $(OPTIONS) $(USER_OPTIONS)
+actions link bind LIBRARIES {
+    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" @($(<[1]:T).rsp:O=FC:<=@":>=":E=-Wl,-R$(_)-Wl,"$(RPATH)" -Wl,-rpath-link$(_)-Wl,"$(RPATH_LINK)" $(START-GROUP) "$(>:T)" "$(LIBRARIES:T)" $(FINDLIBS-ST-PFX:T) -l$(FINDLIBS-ST:T) $(FINDLIBS-SA-PFX:T) -l$(FINDLIBS-SA:T) $(END-GROUP)) $(OPTIONS) $(USER_OPTIONS)
 }
 
-# Target OS is Windows, does not need the RPATH and SONAME stuff
-actions link.dll-w bind LIBRARIES {
-    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" -shared @"@($(<[1]:T).rsp:E=$(START-GROUP) "$(>:T)" "$(LIBRARIES:T)" $(FINDLIBS-ST-PFX:T) -l$(FINDLIBS-ST:T) $(FINDLIBS-SA-PFX:T) -l$(FINDLIBS-SA:T) $(END-GROUP))" $(OPTIONS) $(USER_OPTIONS)
-    
+actions link.dll bind LIBRARIES {
+    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -o "$(<)" @($(<[1]:T).rsp:O=FC:<=@":>=":E=-Wl,-R$(_)-Wl,"$(RPATH)" $(SONAME_OPT)$(<[1]:D=) -shared $(START-GROUP) "$(>:T)" "$(LIBRARIES:T)" $(FINDLIBS-ST-PFX:T) -l$(FINDLIBS-ST:T) $(FINDLIBS-SA-PFX:T) -l$(FINDLIBS-SA:T) $(END-GROUP)) $(OPTIONS) $(USER_OPTIONS)
 }
diff --git a/src/tools/clang-vxworks.jam b/src/tools/clang-vxworks.jam
index d5dfc33a0d..33fe3ef2bf 100644
--- a/src/tools/clang-vxworks.jam
+++ b/src/tools/clang-vxworks.jam
@@ -16,9 +16,9 @@ import generators ;
 
 feature.extend-subfeature toolset clang : platform : vxworks ;
 
-toolset.inherit-generators clang-vxworks 
-  <toolset>clang <toolset-clang:platform>vxworks 
-  : gcc 
+toolset.inherit-generators clang-vxworks
+  <toolset>clang <toolset-clang:platform>vxworks
+  : gcc
   # Don't inherit PCH generators. They were not tested, and probably
   # don't work for this compiler.
   : gcc.mingw.link gcc.mingw.link.dll gcc.compile.c.pch gcc.compile.c++.pch
@@ -30,12 +30,12 @@ generators.override clang-vxworks.searched-lib-generator : searched-lib-generato
 
 
 toolset.inherit-rules clang-vxworks : gcc ;
-toolset.inherit-flags clang-vxworks : gcc 
+toolset.inherit-flags clang-vxworks : gcc
         : <inlining>full
           <architecture>x86/<address-model>32
           <architecture>x86/<address-model>64
         ;
-        
+
 if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
 {
     .debug-configuration = true ;
@@ -45,22 +45,22 @@ if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
 #   compile and link options allow you to specify addition command line options for each version
 rule init ( version ? :  command * : options * )
 {
-    command = [ common.get-invocation-command clang-vxworks : ccllvm 
+    command = [ common.get-invocation-command clang-vxworks : ccllvm
         : $(command) ] ;
-    
+
     linker = [ get-values <linker> : $(options) ] ;
     linker   ?= ld ;
-    
+
     # Determine the version
     local command-string = $(command:J=" ") ;
     if $(command)
-    {    
+    {
         version ?= [ MATCH "^([0-9.]+)"
             : [ SHELL "$(command-string) -dumpversion" ] ] ;
     }
 
     local condition = [ common.check-init-parameters clang-vxworks
-        : version $(version) ] ;    
+        : version $(version) ] ;
 
     common.handle-options clang-vxworks : $(condition) : $(command) : $(options) ;
 
@@ -112,14 +112,11 @@ actions piecemeal archive
 rule link ( targets * : sources * : properties * )
 {
   SPACE on $(targets) = " " ;
-  # Serialize execution of the 'link' action, since
-  # running N links in parallel is just slower.
-  JAM_SEMAPHORE on $(targets) = <s>clang-vxworks-link-semaphore ;
 }
 
 actions link bind LIBRARIES
 {
-    "$(.LD)" $(USER_OPTIONS) -L"$(LINKPATH)" -o "$(<)" "$(>)" "$(LIBRARIES)" $(START-GROUP) $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS) 
+    "$(.LD)" $(USER_OPTIONS) -L"$(LINKPATH)" -o "$(<)" "$(>)" "$(LIBRARIES)" $(START-GROUP) $(FINDLIBS-ST-PFX) -l$(FINDLIBS-ST) $(FINDLIBS-SA-PFX) -l$(FINDLIBS-SA) $(END-GROUP) $(OPTIONS)
     }
 
 actions link.dll bind LIBRARIES
diff --git a/src/tools/clang-win.jam b/src/tools/clang-win.jam
index 94a8f51572..e382aba311 100644
--- a/src/tools/clang-win.jam
+++ b/src/tools/clang-win.jam
@@ -18,13 +18,16 @@ import regex ;
 
 feature.extend-subfeature toolset clang : platform : win ;
 
-toolset.inherit-generators clang-win <toolset>clang <toolset-clang:platform>win : msvc : msvc.compile.c.pch msvc.compile.c++.pch ;
-toolset.inherit-flags clang-win : msvc ;
+toolset.inherit-generators clang-win <toolset>clang <toolset-clang:platform>win : msvc ;
+toolset.inherit-flags clang-win : msvc : : YLOPTION ;
 toolset.inherit-rules clang-win : msvc ;
 
 # Override default do-nothing generators.
 generators.override clang-win.compile.rc : rc.compile.resource ;
 generators.override clang-win.compile.mc : mc.compile ;
+generators.override clang-win.compile.c.pch   : pch.default-c-pch-generator   ;
+generators.override clang-win.compile.c++.pch : pch.default-cpp-pch-generator ;
+
 
 if [ MATCH (--debug-(clang-(win-)?)?configuration) : [ modules.peek : ARGV ] ]
 {
@@ -74,11 +77,17 @@ rule init ( version ? : command * : options * )
     local compiler = "\"$(command)\"" ;
     compiler = "$(compiler:J= )" ;
 
-    version ?= [ MATCH "version ([0-9.]+)" : [ SHELL "$(compiler) -v 2>&1" ] ] ;
+    local version-output = [ SHELL "$(compiler) -v 2>&1" ] ;
+
+    version ?= [ MATCH "version ([0-9.]+)" : $(version-output) ] ;
+    local target = [ MATCH "Target: ([A-Za-z0-9_]+)" : $(version-output) ] ;
 
-    .notice "using compiler '$(compiler)', version '$(version)'" ;
+    local default-addr = 32 ;
+    if $(target) = x86_64 { default-addr = 64 ; }
 
-    local condition = [  common.check-init-parameters clang-win : version $(version) ] ;
+    .notice "using compiler '$(compiler)', version '$(version)', target '$(target)', default address-model=$(default-addr)" ;
+
+    local condition = [ common.check-init-parameters clang-win : version $(version) ] ;
 
     common.handle-options clang-win : $(condition) : $(command) : $(options) ;
     
@@ -167,10 +176,12 @@ rule init ( version ? : command * : options * )
         .notice "$(addr):" "using idl-compiler '$(idl-compiler)'" ;
 
         local cond = "$(condition)/<architecture>/<address-model>$(addr)" "$(condition)/<architecture>x86/<address-model>$(addr)" ;
-        if $(addr) = 32 { cond += "$(condition)/<architecture>/<address-model>" ; }
+        if $(addr) = $(default-addr) { cond += "$(condition)/<architecture>/<address-model>" "$(condition)/<architecture>x86/<address-model>" ; }
 
         toolset.flags clang-win.compile .CC $(cond) : $(compiler) -m$(addr) ;
-        toolset.flags clang-win.link .LD $(cond) : $(compiler) -m$(addr) /link "/incremental:no" "/manifest" ;
+        toolset.flags clang-win.link .LD $(cond) : $(compiler) -m$(addr) ;
+        toolset.flags clang-win.link LINKOPT $(cond) : /link ;
+        toolset.flags clang-win.link LINKFLAGS $(cond) : "/incremental:no" "/manifest" ;
         toolset.flags clang-win.compile .ASM $(cond) : $(assembler) -nologo -c -Zp4 -Cp -Cx ;
         toolset.flags clang-win.compile .ASM_OUTPUT $(cond) : -Fo ;
         toolset.flags clang-win.archive .LD $(cond) : $(archiver) /nologo ;
@@ -181,4 +192,9 @@ rule init ( version ? : command * : options * )
     }
 
     toolset.flags clang-win.link LIBRARY_OPTION <toolset>clang-win : "" : unchecked ;
+
+    # Enable response file control
+    toolset.flags clang-win RESPONSE_FILE_SUB <response-file>auto : a ;
+    toolset.flags clang-win RESPONSE_FILE_SUB <response-file>file : f ;
+    toolset.flags clang-win RESPONSE_FILE_SUB <response-file>contents : c ;
 }
diff --git a/src/tools/common.jam b/src/tools/common.jam
index d5b17f816c..28c768d562 100644
--- a/src/tools/common.jam
+++ b/src/tools/common.jam
@@ -929,6 +929,7 @@ local rule toolset-tag ( name : type ? : property-set )
         case cw : tag += cw ;
         case darwin* : tag += xgcc ;
         case edg* : tag += edg ;
+        case embarcadero* : tag += embtc ;
         case gcc* :
         {
             switch [ $(property-set).get <target-os> ]
@@ -999,6 +1000,13 @@ local rule toolset-tag ( name : type ? : property-set )
         version = ;
     }
 
+    # Use un-versioned toolset name for Embarcadero, to avoid having to update
+    # the auto-linking logic on every release.
+    if $(tag) = embtc
+    {
+        version = ;
+    }
+
     tag += $(version) ;
 
     return $(tag:J=) ;
diff --git a/src/tools/cray.jam b/src/tools/cray.jam
index d586af3af4..e4f4ec0d4b 100644
--- a/src/tools/cray.jam
+++ b/src/tools/cray.jam
@@ -644,10 +644,6 @@ rule gcc-link-procedure ( targets * : sources * : properties * )
     # Copied from 'gcc.jam'.
 
     SPACE on $(targets) = " " ;
-    # Serialize execution of the 'link' action, since running N links in
-    # parallel is just slower. For now, serialize only gcc links, it might be a
-    # good idea to serialize all links.
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
     gcc.quote-rpath $(targets) ;
 }
 
@@ -657,7 +653,6 @@ rule gcc-link-dll-procedure ( targets * : sources * : properties * )
     # Copied from 'gcc.jam'.
 
     SPACE on $(targets) = " " ;
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
     gcc.quote-rpath $(targets) ;
 }
 
diff --git a/src/tools/darwin.jam b/src/tools/darwin.jam
index c28ca42b01..4841cbf5c7 100644
--- a/src/tools/darwin.jam
+++ b/src/tools/darwin.jam
@@ -502,6 +502,8 @@ rule setup-address-model ( targets * : sources * : properties * )
         {
             if $(instruction-set) {
                 options = -arch$(_)$(instruction-set) ;
+            } else if $(address-model) = 64 {
+                options = -arch arm64 ;
             } else {
                 options = -arch arm ;
             }
diff --git a/src/tools/embarcadero.jam b/src/tools/embarcadero.jam
index c54a1ef5eb..9bf094f21b 100644
--- a/src/tools/embarcadero.jam
+++ b/src/tools/embarcadero.jam
@@ -25,7 +25,7 @@ several versions of the compiler.
 
 `version`:
 
-The version should be the compiler version if specified. if the 
+The version should be the compiler version if specified. if the
 version is not specified Boost Build will find the latest installed
 version of Embarcadero C++ and use that for the version. If the version
 is specified Boost Build does not check if this matches any particular
@@ -146,8 +146,8 @@ generators.override embarcadero.prebuilt : builtin.prebuilt ;
 generators.override embarcadero.searched-lib-generator : searched-lib-generator ;
 
 toolset.inherit-rules embarcadero : clang-linux ;
-toolset.inherit-flags embarcadero 
-    : clang-linux 
+toolset.inherit-flags embarcadero
+    : clang-linux
     : <runtime-link>shared
       <link>shared
       <threading>multi
@@ -192,9 +192,9 @@ rule init ( version ? :  command * : options * )
   local compiler = bcc64 ;
   local preprocessor = cpp64 ;
   local amodel = 64 ;
-  
+
   local optam = [ feature.get-values <address-model> : $(options) ] ;
-  
+
   if $(optam)
     {
     if $(optam) = 32
@@ -208,29 +208,29 @@ rule init ( version ? :  command * : options * )
         $(optam) = "" ;
         }
     }
-  
+
   command = [ common.get-invocation-command embarcadero : $(compiler) : $(command) ] ;
-  
+
   switch $(command[1]:BL)
     {
     case bcc32x :
         compiler = bcc32x ;
         preprocessor = cpp32x ;
         amodel = 32 ;
-    case bcc64 : 
+    case bcc64 :
         compiler = bcc64 ;
         preprocessor = cpp64 ;
         amodel = 64 ;
-    case "bcc32x.exe" : 
+    case "bcc32x.exe" :
         compiler = bcc32x ;
         preprocessor = cpp32x ;
         amodel = 32 ;
-    case "bcc64.exe" : 
+    case "bcc64.exe" :
         compiler = bcc64 ;
         preprocessor = cpp64 ;
         amodel = 64 ;
     }
-  
+
   if $(optam) && $(optam) != $(amodel)
     {
     errors.user-error "embarcadero initialization: compiler and address model" :
@@ -250,43 +250,43 @@ rule init ( version ? :  command * : options * )
             cl_version = 5.0 ;
             }
       }
-    
+
       local condition = [ common.check-init-parameters embarcadero : version $(version) ] ;
       handle-options $(condition) : $(command) : $(options) ;
-    
+
       # Support for the Embarcadero root directory. If the Embarcadero binary
       # directory is not in the PATH we need to tell the underlying clang
       # implementation where to find the Embarcadero header/library files
       # and set the correct runtime path so that we can execute Embarcadero
       # programs and find Embarcadero DLLs.
-    
+
       local root = [ feature.get-values <root> : $(options) ] ;
-      
+
       # 1) Look in registry
-    
+
       if ! $(root)
         {
-        
+
         local sdkdir = [ get_sdk_dir ] ;
-        
+
         if $(sdkdir)
             {
-            
+
             local bdsv = [ get_bds_version $(sdkdir) ] ;
-            
+
             if $(bdsv)
                 {
-                
+
                 local has_dec = [ MATCH "(.+[.])" : $(bdsv) ] ;
                 local bdsv_full ;
-                
+
                 if ! $(has_dec)
                     {
                     bdsv_full = $(bdsv).0 ;
                     }
-                
+
                 local troot = [ W32_GETREG "HKEY_LOCAL_MACHINE\\SOFTWARE\\Embarcadero\\BDS\\$(bdsv)" : RootDir ] ;
-                
+
                 if $(troot)
                     {
                     troot = $(troot:T) ;
@@ -320,44 +320,44 @@ rule init ( version ? :  command * : options * )
                                 troot = [ concatenate $(troot) : name ] ;
                                 root = $(troot:D) ;
                                 }
-                            }   
+                            }
                         }
                     }
                 }
             }
         }
-        
-        
+
+
       # 2) Look for path in the command
-        
+
       if ! $(root)
         {
-        
+
         local cpath = $(command[1]:D) ;
-        
+
         if $(cpath)
             {
             root = $(cpath:P) ;
             }
         }
-        
+
       # 3) Search for the directory of the command
-        
-      if ! $(root) 
+
+      if ! $(root)
         {
-        
+
         local pdirs = [ path.programs-path ] ;
-        
+
         for local dir in $(pdirs)
             {
-            
+
             local match = [ MATCH "/(.:.+)" : $(dir) ] ;
-            
+
             if $(match)
                 {
                 dir = "$(match)" ;
                 }
-            
+
             if [ CHECK_IF_FILE $(dir)/$(command) ]
                 {
                 root = $(dir:P) ;
@@ -370,24 +370,24 @@ rule init ( version ? :  command * : options * )
                 }
             }
         }
-        
-      if ! $(root) 
+
+      if ! $(root)
         {
         errors.user-error "Embarcadero toolset initialization: the root directory for the Embarcadero installation can not be found" ;
         }
       else
         {
-        
+
         local lib_path = $(root)/bin $(root)/bin64 $(root)/Bpl C:/Users/Public/Documents/Embarcadero ;
         if $(.debug-configuration)
         {
             ECHO "notice:" using Embarcadero libraries with clang compilation"::" $(condition) "::" $(lib_path) ;
         }
         flags embarcadero.link RUN_PATH $(condition) : $(lib_path) ;
-        
+
         local system_include_option = "-isystem " ;
         local system_include_directories = $(root)/include/windows/crtl $(root)/include/windows/sdk $(root)/include/windows/rtl $(root)/include/dinkumware64 ;
-        
+
         local lib_dir_release ;
         local lib_dir_debug ;
         local archiver ;
@@ -396,7 +396,7 @@ rule init ( version ? :  command * : options * )
         local assembler ;
         local asmflags ;
         local asmoutput ;
-        
+
         if $(compiler) = bcc32x
             {
             lib_dir_release = $(root)/lib/win32c/release $(root)/lib/win32c/release/psdk ;
@@ -405,7 +405,7 @@ rule init ( version ? :  command * : options * )
             arflags = /P512 ;
             implib = implib ;
             assembler = $(root)/bin/tasm32 ;
-            
+
             # /ml makes all symbol names case-sensitive
 
             asmflags = /ml ;
@@ -413,14 +413,14 @@ rule init ( version ? :  command * : options * )
             }
         else if $(compiler) = bcc64
             {
-            
+
             lib_dir_release = $(root)/lib/win64/release $(root)/lib/win64/release/psdk ;
             lib_dir_debug = $(root)/lib/win64/debug ;
             archiver = tlib64 ;
             arflags = /P2048 ;
             implib = mkexp ;
             }
-        
+
         flags embarcadero.compile .EMB_SYSINC $(condition) : $(system_include_option)$(system_include_directories) ;
         flags embarcadero.link LINKPATH $(condition)/<variant>release : $(lib_dir_release) ;
         flags embarcadero.link LINKPATH $(condition)/<variant>debug : $(lib_dir_debug) $(lib_dir_release) ;
@@ -432,9 +432,9 @@ rule init ( version ? :  command * : options * )
         flags embarcadero.asm USER_OPTIONS $(condition) : [ feature.get-values <asmflags> : $(options) ] ;
         flags embarcadero.archive AROPTIONS $(condition) : [ feature.get-values <archiveflags> : $(options) ] ;
         flags embarcadero.link.dll .IMPLIB_COMMAND $(condition) : $(root)/bin/$(implib) ;
-        
+
         local mte = [ feature.get-values <user-interface> : $(options) ] ;
-        
+
         if $(mte)
             {
             flags embarcadero OPTIONS <main-target-type>EXE/$(condition) : <user-interface>$(mte) ;
@@ -453,7 +453,7 @@ local rule concatenate ( path : name )
     local result ;
     local has_ending_slash = [ MATCH ".*([/\\])$" : $(path) ] ;
     local has_backward_slash = [ MATCH ".*([\\])" : $(path) ] ;
-    
+
     if $(has_ending_slash)
         {
         result = $(path)$(name) ;
@@ -471,28 +471,28 @@ local rule concatenate ( path : name )
 
 local rule get_sdk_dir ( )
     {
-    
+
     local ret ;
     local appdata = [ os.environ APPDATA ] ;
-    
+
     if $(appdata)
         {
         ret = $(appdata:T)/Embarcadero/BDS ;
         }
     return $(ret) ;
     }
-    
+
 local rule get_bds_version ( sdir )
     {
-    
+
     local ret ;
     local flist = [ GLOB $(sdir) : * ] ;
-    
+
     if $(flist)
         {
-        
+
         local dirs ;
-        
+
         for local file in $(flist)
             {
             if ! [ CHECK_IF_FILE $(file) ]
@@ -502,9 +502,9 @@ local rule get_bds_version ( sdir )
             }
         if $(dirs)
             {
-            
+
             local ldir = $(dirs[-1]) ;
-            
+
             ret =  $(ldir:B) ;
             }
         }
@@ -559,7 +559,7 @@ local opt_drtl = -tR ;
 local opt_dapp = -tW ;
 local opt_compile_flags = -DNDEBUG ;
 local opt_lflags = "-lS:1048576 -lSc:4098 -lH:1048576 -lHc:8192" ;
-    
+
 flags embarcadero OPTIONS <user-interface>console : $(opt_console) ;
 flags embarcadero OPTIONS <user-interface>gui : $(opt_dapp) ;
 flags embarcadero OPTIONS <runtime-link>shared : $(opt_drtl) ;
@@ -602,16 +602,14 @@ rule archive ( targets * : sources * : properties * )
 }
 
 actions updated together piecemeal archive
-{ 
+{
     "$(.AR)" $(AROPTIONS) $(.ARFLAGS) /u /a /C "$(<)" +-"$(>)"
 }
 
 rule link ( targets * : sources * : properties * ) {
-  JAM_SEMAPHORE on $(targets) = <s>embarcadero-link-semaphore ;
 }
 
 rule link.dll ( targets * : sources * : properties * ) {
-  JAM_SEMAPHORE on $(targets) = <s>embarcadero-link-semaphore ;
 }
 
 actions link bind LIBRARIES {
diff --git a/src/tools/emscripten.jam b/src/tools/emscripten.jam
index a125760706..0a765765bb 100644
--- a/src/tools/emscripten.jam
+++ b/src/tools/emscripten.jam
@@ -94,7 +94,7 @@ actions compile.c++
 
 actions archive
 {
-    "$(CONFIG_COMMAND)" $(AROPTIONS) -o "$(<)" "$(>)"
+    "$(CONFIG_COMMAND)" $(AROPTIONS) -r -o "$(<)" "$(>)"
 }
 
 toolset.flags emscripten.link USER_OPTIONS <linkflags> ;
diff --git a/src/tools/features/compileflags-feature.jam b/src/tools/features/compileflags-feature.jam
new file mode 100644
index 0000000000..229bed730f
--- /dev/null
+++ b/src/tools/features/compileflags-feature.jam
@@ -0,0 +1,19 @@
+# Copyright 2020 René Ferdinand Rivera Morell
+# 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 feature ;
+
+#| tag::doc[]
+
+[[bbv2.builtin.features.compileflags]]`cflags`::
+The value of this feature is passed without modification to the corresponding
+tools. The values from the `compileflags` is applied to all compilation of any
+language for the tools.
+
+|# # end::doc[]
+
+feature.feature compileflags
+    :
+    : free ;
diff --git a/src/tools/features/response-file-feature.jam b/src/tools/features/response-file-feature.jam
new file mode 100644
index 0000000000..6d7c0bd596
--- /dev/null
+++ b/src/tools/features/response-file-feature.jam
@@ -0,0 +1,28 @@
+# Copyright 2020 René Ferdinand Rivera Morell
+# 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 feature ;
+
+#| tag::doc[]
+
+[[bbv2.builtin.features.response-file]]`response-file`::
+*Allowed values:* `auto`, `file`, `contents`.
++
+Controls whether a response file is used, or not, during the build of the
+applicable target. For `file` a response file is created and the filename
+replaced in the action. For `contents` the contents (`:E=`) is replaced
+in the action and no response file is created. For `auto` either a response
+file is created, or the contents replaced, based on the length of the
+contents such that if the contents fits within the limits of the command
+execution line length limits the contents is replaced. Otherwise a
+response file is created and the filename is replaced in the actions.
++
+Supported for `clang-linux` and `msvc` toolsets.
+
+|# # end::doc[]
+
+feature.feature response-file
+    : auto file contents
+    : incidental ;
diff --git a/src/tools/gcc.jam b/src/tools/gcc.jam
index ff3209f7b8..6f298e7551 100644
--- a/src/tools/gcc.jam
+++ b/src/tools/gcc.jam
@@ -916,12 +916,6 @@ toolset.flags gcc.link.dll .IMPLIB-COMMAND <target-os>cygwin : "-Wl,--out-implib
 
     # On AIX we *have* to use the native linker.
     #
-    # Using -brtl, the AIX linker will look for libraries with both the .a
-    # and .so extensions, such as libfoo.a and libfoo.so. Without -brtl, the
-    # AIX linker looks only for libfoo.a. Note that libfoo.a is an archived
-    # file that may contain shared objects and is different from static libs
-    # as on Linux.
-    #
     # The -bnoipath strips the prepending (relative) path of libraries from
     # the loader section in the target library or executable. Hence, during
     # load-time LIBPATH (identical to LD_LIBRARY_PATH) or a hard-coded
@@ -939,7 +933,7 @@ toolset.flags gcc.link.dll .IMPLIB-COMMAND <target-os>cygwin : "-Wl,--out-implib
     # AIX 4.x and AIX 6.x. For details about the AIX linker see:
     # http://download.boulder.ibm.com/ibmdl/pub/software/dw/aix/es-aix_ll.pdf
     #
-    toolset.flags gcc.link OPTIONS <target-os>aix : -Wl,-brtl -Wl,-bnoipath -Wl,-bbigtoc ;
+    toolset.flags gcc.link OPTIONS <target-os>aix : -Wl,-bnoipath -Wl,-bbigtoc ;
 
     # See note [1]
     toolset.flags gcc.link OPTIONS <target-os>aix/<runtime-link>static : -static ;
@@ -974,13 +968,15 @@ toolset.flags gcc.link.dll .IMPLIB-COMMAND <target-os>cygwin : "-Wl,--out-implib
     # support -s.
     toolset.flags gcc.link OPTIONS <target-os>$(generic-os)/<strip>on :
         -Wl,--strip-all ;
-    toolset.flags gcc.link RPATH <target-os>$(generic-os) : <dll-path> ;
-    toolset.flags gcc.link RPATH_OPTION <target-os>$(generic-os) : -rpath ;
-    toolset.flags gcc.link RPATH_LINK <target-os>$(generic-os) : <xdll-path> ;
     toolset.flags gcc.link START-GROUP <target-os>$(generic-os) :
         -Wl,--start-group ;
     toolset.flags gcc.link END-GROUP <target-os>$(generic-os) : -Wl,--end-group ;
 
+    local rpath-os = [ set.difference $(all-os) : aix darwin vxworks solaris osf hpux windows ] ;
+    toolset.flags gcc.link RPATH <target-os>$(rpath-os) : <dll-path> ;
+    toolset.flags gcc.link RPATH_OPTION <target-os>$(rpath-os) : -rpath ;
+    toolset.flags gcc.link RPATH_LINK <target-os>$(rpath-os) : <xdll-path> ;
+
     # gnu ld has the ability to change the search behaviour for libraries
     # referenced by the -l switch. These modifiers are -Bstatic and
     # -Bdynamic and change search for -l switches that follow them. The
@@ -1096,33 +1092,23 @@ rule quote-rpath ( targets * )
 rule link ( targets * : sources * : properties * )
 {
     SPACE on $(targets) = " " ;
-    # Serialize execution of the 'link' action, since running N links in
-    # parallel is just slower. For now, serialize only gcc links, it might be a
-    # good idea to serialize all links.
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
     quote-rpath $(targets) ;
 }
 
 rule link.dll ( targets * : sources * : properties * )
 {
     SPACE on $(targets) = " " ;
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
     quote-rpath $(targets) ;
 }
 
 rule link.mingw ( targets * : sources * : properties * )
 {
     SPACE on $(targets) = " " ;
-    # Serialize execution of the 'link' action, since running N links in
-    # parallel is just slower. For now, serialize only gcc links, it might be a
-    # good idea to serialize all links.
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
 }
 
 rule link.dll.mingw ( targets * : sources * : properties * )
 {
     SPACE on $(targets) = " " ;
-    JAM_SEMAPHORE on $(targets) = <s>gcc-link-semaphore ;
 }
 
 actions link.mingw bind LIBRARIES
diff --git a/src/tools/generators/searched-lib-generator.jam b/src/tools/generators/searched-lib-generator.jam
index b3435daa35..84757a018c 100644
--- a/src/tools/generators/searched-lib-generator.jam
+++ b/src/tools/generators/searched-lib-generator.jam
@@ -38,7 +38,7 @@ class searched-lib-generator : generator
 
             local search = [ feature.get-values <search> : $(properties) ] ;
 
-            local a = [ new null-action [ $(property-set).add-raw <relevant>link ] ] ;
+            local a = [ new null-action [ $(property-set).add-raw <relevant>link <relevant>search ] ] ;
             local lib-name = [ feature.get-values <name> : $(properties) ] ;
             lib-name ?= $(name) ;
             local t = [ new searched-lib-target $(lib-name) : $(project)
@@ -47,7 +47,7 @@ class searched-lib-generator : generator
             #    lib png : z : <name>png ;
             # the 'z' target should be returned, so that apps linking to 'png'
             # will link to 'z', too.
-            return [ property-set.create <xdll-path>$(search) <relevant>link ]
+            return [ property-set.create <xdll-path>$(search) <relevant>link <relevant>search <relevant>name ]
                    [ virtual-target.register $(t) ] $(sources) ;
         }
     }
@@ -88,7 +88,7 @@ class searched-lib-target : abstract-file-target
 
     rule relevant ( )
     {
-        return [ property-set.create <relevant>link ] ;
+        return [ property-set.create <relevant>link <relevant>search ] ;
     }
 
     rule path ( )
diff --git a/src/tools/intel-darwin.jam b/src/tools/intel-darwin.jam
index 6dc5d8e3bf..7da7b079c6 100644
--- a/src/tools/intel-darwin.jam
+++ b/src/tools/intel-darwin.jam
@@ -16,9 +16,9 @@ import generators ;
 
 feature.extend-subfeature toolset intel : platform : darwin ;
 
-toolset.inherit-generators intel-darwin 
-  <toolset>intel <toolset-intel:platform>darwin 
-  : gcc 
+toolset.inherit-generators intel-darwin
+  <toolset>intel <toolset-intel:platform>darwin
+  : gcc
   # Don't inherit PCH generators. They were not tested, and probably
   # don't work for this compiler.
   : gcc.mingw.link gcc.mingw.link.dll gcc.compile.c.pch gcc.compile.c++.pch
@@ -29,20 +29,20 @@ generators.override intel-darwin.prebuilt : builtin.prebuilt ;
 generators.override intel-darwin.searched-lib-generator : searched-lib-generator ;
 
 toolset.inherit-rules intel-darwin : gcc ;
-toolset.inherit-flags intel-darwin : gcc 
-        : <inlining>off <inlining>on <inlining>full <optimization>space 
+toolset.inherit-flags intel-darwin : gcc
+        : <inlining>off <inlining>on <inlining>full <optimization>space
           <warnings>off <warnings>all <warnings>on
           <warnings>extra <warnings>pedantic
           <warnings-as-errors>off <warnings-as-errors>on
           <architecture>x86/<address-model>32
           <architecture>x86/<address-model>64
         ;
-        
+
 if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
 {
     .debug-configuration = true ;
 }
-                       
+
 # Initializes the intel-darwin toolset
 #   version in mandatory
 #   name (default icc) is used to invoke the specified intel compiler
@@ -51,8 +51,8 @@ rule init ( version ? :  command * : options * )
 {
     local condition = [ common.check-init-parameters intel-darwin
         : version $(version) ] ;
-    
-    command = [ common.get-invocation-command intel-darwin : icc 
+
+    command = [ common.get-invocation-command intel-darwin : icc
         : $(command) : /opt/intel_cc_80/bin ] ;
 
     common.handle-options intel-darwin : $(condition) : $(command) : $(options) ;
@@ -67,12 +67,12 @@ rule init ( version ? :  command * : options * )
     {
         bin ?= [ common.get-absolute-tool-path $(command[-1]) ] ;
         root ?= $(bin:D) ;
-    
+
         if $(root)
         {
             # Libraries required to run the executable may be in either
-            # $(root)/lib (10.1 and earlier) 
-            #     or 
+            # $(root)/lib (10.1 and earlier)
+            #     or
             # $(root)/lib/architecture-name (11.0 and later:
             local lib_path = $(root)/lib $(root:P)/lib/$(bin:B) ;
             if $(.debug-configuration)
@@ -80,7 +80,7 @@ rule init ( version ? :  command * : options * )
                 ECHO notice\: using intel libraries "::" $(condition) "::" $(lib_path) ;
             }
             flags intel-darwin.link RUN_PATH $(condition) : $(lib_path) ;
-        }   
+        }
     }
 
     local m = [ MATCH (..).* : $(version) ] ;
@@ -90,7 +90,7 @@ rule init ( version ? :  command * : options * )
     }
 
     local major = $(m) ;
-    
+
     if $(major) = "9" {
       flags intel-darwin.compile OPTIONS $(condition)/<inlining>off : -Ob0 ;
       flags intel-darwin.compile OPTIONS $(condition)/<inlining>on : -Ob1  ;
@@ -136,7 +136,7 @@ flags intel-darwin.compile.c++ OPTIONS <cxxflags> ;
 
 flags intel-darwin.compile OPTIONS <optimization>space : -O1 ; # no specific space optimization flag in icc
 
-# 
+#
 .cpu-type-em64t    = prescott nocona core2 corei7 corei7-avx core-avx-i
                      conroe conroe-xe conroe-l allendale merom
                      merom-xe kentsfield kentsfield-xe penryn wolfdale
@@ -190,11 +190,11 @@ rule archive ( targets * : sources * : properties * )
   # Always remove archive and start again. Here's rationale from
   # Andre Hentz:
   #
-  # I had a file, say a1.c, that was included into liba.a. 
-  # I moved a1.c to a2.c, updated my Jamfiles and rebuilt. 
-  # My program was crashing with absurd errors. 
-  # After some debugging I traced it back to the fact that a1.o was *still* 
-  # in liba.a 
+  # I had a file, say a1.c, that was included into liba.a.
+  # I moved a1.c to a2.c, updated my Jamfiles and rebuilt.
+  # My program was crashing with absurd errors.
+  # After some debugging I traced it back to the fact that a1.o was *still*
+  # in liba.a
   #
   # Rene Rivera:
   #
@@ -226,9 +226,6 @@ flags intel-darwin.link USER_OPTIONS <linkflags> ;
 rule link ( targets * : sources * : properties * )
 {
   SPACE on $(targets) = " " ;
-  # Serialize execution of the 'link' action, since
-  # running N links in parallel is just slower.
-  JAM_SEMAPHORE on $(targets) = <s>intel-darwin-link-semaphore ;
 }
 
 actions link bind LIBRARIES
diff --git a/src/tools/intel-linux.jam b/src/tools/intel-linux.jam
index 920cefed0f..919dce39f1 100644
--- a/src/tools/intel-linux.jam
+++ b/src/tools/intel-linux.jam
@@ -6,20 +6,23 @@
 #  http://www.boost.org/LICENSE_1_0.txt)
 
 import toolset ;
-import feature ;
 import toolset : flags ;
 
-import intel ;
-import gcc ;
 import common ;
 import errors ;
+import feature ;
+import gcc ;
 import generators ;
-import type ;
+import intel ;
 import numbers ;
+import os ;
+import path ;
+import regex ;
+import type ;
 
 feature.extend-subfeature toolset intel : platform : linux ;
 
-toolset.inherit-generators intel-linux 
+toolset.inherit-generators intel-linux
      <toolset>intel <toolset-intel:platform>linux : gcc : gcc.mingw.link gcc.mingw.link.dll ;
 generators.override intel-linux.prebuilt : builtin.lib-generator ;
 generators.override intel-linux.prebuilt : builtin.prebuilt ;
@@ -28,140 +31,208 @@ generators.override intel-linux.searched-lib-generator : searched-lib-generator
 # Override default do-nothing generators.
 generators.override intel-linux.compile.c.pch   : pch.default-c-pch-generator   ;
 generators.override intel-linux.compile.c++.pch : pch.default-cpp-pch-generator ;
- 
+
 type.set-generated-target-suffix PCH : <toolset>intel <toolset-intel:platform>linux : pchi ;
 
 toolset.inherit-rules intel-linux : gcc ;
-toolset.inherit-flags intel-linux : gcc 
+toolset.inherit-flags intel-linux : gcc
         : <inlining>off <inlining>on <inlining>full
           <optimization>space <optimization>speed
           <warnings>off <warnings>all <warnings>on
           <warnings>extra <warnings>pedantic
           <warnings-as-errors>off <warnings-as-errors>on
         ;
-        
+
 if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
 {
     .debug-configuration = true ;
 }
-                       
-# Initializes the intel-linux toolset
-#   version in mandatory
-#   name (default icpc) is used to invoke the specified intel-linux compiler
-#   compile and link options allow you to specify addition command line options for each version
+
+.home = [ os.home-directories ] ;
+.home = $(.home[1]) ;
+
+# Intel oneAPI 2020, and onward.
+.bin(oneAPI) =
+    [ path.join $(.home) intel/oneapi/compiler/latest/linux/bin ]
+    /opt/intel/oneapi/compiler/latest/linux/bin ;
+# Intel C++ Composer XE 2011 for Linux, aka Intel C++ Compiler XE 12.0,
+# aka intel-linux-12.0.
+.bin(12.0) = /opt/intel/bin ;
+# Intel C++ Compiler 11.1.
+.bin(11.1) = /opt/intel_cce_11.1.064.x86_64/bin ;
+# Intel C++ Compiler 11.0.
+.bin(11.0) = /opt/intel_cce_11.0.074.x86_64/bin ;
+# Intel C++ Compiler 10.1.
+.bin(10.1) = /opt/intel_cce_10.1.013_x64/bin ;
+# Intel C++ Compiler 9.1.
+.bin(9.1) = /opt/intel_cc_91/bin ;
+# Intel C++ Compiler 9.0.
+.bin(9.0) = /opt/intel_cc_90/bin ;
+# Intel C++ Compiler 8.1.
+.bin(8.1) = /opt/intel_cc_81/bin ;
+# Intel C++ Compiler 8.0.
+.bin(8.0) = /opt/intel_cc_80/bin ;
+
 rule init ( version ? :  command * : options * )
 {
-    local condition = [ common.check-init-parameters intel-linux
-        : version $(version) ] ;
-    
-    if $(.debug-configuration)
+    local user_version = [ MATCH "([0-9.]+)" : $(version) ] ;
+    local user_command = $(command) ;
+    if $(user_version)
     {
-        ECHO "notice: intel-linux version is" $(version) ;
+        user_version = [ regex.split $(user_version) "[.]" ] ;
     }
 
-    local default_path ;
-
-    # Intel C++ Composer XE 2011 for Linux, aka Intel C++ Compiler XE 12.0,
-    # aka intel-linux-12.0. In this version, Intel thankfully decides to install
-    # to a sane 'intel' folder in /opt.
-    if [ MATCH "(12[.]0|12)" : $(version) ]
-        { default_path = /opt/intel/bin ; }
-    # Intel C++ Compiler 11.1. 
-    else if [ MATCH "(11[.]1)" : $(version) ]
-        { default_path = /opt/intel_cce_11.1.064.x86_64/bin ; }
-    # Intel C++ Compiler 11.0. 
-    else if [ MATCH "(11[.]0|11)" : $(version) ]
-        { default_path = /opt/intel_cce_11.0.074.x86_64/bin ; }
-    # Intel C++ Compiler 10.1. 
-    else if [ MATCH "(10[.]1)" : $(version) ]
-        { default_path = /opt/intel_cce_10.1.013_x64/bin ; }
-    # Intel C++ Compiler 9.1. 
-    else if [ MATCH "(9[.]1)" : $(version) ]
-        { default_path = /opt/intel_cc_91/bin ; }
-    # Intel C++ Compiler 9.0. 
-    else if [ MATCH "(9[.]0|9)" : $(version) ]
-        { default_path = /opt/intel_cc_90/bin ; }
-    # Intel C++ Compiler 8.1. 
-    else if [ MATCH "(8[.]1)" : $(version) ]
-        { default_path = /opt/intel_cc_81/bin ; }
-    # Intel C++ Compiler 8.0 - this used to be the default, so now it's the
-    # fallback. 
-    else 
-        { default_path = /opt/intel_cc_80/bin ; }
-            
-    if $(.debug-configuration)
+    local command_lib_path ;
+    local detected_version ;
+    local detected_command ;
+    if ! $(user_version) && ! $(user_command)
     {
-        ECHO "notice: default search path for intel-linux is" $(default_path) ;
-    }
-
-    command = [ common.get-invocation-command intel-linux : icpc 
-        : $(command) : $(default_path) ] ;
-                
-    common.handle-options intel-linux : $(condition) : $(command) : $(options) ;
-    
-    local root = [ feature.get-values <root> : $(options) ] ;
-    local bin ;
-    if $(command) || $(root)
-    {
-        bin ?= [ common.get-absolute-tool-path $(command[-1]) ] ;
-        root ?= $(bin:D) ;
-        
-        local command-string = $(command:J=" ") ;
-        local version-output = [ SHELL "$(command-string) --version" ] ;
-        local real-version = [ MATCH "([0-9.]+)" : $(version-output) ] ;
-        local major = [ MATCH "([0-9]+).*" : $(real-version) ] ;
-        
-        # If we failed to determine major version, use the behaviour for
-        # the current compiler.
-        if $(major) && [ numbers.less $(major) 10 ]
+        # If nothing given, try and discover the latest toolset available.
+        if ! $(detected_command)
         {
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-Ob0" ;
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-Ob1" ;
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-Ob2" ;            
-            flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-O1" ;
-            flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ;
+            local bin_paths = $(.bin(oneAPI)) ;
+            detected_command = [ common.find-tool icpx : $(bin_paths) : path-last ] ;
+            command_lib_path = $(detected_command:D)/../compiler/lib/intel64 ;
         }
-        else if $(major) && [ numbers.less $(major) 11 ]
+        if ! $(detected_command)
         {
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ; 
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ; 
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ;                
-            flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-O1" ;
-            flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ;
+            local bin_paths = $(.bin(12.0)) $(.bin(11.1)) $(.bin(11.0)) ;
+            detected_command = [ common.find-tool icpc : $(bin_paths) : path-last ] ;
+            command_lib_path = $(detected_command:D)/../lib/x86_64 ;
         }
-        else # newer version of intel do have -Os (at least 11+, don't know about 10)
-        {                        
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ; 
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ; 
-            flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ;                
-            flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-Os" ;
-            flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ;
-        }        
-           
-        if $(root)
+        if ! $(detected_command)
         {
-            # Libraries required to run the executable may be in either
-            # $(root)/lib (10.1 and earlier) 
-            #     or 
-            # $(root)/lib/architecture-name (11.0 and later:
-            local lib_path = $(root)/lib $(root:P)/lib/$(bin:B) ;
-            if $(.debug-configuration)
+            local bin_paths = $(.bin(10.1)) $(.bin(9.1)) $(.bin(9.0))
+                $(.bin(8.1)) $(.bin(8.0)) ;
+            detected_command = [ common.find-tool icpc : $(bin_paths) : path-last ] ;
+            command_lib_path = $(detected_command:D)/../lib ;
+        }
+        if $(detected_command)
+        {
+            local version_cmd = "LD_LIBRARY_PATH=$(command_lib_path) $(detected_command) --version" ;
+            local version_output = [ SHELL $(version_cmd) ] ;
+            detected_version = [ MATCH "([0-9.]+)" : $(version_output) ] ;
+        }
+    }
+    else if $(user_command)
+    {
+        # If only a command given, determine the version from the command.
+        # Note, we assume that the user command does everything needed to
+        # property execute the command.
+        local version_cmd = $(user_command:J=" ") ;
+        local version_output = [ SHELL "$(version_cmd) --version" ] ;
+        detected_command = $(user_command) ;
+        detected_version = [ MATCH "([0-9.]+)" : $(version_output) ] ;
+    }
+    else if $(user_version)
+    {
+        # Only version given, try and find the command in the location for the version.
+        if [ numbers.less $(user_version[1]) 2020 ]
+        {
+            local version_xy = $(user_version[1]) $(user_version[2]) ;
+            local bin_paths = $(.bin($(version_xy:J=.))) ;
+            if $(bin_paths)
+            {
+                detected_command = [ common.find-tool icpc : $(bin_paths) : path-last ] ;
+            }
+            if [ numbers.less $(user_version[1]) 11 ]
+            {
+                command_lib_path = $(detected_command:D)/../lib ;
+            }
+            else
             {
-                ECHO notice\: using intel libraries "::" $(condition) "::" $(lib_path) ;
+                command_lib_path = $(detected_command:D)/../lib/x86_64 ;
             }
-            flags intel-linux.link RUN_PATH $(condition) : $(lib_path) ;
-        }   
+        }
+        else
+        {
+            detected_command = [ common.find-tool icpx
+                : [ regex.replace-list $(.bin(oneAPI)) : "latest" : $(user_version:J=.) ]
+                : path-last ] ;
+            command_lib_path = $(detected_command:D)/../compiler/lib/intel64 ;
+        }
+        if $(detected_command)
+        {
+            local version_cmd = "LD_LIBRARY_PATH=$(command_lib_path) $(detected_command) --version" ;
+            local version_output = [ SHELL $(version_cmd) ] ;
+            detected_version = [ MATCH "([0-9.]+)" : $(version_output) ] ;
+        }
+    }
+
+    if $(.debug-configuration)
+    {
+        ECHO "notice: intel-linux command is" $(command:E=$(detected_command)) ;
+    }
+
+    version ?= $(detected_version) ;
+    local condition = [ common.check-init-parameters intel-linux : version $(version) ] ;
+
+    if $(.debug-configuration)
+    {
+        ECHO "notice: intel-linux version is" $(version) ;
     }
-}
 
-SPACE = " " ;
+    command ?= $(detected_command) ;
+    common.handle-options intel-linux : $(condition) : $(command) : $(options) ;
 
-flags intel-linux.compile OPTIONS <warnings>off : -w0 ;
-flags intel-linux.compile OPTIONS <warnings>on : -w1 ;
-flags intel-linux.compile OPTIONS <warnings>all : -w2 ;
-flags intel-linux.compile OPTIONS <warnings>extra : -w3 ;
-flags intel-linux.compile OPTIONS <warnings>pedantic : -w3 -Wcheck ;
-flags intel-linux.compile OPTIONS <warnings-as-errors>on : -Werror-all ;
+    local tool_version = $(detected_version) ;
+    if $(tool_version)
+    {
+        tool_version = [ regex.split $(tool_version) "[.]" ] ;
+    }
+    tool_version ?= $(user_version) ;
+
+    if [ numbers.less $(tool_version[1]) 10 ]
+    {
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-Ob0" ;
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-Ob1" ;
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-Ob2" ;
+        flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-O1" ;
+        flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ;
+    }
+    else if [ numbers.less $(tool_version[1]) 11 ]
+    {
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ;
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ;
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ;
+        flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-O1" ;
+        flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ;
+    }
+    else # newer version of intel do have -Os (at least 11+, don't know about 10)
+    {
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>off : "-inline-level=0" ;
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>on : "-inline-level=1" ;
+        flags intel-linux.compile OPTIONS $(condition)/<inlining>full : "-inline-level=2" ;
+        flags intel-linux.compile OPTIONS $(condition)/<optimization>space : "-Os" ;
+        flags intel-linux.compile OPTIONS $(condition)/<optimization>speed : "-O3 -ip" ;
+    }
+    if [ numbers.less $(tool_version[1]) 2020 ]
+    {
+        flags intel-linux.compile OPTIONS <warnings>off : -w0 ;
+        flags intel-linux.compile OPTIONS <warnings>on : -w1 ;
+        flags intel-linux.compile OPTIONS <warnings>all : -w2 ;
+        flags intel-linux.compile OPTIONS <warnings>extra : -w3 ;
+        flags intel-linux.compile OPTIONS <warnings>pedantic : -w3 -Wcheck ;
+        flags intel-linux.compile OPTIONS <warnings-as-errors>on : -Werror-all ;
+    }
+    else
+    {
+        flags intel-linux.compile OPTIONS <warnings>off : -w ;
+        flags intel-linux.compile OPTIONS <warnings>on : -Wall ;
+        flags intel-linux.compile OPTIONS <warnings>all : -Wall ;
+        flags intel-linux.compile OPTIONS <warnings>extra : -Wall ;
+        flags intel-linux.compile OPTIONS <warnings>pedantic : -Wall ;
+        flags intel-linux.compile OPTIONS <warnings-as-errors>on : -Werror-all ;
+    }
+    if $(.debug-configuration)
+    {
+        ECHO notice\: using intel libraries "::" $(condition) "::" $(command_lib_path) ;
+    }
+    flags intel-linux.compile RUN_PATH $(condition) : $(command_lib_path) ;
+    flags intel-linux.link RUN_PATH $(condition) : $(command_lib_path) ;
+}
+
+_ = " " ;
 
 rule compile.c++ ( targets * : sources * : properties * )
 {
@@ -170,7 +241,7 @@ rule compile.c++ ( targets * : sources * : properties * )
 
 actions compile.c++ bind PCH_FILE
 {
-    "$(CONFIG_COMMAND)" -c -xc++ $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)"  -use-pch"$(PCH_FILE)" -c -o "$(<)" "$(>)"
+    LD_LIBRARY_PATH="$(RUN_PATH)" "$(CONFIG_COMMAND)" -c -xc++ $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)"  -use-pch"$(PCH_FILE)" -c -o "$(<)" "$(>)"
 }
 
 rule compile.c ( targets * : sources * : properties * )
@@ -180,7 +251,7 @@ rule compile.c ( targets * : sources * : properties * )
 
 actions compile.c bind PCH_FILE
 {
-    "$(CONFIG_COMMAND)" -c -xc $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -use-pch"$(PCH_FILE)" -c -o "$(<)" "$(>)"
+    LD_LIBRARY_PATH="$(RUN_PATH)" "$(CONFIG_COMMAND)" -c -xc $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -use-pch"$(PCH_FILE)" -c -o "$(<)" "$(>)"
 }
 
 rule compile.c++.pch ( targets * : sources * : properties * )
@@ -193,12 +264,12 @@ rule compile.c++.pch ( targets * : sources * : properties * )
 #
 actions compile.c++.pch
 {
-    rm -f "$(<)" && "$(CONFIG_COMMAND)" -x c++-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -pch-create "$(<)" "$(>)"
+    rm -f "$(<)" && LD_LIBRARY_PATH="$(RUN_PATH)" "$(CONFIG_COMMAND)" -x c++-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -pch-create "$(<)" "$(>)"
 }
 
 actions compile.fortran
 {
-    "ifort" -c $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"
+    LD_LIBRARY_PATH="$(RUN_PATH)" "ifort" -c $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -o "$(<)" "$(>)"
 }
 
 rule compile.c.pch ( targets * : sources * : properties * )
@@ -207,31 +278,26 @@ rule compile.c.pch ( targets * : sources * : properties * )
 
 actions compile.c.pch
 {
-    rm -f "$(<)" && "$(CONFIG_COMMAND)" -x c-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -pch-create "$(<)" "$(>)"
+    rm -f "$(<)" && LD_LIBRARY_PATH="$(RUN_PATH)" "$(CONFIG_COMMAND)" -x c-header $(OPTIONS) $(USER_OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -c -pch-create "$(<)" "$(>)"
 }
 
 rule link ( targets * : sources * : properties * )
 {
-    SPACE on $(targets) = " " ;
-    JAM_SEMAPHORE on $(targets) = <s>intel-linux-link-semaphore ;
+    _ on $(targets) = " " ;
 }
 
 actions link bind LIBRARIES
 {
-    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,-R$(SPACE)-Wl,"$(RPATH)" -Wl,-rpath-link$(SPACE)-Wl,"$(RPATH_LINK)" -o "$(<)" "$(>)" "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(OPTIONS) $(USER_OPTIONS)
+    LD_LIBRARY_PATH="$(RUN_PATH)" "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,-R$(_)-Wl,"$(RPATH)" -Wl,-rpath-link$(_)-Wl,"$(RPATH_LINK)" -o "$(<)" "$(>)" "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(OPTIONS) $(USER_OPTIONS)
 }
 
 rule link.dll ( targets * : sources * : properties * )
 {
-    SPACE on $(targets) = " " ;
-    JAM_SEMAPHORE on $(targets) = <s>intel-linux-link-semaphore ;
+    _ on $(targets) = " " ;
 }
 
 # Differ from 'link' above only by -shared.
 actions link.dll bind LIBRARIES
 {
-    "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,-R$(SPACE)-Wl,"$(RPATH)" -o "$(<)" -Wl,-soname$(SPACE)-Wl,$(<[1]:D=) -shared "$(>)"  "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(OPTIONS) $(USER_OPTIONS)
+    LD_LIBRARY_PATH="$(RUN_PATH)" "$(CONFIG_COMMAND)" -L"$(LINKPATH)" -Wl,-R$(_)-Wl,"$(RPATH)" -o "$(<)" -Wl,-soname$(_)-Wl,$(<[1]:D=) -shared "$(>)"  "$(LIBRARIES)" -l$(FINDLIBS-SA) -l$(FINDLIBS-ST) $(OPTIONS) $(USER_OPTIONS)
 }
-
-
-
diff --git a/src/tools/intel-vxworks.jam b/src/tools/intel-vxworks.jam
index c217ead32c..e70e4e2610 100644
--- a/src/tools/intel-vxworks.jam
+++ b/src/tools/intel-vxworks.jam
@@ -156,7 +156,7 @@ flags intel-vxworks ARFLAGS <archiveflags> ;
 
 rule archive ( targets * : sources * : properties * )
 {
-  # Always remove archive and start again. 
+  # Always remove archive and start again.
   # of the archive.
   #
   local clean.a = $(targets[1])(clean) ;
@@ -179,9 +179,6 @@ flags intel-vxworks.link USER_OPTIONS <linkflags> ;
 rule link ( targets * : sources * : properties * )
 {
   SPACE on $(targets) = " " ;
-  # Serialize execution of the 'link' action, since
-  # running N links in parallel is just slower.
-  JAM_SEMAPHORE on $(targets) = <s>intel-vxworks-link-semaphore ;
 }
 
 actions link bind LIBRARIES
diff --git a/src/tools/intel-win.jam b/src/tools/intel-win.jam
index f79fd530a2..08acd9ab3e 100644
--- a/src/tools/intel-win.jam
+++ b/src/tools/intel-win.jam
@@ -16,6 +16,7 @@ import toolset ;
 import generators ;
 import type ;
 import path ;
+import numbers ;
 
 feature.extend-subfeature toolset intel : platform : win ;
 
@@ -166,27 +167,44 @@ local rule configure-really ( version ? : command * : options * : compatibility
     local root = [ feature.get-values <root> : $(options) ] ;
     if $(command) || $(root)
     {
-        local bin = [ common.get-absolute-tool-path $(command[-1]) ] ;
-        if $(major) >= 12
+        local bin ;
+        if $(command)
         {
-            bin = [ path.make $(bin) ] ;
-            bin = [ path.parent $(bin) ] ;
+            bin = [ common.get-absolute-tool-path $(command[-1]) ] ;
+            if $(bin) && ( $(major) = 12 || [ numbers.less 12 $(major) ] )
+            {
+                bin = [ path.make $(bin) ] ;
+                bin = [ path.parent $(bin) ] ;
+            }
         }
         root ?= $(bin) ;
         root = $(root)/ ;
     }
 
     local setup ;
-    setup = [ path.glob $(root) : iclvars_*.bat ] ;
+    local setup_astk_bat ;
+    local setup_bat ;
+    if $(major) = 21 || [ numbers.less 21 $(major) ]
+    {
+        setup_astk_bat = "setvars_*.bat" ;
+        setup_bat = "setvars.bat" ;
+    }
+    else
+    {
+        setup_astk_bat = "iclvars_*.bat" ;
+        setup_bat = "iclvars.bat" ;
+    }
+    
+    setup = [ path.glob $(root) : $(setup_astk_bat) ] ;
     if ! $(setup)
     {
-       setup = [ path.join $(root) "iclvars.bat" ] ;
+       setup = [ path.join $(root) $(setup_bat) ] ;
        setup = [ path.native $(setup) ] ;
     }
 
     local target_types ;
     local iclvars_vs_arg ;
-    if $(major) >= 12
+    if $(major) = 12 || [ numbers.less 12 $(major) ]
     {
         # if we have a known intel toolset check for visual studio compatibility
         # if not trust parameters
@@ -208,7 +226,17 @@ local rule configure-really ( version ? : command * : options * : compatibility
         # and don't rely on whether the OS reports whether we're 64 or 32 bit
         # as that really only tells us which subsystem bjam is running in:
         #
-        local intel64_path = [ path.join $(root) intel64 ] ;
+        local root_start ;
+        if $(major) = 21 || [ numbers.less 21 $(major) ]
+        {
+            root_start = [ path.join $(root) "compiler/latest/windows/bin" ] ;
+            root_start = [ path.native $(root_start) ] ;
+        }
+        else
+        {
+            root_start = $(root) ;
+        }
+        local intel64_path = [ path.join $(root_start) intel64 ] ;
         if [ path.glob $(intel64_path) : icl.exe ]
         {
             target_types = ia32 intel64 ;
@@ -233,7 +261,7 @@ local rule configure-really ( version ? : command * : options * : compatibility
     {
         local cpu-conditions ;
         local setup-call ;
-        if $(major) >= 12
+        if $(major) = 12 || [ numbers.less 12 $(major) ]
         {
             cpu-conditions = $(condition)/$(.cpu-arch-$(c)) ;
 
@@ -310,18 +338,18 @@ local rule configure-really ( version ? : command * : options * : compatibility
 
     # Disable Microsoft "secure" overloads in Dinkumware libraries since they
     # cause compile errors with Intel versions 9 and 10.
-    if $(major) < 12
+    if [ numbers.less $(major) 12 ]
     {
         C++FLAGS += -D_SECURE_SCL=0 ;
     }
 
-    if $(major) > 5
+    if [ numbers.less 5 $(major) ]
     {
         C++FLAGS += "/Zc:forScope" ; # Add support for correct for loop scoping.
     }
 
     # Add options recognized only by intel7 and above.
-    if $(major) >= 7
+    if $(major) = 7 || [ numbers.less 7 $(major) ]
     {
         C++FLAGS += /Qansi_alias ;
     }
@@ -340,7 +368,7 @@ local rule configure-really ( version ? : command * : options * : compatibility
     }
     else
     {
-        if $(major) > 5
+        if [ numbers.less 5 $(major) ]
         {
             # Add support for wchar_t
             C++FLAGS += "/Zc:wchar_t"
@@ -498,6 +526,8 @@ if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
 .iclvars-18.0-supported-vcs = "14.1 14.0 12.0 11.0 10.0" ;
 .iclvars-19.0-supported-vcs = "14.2 14.1 14.0 12.0" ;
 .iclvars-19.1-supported-vcs = "14.2 14.1 14.0 12.0" ;
+.iclvars-21.1-supported-vcs = "14.2 14.1" ;
+.iclvars-2021.1-supported-vcs = "14.2 14.1" ;
 .iclvars-version-alias-vc14.2 = vs2019 ;
 .iclvars-version-alias-vc14.1 = vs2017 ;
 .iclvars-version-alias-vc14 = vs2015 ;
diff --git a/src/tools/intel.jam b/src/tools/intel.jam
index 0c602a8c09..83b00ae313 100644
--- a/src/tools/intel.jam
+++ b/src/tools/intel.jam
@@ -44,12 +44,13 @@ Specifies additional command line options that will be passed to the linker.
 For the Linux version, specifies the root directory of the compiler installation.
 This option is necessary only if it is not possible to detect this information
 from the compiler command -- for example if the specified compiler command is
-a user script. For the Windows version, specifies the directory where the
-`iclvars.bat` file for configuring the compiler exists. Specifying the `root`
-option without specifying the compiler command allows the end-user not to have
-to worry about whether he is compiling 32-bit or 64-bit code, as the toolset will
-automatically configure the compiler for the appropriate address model and compiler
-command using the `iclvars.bat` batch file.
+a user script. For the Windows version, specifies the directory of the
+`iclvars.bat` file, for versions prior to 21 ( or 2021 ), or of the `setvars.bat`,
+for versions from 21 ( or 2021 ) on up, for configuring the compiler. 
+Specifying the `root` option without specifying the compiler command allows the
+end-user not to have to worry about whether they are compiling 32-bit or 64-bit code,
+as the toolset will automatically configure the compiler for the appropriate address
+model and compiler command using the `iclvars.bat` or `setvars.bat` batch file.
 
 |# # end::doc[]
 
diff --git a/src/tools/msvc.jam b/src/tools/msvc.jam
index bf07a93f9d..07c0a91b7f 100644
--- a/src/tools/msvc.jam
+++ b/src/tools/msvc.jam
@@ -227,6 +227,7 @@ import property-set ;
 import rc ;
 import sequence ;
 import set ;
+import testing ;
 import toolset ;
 import type ;
 import virtual-target ;
@@ -450,19 +451,19 @@ rule configure-version-specific ( toolset : version : conditions )
     # version 7.* explicitly or if we auto-detected the version ourselves.
     if ! [ MATCH ^(6\\.) : $(version) ]
     {
-        toolset.flags $(toolset).compile CFLAGS $(conditions) : "/Zc:forScope" "/Zc:wchar_t" ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions) : "/Zc:forScope" "/Zc:wchar_t" ;
         toolset.flags $(toolset).compile.c++ C++FLAGS $(conditions) : /wd4675 ;
 
         # Explicitly disable the 'function is deprecated' warning. Some msvc
         # versions have a bug, causing them to emit the deprecation warning even
         # with /W0.
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<warnings>off : /wd4996 ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<warnings>off : /wd4996 ;
 
         if [ MATCH "^([78]\\.)" : $(version) ]
         {
             # 64-bit compatibility warning deprecated since 9.0, see
             # http://msdn.microsoft.com/en-us/library/yt4xw8fh.aspx
-            toolset.flags $(toolset).compile CFLAGS $(conditions)/<warnings>all : /Wp64 ;
+            toolset.flags $(toolset).compile OPTIONS $(conditions)/<warnings>all : /Wp64 ;
         }
     }
 
@@ -471,17 +472,88 @@ rule configure-version-specific ( toolset : version : conditions )
     # variables and functions that have internal linkage
     if ! [ version.version-less [ SPLIT_BY_CHARACTERS [ MATCH "^([0123456789.]+)" : $(version) ] : . ] : 12 ]
     {
-        toolset.flags $(toolset).compile CFLAGS $(conditions) : "/Zc:inline" ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions) : "/Zc:inline" ;
 
         # /Gy analog for variables: https://devblogs.microsoft.com/cppblog/introducing-gw-compiler-switch/
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<optimization>speed $(conditions)/<optimization>space : /Gw ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<optimization>speed $(conditions)/<optimization>space : /Gw ;
     }
 
     # 14.0 introduced /Zc:throwingNew opt-in flag that disables a workaround
     # for not throwing operator new in VC up to 6.0
     if ! [ version.version-less [ SPLIT_BY_CHARACTERS [ MATCH "^([0123456789.]+)" : $(version) ] : . ] : 14 ]
     {
-        toolset.flags $(toolset).compile CFLAGS $(conditions) : "/Zc:throwingNew" ;
+        toolset.flags $(toolset).compile C++FLAGS $(conditions) : "/Zc:throwingNew" ;
+    }
+
+    # 14.27 (VS2019 Version 16.7) introduced support for ASAN on x86 and x64 CPUs
+    # This check however now only tests for 14.2 (which is 16.0) as msvc.jam doesn't distinguish between minor versions (e.g. 14.21..14.28 etc)
+    if ! [ version.version-less [ SPLIT_BY_CHARACTERS [ MATCH "^([0123456789.]+)" : $(version) ] : . ] : 14 2 ]
+    {
+        # General asan compile and link options.
+        toolset.flags $(toolset).compile OPTIONS
+            $(conditions)/<address-sanitizer>on
+            :   /fsanitize=address /FS ;
+        toolset.flags $(toolset).link LINKFLAGS
+            $(conditions)/<address-sanitizer>on
+            :   -incremental\:no ;
+
+        # The various 64 bit runtime asan support libraries and related flags.
+        toolset.flags $(toolset).link FINDLIBS_SA
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>shared
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>shared
+            :   clang_rt.asan_dynamic-x86_64
+                clang_rt.asan_dynamic_runtime_thunk-x86_64 ;
+        toolset.flags $(toolset).link LINKFLAGS
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>shared
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>shared
+            :   /wholearchive\:"clang_rt.asan_dynamic-x86_64.lib"
+                /wholearchive\:"clang_rt.asan_dynamic_runtime_thunk-x86_64.lib" ;
+        toolset.flags $(toolset).link FINDLIBS_SA
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>static/<main-target-type>EXE
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>static/<main-target-type>UNIT_TEST
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>static/<main-target-type>EXE
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>static/<main-target-type>UNIT_TEST
+            :   clang_rt.asan-x86_64
+                clang_rt.asan_cxx-x86_64 ;
+        toolset.flags $(toolset).link LINKFLAGS
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>static/<main-target-type>EXE
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>static/<main-target-type>UNIT_TEST
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>static/<main-target-type>EXE
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>static/<main-target-type>UNIT_TEST
+            :   /wholearchive\:"clang_rt.asan-x86_64.lib"
+                /wholearchive\:"clang_rt.asan_cxx-x86_64.lib" ;
+        toolset.flags $(toolset).link.dll FINDLIBS_SA
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>static
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>static
+            :   clang_rt.asan_dll_thunk-x86_64 ;
+        toolset.flags $(toolset).link.dll LINKFLAGS
+            $(conditions)/<address-sanitizer>on/<address-model>/<runtime-link>static
+            $(conditions)/<address-sanitizer>on/<address-model>64/<runtime-link>static
+            :   /wholearchive\:"clang_rt.asan_dll_thunk-x86_64.lib" ;
+
+        # The various 32 bit runtime asan support libraries and related flags.
+        toolset.flags $(toolset).link FINDLIBS_SA
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>shared
+            :   clang_rt.asan_dynamic-i386 clang_rt.asan_dynamic_runtime_thunk-i386 ;
+        toolset.flags $(toolset).link LINKFLAGS
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>shared
+            :   /wholearchive\:"clang_rt.asan_dynamic-i386.lib"
+                /wholearchive\:"clang_rt.asan_dynamic_runtime_thunk-i386.lib" ;
+        toolset.flags $(toolset).link FINDLIBS_SA
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>static/<main-target-type>EXE
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>static/<main-target-type>UNIT_TEST
+            :   clang_rt.asan-i386 clang_rt.asan_cxx-i386 ;
+        toolset.flags $(toolset).link LINKFLAGS
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>static/<main-target-type>EXE
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>static/<main-target-type>UNIT_TEST
+            :   /wholearchive\:"clang_rt.asan-i386.lib"
+                /wholearchive\:"clang_rt.asan_cxx-i386.lib" ;
+        toolset.flags $(toolset).link.dll FINDLIBS_SA
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>static/<main-target-type>LIB/<link>shared
+            :   clang_rt.asan_dll_thunk-i386 ;
+        toolset.flags $(toolset).link.dll LINKFLAGS
+            $(conditions)/<address-sanitizer>on/<address-model>32/<runtime-link>static/<main-target-type>LIB/<link>shared
+            :   /wholearchive\:"clang_rt.asan_dll_thunk-i386.lib" ;
     }
 
     #
@@ -491,34 +563,34 @@ rule configure-version-specific ( toolset : version : conditions )
     if [ MATCH "^([67])" : $(version) ]
     {
         # 8.0 deprecates some of the options.
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<optimization>speed $(conditions)/<optimization>space : /Ogiy /Gs ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<optimization>speed : /Ot ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<optimization>space : /Os ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<optimization>speed $(conditions)/<optimization>space : /Ogiy /Gs ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<optimization>speed : /Ot ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<optimization>space : /Os ;
 
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-i386)/<instruction-set> : /GB ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-i386)/<instruction-set>i486 : /G4 ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-i386)/<instruction-set>$(.cpu-type-g5) : /G5 ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-i386)/<instruction-set>$(.cpu-type-g6) : /G6 ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-i386)/<instruction-set>$(.cpu-type-g7) : /G7 ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-i386)/<instruction-set> : /GB ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-i386)/<instruction-set>i486 : /G4 ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-i386)/<instruction-set>$(.cpu-type-g5) : /G5 ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-i386)/<instruction-set>$(.cpu-type-g6) : /G6 ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-i386)/<instruction-set>$(.cpu-type-g7) : /G7 ;
 
         # Improve floating-point accuracy. Otherwise, some of C++ Boost's "math"
         # tests will fail.
-        toolset.flags $(toolset).compile CFLAGS $(conditions) : /Op ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions) : /Op ;
 
         # 7.1 and below have single-threaded static RTL.
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<runtime-debugging>off/<runtime-link>static/<threading>single : /ML ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<runtime-debugging>on/<runtime-link>static/<threading>single : /MLd ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<runtime-debugging>off/<runtime-link>static/<threading>single : /ML ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<runtime-debugging>on/<runtime-link>static/<threading>single : /MLd ;
     }
     else
     {
         # 8.0 and above adds some more options.
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-amd64)/<instruction-set> : "/favor:blend" ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-amd64)/<instruction-set>$(.cpu-type-em64t) : "/favor:EM64T" ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/$(.cpu-arch-amd64)/<instruction-set>$(.cpu-type-amd64) : "/favor:AMD64" ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-amd64)/<instruction-set> : "/favor:blend" ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-amd64)/<instruction-set>$(.cpu-type-em64t) : "/favor:EM64T" ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/$(.cpu-arch-amd64)/<instruction-set>$(.cpu-type-amd64) : "/favor:AMD64" ;
 
         # 8.0 and above only has multi-threaded static RTL.
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<runtime-debugging>off/<runtime-link>static/<threading>single : /MT ;
-        toolset.flags $(toolset).compile CFLAGS $(conditions)/<runtime-debugging>on/<runtime-link>static/<threading>single : /MTd ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<runtime-debugging>off/<runtime-link>static/<threading>single : /MT ;
+        toolset.flags $(toolset).compile OPTIONS $(conditions)/<runtime-debugging>on/<runtime-link>static/<threading>single : /MTd ;
 
         # Specify target machine type so the linker will not need to guess.
         toolset.flags $(toolset).link LINKFLAGS $(conditions)/$(.cpu-arch-amd64) : "/MACHINE:X64" ;
@@ -587,7 +659,7 @@ if [ os.name ] in NT
     actions archive
     {
         if exist "$(<[1])" DEL "$(<[1])"
-        $(.SETUP) $(.LD) $(AROPTIONS) /out:"$(<[1])" @"@($(<[1]:W).rsp:E=$(.nl)"$(>)" $(.nl)$(LIBRARIES_MENTIONED_BY_FILE) $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
+        $(.SETUP) $(.LD) $(AROPTIONS) /out:"$(<[1])" @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>)" $(LIBRARIES_MENTIONED_BY_FILE) "$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" "$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")
     }
 }
 else
@@ -595,7 +667,7 @@ else
     actions archive
     {
         $(.RM) "$(<[1])"
-        $(.SETUP) $(.LD) $(AROPTIONS) /out:"$(<[1])" @"@($(<[1]:W).rsp:E=$(.nl)"$(>)" $(.nl)$(LIBRARIES_MENTIONED_BY_FILE) $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
+        $(.SETUP) $(.LD) $(AROPTIONS) /out:"$(<[1])" @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>)" $(LIBRARIES_MENTIONED_BY_FILE) "$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" "$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")
     }
 }
 
@@ -613,8 +685,7 @@ actions compile.asm
 rule compile.c ( targets + : sources * : properties * )
 {
     set-setup-command $(targets) : $(properties) ;
-    C++FLAGS on $(targets[1]) = ;
-    get-rspline $(targets) : -TC ;
+    get-rspline $(targets) : -TC CFLAGS  ;
     compile-c-c++ $(<) : $(>) [ on $(<) return $(PCH_FILE) ] [ on $(<) return $(PCH_HEADER) ] ;
 }
 
@@ -622,8 +693,7 @@ rule compile.c ( targets + : sources * : properties * )
 rule compile.c.preprocess ( targets + : sources * : properties * )
 {
     set-setup-command $(targets) : $(properties) ;
-    C++FLAGS on $(targets[1]) = ;
-    get-rspline $(targets) : -TC ;
+    get-rspline $(targets) : -TC CFLAGS ;
     preprocess-c-c++ $(<) : $(>) [ on $(<) return $(PCH_FILE) ] [ on $(<) return $(PCH_HEADER) ] ;
 }
 
@@ -631,9 +701,8 @@ rule compile.c.preprocess ( targets + : sources * : properties * )
 rule compile.c.pch ( targets + : sources * : properties * )
 {
     set-setup-command $(targets) : $(properties) ;
-    C++FLAGS on $(targets[1]) = ;
-    get-rspline $(targets[1]) : -TC ;
-    get-rspline $(targets[2]) : -TC ;
+    get-rspline $(targets[1]) : -TC CFLAGS ;
+    get-rspline $(targets[2]) : -TC CFLAGS ;
     local pch-source = [ on $(<) return $(PCH_SOURCE) ] ;
     if $(pch-source)
     {
@@ -668,12 +737,12 @@ toolset.flags msvc YLOPTION : "-Yl" ;
 #
 actions compile-c-c++ bind PDB_NAME
 {
-    $(.SETUP) $(.CC) @"@($(<[1]:W).rsp:E="$(>[1]:W)" -Fo"$(<[1]:W)" $(PDB_CFLAG)"$(PDB_NAME)" -Yu"$(>[3]:D=)" -Fp"$(>[2]:W)" $(CC_RSPLINE))" $(.CC.FILTER)
+    $(.SETUP) $(.CC) @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>[1]:W)" -Fo"$(<[1]:W)" $(PDB_CFLAG)"$(PDB_NAME)" -Yu"$(>[3]:D=)" -Fp"$(>[2]:W)" $(CC_RSPLINE)) $(.CC.FILTER)
 }
 
 actions preprocess-c-c++ bind PDB_NAME
 {
-    $(.SETUP) $(.CC) @"@($(<[1]:W).rsp:E="$(>[1]:W)" -E $(PDB_CFLAG)"$(PDB_NAME)" -Yu"$(>[3]:D=)" -Fp"$(>[2]:W)" $(CC_RSPLINE))" >"$(<[1]:W)"
+    $(.SETUP) $(.CC) @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>[1]:W)" -E $(PDB_CFLAG)"$(PDB_NAME)" -Yu"$(>[3]:D=)" -Fp"$(>[2]:W)" $(CC_RSPLINE))" >"$(<[1]:W)"
 }
 
 rule compile-c-c++ ( targets + : sources * )
@@ -700,7 +769,7 @@ rule preprocess-c-c++ ( targets + : sources * )
 # syntax highlighting in the messy N-quoted code below.
 actions compile-c-c++-pch
 {
-    $(.SETUP) $(.CC) @"@($(<[1]:W).rsp:E="$(>[2]:W)" -Fo"$(<[2]:W)" -Yc"$(>[1]:D=)" $(YLOPTION)"__bjam_pch_symbol_$(>[1]:D=)" -Fp"$(<[1]:W)" $(CC_RSPLINE))" "@($(<[1]:W).cpp:E=#include $(.escaped-double-quote)$(>[1]:D=)$(.escaped-double-quote)$(.nl))" $(.CC.FILTER)
+    $(.SETUP) $(.CC) @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>[2]:W)" -Fo"$(<[2]:W)" -Yc"$(>[1]:D=)" $(YLOPTION)"__bjam_pch_symbol_$(>[1]:D=)" -Fp"$(<[1]:W)" $(CC_RSPLINE)) @($(<[1]:W).cpp:<=":>=":E=$(.hash)include $(.escaped-double-quote)$(>[1]:D=)$(.escaped-double-quote)$(.nl)) $(.CC.FILTER)
 }
 
 
@@ -709,21 +778,21 @@ actions compile-c-c++-pch
 # given as one of the source parameters.
 actions compile-c-c++-pch-s
 {
-    $(.SETUP) $(.CC) @"@($(<[1]:W).rsp:E="$(>[2]:W)" -Fo"$(<[2]:W)" -Yc"$(>[1]:D=)" $(YLOPTION)"__bjam_pch_symbol_$(>[1]:D=)" -Fp"$(<[1]:W)" $(CC_RSPLINE))" $(.CC.FILTER)
+    $(.SETUP) $(.CC) @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>[2]:W)" -Fo"$(<[2]:W)" -Yc"$(>[1]:D=)" $(YLOPTION)"__bjam_pch_symbol_$(>[1]:D=)" -Fp"$(<[1]:W)" $(CC_RSPLINE)) $(.CC.FILTER)
 }
 
 
 rule compile.c++ ( targets + : sources * : properties * )
 {
     set-setup-command $(targets) : $(properties) ;
-    get-rspline $(targets) : -TP ;
+    get-rspline $(targets) : -TP C++FLAGS ;
     compile-c-c++ $(<) : $(>) [ on $(<) return $(PCH_FILE) ] [ on $(<) return $(PCH_HEADER) ] ;
 }
 
 rule compile.c++.preprocess ( targets + : sources * : properties * )
 {
     set-setup-command $(targets) : $(properties) ;
-    get-rspline $(targets) : -TP ;
+    get-rspline $(targets) : -TP C++FLAGS ;
     preprocess-c-c++ $(<) : $(>) [ on $(<) return $(PCH_FILE) ] [ on $(<) return $(PCH_HEADER) ] ;
 }
 
@@ -731,8 +800,8 @@ rule compile.c++.preprocess ( targets + : sources * : properties * )
 rule compile.c++.pch ( targets + : sources * : properties * )
 {
     set-setup-command $(targets) : $(properties) ;
-    get-rspline $(targets[1]) : -TP ;
-    get-rspline $(targets[2]) : -TP ;
+    get-rspline $(targets[1]) : -TP C++FLAGS ;
+    get-rspline $(targets[2]) : -TP C++FLAGS ;
     local pch-source = [ on $(<) return $(PCH_SOURCE) ] ;
     if $(pch-source)
     {
@@ -754,7 +823,7 @@ rule compile.idl ( targets + : sources * : properties * )
 #
 actions compile.idl
 {
-    $(.SETUP) $(.IDL) /nologo @"@($(<[1]:W).rsp:E=$(.nl)"$(>:W)" $(.nl)-D$(DEFINES) $(.nl)"-I$(INCLUDES:W)" $(.nl)-U$(UNDEFS) $(.nl)$(MIDLFLAGS) $(.nl)/tlb "$(<[1]:W)" $(.nl)/h "$(<[2]:W)" $(.nl)/iid "$(<[3]:W)" $(.nl)/proxy "$(<[4]:W)" $(.nl)/dlldata "$(<[5]:W)")"
+    $(.SETUP) $(.IDL) /nologo @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>:W)" -D$(DEFINES) "-I$(INCLUDES:W)" -U$(UNDEFS) $(MIDLFLAGS) /tlb "$(<[1]:W)" /h "$(<[2]:W)" /iid "$(<[3]:W)" /proxy "$(<[4]:W)" /dlldata "$(<[5]:W)")
     $(.TOUCH_FILE) "$(<[4]:W)"
     $(.TOUCH_FILE) "$(<[5]:W)"
 }
@@ -846,7 +915,7 @@ rule link.dll ( targets + : sources * : properties * )
 {
     actions link bind DEF_FILE LIBRARIES_MENTIONED_BY_FILE MANIFEST_FILE
     {
-        $(.SETUP) $(.LD) $(LINKFLAGS) /out:"$(<[1]:W)" /LIBPATH:"$(LINKPATH:W)" /MANIFESTINPUT:"$(MANIFEST_FILE)" $(OPTIONS) @"@($(<[1]:W).rsp:E=$(.nl)"$(>)" $(.nl)$(LIBRARIES_MENTIONED_BY_FILE) $(.nl)$(LIBRARIES) $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
+        $(.SETUP) $(.LD) @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>)" $(LIBRARIES_MENTIONED_BY_FILE) $(LIBRARIES) "$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" "$(LIBRARY_OPTION)$(FINDLIBS_SA).lib") $(LINKOPT) $(LINKFLAGS) /out:"$(<[1]:W)" /LIBPATH:"$(LINKPATH:W)" /MANIFESTINPUT:"$(MANIFEST_FILE)"
     }
 
     actions manifest
@@ -861,7 +930,7 @@ rule link.dll ( targets + : sources * : properties * )
 
     actions link.dll bind IMPORT_LIB DEF_FILE LIBRARIES_MENTIONED_BY_FILE MANIFEST_FILE
     {
-        $(.SETUP) $(.LD) /DLL $(LINKFLAGS) /out:"$(<[1]:W)" /IMPLIB:"$(IMPORT_LIB:W)" /LIBPATH:"$(LINKPATH:W)" /def:"$(DEF_FILE)" /MANIFESTINPUT:"$(MANIFEST_FILE)" $(OPTIONS) @"@($(<[1]:W).rsp:E=$(.nl)"$(>)" $(.nl)$(LIBRARIES_MENTIONED_BY_FILE) $(.nl)$(LIBRARIES) $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" $(.nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA).lib")"
+        $(.SETUP) $(.LD) @($(<[1]:W).rsp:O=FC:<=@":>=":E="$(>)" $(LIBRARIES_MENTIONED_BY_FILE) $(LIBRARIES) "$(LIBRARY_OPTION)$(FINDLIBS_ST).lib" "$(LIBRARY_OPTION)$(FINDLIBS_SA).lib") $(LINKOPT) $(LINKFLAGS) /out:"$(<[1]:W)" /LIBPATH:"$(LINKPATH:W)" /MANIFESTINPUT:"$(MANIFEST_FILE)" /DLL /IMPLIB:"$(IMPORT_LIB:W)" /def:"$(DEF_FILE)"
     }
 
     actions manifest.dll
@@ -1592,7 +1661,7 @@ local rule configure-really ( version ? : options * )
 
         # LTO
         toolset.flags msvc.compile OPTIONS $(conditions)/<lto>on : /GL ;
-        toolset.flags msvc.link OPTIONS $(conditions)/<lto>on : /LTCG ;
+        toolset.flags msvc.link LINKFLAGS $(conditions)/<lto>on : /LTCG ;
 
         # Set version-specific flags.
         configure-version-specific msvc : $(version) : $(conditions) ;
@@ -1691,11 +1760,11 @@ local rule default-path ( version )
 
 
 
-rule get-rspline ( target : lang-opt )
+rule get-rspline ( target : lang-opt lang-flags )
 {
     CC_RSPLINE on $(target) = [ on $(target) return $(lang-opt) -U$(UNDEFS)
-        $(CFLAGS) $(C++FLAGS) $(OPTIONS) -c $(.nl)-D$(DEFINES)
-        $(.nl)\"-I$(INCLUDES:W)\" $(.nl)\"-FI$(FORCE_INCLUDES:W)\" ] ;
+        $($(lang-flags)) $(OPTIONS) -c -D$(DEFINES)
+        \"-I$(INCLUDES:W)\" \"-FI$(FORCE_INCLUDES:W)\" ] ;
 }
 
 class msvc-linking-generator : linking-generator
@@ -1830,25 +1899,25 @@ local rule register-toolset-really ( )
     # Declare flags for compilation.
     #
 
-    toolset.flags msvc.compile CFLAGS <optimization>speed : /O2 ;
-    toolset.flags msvc.compile CFLAGS <optimization>space : /O1 ;
+    toolset.flags msvc.compile OPTIONS <optimization>speed : /O2 ;
+    toolset.flags msvc.compile OPTIONS <optimization>space : /O1 ;
 
-    toolset.flags msvc.compile CFLAGS $(.cpu-arch-ia64)/<instruction-set>$(.cpu-type-itanium) : /G1 ;
-    toolset.flags msvc.compile CFLAGS $(.cpu-arch-ia64)/<instruction-set>$(.cpu-type-itanium2) : /G2 ;
+    toolset.flags msvc.compile OPTIONS $(.cpu-arch-ia64)/<instruction-set>$(.cpu-type-itanium) : /G1 ;
+    toolset.flags msvc.compile OPTIONS $(.cpu-arch-ia64)/<instruction-set>$(.cpu-type-itanium2) : /G2 ;
 
-    toolset.flags msvc.compile CFLAGS <debug-symbols>on/<debug-store>object : /Z7 ;
-    toolset.flags msvc.compile CFLAGS <debug-symbols>on/<debug-store>database : /Zi ;
-    toolset.flags msvc.compile CFLAGS <optimization>off : /Od ;
-    toolset.flags msvc.compile CFLAGS <inlining>off : /Ob0 ;
-    toolset.flags msvc.compile CFLAGS <inlining>on : /Ob1 ;
-    toolset.flags msvc.compile CFLAGS <inlining>full : /Ob2 ;
+    toolset.flags msvc.compile OPTIONS <debug-symbols>on/<debug-store>object : /Z7 ;
+    toolset.flags msvc.compile OPTIONS <debug-symbols>on/<debug-store>database : /Zi ;
+    toolset.flags msvc.compile OPTIONS <optimization>off : /Od ;
+    toolset.flags msvc.compile OPTIONS <inlining>off : /Ob0 ;
+    toolset.flags msvc.compile OPTIONS <inlining>on : /Ob1 ;
+    toolset.flags msvc.compile OPTIONS <inlining>full : /Ob2 ;
 
-    toolset.flags msvc.compile CFLAGS <warnings>on : /W3 ;
-    toolset.flags msvc.compile CFLAGS <warnings>off : /W0 ;
-    toolset.flags msvc.compile CFLAGS <warnings>all : /W4 ;
-    toolset.flags msvc.compile CFLAGS <warnings>extra : /W4 ;
-    toolset.flags msvc.compile CFLAGS <warnings>pedantic : /W4 ;
-    toolset.flags msvc.compile CFLAGS <warnings-as-errors>on : /WX ;
+    toolset.flags msvc.compile OPTIONS <warnings>on : /W3 ;
+    toolset.flags msvc.compile OPTIONS <warnings>off : /W0 ;
+    toolset.flags msvc.compile OPTIONS <warnings>all : /W4 ;
+    toolset.flags msvc.compile OPTIONS <warnings>extra : /W4 ;
+    toolset.flags msvc.compile OPTIONS <warnings>pedantic : /W4 ;
+    toolset.flags msvc.compile OPTIONS <warnings-as-errors>on : /WX ;
 
     toolset.flags msvc.compile C++FLAGS  <exception-handling>on/<asynch-exceptions>off/<extern-c-nothrow>off : /EHs ;
     toolset.flags msvc.compile C++FLAGS  <exception-handling>on/<asynch-exceptions>off/<extern-c-nothrow>on : /EHsc ;
@@ -1862,16 +1931,16 @@ local rule register-toolset-really ( )
     # By default 8.0 enables rtti support while prior versions disabled it. We
     # simply enable or disable it explicitly so we do not have to depend on this
     # default behaviour.
-    toolset.flags msvc.compile CFLAGS <rtti>on : /GR ;
-    toolset.flags msvc.compile CFLAGS <rtti>off : /GR- ;
-    toolset.flags msvc.compile CFLAGS <runtime-debugging>off/<runtime-link>shared : /MD ;
-    toolset.flags msvc.compile CFLAGS <runtime-debugging>on/<runtime-link>shared : /MDd ;
+    toolset.flags msvc.compile C++FLAGS <rtti>on : /GR ;
+    toolset.flags msvc.compile C++FLAGS <rtti>off : /GR- ;
+    toolset.flags msvc.compile OPTIONS <runtime-debugging>off/<runtime-link>shared : /MD ;
+    toolset.flags msvc.compile OPTIONS <runtime-debugging>on/<runtime-link>shared : /MDd ;
 
-    toolset.flags msvc.compile CFLAGS <runtime-debugging>off/<runtime-link>static/<threading>multi : /MT ;
-    toolset.flags msvc.compile CFLAGS <runtime-debugging>on/<runtime-link>static/<threading>multi : /MTd ;
+    toolset.flags msvc.compile OPTIONS <runtime-debugging>off/<runtime-link>static/<threading>multi : /MT ;
+    toolset.flags msvc.compile OPTIONS <runtime-debugging>on/<runtime-link>static/<threading>multi : /MTd ;
 
-    toolset.flags msvc.compile OPTIONS <cflags> : ;
-    toolset.flags msvc.compile.c++ OPTIONS <cxxflags> : ;
+    toolset.flags msvc.compile CFLAGS <cflags> : ;
+    toolset.flags msvc.compile.c++ C++FLAGS <cxxflags> : ;
 
     toolset.flags msvc.compile PDB_CFLAG <debug-symbols>on/<debug-store>database : /Fd ;
 
@@ -1909,7 +1978,7 @@ local rule register-toolset-really ( )
         toolset.flags msvc LINKFLAGS <user-interface>native : "/subsystem:native" ;
         toolset.flags msvc LINKFLAGS <user-interface>auto : "/subsystem:posix" ;
 
-        toolset.flags msvc.link OPTIONS <linkflags> ;
+        toolset.flags msvc.link LINKFLAGS <linkflags> ;
         toolset.flags msvc.link LINKPATH <library-path> ;
 
         toolset.flags msvc.link FINDLIBS_ST <find-static-library> ;
@@ -1922,6 +1991,11 @@ local rule register-toolset-really ( )
 
     toolset.flags msvc.archive AROPTIONS <archiveflags> ;
 
+    # Enable response file control
+    toolset.flags msvc RESPONSE_FILE_SUB <response-file>auto : a ;
+    toolset.flags msvc RESPONSE_FILE_SUB <response-file>file : f ;
+    toolset.flags msvc RESPONSE_FILE_SUB <response-file>contents : c ;
+
     # Create a project to allow building the setup scripts
     project.initialize $(__name__) ;
     .project = [ project.current ] ;
@@ -1990,35 +2064,57 @@ if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
 .RM = [ common.rm-command ] ;
 .nl = "
 " ;
+_ = " " ;
 .ProgramFiles = [ path.make [ common.get-program-files-dir ] ] ;
 .escaped-double-quote = "\"" ;
+.hash = "\#" ;
 .TOUCH_FILE = [ common.file-touch-command ] ;
 
 # List of all registered configurations.
 .versions = [ new configurations ] ;
 
 # Supported CPU architectures.
-.cpu-arch-i386 =
-    <architecture>/<address-model>
-    <architecture>/<address-model>32
-    <architecture>x86/<address-model>
-    <architecture>x86/<address-model>32 ;
-
-.cpu-arch-amd64 =
-    <architecture>/<address-model>64
-    <architecture>x86/<address-model>64 ;
-
-.cpu-arch-ia64 =
-    <architecture>ia64/<address-model>
-    <architecture>ia64/<address-model>64 ;
-
-.cpu-arch-arm =
-    <architecture>arm/<address-model>
-    <architecture>arm/<address-model>32 ;
-
-.cpu-arch-arm64 =
-    <architecture>arm/<address-model>
-    <architecture>arm/<address-model>64 ;
+.cpu-arch-info-i386  = x86  32 ;
+.cpu-arch-info-amd64 = x86  64 ;
+.cpu-arch-info-ia64  = ia64 64 ;
+.cpu-arch-info-arm   = arm  32 ;
+.cpu-arch-info-arm64 = arm  64 ;
+
+# Fill explicit architecture and address model values
+for local cpu in [ MATCH "^\\.cpu-arch-info-(.*)" : [ VARNAMES $(__name__) ] ]
+{
+    local arch = $(.cpu-arch-info-$(cpu)[1]) ;
+    .cpus-on-$(arch) += $(cpu) ;
+    .cpu-arch-$(cpu) = <architecture>$(arch)/<address-model>$(.cpu-arch-info-$(cpu)[2]) ;
+}
+
+# Match implicit architecture and address model based on the current platform
+.default-cpu-arch = [ os.environ PROCESSOR_ARCHITEW6432 ] ;
+.default-cpu-arch ?= [ os.environ PROCESSOR_ARCHITECTURE ] ;
+.default-cpu-arch = $(.default-cpu-arch:L) ;
+switch $(.default-cpu-arch)
+{
+    case x86   : .default-cpu-arch = i386 ;
+    case em64t : .default-cpu-arch = amd64 ;
+}
+
+for local cpu in $(.cpus-on-$(.cpu-arch-info-$(.default-cpu-arch)[1]))
+{
+    .cpu-arch-$(cpu) += <architecture>/<address-model>$(.cpu-arch-info-$(cpu)[2]) ;
+}
+
+.cpu-arch-$(.default-cpu-arch) += <architecture>$(.cpu-arch-info-$(.default-cpu-arch)[1])/<address-model> ;
+.cpu-arch-$(.default-cpu-arch) += <architecture>/<address-model> ;
+
+# If there is only one address model for an architecture we allow to ommit it
+for local arch in [ MATCH "^\\.cpus-on-(.*)" : [ VARNAMES $(__name__) ] ]
+{
+    if ! $(.cpus-on-$(arch)[2-]) && $(.cpus-on-$(arch)[1]) != $(.default-cpu-arch)
+    {
+        .cpu-arch-$(.cpus-on-$(arch)) += <architecture>$(arch)/<address-model> ;
+    }
+}
+
 
 # Supported CPU types (only Itanium optimization options are supported from
 # VC++ 2005 on). See
diff --git a/src/tools/package.jam b/src/tools/package.jam
index 7ae9dc54a0..a61a9e5244 100644
--- a/src/tools/package.jam
+++ b/src/tools/package.jam
@@ -253,9 +253,9 @@ rule install ( name package-name ? : requirements * : binaries * : libraries * :
         $(name)-lib-shared-universe $(name)-lib-shared-cygwin ;
 }
 
-rule install-data ( target-name : package-name : data * : requirements * )
+rule install-data ( target-name : package-name ? : data * : requirements * )
 {
-    package-name ?= target-name ;
+    package-name ?= $(target-name) ;
 
     local paths = [ paths $(package-name) : $(requirements) ] ;
     local datadir = [ $(paths).datarootdir ] ;
diff --git a/src/tools/qcc.jam b/src/tools/qcc.jam
index 740e90705d..aac6059661 100644
--- a/src/tools/qcc.jam
+++ b/src/tools/qcc.jam
@@ -240,10 +240,6 @@ toolset.flags qcc.link RPATH_LINK : <xdll-path> : unchecked ;
 rule link ( targets * : sources * : properties * )
 {
     SPACE on $(targets) = " " ;
-    # Serialize execution of the 'link' action, since running N links in
-    # parallel is just slower. For now, serialize only qcc links while it might
-    # be a good idea to serialize all links.
-    JAM_SEMAPHORE on $(targets) = <s>qcc-link-semaphore ;
     check-target-platform $(1) ;
 }
 
@@ -289,7 +285,6 @@ actions piecemeal archive
 rule link.dll ( targets * : sources * : properties * )
 {
     SPACE on $(targets) = " " ;
-    JAM_SEMAPHORE on $(targets) = <s>qcc-link-semaphore ;
     check-target-platform $(1) ;
 }
 
diff --git a/src/tools/quickbook.jam b/src/tools/quickbook.jam
index 9870e9e41d..72c8e609aa 100644
--- a/src/tools/quickbook.jam
+++ b/src/tools/quickbook.jam
@@ -1,5 +1,5 @@
 #
-#   Copyright (c) 2005 Jo�o Abecasis
+#   Copyright (c) 2005 João Abecasis
 #   Copyright (c) 2005 Vladimir Prus
 #   Copyright (c) 2006 Rene Rivera
 #
diff --git a/src/util/indirect.jam b/src/util/indirect.jam
index 095fea95ff..9d153f6978 100644
--- a/src/util/indirect.jam
+++ b/src/util/indirect.jam
@@ -105,6 +105,49 @@ rule call ( [indirect-rule] r args * : * )
         $(12) : $(13) : $(14) : $(15) : $(16) : $(17) : $(18) : $(19) ] ;
 }
 
+.parts_regex = "^([^@]*)@" "([^%]*)%" "([^%]+)$" ;
+.parts_regex = $(.parts_regex:J=) ;
+
+# Get the three parts of an indirect reference in a feature.
+#
+rule parts ( x )
+{
+    return [ MATCH "$(.parts_regex)" : $(x) ] ;
+}
+
+# Compute teh difference between two lists containing indirect references.
+# The context of the references are not considered for equality comparisons.
+#
+rule difference ( s1 * : s2 * )
+{
+    local result ;
+    local s2-min ;
+    for local s2i in $(s2)
+    {
+        local m = [ parts $(s2i) ] ;
+        if $(m)
+        {
+            s2-min += "$(m[1])@%$(m[3])" ;
+        }
+    }
+    for local s1i in $(s1)
+    {
+        local m = [ parts $(s1i) ] ;
+        if $(m)
+        {
+            if ! ( $(m[1])@%$(m[3]) in $(s2-min) )
+            {
+                result += $(s1i) ;
+            }
+        }
+        else
+        {
+            result += $(s1i) ;
+        }
+    }
+    return $(result) ;
+}
+
 
 rule __test__
 {
diff --git a/test/BoostBuild.py b/test/BoostBuild.py
index 209fba3bd2..4ccc2b5d25 100644
--- a/test/BoostBuild.py
+++ b/test/BoostBuild.py
@@ -1,6 +1,6 @@
 # Copyright 2002-2005 Vladimir Prus.
 # Copyright 2002-2003 Dave Abrahams.
-# Copyright 2006 Rene Rivera.
+# Copyright 2006 Rene Ferdinand Rivera Morell.
 # 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)
@@ -236,12 +236,17 @@ class Tester(TestCmd.TestCmd):
                                     system output like the --verbose command
                                     line option does.
     """
-    def __init__(self, arguments=None, executable="b2",
+    def __init__(self, arguments=None, executable=None,
         match=TestCmd.match_exact, boost_build_path=None,
         translate_suffixes=True, pass_toolset=True, use_test_config=True,
         ignore_toolset_requirements=False, workdir="", pass_d0=False,
         **keywords):
 
+        if not executable:
+            executable = os.getenv('B2')
+        if not executable:
+            executable = 'b2'
+
         assert arguments.__class__ is not str
         self.original_workdir = os.path.dirname(__file__)
         if workdir and not os.path.isabs(workdir):
@@ -356,6 +361,12 @@ def copy(self, src, dst):
         except:
             self.fail_test(1)
 
+    def copy_timestamp(self, src, dst):
+        src_name = self.native_file_name(src)
+        dst_name = self.native_file_name(dst)
+        stats = os.stat(src_name)
+        os.utime(dst_name, (stats.st_atime, stats.st_mtime))
+
     def copy_preserving_timestamp(self, src, dst):
         src_name = self.native_file_name(src)
         dst_name = self.native_file_name(dst)
diff --git a/test/TestCmd.py b/test/TestCmd.py
index 7b53e9f403..1a9907a7f9 100644
--- a/test/TestCmd.py
+++ b/test/TestCmd.py
@@ -362,7 +362,7 @@ def preserve(self, *conditions):
         directories to be preserved for all conditions.
 
         """
-        if conditions is ():
+        if conditions == ():
             conditions = ('pass_test', 'fail_test', 'no_result')
         for cond in conditions:
             self._preserve[cond] = 1
diff --git a/test/configure.py b/test/configure.py
index 9e47af2e5e..b3d97520f3 100644
--- a/test/configure.py
+++ b/test/configure.py
@@ -33,8 +33,8 @@ def test_check_target_builds():
 """)
     t.run_build_system()
     t.expect_output_lines([
-        "    - pass builds              : yes",
-        "    - fail builds              : no"])
+        "    - pass builds              : yes*",
+        "    - fail builds              : no*"])
     t.expect_addition("bin/$toolset/debug*/pass.obj")
     t.expect_addition("bin/$toolset/debug*/foo.obj")
     t.expect_addition("bin/$toolset/debug*/bar.obj")
@@ -43,15 +43,15 @@ def test_check_target_builds():
     # An up-to-date build should use the cache
     t.run_build_system()
     t.expect_output_lines([
-        "    - pass builds              : yes (cached)",
-        "    - fail builds              : no  (cached)"])
+        "    - pass builds              : yes (cached)*",
+        "    - fail builds              : no  (cached)*"])
     t.expect_nothing_more()
 
     # -a should re-run everything, including configuration checks
     t.run_build_system(["-a"])
     t.expect_output_lines([
-        "    - pass builds              : yes",
-        "    - fail builds              : no"])
+        "    - pass builds              : yes*",
+        "    - fail builds              : no*"])
     t.expect_touch("bin/$toolset/debug*/pass.obj")
     t.expect_touch("bin/$toolset/debug*/foo.obj")
     t.expect_touch("bin/$toolset/debug*/bar.obj")
@@ -60,23 +60,23 @@ def test_check_target_builds():
     # --reconfigure should re-run configuration checks only
     t.run_build_system(["--reconfigure"])
     t.expect_output_lines([
-        "    - pass builds              : yes",
-        "    - fail builds              : no"])
+        "    - pass builds              : yes*",
+        "    - fail builds              : no*"])
     t.expect_touch("bin/$toolset/debug*/pass.obj")
     t.expect_nothing_more()
 
     # -a -n should not rebuild configuration checks
     t.run_build_system(["-a", "-n"])
     t.expect_output_lines([
-        "    - pass builds              : yes (cached)",
-        "    - fail builds              : no  (cached)"])
+        "    - pass builds              : yes (cached)*",
+        "    - fail builds              : no  (cached)*"])
     t.expect_nothing_more()
 
     # --clean-all should clear all configuration checks
     t.run_build_system(["--clean-all"])
     t.expect_output_lines([
-        "    - pass builds              : yes (cached)",
-        "    - fail builds              : no  (cached)"])
+        "    - pass builds              : yes (cached)*",
+        "    - fail builds              : no  (cached)*"])
     t.expect_removal("bin/$toolset/debug*/pass.obj")
     t.expect_removal("bin/$toolset/debug*/foo.obj")
     t.expect_removal("bin/$toolset/debug*/bar.obj")
@@ -96,8 +96,8 @@ def test_check_target_builds():
     # state here.
     t.run_build_system()
     t.expect_output_lines([
-        "    - pass builds              : yes",
-        "    - fail builds              : no"])
+        "    - pass builds              : yes*",
+        "    - fail builds              : no*"])
     t.expect_addition("bin/$toolset/debug*/pass.obj")
     t.expect_addition("bin/$toolset/debug*/foo.obj")
     t.expect_addition("bin/$toolset/debug*/bar.obj")
@@ -127,7 +127,7 @@ def test_choose():
 """)
     t.run_build_system()
     t.expect_output_lines([
-        "    - which one?               : pass"])
+        "    - which one?               : pass*"])
     t.expect_addition("bin/$toolset/debug*/pass.obj")
     t.expect_addition("bin/$toolset/debug*/foo.obj")
     t.expect_nothing_more()
@@ -135,34 +135,34 @@ def test_choose():
     # An up-to-date build should use the cache
     t.run_build_system()
     t.expect_output_lines([
-        "    - which one?               : pass (cached)"])
+        "    - which one?               : pass (cached)*"])
     t.expect_nothing_more()
 
     # -a should re-run everything, including configuration checks
     t.run_build_system(["-a"])
     t.expect_output_lines([
-        "    - which one?               : pass"])
+        "    - which one?               : pass*"])
     t.expect_touch("bin/$toolset/debug*/pass.obj")
     t.expect_touch("bin/$toolset/debug*/foo.obj")
     t.expect_nothing_more()
-    
+
     # --reconfigure should re-run configuration checks only
     t.run_build_system(["--reconfigure"])
     t.expect_output_lines([
-        "    - which one?               : pass"])
+        "    - which one?               : pass*"])
     t.expect_touch("bin/$toolset/debug*/pass.obj")
     t.expect_nothing_more()
 
     # -a -n should not rebuild configuration checks
     t.run_build_system(["-a", "-n"])
     t.expect_output_lines([
-        "    - which one?               : pass (cached)"])
+        "    - which one?               : pass (cached)*"])
     t.expect_nothing_more()
 
     # --clean-all should clear all configuration checks
     t.run_build_system(["--clean-all"])
     t.expect_output_lines([
-        "    - which one?               : pass (cached)"])
+        "    - which one?               : pass (cached)*"])
     t.expect_removal("bin/$toolset/debug*/pass.obj")
     t.expect_removal("bin/$toolset/debug*/foo.obj")
     t.expect_nothing_more()
@@ -180,7 +180,7 @@ def test_choose():
     # state here.
     t.run_build_system()
     t.expect_output_lines([
-        "    - which one?               : pass"])
+        "    - which one?               : pass*"])
     t.expect_addition("bin/$toolset/debug*/pass.obj")
     t.expect_addition("bin/$toolset/debug*/foo.obj")
     t.expect_nothing_more()
@@ -226,8 +226,8 @@ def test_translation():
 """)
     t.run_build_system(["subdir"])
     t.expect_output_lines([
-        "    - pass builds              : yes",
-        "    - fail builds              : no"])
+        "    - pass builds              : yes*",
+        "    - fail builds              : no*"])
     t.expect_addition("subdir/bin/$toolset/debug*/pass.obj")
     t.expect_addition("subdir/bin/$toolset/debug*/foo.obj")
     t.expect_addition("subdir/bin/$toolset/debug*/bar.obj")
@@ -252,12 +252,12 @@ def test_choose_none():
 """)
     t.run_build_system()
     t.expect_output_lines([
-        "    - which one?               : none"])
+        "    - which one?               : none*"])
 
     # An up-to-date build should use the cache
     t.run_build_system()
     t.expect_output_lines([
-        "    - which one?               : none (cached)"])
+        "    - which one?               : none (cached)*"])
     t.expect_nothing_more()
     t.cleanup()
 
diff --git a/test/core_at_file.py b/test/core_at_file.py
index 50fa51220f..a9ec49ba84 100755
--- a/test/core_at_file.py
+++ b/test/core_at_file.py
@@ -1,6 +1,7 @@
 #!/usr/bin/python
 
 # Copyright 2011 Steven Watanabe
+# Copyright 2020 Rene Ferdinand Rivera Morell
 # 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)
@@ -13,27 +14,27 @@
 t.write("file.jam", """\
 name = n1 n2 ;
 contents = M1 M2 ;
-EXIT "file:" "@(o$(name) .txt:E= test -D$(contents))" : 0 ;
+EXIT "file:" "@(o$(name:J=) .txt:E= test -D$(contents))" : 0 ;
 """)
 
 t.run_build_system()
-t.expect_output_lines("file: on1 on2 .txt");
-t.expect_addition("on1 on2 .txt")
-t.expect_content("on1 on2 .txt", " test -DM1 -DM2", True)
+t.expect_output_lines("file: on1n2 .txt")
+t.expect_addition("on1n2 .txt")
+t.expect_content("on1n2 .txt", " test -DM1 -DM2", True)
 
 t.rm(".")
 
 t.write("file.jam", """\
 name = n1 n2 ;
 contents = M1 M2 ;
-actions run { echo file: "@(o$(name) .txt:E= test -D$(contents))" }
+actions run { echo file: "@(o$(name:J=) .txt:E= test -D$(contents))" }
 run all ;
 """)
 
 t.run_build_system(["-d2"])
-t.expect_output_lines(' echo file: "on1 on2 .txt" ');
-t.expect_addition("on1 on2 .txt")
-t.expect_content("on1 on2 .txt", " test -DM1 -DM2", True)
+t.expect_output_lines(' echo file: "on1n2 .txt" ')
+t.expect_addition("on1n2 .txt")
+t.expect_content("on1n2 .txt", " test -DM1 -DM2", True)
 
 t.rm(".")
 
diff --git a/test/flags.py b/test/flags.py
index bdb2b6b7dc..c9af560c90 100644
--- a/test/flags.py
+++ b/test/flags.py
@@ -58,12 +58,12 @@
     BoostBuild.annotation("config.log", log_file)
     t.fail_test(True)
 
-t.expect_output_lines(['    - has --illegal-flag-cpp   : no',
-                       '    - has -DMACRO_CPP          : yes',
-                       '    - has --illegal-flag-c     : no',
-                       '    - has -DMACRO_C            : yes',
-                       '    - has --illegal-flag-link  : no',
-                       '    - has *bin*/input.* : yes'])
+t.expect_output_lines(['    - has --illegal-flag-cpp   : no*',
+                       '    - has -DMACRO_CPP          : yes*',
+                       '    - has --illegal-flag-c     : no*',
+                       '    - has -DMACRO_C            : yes*',
+                       '    - has --illegal-flag-link  : no*',
+                       '    - has *bin*/input.* : yes*'])
 t.expect_addition('bin/$toolset/debug*/fail_cpp.obj')
 t.expect_addition('bin/$toolset/debug*/pass_cpp.obj')
 t.expect_addition('bin/$toolset/debug*/fail_c.obj')
diff --git a/test/pch.py b/test/pch.py
index 6925cb3f4e..9e853eca53 100644
--- a/test/pch.py
+++ b/test/pch.py
@@ -1,6 +1,7 @@
 #!/usr/bin/python
 
 # Copyright 2006 Vladimir Prus.
+# Copyright Nikita Kniazev 2020.
 # 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)
@@ -20,27 +21,27 @@
 exe hello-afx : hello-afx.cpp pch-afx : <define>HELLO <include>. ;
 """)
 
-t.write("pch.hpp.bad", """
-THIS WILL NOT COMPILE
-""")
-
-# Note that pch.hpp is written after pch.hpp.bad, so its timestamp will not be
-# less than timestamp of pch.hpp.bad.
-sleep(1)
-t.write("pch.hpp", """
+pch_content = """\
 #undef HELLO
 class TestClass
 {
 public:
     TestClass( int, int ) {}
 };
-""")
+"""
+t.write("pch.hpp", pch_content)
 
 t.write("pch.cpp", """#include <pch.hpp>
 """)
 
+toolset = BoostBuild.get_toolset()
+# Clang with posix interface always include everything in source files
+if not toolset.startswith('clang') or toolset.startswith('clang-win'):
+    include = '#include <pch.hpp>'
+else:
+    include = ''
 for name in ("hello.cpp", "hello-afx.cpp"):
-    t.write(name, """#include <pch.hpp>
+    t.write(name, include + """
 int main() { TestClass c(1, 2); }
 """)
 
@@ -49,10 +50,14 @@ class TestClass
 t.expect_addition("bin/$toolset/debug*/hello-afx.exe")
 
 
-# Now make the header unusable, without changing timestamp. If everything is OK,
+# Now make the header unusable, replace its content with some garbage, but
+# preserve the size and timestamp to fool the compiler. If everything is OK,
 # B2 will not recreate PCH, and compiler will happily use pre-compiled
 # header, not noticing that the real header is bad.
 
+s = "THIS WILL NOT COMPILE. "
+t.write("pch.hpp.bad", s + (len(pch_content) - len(s)) * 'x')
+t.copy_timestamp("pch.hpp", "pch.hpp.bad")
 t.copy_preserving_timestamp("pch.hpp.bad", "pch.hpp")
 
 t.rm("bin/$toolset/debug*/hello.obj")
diff --git a/test/searched_lib.py b/test/searched_lib.py
index 2081230a12..5c1da5f35b 100644
--- a/test/searched_lib.py
+++ b/test/searched_lib.py
@@ -163,6 +163,22 @@
 t.run_build_system(["-n"])
 
 
+# A regression test. Virtual targets distinguished by their search paths were
+# not differentiated when registered, which caused search paths to be selected
+# incorrectly for build requests with multiple feature values.
+t.write("jamroot.jam", "")
+t.write("a.cpp", "")
+t.write("jamfile.jam", """\
+exe a : a.cpp l ;
+lib l : : <name>l <search>lib32 <address-model>32 ;
+lib l : : <name>l <search>lib64 <address-model>64 ;
+""")
+
+t.run_build_system(["-n","address-model=32,64"])
+t.fail_test(t.stdout().find("lib32") == -1)
+t.fail_test(t.stdout().find("lib64") == -1)
+
+
 # Make sure plain "lib foobar ; " works.
 t.write("jamfile.jam", """\
 exe a : a.cpp foobar ;
diff --git a/test/test_all.py b/test/test_all.py
index ebb6a8cf92..307e8bef71 100644
--- a/test/test_all.py
+++ b/test/test_all.py
@@ -324,9 +324,8 @@ def reorder_tests(tests, first_test):
     # assumes otherwise. Hence enable it only when not on Windows.
     tests.append("gcc_runtime")
 
-# PCH test seems broken in strange ways. Disable it.
-# if toolset.startswith("gcc") or toolset.startswith("msvc"):
-#     tests.append("pch")
+if toolset.startswith("clang") or toolset.startswith("gcc") or toolset.startswith("msvc"):
+    tests.append("pch")
 
 # Disable on OSX as it doesn't seem to work for unknown reasons.
 if sys.platform != 'darwin':
diff --git a/test/toolset-mock/src/MockProgram.py b/test/toolset-mock/src/MockProgram.py
index 795b8676d5..886197ac57 100644
--- a/test/toolset-mock/src/MockProgram.py
+++ b/test/toolset-mock/src/MockProgram.py
@@ -1,4 +1,6 @@
+# coding: utf-8
 # Copyright 2017 Steven Watanabe
+# Copyright 2020 René Ferdinand Rivera Morell
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
@@ -120,6 +122,17 @@ def match(self, command_line, pos, outputs):
         if s.startswith(self.prefix) and try_match([s[len(self.prefix):]], 0, self.a, outputs) == 1:
             return pos + 1
 
+#
+class opt(object):
+    def __init__(self, *args):
+        self.args = args
+    def match(self, command_line, pos, outputs):
+        for p in self.args:
+            res = try_match_one(command_line, pos, p, outputs)
+            if res is not None:
+                pos = res
+        return pos
+
 # Given a file id, returns a string that will be
 # written to the file to allow it to be recognized.
 def make_file_contents(id):
diff --git a/test/toolset-mock/src/ar.py b/test/toolset-mock/src/ar.py
index 853fe1dd8b..dec40bd074 100644
--- a/test/toolset-mock/src/ar.py
+++ b/test/toolset-mock/src/ar.py
@@ -1,6 +1,8 @@
 #!/usr/bin/python
+# coding: utf-8
 #
 # Copyright 2017-2018 Steven Watanabe
+# Copyright 2020 René Ferdinand Rivera Morell
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,5 +22,6 @@
 command('ar', 'rc', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/libl1.a'), input_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/lib.o'))
 command('ar', 'rcu', output_file('bin/clang-vxworks-4.0.1/debug/link-static/libl1.a'), input_file('bin/clang-vxworks-4.0.1/debug/link-static/lib.o'))
 command('ar', 'rcu', output_file('bin/clang-vxworks-4.0.1/debug/link-static/runtime-link-static/libl1.a'), input_file('bin/clang-vxworks-4.0.1/debug/link-static/runtime-link-static/lib.o'))
+command('ar', 'rc', output_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/libl1.lib'), input_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/lib.obj'))
 
 main()
diff --git a/test/toolset-mock/src/clang-linux-3.9.0.py b/test/toolset-mock/src/clang-linux-3.9.0.py
index 02d28db541..424acb02ac 100644
--- a/test/toolset-mock/src/clang-linux-3.9.0.py
+++ b/test/toolset-mock/src/clang-linux-3.9.0.py
@@ -1,7 +1,8 @@
 #!/usr/bin/python
+# coding: utf-8
 #
 # Copyright 2017 Steven Watanabe
-# Copyright 2020 Rene Rivera
+# Copyright 2020 René Ferdinand Rivera Morell
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
@@ -12,38 +13,76 @@
 command('clang++', '-print-prog-name=ar', stdout=script('ar.py'))
 command('clang++', '-print-prog-name=ranlib', stdout=script('ranlib.py'))
 
-if allow_properties('variant=debug', 'link=shared', 'threading=single', 'runtime-link=shared'):
+# target-os=linux ..
+
+if allow_properties('target-os=linux', 'variant=debug', 'link=shared', 'threading=single', 'runtime-link=shared'):
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-fPIC', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/lib.o'), input_file(source='lib.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/libl1.so'), arg_file('@bin/clang-linux-3.9.0/debug*/libl1.so.rsp'), unordered('-g', '-fPIC'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/libl1.so'), '-Wl,-soname', '-Wl,libl1.so', '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/lib.o'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-fPIC'))
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-fPIC', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/main.o'), input_file(source='main.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/test'), arg_file('@bin/clang-linux-3.9.0/debug*/test.rsp'), unordered('-g', '-fPIC'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/test'), '-Wl,-R', arg('-Wl,', target_path('bin/clang-linux-3.9.0/debug/libl1.so')), '-Wl,-rpath-link', arg('-Wl,', target_path('bin/clang-linux-3.9.0/debug/libl1.so')), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/main.o'), input_file('bin/clang-linux-3.9.0/debug/libl1.so'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-fPIC'))
 
-if allow_properties('variant=release', 'link=shared', 'threading=single', 'runtime-link=shared', 'strip=on'):
+if allow_properties('target-os=linux', 'variant=release', 'link=shared', 'threading=single', 'runtime-link=shared', 'strip=on'):
     command('clang++', unordered(ordered('-x', 'c++'), '-O3', '-Wno-inline', '-Wall', '-fPIC', '-DNDEBUG', '-c'), '-o', output_file('bin/clang-linux-3.9.0/release/lib.o'), input_file(source='lib.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/release/strip-on/libl1.so'), arg_file('@bin/clang-linux-3.9.0/release/strip-on*/libl1.so.rsp'), unordered('-fPIC', '-Wl,--strip-all'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/release/libl1.so'), '-Wl,-soname', '-Wl,libl1.so', '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/release/lib.o'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-fPIC', '-Wl,--strip-all'))
     command('clang++', unordered(ordered('-x', 'c++'), '-O3', '-Wno-inline', '-Wall', '-fPIC', '-DNDEBUG', '-c'), '-o', output_file('bin/clang-linux-3.9.0/release/main.o'), input_file(source='main.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/release/test'), arg_file('@bin/clang-linux-3.9.0/release/strip-on*/test.rsp'), unordered('-fPIC', '-Wl,--strip-all'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/release/test'), '-Wl,-R', arg('-Wl,', target_path('bin/clang-linux-3.9.0/release/libl1.so')), '-Wl,-rpath-link', arg('-Wl,', target_path('bin/clang-linux-3.9.0/release/libl1.so')), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/release/main.o'), input_file('bin/clang-linux-3.9.0/release/libl1.so'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-fPIC', '-Wl,--strip-all'))
 
-if allow_properties('variant=debug', 'link=shared', 'threading=multi', 'runtime-link=shared'):
+if allow_properties('target-os=linux', 'variant=debug', 'link=shared', 'threading=multi', 'runtime-link=shared'):
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-pthread', '-fPIC', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/threading-multi/lib.o'), input_file(source='lib.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/threading-multi/libl1.so'), arg_file('@bin/clang-linux-3.9.0/debug*/threading-multi/libl1.so.rsp'), unordered('-g', '-pthread', '-fPIC'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/threading-multi/libl1.so'), '-Wl,-soname', '-Wl,libl1.so', '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/threading-multi/lib.o'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-lrt', '-Wl,--end-group', unordered('-g', '-pthread', '-fPIC'))
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-pthread', '-fPIC', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/threading-multi/main.o'), input_file(source='main.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/threading-multi/test'), arg_file('@bin/clang-linux-3.9.0/debug*/threading-multi/test.rsp'), unordered('-g', '-pthread', '-fPIC'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/threading-multi/test'), '-Wl,-R', arg('-Wl,', target_path('bin/clang-linux-3.9.0/debug/threading-multi/libl1.so')), '-Wl,-rpath-link', arg('-Wl,', target_path('bin/clang-linux-3.9.0/debug/threading-multi/libl1.so')), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/threading-multi/main.o'), input_file('bin/clang-linux-3.9.0/debug/threading-multi/libl1.so'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-lrt', '-Wl,--end-group', unordered('-g', '-pthread', '-fPIC'))
 
-if allow_properties('variant=debug', 'link=static', 'threading=single', 'runtime-link=shared'):
+if allow_properties('target-os=linux', 'variant=debug', 'link=static', 'threading=single', 'runtime-link=shared'):
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/lib.o'), input_file(source='lib.cpp'))
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/main.o'), input_file(source='main.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/test'), arg_file('@bin/clang-linux-3.9.0/debug/link-static*/test.rsp'), '-g')
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/test'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/link-static/main.o'), input_file('bin/clang-linux-3.9.0/debug/link-static/libl1.a'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', '-g')
 
-if allow_properties('variant=debug', 'link=static', 'threading=single', 'runtime-link=static'):
+if allow_properties('target-os=linux', 'variant=debug', 'link=static', 'threading=single', 'runtime-link=static'):
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/lib.o'), input_file(source='lib.cpp'))
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/main.o'), input_file(source='main.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/test'), arg_file('@bin/clang-linux-3.9.0/debug/link-static/runtime-link-static*/test.rsp'), unordered('-g', '-static'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/test'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/main.o'), input_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/libl1.a'), '-Wl,--end-group', unordered('-g', '-static'))
 
-if allow_properties('variant=debug', 'link=shared', 'threading=single', 'runtime-link=shared', 'architecture=x86', 'address-model=32'):
+if allow_properties('target-os=linux', 'variant=debug', 'link=shared', 'threading=single', 'runtime-link=shared', 'architecture=x86', 'address-model=32'):
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-march=i686', '-m32', '-fPIC', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/lib.o'), input_file(source='lib.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/libl1.so'), arg_file('@bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86*/libl1.so.rsp'), unordered('-g', '-march=i686', '-fPIC', '-m32'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/libl1.so'), '-Wl,-soname', '-Wl,libl1.so', '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/lib.o'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-march=i686', '-fPIC', '-m32'))
     command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-march=i686', '-m32', '-fPIC', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/main.o'), input_file(source='main.cpp'))
-    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/test'), arg_file('@bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86*/test.rsp'), unordered('-g', '-march=i686', '-fPIC', '-m32'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/test'), '-Wl,-R', arg('-Wl,', target_path('bin/clang-linux-3.9.0/debug/libl1.so')), '-Wl,-rpath-link', arg('-Wl,', target_path('bin/clang-linux-3.9.0/debug/libl1.so')), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/main.o'), input_file('bin/clang-linux-3.9.0/debug/libl1.so'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-march=i686', '-fPIC', '-m32'))
+
+# target-os=windows ..
+
+if allow_properties('target-os=windows', 'variant=debug', 'link=shared', 'threading=single', 'runtime-link=shared'):
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/target-os-windows/lib.obj'), input_file(source='lib.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/target-os-windows/l1.dll'), '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/target-os-windows/lib.obj'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g'))
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/target-os-windows/main.obj'), input_file(source='main.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/target-os-windows/test.exe'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/target-os-windows/main.obj'), input_file('bin/clang-linux-3.9.0/debug/target-os-windows/l1.dll'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g'))
+
+if allow_properties('target-os=windows', 'variant=release', 'link=shared', 'threading=single', 'runtime-link=shared', 'strip=on'):
+    command('clang++', unordered(ordered('-x', 'c++'), '-O3', '-Wno-inline', '-Wall', '-DNDEBUG', '-c'), '-o', output_file('bin/clang-linux-3.9.0/release/target-os-windows/lib.obj'), input_file(source='lib.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/release/strip-on/target-os-windows/l1.dll'), '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/release/target-os-windows/lib.obj'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-Wl,--strip-all'))
+    command('clang++', unordered(ordered('-x', 'c++'), '-O3', '-Wno-inline', '-Wall', '-DNDEBUG', '-c'), '-o', output_file('bin/clang-linux-3.9.0/release/strip-on/target-os-windows/main.obj'), input_file(source='main.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/release/test'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/release/strip-on/target-os-windows/main.obj'), input_file('bin/clang-linux-3.9.0/release/strip-on/target-os-windows/l1.dll'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-Wl,--strip-all'))
+
+if allow_properties('target-os=windows', 'variant=debug', 'link=shared', 'threading=multi', 'runtime-link=shared'):
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-pthread', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/target-os-windows/threading-multi/lib.obj'), input_file(source='lib.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/target-os-windows/threading-multi/l1.dll'), '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/target-os-windows/threading-multi/lib.obj'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-pthread'))
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-pthread', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/target-os-windows/threading-multi/main.obj'), input_file(source='main.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/threading-multi/test'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/target-os-windows/threading-multi/main.obj'), input_file('bin/clang-linux-3.9.0/debug/target-os-windows/threading-multi/l1.dll'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-pthread'))
+
+if allow_properties('target-os=windows', 'variant=debug', 'link=static', 'threading=single', 'runtime-link=shared'):
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/lib.obj'), input_file(source='lib.cpp'))
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/main.obj'), input_file(source='main.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/test.exe'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/main.obj'), input_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/libl1.lib'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', '-g')
+
+if allow_properties('target-os=windows', 'variant=debug', 'link=static', 'threading=single', 'runtime-link=static'):
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/target-os-windows/lib.obj'), input_file(source='lib.cpp'))
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/target-os-windows/main.obj'), input_file(source='main.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/target-os-windows/test.exe'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/main.obj'), input_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/libl1.lib'), '-Wl,--end-group', unordered('-g', '-static'))
+
+if allow_properties('target-os=windows', 'variant=debug', 'link=shared', 'threading=single', 'runtime-link=shared', 'architecture=x86', 'address-model=32'):
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-march=i686', '-m32', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86/target-os-windows/lib.obj'), input_file(source='lib.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86/target-os-windows/l1.dll'), '-shared', '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86/target-os-windows/lib.obj'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-march=i686', '-m32'))
+    command('clang++', unordered(ordered('-x', 'c++'), '-O0', '-fno-inline', '-Wall', '-g', '-march=i686', '-m32', '-c'), '-o', output_file('bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86/target-os-windows/main.obj'), input_file(source='main.cpp'))
+    command('clang++', '-o', output_file('bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86/target-os-windows/test.exe'), '-Wl,--start-group', input_file('bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86/target-os-windows/main.obj'), input_file('bin/clang-linux-3.9.0/debug/address-model-32/architecture-x86/target-os-windows/l1.dll'), '-Wl,-Bstatic', '-Wl,-Bdynamic', '-Wl,--end-group', unordered('-g', '-march=i686', '-m32'))
 
 main()
diff --git a/test/toolset-mock/src/ranlib.py b/test/toolset-mock/src/ranlib.py
index 4abe21ed0f..42d8ee343a 100644
--- a/test/toolset-mock/src/ranlib.py
+++ b/test/toolset-mock/src/ranlib.py
@@ -1,6 +1,8 @@
 #!/usr/bin/python
+# coding: utf-8
 #
 # Copyright 2017 Steven Watanabe
+# Copyright 2020 René Ferdinand Rivera Morell
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
@@ -18,5 +20,6 @@
 command('ranlib', '-cs', input_file('bin/intel-darwin-10.2/debug/link-static/runtime-link-static/target-os-darwin/libl1.a'))
 command('ranlib', input_file('bin/clang-linux-3.9.0/debug/link-static/libl1.a'))
 command('ranlib', input_file('bin/clang-linux-3.9.0/debug/link-static/runtime-link-static/libl1.a'))
+command('ranlib', input_file('bin/clang-linux-3.9.0/debug/link-static/target-os-windows/libl1.lib'))
 
 main()
diff --git a/test/toolset_clang_linux.py b/test/toolset_clang_linux.py
index 2fbf84b6d0..5bc287378b 100644
--- a/test/toolset_clang_linux.py
+++ b/test/toolset_clang_linux.py
@@ -1,6 +1,8 @@
 #!/usr/bin/python
+# coding: utf-8
 #
 # Copyright 2017 Steven Watanabe
+# Copyright 2020 René Ferdinand Rivera Morell
 #
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at
@@ -17,3 +19,11 @@
     ["target-os=linux", "link=static"],
     ["target-os=linux", "link=static", "runtime-link=static"],
     ["target-os=linux", "architecture=x86", "address-model=32"]])
+
+test_toolset("clang-linux", "3.9.0", [
+    ["target-os=windows"],
+    ["target-os=windows", "release", "strip=on"],
+    ["target-os=windows", "threading=multi"],
+    ["target-os=windows", "link=static"],
+    ["target-os=windows", "architecture=x86", "address-model=32"]
+    ])