Update Jamfile to generate dependencies

Add cmake files
2017-06-24 03:45:04 +03:00 · 2017-06-24 00:38:16 +03:00
43 changed files with 1551 additions and 2597 deletions
@@ -1,4 +1,4 @@
-# Copyright 2016, 2017, 2018 Peter Dimov
+# Copyright 2016 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)

@@ -8,11 +8,14 @@ sudo: false

 python: "2.7"

+os:
+  - linux
+  - osx
+
 branches:
  only:
    - master
    - develop
-    - /feature\/.*/

 env:
  matrix:
@@ -25,32 +28,10 @@ matrix:

  include:
    - os: linux
-      compiler: g++
-      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03

    - os: linux
-      compiler: g++-4.4
-      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.4
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.6
-      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
-      addons:
-        apt:
-          packages:
-            - g++-4.6
-          sources:
-            - ubuntu-toolchain-r-test
-
-    - os: linux
-      compiler: g++-4.7
-      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -59,17 +40,34 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-4.8
-      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++03
      addons:
        apt:
          packages:
            - g++-4.8
          sources:
            - ubuntu-toolchain-r-test
+
    - os: linux
-      compiler: g++-4.9
-      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -78,8 +76,16 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-5
-      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -88,8 +94,25 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-6
-      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -98,70 +121,40 @@ matrix:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-7
-      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
      addons:
        apt:
          packages:
-            - g++-7
+            - g++-6
          sources:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
      addons:
        apt:
          packages:
-            - g++-8
+            - g++-6
          sources:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: g++-8
-      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
      addons:
        apt:
          packages:
-            - g++-8
+            - g++-6
          sources:
            - ubuntu-toolchain-r-test

    - os: linux
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03

    - os: linux
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.3
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11

    - os: linux
-      compiler: /usr/bin/clang++
-      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
-      addons:
-        apt:
-          packages:
-            - clang-3.4
-
-    - os: linux
-      compiler: clang++-3.5
-      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.5
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.5
-
-    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -171,20 +164,17 @@ matrix:
            - llvm-toolchain-precise-3.6

    - os: linux
-      compiler: clang++-3.6
-      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
      addons:
        apt:
          packages:
            - clang-3.6
-            - libstdc++-4.9-dev
          sources:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-precise-3.6

    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -194,20 +184,17 @@ matrix:
            - llvm-toolchain-precise-3.7

    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
      addons:
        apt:
          packages:
            - clang-3.7
-            - libstdc++-4.9-dev
          sources:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-precise-3.7

    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -217,20 +204,37 @@ matrix:
            - llvm-toolchain-precise-3.8

    - os: linux
-      compiler: clang++-3.8
-      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++11
      addons:
        apt:
          packages:
            - clang-3.8
-            - libstdc++-4.9-dev
          sources:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-precise-3.8

    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++03
      addons:
        apt:
          packages:
@@ -240,122 +244,50 @@ matrix:
            - llvm-toolchain-precise-3.9

    - os: linux
-      compiler: clang++-3.9
-      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
      addons:
        apt:
          packages:
            - clang-3.9
-            - libstdc++-4.9-dev
          sources:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-precise-3.9

    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
      addons:
        apt:
          packages:
-            - clang-4.0
+            - clang-3.9
          sources:
            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
+            - llvm-toolchain-precise-3.9

    - os: linux
-      compiler: clang++-4.0
-      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
      addons:
        apt:
          packages:
-            - clang-4.0
-            - libstdc++-4.9-dev
+            - clang-3.9
          sources:
            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-4.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-5.0
-      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-5.0
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-            - libstdc++-4.9-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-6.0
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-6.0
-            - libstdc++-5-dev
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
-
-    - os: linux
-      compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - libc++-dev
-
-    - os: linux
-      compiler: clang++-libc++
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - libc++-dev
+            - llvm-toolchain-precise-3.9

    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++14
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++1z

 install:
-  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
  - cd ..
-  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
  - cd boost-root
  - git submodule update --init tools/build
  - git submodule update --init libs/config
@@ -367,8 +299,8 @@ install:

 script:
  - |-
-    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 -j3 libs/system/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
+    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
+  - ./b2 libs/system/test toolset=$TOOLSET

 notifications:
  email:
@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.5)
+
+include(cmake/BoostVersion.cmake)
+set(BOOST_PROJECT_NAME system)
+
+project(boost_${BOOST_PROJECT_NAME} VERSION ${BOOST_VERSION} LANGUAGES CXX)
+
+include(cmake/default.cmake)
@@ -10,7 +10,6 @@ branches:
  only:
    - master
    - develop
-    - /feature\/.*/

 environment:
  matrix:
@@ -22,47 +21,38 @@ environment:
      TOOLSET: msvc-11.0
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXFLAGS: cxxflags=-std=c++03
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXFLAGS: cxxflags=-std=c++11
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXFLAGS: cxxflags=-std=c++03
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXFLAGS: cxxflags=-std=c++11
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXFLAGS: cxxflags=-std=c++03
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXFLAGS: cxxflags=-std=c++11
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      TOOLSET: msvc-14.0
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1
-      CXXSTD: 17
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\cygwin\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\cygwin64\bin;
-      TOOLSET: gcc
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\cygwin64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw\bin;
-      TOOLSET: gcc
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
-      TOOLSET: gcc
-      CXXSTD: 03,11

 install:
-  - set BOOST_BRANCH=develop
-  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
  - cd ..
-  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
  - cd boost-root
  - git submodule update --init tools/build
  - git submodule update --init libs/config
@@ -70,11 +60,10 @@ install:
  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\system
  - python tools/boostdep/depinst/depinst.py system
  - cmd /c bootstrap
-  - b2 -d0 headers
+  - b2 headers

 build: off

 test_script:
  - PATH=%ADDPATH%%PATH%
-  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - b2 -j3 libs/system/test toolset=%TOOLSET% variant=debug,release %CXXSTD%
+  - b2 libs/system/test toolset=%TOOLSET% %CXXFLAGS%
@@ -0,0 +1 @@
+set(BOOST_VERSION 1.65.0)
@@ -0,0 +1,20 @@
+# Update cmake files
+
+install BoostVersion_ : ../../../BoostVersion.cmake : <location>. ;
+install default_ : ../../../cmake/default.cmake : <location>. ;
+
+# Update dependencies
+
+import path ;
+
+path-constant LIBDIR : .. ;
+
+actions boostdep-cmake
+{
+    "$(LIBDIR)/../../dist/bin/boostdep" --cmake $(LIBDIR:B) > $(1)
+}
+
+make dependencies.cmake : : @boostdep-cmake ;
+always dependencies.cmake ;
+
+install dependencies_ : dependencies.cmake : <location>. ;
@@ -0,0 +1,103 @@
+#
+# Default CMakeLists.txt contents for a Boost library
+#
+
+# sources.cmake defines ${PROJECT_NAME}_SOURCES
+include(cmake/sources.cmake)
+
+if("${${PROJECT_NAME}_SOURCES}" STREQUAL "")
+
+  # if no sources, this is a header-only library
+  add_library(boost_${BOOST_PROJECT_NAME} INTERFACE)
+
+  # include directory
+  target_include_directories(${PROJECT_NAME} INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+  )
+
+else()
+
+  # a library that requires building
+  add_library(${PROJECT_NAME} ${${PROJECT_NAME}_SOURCES})
+
+  # include directory
+  target_include_directories(${PROJECT_NAME} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+  )
+
+endif()
+
+# add namespaced alias
+add_library(boost::${BOOST_PROJECT_NAME} ALIAS ${PROJECT_NAME})
+
+# set imported target name to the unqualified name, it will be namespaced
+set_property(TARGET ${PROJECT_NAME} PROPERTY EXPORT_NAME ${BOOST_PROJECT_NAME})
+
+# link to dependencies
+include(CMakeFindDependencyMacro)
+
+function(boost_declare_dependency package type target)
+
+  target_link_libraries(${PROJECT_NAME} ${type} ${target})
+
+  if(${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_SOURCE_DIR})
+
+    find_dependency(${package} ${PROJECT_VERSION} EXACT)
+
+  endif()
+
+endfunction()
+
+include(cmake/dependencies.cmake)
+
+# target installation
+install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}-targets
+    RUNTIME DESTINATION bin
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    INCLUDES DESTINATION include
+)
+
+# header installation
+install(DIRECTORY include/ DESTINATION include)
+
+# export target info to ${PROJECT_NAME}-targets.cmake, used by -config.cmake
+install(EXPORT ${PROJECT_NAME}-targets
+  FILE ${PROJECT_NAME}-targets.cmake
+  NAMESPACE boost::
+  DESTINATION lib/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+)
+
+# install -dependencies.cmake, used by -config.cmake
+
+install(FILES cmake/dependencies.cmake
+  DESTINATION lib/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+  RENAME ${PROJECT_NAME}-dependencies.cmake
+)
+
+# write ${PROJECT_NAME}-config.cmake
+file(WRITE "${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake" "
+include(\${CMAKE_CURRENT_LIST_DIR}/${PROJECT_NAME}-targets.cmake)
+include(CMakeFindDependencyMacro)
+function(boost_declare_dependency package type target)
+  find_dependency(\${package} ${PROJECT_VERSION} EXACT)
+endfunction()
+include(\${CMAKE_CURRENT_LIST_DIR}/${PROJECT_NAME}-dependencies.cmake)
+")
+
+include(CMakePackageConfigHelpers)
+
+# write ${PROJECT_NAME}-config-version.cmake
+write_basic_package_version_file("${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY AnyNewerVersion
+)
+
+# install -config, -config-version
+install(FILES
+    "${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake"
+    "${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake"
+  DESTINATION lib/cmake/${PROJECT_NAME}-${PROJECT_VERSION}
+)
@@ -0,0 +1,8 @@
+# Generated file. Do not edit.
+
+boost_declare_dependency(boost_assert PUBLIC boost::assert)
+boost_declare_dependency(boost_config PUBLIC boost::config)
+boost_declare_dependency(boost_core PUBLIC boost::core)
+boost_declare_dependency(boost_predef PUBLIC boost::predef)
+boost_declare_dependency(boost_winapi PUBLIC boost::winapi)
+
@@ -0,0 +1,3 @@
+set(${PROJECT_NAME}_SOURCES
+  src/error_code.cpp
+)
@@ -60,7 +60,8 @@
      &nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-constructors">Class <code>error_condition</code> constructors</a><br>
      &nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-modifiers">Class <code>error_condition</code> modifiers</a><br>
      &nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-observers">Class <code>error_condition</code> observers</a><br>
-      <a href="#Function-boost-throws">Function <code>boost::throws()</code></a><br>
+      <a href="#throws-object"><code>throws</code> object</a><br>
+      <a href="#Semantics-of-throws">Semantics of <code>throws</code> object</a><br>
      <a href="#Non-member-functions">Non-member functions</a><br>
      <a href="#Header-system_error">Header &lt;boost/system/system_error.hpp&gt;</a><br>
      &nbsp;&nbsp;&nbsp;<a href="#Class-system_error">Class <code>system_error</code></a><br>
@@ -80,7 +81,7 @@ noexcept</code> and explicit conversion operators. The actual implementation
 uses C++11 features only when they are available, and otherwise falls back on 
 C++03 features.</p>
 <h2><a name="Macros">Macros</a></h2>
-<p>Users may define the following macros if desired. Sensible defaults are
+<p>Users may defined the following macros if desired. Sensible defaults are 
 provided, so users may ignore these macros if they prefer.</p>
 <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" height="368">
  <tr>
@@ -109,16 +110,17 @@ provided, so users may ignore these macros if they prefer.</p>
    facility.</td>
  </tr>
  <tr>
-    <td valign="top" height="32"><code>BOOST_SYSTEM_ENABLE_DEPRECATED</code></td>
+    <td valign="top" height="32"><code>BOOST_SYSTEM_NO_DEPRECATED</code></td>
    <td valign="top" height="32">Not defined.</td>
-    <td valign="top" height="32">Deprecated features are provided for compatibility.</td>
+    <td valign="top" height="32">Deprecated features are excluded.</td>
  </tr>
  </table>
 <h2><a name="Deprecated-names">Deprecated names</a></h2>
-<p>In the process of adding Boost.System to the C++11 standard library, the
-C++ committee changed some names. To ease transition, Boost.System deprecates
-the old names, but will provide them when the macro
-<code>BOOST_SYSTEM_ENABLE_DEPRECATED</code> is defined.</p>
+<p>In the process of adding Boost.System to C++0x standard library, the C++ 
+committee changed some  
+names. To ease transition, Boost.System deprecates the old 
+names, but continues to provide them unless macro <code>BOOST_SYSTEM_NO_DEPRECATED</code> 
+is defined.</p>
 <table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
  <tr>
    <td><b><i>Old usage, now deprecated</i></b></td>
@@ -314,12 +316,8 @@ fixed by globally adding () to these names to turn them into function calls.</p>
        operator&lt;&lt;( basic_ostream&lt;charT,traits&gt;&amp; os, const error_code &amp; ec );

    size_t hash_value( const error_code &amp; ec );
-
-  } // namespace system
-
-  system::error_code &amp; throws();
-    
-} // namespace boost</pre>
+  }
+}</pre>
 </blockquote>
 <p>The value of each<code> errc_t</code> constant shall be the same as the 
 value of the <code>&lt;cerrno&gt;</code> macro shown in the above synopsis.</p>
@@ -646,6 +644,36 @@ observers</a></h3>
  <code>int</code>) that can occur with <code>bool</code> are not allowed, 
  eliminating some sources of user error. One possible implementation choice for 
  this type is pointer to member. <i>--end note</i> <i>]</i></p>
+</blockquote>
+  <h2><a name="throws-object"><code>throws</code> object</a></h2>
+  <pre>extern error_code throws;</pre>
+<p>The predefined <code>error_code</code> object <code>throws</code> is supplied 
+for use as a &quot;throw on error&quot; tag.</p>
+<h2><a name="Semantics-of-throws">Semantics of <code>throws</code></a> object</h2>
+<p>Functions that specify an argument in the form <code>error_code&amp; ec=throws</code>, 
+with appropriate namespace qualifiers, have the following error handling 
+semantics:</p>
+<blockquote>
+  <p><i>Postconditions:</i></p>
+  <blockquote>
+    <p>If <code>&amp;ec != &amp;throws</code> and an error occurred:</p>
+    <ul>
+      <li> <code>ec.value()</code> returns the implementation specific error 
+      number for the particular error that occurred.</li>
+      <li><code>ec.category()</code> returns the <code>
+    <a href="#Class-error_category">error_category</a></code> for <code>ec.value()</code>.</li>
+    </ul>
+    <p>if <code>&amp;ec != &amp;throws</code> and an error did not occur, <code>ec.clear()</code>.</p>
+  </blockquote>
+  <p><i>Throws:</i></p>
+  <blockquote>
+  <p>If an error occurs and <code>&amp;ec == &amp;throws</code>, throws an exception of type
+  <code><a href="#Class-system_error">system_error</a></code> or of a type 
+  derived from <code><a href="#Class-system_error">system_error</a></code>. The 
+  exception's <code>code()</code> member function returns a reference to an
+  <code>error_code</code> object with the behavior specified in <i>
+  Postconditions</i>.</p>
+  </blockquote>
 </blockquote>
 <h2><a name="Non-member-functions">Non-member functions</a></h2>
  <pre>bool operator==( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;</pre>
@@ -708,37 +736,6 @@ bool operator!=( const error_condition &amp; condition, const error_code &amp; c
  <p><i>Returns: </i>&nbsp;A hash value representing <code>ec</code>.</p>
 </blockquote>

-<h2><a name="Function-boost-throws">Function <code>boost::throws()</code></a></h2>
-
-  <pre>system::error_code&amp; throws();</pre>
-<blockquote>
-<p><i>Returns:</i> A <code>system::error_code</code> reference 
-for use in some user-defined function signature as a &quot;throw on error&quot; tag.</p>
-<p><i>Remark:</i> The only valid use for the returned reference is to test its 
-address for equality or inequality to the address of the reference returned by 
-another call to throws(). The returned reference itself has been poisoned so 
-that an attempt to dereference it will fail.</p>
-<p>[<i>Example: </i>Example of a function that uses the <code>throws()</code> idiom:</p>
-  <blockquote>
-  <pre>int divide(int dividend, int divisor,
-           boost::system::error_code&amp; ec = boost::throws())
-{
-  if (divisor == 0)                             // is there an error?
-  {
-    if (&amp;ec == &amp;boost::throws())                // throw on error
-      throw &quot;oops!&quot;;                            // whatever exception you prefer
-    ec = error_code(EDOM, generic_category());  // report error via error_code
-    return 0;
-  }
-
-  if (&amp;ec != &amp;boost::throws())                  // error reporting via error_code
-    ec.clear();
-  return dividend / divisor;
-}</pre>
-  </blockquote>
-  <p>&mdash; <i>end Example</i>]</p>
-</blockquote>
-
 <h2><a name="Header-system_error">Header &lt;boost/system/system_error.hpp&gt;</a></h2>

 <h3><a name="Class-system_error">Class <code>
@@ -821,7 +818,7 @@ application program interfaces.</p>
 <hr>

 <p>Revised 
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->September 07, 2017<!--webbot bot="Timestamp" endspan i-checksum="38006" --> </font>
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->January 06, 2014<!--webbot bot="Timestamp" endspan i-checksum="31400" --> </font>
 </p>

 <p>© Copyright Beman Dawes, 2006, 2007, 2008, 2013</p>
@@ -7,16 +7,15 @@

 //  See http://www.boost.org/libs/system for documentation.

-#ifndef BOOST_SYSTEM_CONFIG_HPP
+#ifndef BOOST_SYSTEM_CONFIG_HPP                  
 #define BOOST_SYSTEM_CONFIG_HPP

 #include <boost/config.hpp>
+#include <boost/predef/platform.h>
 #include <boost/system/api_config.hpp>  // for BOOST_POSIX_API or BOOST_WINDOWS_API

-// This header implemented separate compilation features as described in
+// This header implements separate compilation features as described in
 // http://www.boost.org/more/separate_compilation.html
-//
-// It's only retained for compatibility now that the library is header-only.

 //  normalize macros  ------------------------------------------------------------------//

@@ -47,4 +46,25 @@
 # define BOOST_SYSTEM_DECL
 #endif

+//  enable automatic library variant selection  ----------------------------------------// 
+
+#if !defined(BOOST_SYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SYSTEM_NO_LIB)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_system
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
+#  define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif  // auto-linking disabled
+
 #endif // BOOST_SYSTEM_CONFIG_HPP
+
@@ -1,53 +0,0 @@
-#ifndef BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
-#define BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
-
-// Copyright 2018 Peter Dimov
-//
-// 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)
-//
-// See http://www.boost.org/libs/system for documentation.
-
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
-
-// BOOST_SYSTEM_HAS_SYSTEM_ERROR
-
-#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
-# define BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
-
-#if BOOST_WORKAROUND(BOOST_GCC, < 40600)
-// g++ 4.4's <map> is not good enough
-# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
-#endif
-
-// BOOST_SYSTEM_NOEXCEPT
-// Retained for backward compatibility
-
-#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
-
-// BOOST_SYSTEM_HAS_CONSTEXPR
-
-#if !defined(BOOST_NO_CXX14_CONSTEXPR)
-# define BOOST_SYSTEM_HAS_CONSTEXPR
-#endif
-
-#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
-# define BOOST_SYSTEM_CONSTEXPR constexpr
-#else
-# define BOOST_SYSTEM_CONSTEXPR
-#endif
-
-// BOOST_SYSTEM_REQUIRE_CONST_INIT
-
-#define BOOST_SYSTEM_REQUIRE_CONST_INIT
-
-#if defined(__has_cpp_attribute)
-#if __has_cpp_attribute(clang::require_constant_initialization)
-# undef BOOST_SYSTEM_REQUIRE_CONST_INIT
-# define BOOST_SYSTEM_REQUIRE_CONST_INIT [[clang::require_constant_initialization]]
-#endif
-#endif
-
-#endif // BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
@@ -0,0 +1,483 @@
+//  error_code support implementation file  --------------------------------------------//
+
+//  Copyright Beman Dawes 2002, 2006
+//  Copyright (c) Microsoft Corporation 2014
+//  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)
+
+//  See library home page at http://www.boost.org/libs/system
+
+//--------------------------------------------------------------------------------------//
+
+#include <boost/config/warning_disable.hpp>
+
+#include <boost/system/config.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/cerrno.hpp>
+#include <vector>
+#include <cstdlib>
+#include <cassert>
+
+#include <cstring> // for strerror/strerror_r
+
+# if defined( BOOST_WINDOWS_API )
+#   include <boost/detail/winapi/error_codes.hpp>
+#   include <boost/detail/winapi/error_handling.hpp>
+#   include <boost/detail/winapi/character_code_conversion.hpp>
+#   if !BOOST_PLAT_WINDOWS_RUNTIME
+#     include <boost/system/detail/local_free_on_destruction.hpp>
+#   endif
+#   ifndef ERROR_INCORRECT_SIZE
+#     define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
+#   endif
+# endif
+
+//--------------------------------------------------------------------------------------//
+namespace boost
+{
+    namespace system
+    {
+
+namespace
+{
+
+  //  standard error categories  -------------------------------------------------------//
+
+  class generic_error_category : public error_category
+  {
+  public:
+    generic_error_category(){}
+    const char *   name() const BOOST_SYSTEM_NOEXCEPT;
+    std::string    message( int ev ) const;
+  };
+
+  class system_error_category : public error_category
+  {
+  public:
+    system_error_category(){}
+    const char *        name() const BOOST_SYSTEM_NOEXCEPT;
+    std::string         message( int ev ) const;
+    error_condition     default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
+  };
+
+  //  generic_error_category implementation  ---------------------------------//
+
+  const char * generic_error_category::name() const BOOST_SYSTEM_NOEXCEPT
+  {
+    return "generic";
+  }
+
+  std::string generic_error_category::message( int ev ) const
+  {
+    using namespace boost::system::errc;
+#if defined(__PGI)
+      using boost::system::errc::invalid_argument;
+#endif
+
+    static std::string unknown_err( "Unknown error" );
+  // strerror_r is preferred because it is always thread safe,
+  // however, we fallback to strerror in certain cases because:
+  //   -- Windows doesn't provide strerror_r.
+  //   -- HP and Sun do provide strerror_r on newer systems, but there is
+  //      no way to tell if is available at runtime and in any case their
+  //      versions of strerror are thread safe anyhow.
+  //   -- Linux only sometimes provides strerror_r.
+  //   -- Tru64 provides strerror_r only when compiled -pthread.
+  //   -- VMS doesn't provide strerror_r, but on this platform, strerror is
+  //      thread safe.
+  # if defined(BOOST_WINDOWS_API) || defined(__hpux) || defined(__sun)\
+     || (defined(__linux) && (!defined(__USE_XOPEN2K)\
+     || defined(BOOST_SYSTEM_USE_STRERROR)))\
+     || (defined(__osf__) && !defined(_REENTRANT))\
+     || (defined(__INTEGRITY))\
+     || (defined(__vms))\
+     || (defined(__QNXNTO__))
+      const char * c_str = std::strerror( ev );
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
+  # else  // use strerror_r
+      char buf[64];
+      char * bp = buf;
+      std::size_t sz = sizeof(buf);
+  #  if defined(__CYGWIN__) || defined(__USE_GNU)
+      // Oddball version of strerror_r
+      const char * c_str = strerror_r( ev, bp, sz );
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
+  #  else
+      // POSIX version of strerror_r
+      int result;
+      for (;;)
+      {
+        // strerror_r returns 0 on success, otherwise ERANGE if buffer too small,
+        // invalid_argument if ev not a valid error number
+  #  if defined (__sgi)
+        const char * c_str = strerror( ev );
+        result = 0;
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
+  #  else
+        result = strerror_r( ev, bp, sz );
+  #  endif
+        if (result == 0 )
+          break;
+        else
+        {
+  #  if defined(__linux)
+          // Linux strerror_r returns -1 on error, with error number in errno
+          result = errno;
+  #  endif
+          if ( result !=  ERANGE ) break;
+          if ( sz > sizeof(buf) ) std::free( bp );
+          sz *= 2;
+          if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
+            return std::string( "ENOMEM" );
+        }
+      }
+      std::string msg;
+#   ifndef BOOST_NO_EXCEPTIONS
+      try
+#   endif
+      {
+        msg = ( ( result == invalid_argument ) ? "Unknown error" : bp );
+      }
+
+#   ifndef BOOST_NO_EXCEPTIONS
+      // See ticket #2098
+      catch(...)
+      {
+        // just eat the exception
+      }
+#   endif
+
+      if ( sz > sizeof(buf) ) std::free( bp );
+      sz = 0;
+      return msg;
+  #  endif   // else POSIX version of strerror_r
+  # endif  // else use strerror_r
+  }
+  //  system_error_category implementation  --------------------------------------------//
+
+  const char * system_error_category::name() const BOOST_SYSTEM_NOEXCEPT
+  {
+    return "system";
+  }
+
+  error_condition system_error_category::default_error_condition( int ev ) const
+    BOOST_SYSTEM_NOEXCEPT
+  {
+    using namespace boost::system::errc;
+#if defined(__PGI)
+      using boost::system::errc::invalid_argument;
+#endif
+
+# if defined(BOOST_WINDOWS_API)
+#   if defined(WINAPI_FAMILY) && ((WINAPI_FAMILY & WINAPI_PARTITION_APP) != 0)
+    // When using the Windows Runtime, most system errors are reported as HRESULTs.
+    // We want to map the common Win32 errors to their equivalent error condition,
+    // whether or not they are reported via an HRESULT.
+    if ( ev < 0 ) // Check for failed HRESULTs only.
+      if ( HRESULT_FACILITY( ev ) == FACILITY_WIN32 )
+        ev = HRESULT_CODE( ev );
+#   endif
+# endif
+
+# if defined(BOOST_WINDOWS_API)
+
+    using namespace boost::detail::winapi; // for error codes
+
+# endif
+
+    switch ( ev )
+    {
+    case 0: return make_error_condition( success );
+# if defined(BOOST_POSIX_API)
+    // POSIX-like O/S -> posix_errno decode table  -------------------------------------//
+    case E2BIG: return make_error_condition( argument_list_too_long );
+    case EACCES: return make_error_condition( permission_denied );
+    case EADDRINUSE: return make_error_condition( address_in_use );
+    case EADDRNOTAVAIL: return make_error_condition( address_not_available );
+    case EAFNOSUPPORT: return make_error_condition( address_family_not_supported );
+    case EAGAIN: return make_error_condition( resource_unavailable_try_again );
+#   if EALREADY != EBUSY  //  EALREADY and EBUSY are the same on QNX Neutrino
+    case EALREADY: return make_error_condition( connection_already_in_progress );
+#   endif
+    case EBADF: return make_error_condition( bad_file_descriptor );
+    case EBADMSG: return make_error_condition( bad_message );
+    case EBUSY: return make_error_condition( device_or_resource_busy );
+    case ECANCELED: return make_error_condition( operation_canceled );
+    case ECHILD: return make_error_condition( no_child_process );
+    case ECONNABORTED: return make_error_condition( connection_aborted );
+    case ECONNREFUSED: return make_error_condition( connection_refused );
+    case ECONNRESET: return make_error_condition( connection_reset );
+    case EDEADLK: return make_error_condition( resource_deadlock_would_occur );
+    case EDESTADDRREQ: return make_error_condition( destination_address_required );
+    case EDOM: return make_error_condition( argument_out_of_domain );
+    case EEXIST: return make_error_condition( file_exists );
+    case EFAULT: return make_error_condition( bad_address );
+    case EFBIG: return make_error_condition( file_too_large );
+    case EHOSTUNREACH: return make_error_condition( host_unreachable );
+    case EIDRM: return make_error_condition( identifier_removed );
+    case EILSEQ: return make_error_condition( illegal_byte_sequence );
+    case EINPROGRESS: return make_error_condition( operation_in_progress );
+    case EINTR: return make_error_condition( interrupted );
+    case EINVAL: return make_error_condition( invalid_argument );
+    case EIO: return make_error_condition( io_error );
+    case EISCONN: return make_error_condition( already_connected );
+    case EISDIR: return make_error_condition( is_a_directory );
+    case ELOOP: return make_error_condition( too_many_symbolic_link_levels );
+    case EMFILE: return make_error_condition( too_many_files_open );
+    case EMLINK: return make_error_condition( too_many_links );
+    case EMSGSIZE: return make_error_condition( message_size );
+    case ENAMETOOLONG: return make_error_condition( filename_too_long );
+    case ENETDOWN: return make_error_condition( network_down );
+    case ENETRESET: return make_error_condition( network_reset );
+    case ENETUNREACH: return make_error_condition( network_unreachable );
+    case ENFILE: return make_error_condition( too_many_files_open_in_system );
+    case ENOBUFS: return make_error_condition( no_buffer_space );
+    case ENODATA: return make_error_condition( no_message_available );
+    case ENODEV: return make_error_condition( no_such_device );
+    case ENOENT: return make_error_condition( no_such_file_or_directory );
+    case ENOEXEC: return make_error_condition( executable_format_error );
+    case ENOLCK: return make_error_condition( no_lock_available );
+    case ENOLINK: return make_error_condition( no_link );
+    case ENOMEM: return make_error_condition( not_enough_memory );
+    case ENOMSG: return make_error_condition( no_message );
+    case ENOPROTOOPT: return make_error_condition( no_protocol_option );
+    case ENOSPC: return make_error_condition( no_space_on_device );
+    case ENOSR: return make_error_condition( no_stream_resources );
+    case ENOSTR: return make_error_condition( not_a_stream );
+    case ENOSYS: return make_error_condition( function_not_supported );
+    case ENOTCONN: return make_error_condition( not_connected );
+    case ENOTDIR: return make_error_condition( not_a_directory );
+  # if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value
+    case ENOTEMPTY: return make_error_condition( directory_not_empty );
+  # endif // ENOTEMPTY != EEXIST
+  # if ENOTRECOVERABLE != ECONNRESET // the same on some Broadcom chips
+    case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable );
+  # endif // ENOTRECOVERABLE != ECONNRESET
+    case ENOTSOCK: return make_error_condition( not_a_socket );
+    case ENOTSUP: return make_error_condition( not_supported );
+    case ENOTTY: return make_error_condition( inappropriate_io_control_operation );
+    case ENXIO: return make_error_condition( no_such_device_or_address );
+  # if EOPNOTSUPP != ENOTSUP
+    case EOPNOTSUPP: return make_error_condition( operation_not_supported );
+  # endif // EOPNOTSUPP != ENOTSUP
+    case EOVERFLOW: return make_error_condition( value_too_large );
+  # if EOWNERDEAD != ECONNABORTED // the same on some Broadcom chips
+    case EOWNERDEAD: return make_error_condition( owner_dead );
+  # endif // EOWNERDEAD != ECONNABORTED
+    case EPERM: return make_error_condition( operation_not_permitted );
+    case EPIPE: return make_error_condition( broken_pipe );
+    case EPROTO: return make_error_condition( protocol_error );
+    case EPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
+    case EPROTOTYPE: return make_error_condition( wrong_protocol_type );
+    case ERANGE: return make_error_condition( result_out_of_range );
+    case EROFS: return make_error_condition( read_only_file_system );
+    case ESPIPE: return make_error_condition( invalid_seek );
+    case ESRCH: return make_error_condition( no_such_process );
+    case ETIME: return make_error_condition( stream_timeout );
+    case ETIMEDOUT: return make_error_condition( timed_out );
+    case ETXTBSY: return make_error_condition( text_file_busy );
+  # if EAGAIN != EWOULDBLOCK
+    case EWOULDBLOCK: return make_error_condition( operation_would_block );
+  # endif // EAGAIN != EWOULDBLOCK
+    case EXDEV: return make_error_condition( cross_device_link );
+  #else
+    // Windows system -> posix_errno decode table  ---------------------------//
+    // see WinError.h comments for descriptions of errors
+    case ERROR_ACCESS_DENIED_: return make_error_condition( permission_denied );
+    case ERROR_ALREADY_EXISTS_: return make_error_condition( file_exists );
+    case ERROR_BAD_UNIT_: return make_error_condition( no_such_device );
+    case ERROR_BUFFER_OVERFLOW_: return make_error_condition( filename_too_long );
+    case ERROR_BUSY_: return make_error_condition( device_or_resource_busy );
+    case ERROR_BUSY_DRIVE_: return make_error_condition( device_or_resource_busy );
+    case ERROR_CANNOT_MAKE_: return make_error_condition( permission_denied );
+    case ERROR_CANTOPEN_: return make_error_condition( io_error );
+    case ERROR_CANTREAD_: return make_error_condition( io_error );
+    case ERROR_CANTWRITE_: return make_error_condition( io_error );
+    case ERROR_CURRENT_DIRECTORY_: return make_error_condition( permission_denied );
+    case ERROR_DEV_NOT_EXIST_: return make_error_condition( no_such_device );
+    case ERROR_DEVICE_IN_USE_: return make_error_condition( device_or_resource_busy );
+    case ERROR_DIR_NOT_EMPTY_: return make_error_condition( directory_not_empty );
+    case ERROR_DIRECTORY_: return make_error_condition( invalid_argument );\
+      // WinError.h: "The directory name is invalid"
+    case ERROR_DISK_FULL_: return make_error_condition( no_space_on_device );
+    case ERROR_FILE_EXISTS_: return make_error_condition( file_exists );
+    case ERROR_FILE_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
+    case ERROR_HANDLE_DISK_FULL_: return make_error_condition( no_space_on_device );
+    case ERROR_INVALID_ACCESS_: return make_error_condition( permission_denied );
+    case ERROR_INVALID_DRIVE_: return make_error_condition( no_such_device );
+    case ERROR_INVALID_FUNCTION_: return make_error_condition( function_not_supported );
+    case ERROR_INVALID_HANDLE_: return make_error_condition( invalid_argument );
+    case ERROR_INVALID_NAME_: return make_error_condition( invalid_argument );
+    case ERROR_LOCK_VIOLATION_: return make_error_condition( no_lock_available );
+    case ERROR_LOCKED_: return make_error_condition( no_lock_available );
+    case ERROR_NEGATIVE_SEEK_: return make_error_condition( invalid_argument );
+    case ERROR_NOACCESS_: return make_error_condition( permission_denied );
+    case ERROR_NOT_ENOUGH_MEMORY_: return make_error_condition( not_enough_memory );
+    case ERROR_NOT_READY_: return make_error_condition( resource_unavailable_try_again );
+    case ERROR_NOT_SAME_DEVICE_: return make_error_condition( cross_device_link );
+    case ERROR_OPEN_FAILED_: return make_error_condition( io_error );
+    case ERROR_OPEN_FILES_: return make_error_condition( device_or_resource_busy );
+    case ERROR_OPERATION_ABORTED_: return make_error_condition( operation_canceled );
+    case ERROR_OUTOFMEMORY_: return make_error_condition( not_enough_memory );
+    case ERROR_PATH_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
+    case ERROR_READ_FAULT_: return make_error_condition( io_error );
+    case ERROR_RETRY_: return make_error_condition( resource_unavailable_try_again );
+    case ERROR_SEEK_: return make_error_condition( io_error );
+    case ERROR_SHARING_VIOLATION_: return make_error_condition( permission_denied );
+    case ERROR_TOO_MANY_OPEN_FILES_: return make_error_condition( too_many_files_open );
+    case ERROR_WRITE_FAULT_: return make_error_condition( io_error );
+    case ERROR_WRITE_PROTECT_: return make_error_condition( permission_denied );
+    case WSAEACCES_: return make_error_condition( permission_denied );
+    case WSAEADDRINUSE_: return make_error_condition( address_in_use );
+    case WSAEADDRNOTAVAIL_: return make_error_condition( address_not_available );
+    case WSAEAFNOSUPPORT_: return make_error_condition( address_family_not_supported );
+    case WSAEALREADY_: return make_error_condition( connection_already_in_progress );
+    case WSAEBADF_: return make_error_condition( bad_file_descriptor );
+    case WSAECONNABORTED_: return make_error_condition( connection_aborted );
+    case WSAECONNREFUSED_: return make_error_condition( connection_refused );
+    case WSAECONNRESET_: return make_error_condition( connection_reset );
+    case WSAEDESTADDRREQ_: return make_error_condition( destination_address_required );
+    case WSAEFAULT_: return make_error_condition( bad_address );
+    case WSAEHOSTUNREACH_: return make_error_condition( host_unreachable );
+    case WSAEINPROGRESS_: return make_error_condition( operation_in_progress );
+    case WSAEINTR_: return make_error_condition( interrupted );
+    case WSAEINVAL_: return make_error_condition( invalid_argument );
+    case WSAEISCONN_: return make_error_condition( already_connected );
+    case WSAEMFILE_: return make_error_condition( too_many_files_open );
+    case WSAEMSGSIZE_: return make_error_condition( message_size );
+    case WSAENAMETOOLONG_: return make_error_condition( filename_too_long );
+    case WSAENETDOWN_: return make_error_condition( network_down );
+    case WSAENETRESET_: return make_error_condition( network_reset );
+    case WSAENETUNREACH_: return make_error_condition( network_unreachable );
+    case WSAENOBUFS_: return make_error_condition( no_buffer_space );
+    case WSAENOPROTOOPT_: return make_error_condition( no_protocol_option );
+    case WSAENOTCONN_: return make_error_condition( not_connected );
+    case WSAENOTSOCK_: return make_error_condition( not_a_socket );
+    case WSAEOPNOTSUPP_: return make_error_condition( operation_not_supported );
+    case WSAEPROTONOSUPPORT_: return make_error_condition( protocol_not_supported );
+    case WSAEPROTOTYPE_: return make_error_condition( wrong_protocol_type );
+    case WSAETIMEDOUT_: return make_error_condition( timed_out );
+    case WSAEWOULDBLOCK_: return make_error_condition( operation_would_block );
+  #endif
+    default: return error_condition( ev, system_category() );
+    }
+  }
+
+# if !defined( BOOST_WINDOWS_API )
+
+  std::string system_error_category::message( int ev ) const
+  {
+    return generic_category().message( ev );
+  }
+# else
+
+  std::string system_error_category::message( int ev ) const
+  {
+#if defined(UNDER_CE) || BOOST_PLAT_WINDOWS_RUNTIME || defined(BOOST_NO_ANSI_APIS)
+    std::wstring buf(128, wchar_t());
+    for (;;)
+    {
+        boost::detail::winapi::DWORD_ retval = boost::detail::winapi::FormatMessageW(
+            boost::detail::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
+            boost::detail::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
+            NULL,
+            ev,
+            boost::detail::winapi::MAKELANGID_(boost::detail::winapi::LANG_NEUTRAL_,
+            boost::detail::winapi::SUBLANG_DEFAULT_), // Default language
+            &buf[0],
+            buf.size(),
+            NULL
+        );
+        
+        if (retval > 0)
+        {
+            buf.resize(retval);
+            break;
+        }
+        else if (boost::detail::winapi::GetLastError() !=
+          boost::detail::winapi::ERROR_INSUFFICIENT_BUFFER_)
+        {
+            return std::string("Unknown error");
+        }
+        else
+        {
+            buf.resize(buf.size() + buf.size() / 2);
+        }
+    }
+    
+    int num_chars = (buf.size() + 1) * 2;
+    boost::detail::winapi::LPSTR_ narrow_buffer =
+      (boost::detail::winapi::LPSTR_)_alloca(num_chars);
+    if (boost::detail::winapi::WideCharToMultiByte(boost::detail::winapi::CP_ACP_, 0,
+      buf.c_str(), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
+    {
+        return std::string("Unknown error");
+    }
+
+    std::string str( narrow_buffer );
+#else
+    boost::detail::winapi::LPVOID_ lpMsgBuf = 0;
+    boost::detail::winapi::DWORD_ retval = boost::detail::winapi::FormatMessageA(
+        boost::detail::winapi::FORMAT_MESSAGE_ALLOCATE_BUFFER_ |
+        boost::detail::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
+        boost::detail::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
+        NULL,
+        ev,
+        boost::detail::winapi::MAKELANGID_(boost::detail::winapi::LANG_NEUTRAL_,
+        boost::detail::winapi::SUBLANG_DEFAULT_), // Default language
+        (boost::detail::winapi::LPSTR_) &lpMsgBuf,
+        0,
+        NULL
+    );
+    detail::local_free_on_destruction lfod(lpMsgBuf);
+    if (retval == 0)
+        return std::string("Unknown error");
+
+    std::string str(static_cast<boost::detail::winapi::LPCSTR_>(lpMsgBuf));
+# endif
+    while ( str.size()
+      && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
+        str.erase( str.size()-1 );
+    if ( str.size() && str[str.size()-1] == '.' )
+      { str.erase( str.size()-1 ); }
+    return str;
+  }
+# endif
+
+} // unnamed namespace
+
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
+                                         //  note that it doesn't matter if this
+                                         //  isn't initialized before use since
+                                         //  the only use is to take its
+                                         //  address for comparison purposes
+# endif
+
+# ifdef BOOST_ERROR_CODE_HEADER_ONLY
+#   define BOOST_SYSTEM_LINKAGE inline
+# else
+#   define BOOST_SYSTEM_LINKAGE BOOST_SYSTEM_DECL
+# endif
+
+    BOOST_SYSTEM_LINKAGE const error_category & system_category() BOOST_SYSTEM_NOEXCEPT
+    {
+      static const system_error_category  system_category_const;
+      return system_category_const;
+    }
+
+    BOOST_SYSTEM_LINKAGE const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
+    {
+      static const generic_error_category generic_category_const;
+      return generic_category_const;
+    }
+
+  } // namespace system
+} // namespace boost
@@ -1,94 +0,0 @@
-// Implementation details of generic_error_category
-//
-// Copyright 2018 Peter Dimov
-//
-// 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)
-//
-// See library home page at http://www.boost.org/libs/system
-
-#include <cstring>
-
-namespace boost
-{
-
-namespace system
-{
-
-namespace detail
-{
-
-#if defined(__GLIBC__)
-
-// glibc has two incompatible strerror_r definitions
-
-inline char const * strerror_r_helper( char const * r, char const * ) BOOST_NOEXCEPT
-{
-    return r;
-}
-
-inline char const * strerror_r_helper( int r, char const * buffer ) BOOST_NOEXCEPT
-{
-    return r == 0? buffer: "Unknown error";
-}
-
-inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
-{
-    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
-}
-
-inline std::string generic_error_category_message( int ev )
-{
-    char buffer[ 128 ];
-    return generic_error_category_message( ev, buffer, sizeof( buffer ) );
-}
-
-#else
-
-// std::strerror is thread-safe on everything else, incl. Windows
-
-# if defined( BOOST_MSVC )
-#  pragma warning( push )
-#  pragma warning( disable: 4996 )
-# endif
-
-inline std::string generic_error_category_message( int ev )
-{
-    char const * m = std::strerror( ev );
-    return m? m: "Unknown error";
-}
-
-inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
-{
-    if( len == 0 )
-    {
-        return buffer;
-    }
-
-    if( len == 1 )
-    {
-        buffer[0] = 0;
-        return buffer;
-    }
-
-    char const * m = std::strerror( ev );
-
-    if( m == 0 ) return "Unknown error";
-
-    std::strncpy( buffer, m, len - 1 );
-    buffer[ len-1 ] = 0;
-
-    return buffer;
-}
-
-# if defined( BOOST_MSVC )
-#  pragma warning( pop )
-# endif
-
-#endif
-
-} // namespace detail
-
-} // namespace system
-
-} // namespace boost
@@ -0,0 +1,42 @@
+//  local_free_on_exit.hpp  ------------------------------------------------------------//
+
+//  Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//  Copyright (c) 2010 Beman Dawes
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  This is derived from boost/asio/detail/local_free_on_block_exit.hpp to avoid
+//  a dependency on asio. Thanks to Chris Kohlhoff for pointing it out.
+
+#ifndef BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
+#define BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
+
+#include <boost/detail/winapi/local_memory.hpp>
+
+namespace boost {
+namespace system {
+namespace detail {
+
+class local_free_on_destruction
+{
+public:
+  explicit local_free_on_destruction(void* p)
+    : p_(p) {}
+
+  ~local_free_on_destruction()
+  {
+    boost::detail::winapi::LocalFree(p_);
+  }
+
+private:
+  void* p_;
+  local_free_on_destruction(const local_free_on_destruction&);  // = deleted
+  local_free_on_destruction& operator=(const local_free_on_destruction&);  // = deleted
+};
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif  // BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
@@ -1,141 +0,0 @@
-// Support for interoperability between Boost.System and <system_error>
-//
-// Copyright 2018 Peter Dimov
-//
-// 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)
-//
-// See library home page at http://www.boost.org/libs/system
-
-#include <system_error>
-#include <map>
-#include <memory>
-
-//
-
-namespace boost
-{
-
-namespace system
-{
-
-namespace detail
-{
-
-class BOOST_SYMBOL_VISIBLE std_category: public std::error_category
-{
-private:
-
-    boost::system::error_category const * pc_;
-
-public:
-
-    explicit std_category( boost::system::error_category const * pc ): pc_( pc )
-    {
-    }
-
-    virtual const char * name() const BOOST_NOEXCEPT
-    {
-        return pc_->name();
-    }
-
-    virtual std::string message( int ev ) const
-    {
-        return pc_->message( ev );
-    }
-
-    virtual std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
-    {
-        return pc_->default_error_condition( ev );
-    }
-
-    virtual bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT;
-    virtual bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT;
-};
-
-inline std::error_category const & to_std_category( boost::system::error_category const & cat )
-{
-    typedef std::map< boost::system::error_category const *, std::unique_ptr<std_category> > map_type;
-
-    static map_type map_;
-
-    map_type::iterator i = map_.find( &cat );
-
-    if( i == map_.end() )
-    {
-        std::unique_ptr<std_category> p( new std_category( &cat ) );
-
-        std::pair<map_type::iterator, bool> r = map_.insert( map_type::value_type( &cat, std::move( p ) ) );
-
-        i = r.first;
-    }
-
-    return *i->second;
-}
-
-inline bool std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT
-{
-    if( condition.category() == *this )
-    {
-        boost::system::error_condition bn( condition.value(), *pc_ );
-        return pc_->equivalent( code, bn );
-    }
-    else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() )
-    {
-        boost::system::error_condition bn( condition.value(), boost::system::generic_category() );
-        return pc_->equivalent( code, bn );
-    }
-
-#ifndef BOOST_NO_RTTI
-
-    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &condition.category() ) )
-    {
-        boost::system::error_condition bn( condition.value(), *pc2->pc_ );
-        return pc_->equivalent( code, bn );
-    }
-
-#endif
-
-    else
-    {
-        return default_error_condition( code ) == condition;
-    }
-}
-
-inline bool std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT
-{
-    if( code.category() == *this )
-    {
-        boost::system::error_code bc( code.value(), *pc_ );
-        return pc_->equivalent( bc, condition );
-    }
-    else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() )
-    {
-        boost::system::error_code bc( code.value(), boost::system::generic_category() );
-        return pc_->equivalent( bc, condition );
-    }
-
-#ifndef BOOST_NO_RTTI
-
-    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &code.category() ) )
-    {
-        boost::system::error_code bc( code.value(), *pc2->pc_ );
-        return pc_->equivalent( bc, condition );
-    }
-#endif
-
-    else if( *pc_ == boost::system::generic_category() )
-    {
-        return std::generic_category().equivalent( code, condition );
-    }
-    else
-    {
-        return false;
-    }
-}
-
-} // namespace detail
-
-} // namespace system
-
-} // namespace boost
@@ -1,132 +0,0 @@
-// POSIX-specific implementation details of system_error_category
-//
-// Copyright 2018 Peter Dimov
-//
-// 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)
-//
-// See library home page at http://www.boost.org/libs/system
-
-namespace boost
-{
-
-namespace system
-{
-
-namespace detail
-{
-
-inline bool is_generic_value( int ev ) BOOST_NOEXCEPT
-{
-    using namespace errc;
-
-    static int const gen[] =
-    {
-        success,
-        address_family_not_supported,
-        address_in_use,
-        address_not_available,
-        already_connected,
-        argument_list_too_long,
-        argument_out_of_domain,
-        bad_address,
-        bad_file_descriptor,
-        bad_message,
-        broken_pipe,
-        connection_aborted,
-        connection_already_in_progress,
-        connection_refused,
-        connection_reset,
-        cross_device_link,
-        destination_address_required,
-        device_or_resource_busy,
-        directory_not_empty,
-        executable_format_error,
-        file_exists,
-        file_too_large,
-        filename_too_long,
-        function_not_supported,
-        host_unreachable,
-        identifier_removed,
-        illegal_byte_sequence,
-        inappropriate_io_control_operation,
-        interrupted,
-        invalid_argument,
-        invalid_seek,
-        io_error,
-        is_a_directory,
-        message_size,
-        network_down,
-        network_reset,
-        network_unreachable,
-        no_buffer_space,
-        no_child_process,
-        no_link,
-        no_lock_available,
-        no_message_available,
-        no_message,
-        no_protocol_option,
-        no_space_on_device,
-        no_stream_resources,
-        no_such_device_or_address,
-        no_such_device,
-        no_such_file_or_directory,
-        no_such_process,
-        not_a_directory,
-        not_a_socket,
-        not_a_stream,
-        not_connected,
-        not_enough_memory,
-        not_supported,
-        operation_canceled,
-        operation_in_progress,
-        operation_not_permitted,
-        operation_not_supported,
-        operation_would_block,
-        owner_dead,
-        permission_denied,
-        protocol_error,
-        protocol_not_supported,
-        read_only_file_system,
-        resource_deadlock_would_occur,
-        resource_unavailable_try_again,
-        result_out_of_range,
-        state_not_recoverable,
-        stream_timeout,
-        text_file_busy,
-        timed_out,
-        too_many_files_open_in_system,
-        too_many_files_open,
-        too_many_links,
-        too_many_symbolic_link_levels,
-        value_too_large,
-        wrong_protocol_type
-    };
-
-    int const n = sizeof( gen ) / sizeof( gen[0] );
-
-    for( int i = 0; i < n; ++i )
-    {
-        if( ev == gen[ i ] ) return true;
-    }
-
-    return false;
-}
-
-inline error_condition system_category_default_error_condition_posix( int ev ) BOOST_NOEXCEPT
-{
-    if( is_generic_value( ev ) )
-    {
-        return error_condition( ev, generic_category() );
-    }
-    else
-    {
-        return error_condition( ev, system_category() );
-    }
-}
-
-} // namespace detail
-
-} // namespace system
-
-} // namespace boost
@@ -1,306 +0,0 @@
-// Windows implementation of system_error_category
-//
-// Copyright Beman Dawes 2002, 2006
-// Copyright (c) Microsoft Corporation 2014
-// Copyright 2018 Peter Dimov
-//
-// 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)
-//
-// See library home page at http://www.boost.org/libs/system
-
-#include <boost/winapi/error_codes.hpp>
-#include <boost/winapi/error_handling.hpp>
-#include <boost/winapi/character_code_conversion.hpp>
-#include <boost/winapi/local_memory.hpp>
-#include <cstdio>
-
-//
-
-namespace boost
-{
-
-namespace system
-{
-
-namespace detail
-{
-
-#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
-
-inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len )
-{
-# if defined( BOOST_MSVC )
-#  pragma warning( push )
-#  pragma warning( disable: 4996 )
-# endif
-
-    _snprintf( buffer, len - 1, "Unknown error (%d)", ev );
-
-    buffer[ len - 1 ] = 0;
-    return buffer;
-
-# if defined( BOOST_MSVC )
-#  pragma warning( pop )
-# endif
-}
-
-#else
-
-inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len )
-{
-    std::snprintf( buffer, len, "Unknown error (%d)", ev );
-    return buffer;
-}
-
-#endif
-
-inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
-{
-    if( len == 0 )
-    {
-        return buffer;
-    }
-
-    if( len == 1 )
-    {
-        buffer[0] = 0;
-        return buffer;
-    }
-
-#if defined(__GNUC__)
-# define BOOST_SYSTEM_ALLOCA __builtin_alloca
-#else
-# define BOOST_SYSTEM_ALLOCA _alloca
-#endif
-
-    wchar_t * wbuffer = static_cast<wchar_t*>( BOOST_SYSTEM_ALLOCA( len * sizeof( wchar_t ) ) );
-
-#undef BOOST_SYSTEM_ALLOCA
-
-    using namespace boost::winapi;
-
-    DWORD_ retval = boost::winapi::FormatMessageW(
-        FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
-        NULL,
-        ev,
-        MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
-        wbuffer,
-        static_cast<DWORD_>( len ),
-        NULL
-    );
-
-    if( retval == 0 )
-    {
-        return unknown_message_win32( ev, buffer, len );
-    }
-
-    int r = boost::winapi::WideCharToMultiByte( CP_ACP_, 0, wbuffer, -1, buffer, static_cast<int>( len ), NULL, NULL );
-
-    if( r == 0 )
-    {
-        return unknown_message_win32( ev, buffer, len );
-    }
-
-    --r; // exclude null terminator
-
-    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
-    {
-        buffer[ --r ] = 0;
-    }
-
-    if( r > 0 && buffer[ r-1 ] == '.' )
-    {
-        buffer[ --r ] = 0;
-    }
-
-    return buffer;
-}
-
-struct local_free
-{
-    void * p_;
-
-    ~local_free()
-    {
-        boost::winapi::LocalFree( p_ );
-    }
-};
-
-inline std::string unknown_message_win32( int ev )
-{
-    char buffer[ 38 ];
-    return unknown_message_win32( ev, buffer, sizeof( buffer ) );
-}
-
-inline std::string system_category_message_win32( int ev )
-{
-    using namespace boost::winapi;
-
-    wchar_t * lpMsgBuf = 0;
-
-    DWORD_ retval = boost::winapi::FormatMessageW(
-        FORMAT_MESSAGE_ALLOCATE_BUFFER_ | FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
-        NULL,
-        ev,
-        MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
-        (LPWSTR_) &lpMsgBuf,
-        0,
-        NULL
-    );
-
-    if( retval == 0 )
-    {
-        return unknown_message_win32( ev );
-    }
-
-    local_free lf_ = { lpMsgBuf };
-
-    int r = boost::winapi::WideCharToMultiByte( CP_ACP_, 0, lpMsgBuf, -1, 0, 0, NULL, NULL );
-
-    if( r == 0 )
-    {
-        return unknown_message_win32( ev );
-    }
-
-    std::string buffer( r, char() );
-
-    r = boost::winapi::WideCharToMultiByte( CP_ACP_, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL );
-
-    if( r == 0 )
-    {
-        return unknown_message_win32( ev );
-    }
-
-    --r; // exclude null terminator
-
-    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
-    {
-        --r;
-    }
-
-    if( r > 0 && buffer[ r-1 ] == '.' )
-    {
-        --r;
-    }
-
-    buffer.resize( r );
-
-    return buffer;
-}
-
-inline error_condition system_category_default_error_condition_win32( int ev ) BOOST_NOEXCEPT
-{
-    // When using the Windows Runtime, most system errors are reported as HRESULTs.
-    // We want to map the common Win32 errors to their equivalent error condition,
-    // whether or not they are reported via an HRESULT.
-
-#define BOOST_SYSTEM_FAILED(hr)           ((hr) < 0)
-#define BOOST_SYSTEM_HRESULT_FACILITY(hr) (((hr) >> 16) & 0x1fff)
-#define BOOST_SYSTEM_HRESULT_CODE(hr)     ((hr) & 0xFFFF)
-#define BOOST_SYSTEM_FACILITY_WIN32       7
-
-    if( BOOST_SYSTEM_FAILED( ev ) && BOOST_SYSTEM_HRESULT_FACILITY( ev ) == BOOST_SYSTEM_FACILITY_WIN32 )
-    {
-        ev = BOOST_SYSTEM_HRESULT_CODE( ev );
-    }
-
-#undef BOOST_SYSTEM_FAILED
-#undef BOOST_SYSTEM_HRESULT_FACILITY
-#undef BOOST_SYSTEM_HRESULT_CODE
-#undef BOOST_SYSTEM_FACILITY_WIN32
-
-    using namespace boost::winapi;
-    using namespace errc;
-
-    // Windows system -> posix_errno decode table
-    // see WinError.h comments for descriptions of errors
-
-    switch ( ev )
-    {
-    case 0: return make_error_condition( success );
-
-    case ERROR_ACCESS_DENIED_: return make_error_condition( permission_denied );
-    case ERROR_ALREADY_EXISTS_: return make_error_condition( file_exists );
-    case ERROR_BAD_UNIT_: return make_error_condition( no_such_device );
-    case ERROR_BUFFER_OVERFLOW_: return make_error_condition( filename_too_long );
-    case ERROR_BUSY_: return make_error_condition( device_or_resource_busy );
-    case ERROR_BUSY_DRIVE_: return make_error_condition( device_or_resource_busy );
-    case ERROR_CANNOT_MAKE_: return make_error_condition( permission_denied );
-    case ERROR_CANTOPEN_: return make_error_condition( io_error );
-    case ERROR_CANTREAD_: return make_error_condition( io_error );
-    case ERROR_CANTWRITE_: return make_error_condition( io_error );
-    case ERROR_CURRENT_DIRECTORY_: return make_error_condition( permission_denied );
-    case ERROR_DEV_NOT_EXIST_: return make_error_condition( no_such_device );
-    case ERROR_DEVICE_IN_USE_: return make_error_condition( device_or_resource_busy );
-    case ERROR_DIR_NOT_EMPTY_: return make_error_condition( directory_not_empty );
-    case ERROR_DIRECTORY_: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid"
-    case ERROR_DISK_FULL_: return make_error_condition( no_space_on_device );
-    case ERROR_FILE_EXISTS_: return make_error_condition( file_exists );
-    case ERROR_FILE_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
-    case ERROR_HANDLE_DISK_FULL_: return make_error_condition( no_space_on_device );
-    case ERROR_INVALID_ACCESS_: return make_error_condition( permission_denied );
-    case ERROR_INVALID_DRIVE_: return make_error_condition( no_such_device );
-    case ERROR_INVALID_FUNCTION_: return make_error_condition( function_not_supported );
-    case ERROR_INVALID_HANDLE_: return make_error_condition( invalid_argument );
-    case ERROR_INVALID_NAME_: return make_error_condition( invalid_argument );
-    case ERROR_LOCK_VIOLATION_: return make_error_condition( no_lock_available );
-    case ERROR_LOCKED_: return make_error_condition( no_lock_available );
-    case ERROR_NEGATIVE_SEEK_: return make_error_condition( invalid_argument );
-    case ERROR_NOACCESS_: return make_error_condition( permission_denied );
-    case ERROR_NOT_ENOUGH_MEMORY_: return make_error_condition( not_enough_memory );
-    case ERROR_NOT_READY_: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_NOT_SAME_DEVICE_: return make_error_condition( cross_device_link );
-    case ERROR_OPEN_FAILED_: return make_error_condition( io_error );
-    case ERROR_OPEN_FILES_: return make_error_condition( device_or_resource_busy );
-    case ERROR_OPERATION_ABORTED_: return make_error_condition( operation_canceled );
-    case ERROR_OUTOFMEMORY_: return make_error_condition( not_enough_memory );
-    case ERROR_PATH_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
-    case ERROR_READ_FAULT_: return make_error_condition( io_error );
-    case ERROR_RETRY_: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_SEEK_: return make_error_condition( io_error );
-    case ERROR_SHARING_VIOLATION_: return make_error_condition( permission_denied );
-    case ERROR_TOO_MANY_OPEN_FILES_: return make_error_condition( too_many_files_open );
-    case ERROR_WRITE_FAULT_: return make_error_condition( io_error );
-    case ERROR_WRITE_PROTECT_: return make_error_condition( permission_denied );
-    case WSAEACCES_: return make_error_condition( permission_denied );
-    case WSAEADDRINUSE_: return make_error_condition( address_in_use );
-    case WSAEADDRNOTAVAIL_: return make_error_condition( address_not_available );
-    case WSAEAFNOSUPPORT_: return make_error_condition( address_family_not_supported );
-    case WSAEALREADY_: return make_error_condition( connection_already_in_progress );
-    case WSAEBADF_: return make_error_condition( bad_file_descriptor );
-    case WSAECONNABORTED_: return make_error_condition( connection_aborted );
-    case WSAECONNREFUSED_: return make_error_condition( connection_refused );
-    case WSAECONNRESET_: return make_error_condition( connection_reset );
-    case WSAEDESTADDRREQ_: return make_error_condition( destination_address_required );
-    case WSAEFAULT_: return make_error_condition( bad_address );
-    case WSAEHOSTUNREACH_: return make_error_condition( host_unreachable );
-    case WSAEINPROGRESS_: return make_error_condition( operation_in_progress );
-    case WSAEINTR_: return make_error_condition( interrupted );
-    case WSAEINVAL_: return make_error_condition( invalid_argument );
-    case WSAEISCONN_: return make_error_condition( already_connected );
-    case WSAEMFILE_: return make_error_condition( too_many_files_open );
-    case WSAEMSGSIZE_: return make_error_condition( message_size );
-    case WSAENAMETOOLONG_: return make_error_condition( filename_too_long );
-    case WSAENETDOWN_: return make_error_condition( network_down );
-    case WSAENETRESET_: return make_error_condition( network_reset );
-    case WSAENETUNREACH_: return make_error_condition( network_unreachable );
-    case WSAENOBUFS_: return make_error_condition( no_buffer_space );
-    case WSAENOPROTOOPT_: return make_error_condition( no_protocol_option );
-    case WSAENOTCONN_: return make_error_condition( not_connected );
-    case WSAENOTSOCK_: return make_error_condition( not_a_socket );
-    case WSAEOPNOTSUPP_: return make_error_condition( operation_not_supported );
-    case WSAEPROTONOSUPPORT_: return make_error_condition( protocol_not_supported );
-    case WSAEPROTOTYPE_: return make_error_condition( wrong_protocol_type );
-    case WSAETIMEDOUT_: return make_error_condition( timed_out );
-    case WSAEWOULDBLOCK_: return make_error_condition( operation_would_block );
-
-    default: return error_condition( ev, system_category() );
-    }
-}
-
-} // namespace detail
-
-} // namespace system
-
-} // namespace boost
@@ -89,7 +89,7 @@ namespace boost
      };
    }  // namespace linux_error

-# ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
    namespace Linux = linux_error;
 # endif

@@ -8,10 +8,10 @@
 #ifndef BOOST_SYSTEM_SYSTEM_ERROR_HPP
 #define BOOST_SYSTEM_SYSTEM_ERROR_HPP

-#include <boost/system/error_code.hpp>
 #include <string>
 #include <stdexcept>
 #include <cassert>
+#include <boost/system/error_code.hpp>

 namespace boost
 {
@@ -28,7 +28,7 @@
 //#include <winerror.h>
 //#endif

-#include <boost/winapi/error_codes.hpp>
+#include <boost/detail/winapi/error_codes.hpp>

 namespace boost
 {
@@ -47,59 +47,59 @@ namespace boost
      {
        success = 0,
        // These names and values are based on Windows winerror.h
-        invalid_function = boost::winapi::ERROR_INVALID_FUNCTION_,
-        file_not_found = boost::winapi::ERROR_FILE_NOT_FOUND_,
-        path_not_found = boost::winapi::ERROR_PATH_NOT_FOUND_,
-        too_many_open_files = boost::winapi::ERROR_TOO_MANY_OPEN_FILES_,
-        access_denied = boost::winapi::ERROR_ACCESS_DENIED_,
-        invalid_handle = boost::winapi::ERROR_INVALID_HANDLE_,
-        arena_trashed = boost::winapi::ERROR_ARENA_TRASHED_,
-        not_enough_memory = boost::winapi::ERROR_NOT_ENOUGH_MEMORY_,
-        invalid_block = boost::winapi::ERROR_INVALID_BLOCK_,
-        bad_environment = boost::winapi::ERROR_BAD_ENVIRONMENT_,
-        bad_format = boost::winapi::ERROR_BAD_FORMAT_,
-        invalid_access = boost::winapi::ERROR_INVALID_ACCESS_,
-        outofmemory = boost::winapi::ERROR_OUTOFMEMORY_,
-        invalid_drive = boost::winapi::ERROR_INVALID_DRIVE_,
-        current_directory = boost::winapi::ERROR_CURRENT_DIRECTORY_,
-        not_same_device = boost::winapi::ERROR_NOT_SAME_DEVICE_,
-        no_more_files = boost::winapi::ERROR_NO_MORE_FILES_,
-        write_protect = boost::winapi::ERROR_WRITE_PROTECT_,
-        bad_unit = boost::winapi::ERROR_BAD_UNIT_,
-        not_ready = boost::winapi::ERROR_NOT_READY_,
-        bad_command = boost::winapi::ERROR_BAD_COMMAND_,
-        crc = boost::winapi::ERROR_CRC_,
-        bad_length = boost::winapi::ERROR_BAD_LENGTH_,
-        seek = boost::winapi::ERROR_SEEK_,
-        not_dos_disk = boost::winapi::ERROR_NOT_DOS_DISK_,
-        sector_not_found = boost::winapi::ERROR_SECTOR_NOT_FOUND_,
-        out_of_paper = boost::winapi::ERROR_OUT_OF_PAPER_,
-        write_fault = boost::winapi::ERROR_WRITE_FAULT_,
-        read_fault = boost::winapi::ERROR_READ_FAULT_,
-        gen_failure = boost::winapi::ERROR_GEN_FAILURE_,
-        sharing_violation = boost::winapi::ERROR_SHARING_VIOLATION_,
-        lock_violation = boost::winapi::ERROR_LOCK_VIOLATION_,
-        wrong_disk = boost::winapi::ERROR_WRONG_DISK_,
-        sharing_buffer_exceeded = boost::winapi::ERROR_SHARING_BUFFER_EXCEEDED_,
-        handle_eof = boost::winapi::ERROR_HANDLE_EOF_,
-        handle_disk_full= boost::winapi::ERROR_HANDLE_DISK_FULL_,
-        rem_not_list = boost::winapi::ERROR_REM_NOT_LIST_,
-        dup_name = boost::winapi::ERROR_DUP_NAME_,
-        bad_net_path = boost::winapi::ERROR_BAD_NETPATH_,
-        network_busy = boost::winapi::ERROR_NETWORK_BUSY_,
+        invalid_function = boost::detail::winapi::ERROR_INVALID_FUNCTION_,
+        file_not_found = boost::detail::winapi::ERROR_FILE_NOT_FOUND_,
+        path_not_found = boost::detail::winapi::ERROR_PATH_NOT_FOUND_,
+        too_many_open_files = boost::detail::winapi::ERROR_TOO_MANY_OPEN_FILES_,
+        access_denied = boost::detail::winapi::ERROR_ACCESS_DENIED_,
+        invalid_handle = boost::detail::winapi::ERROR_INVALID_HANDLE_,
+        arena_trashed = boost::detail::winapi::ERROR_ARENA_TRASHED_,
+        not_enough_memory = boost::detail::winapi::ERROR_NOT_ENOUGH_MEMORY_,
+        invalid_block = boost::detail::winapi::ERROR_INVALID_BLOCK_,
+        bad_environment = boost::detail::winapi::ERROR_BAD_ENVIRONMENT_,
+        bad_format = boost::detail::winapi::ERROR_BAD_FORMAT_,
+        invalid_access = boost::detail::winapi::ERROR_INVALID_ACCESS_,
+        outofmemory = boost::detail::winapi::ERROR_OUTOFMEMORY_,
+        invalid_drive = boost::detail::winapi::ERROR_INVALID_DRIVE_,
+        current_directory = boost::detail::winapi::ERROR_CURRENT_DIRECTORY_,
+        not_same_device = boost::detail::winapi::ERROR_NOT_SAME_DEVICE_,
+        no_more_files = boost::detail::winapi::ERROR_NO_MORE_FILES_,
+        write_protect = boost::detail::winapi::ERROR_WRITE_PROTECT_,
+        bad_unit = boost::detail::winapi::ERROR_BAD_UNIT_,
+        not_ready = boost::detail::winapi::ERROR_NOT_READY_,
+        bad_command = boost::detail::winapi::ERROR_BAD_COMMAND_,
+        crc = boost::detail::winapi::ERROR_CRC_,
+        bad_length = boost::detail::winapi::ERROR_BAD_LENGTH_,
+        seek = boost::detail::winapi::ERROR_SEEK_,
+        not_dos_disk = boost::detail::winapi::ERROR_NOT_DOS_DISK_,
+        sector_not_found = boost::detail::winapi::ERROR_SECTOR_NOT_FOUND_,
+        out_of_paper = boost::detail::winapi::ERROR_OUT_OF_PAPER_,
+        write_fault = boost::detail::winapi::ERROR_WRITE_FAULT_,
+        read_fault = boost::detail::winapi::ERROR_READ_FAULT_,
+        gen_failure = boost::detail::winapi::ERROR_GEN_FAILURE_,
+        sharing_violation = boost::detail::winapi::ERROR_SHARING_VIOLATION_,
+        lock_violation = boost::detail::winapi::ERROR_LOCK_VIOLATION_,
+        wrong_disk = boost::detail::winapi::ERROR_WRONG_DISK_,
+        sharing_buffer_exceeded = boost::detail::winapi::ERROR_SHARING_BUFFER_EXCEEDED_,
+        handle_eof = boost::detail::winapi::ERROR_HANDLE_EOF_,
+        handle_disk_full= boost::detail::winapi::ERROR_HANDLE_DISK_FULL_,
+        rem_not_list = boost::detail::winapi::ERROR_REM_NOT_LIST_,
+        dup_name = boost::detail::winapi::ERROR_DUP_NAME_,
+        bad_net_path = boost::detail::winapi::ERROR_BAD_NETPATH_,
+        network_busy = boost::detail::winapi::ERROR_NETWORK_BUSY_,
        // ...
-        file_exists = boost::winapi::ERROR_FILE_EXISTS_,
-        cannot_make = boost::winapi::ERROR_CANNOT_MAKE_,
+        file_exists = boost::detail::winapi::ERROR_FILE_EXISTS_,
+        cannot_make = boost::detail::winapi::ERROR_CANNOT_MAKE_,
        // ...
-        broken_pipe = boost::winapi::ERROR_BROKEN_PIPE_,
-        open_failed = boost::winapi::ERROR_OPEN_FAILED_,
-        buffer_overflow = boost::winapi::ERROR_BUFFER_OVERFLOW_,
-        disk_full= boost::winapi::ERROR_DISK_FULL_,
+        broken_pipe = boost::detail::winapi::ERROR_BROKEN_PIPE_,
+        open_failed = boost::detail::winapi::ERROR_OPEN_FAILED_,
+        buffer_overflow = boost::detail::winapi::ERROR_BUFFER_OVERFLOW_,
+        disk_full= boost::detail::winapi::ERROR_DISK_FULL_,
        // ...
-        lock_failed = boost::winapi::ERROR_LOCK_FAILED_,
-        busy = boost::winapi::ERROR_BUSY_,
-        cancel_violation = boost::winapi::ERROR_CANCEL_VIOLATION_,
-        already_exists = boost::winapi::ERROR_ALREADY_EXISTS_
+        lock_failed = boost::detail::winapi::ERROR_LOCK_FAILED_,
+        busy = boost::detail::winapi::ERROR_BUSY_,
+        cancel_violation = boost::detail::winapi::ERROR_CANCEL_VIOLATION_,
+        already_exists = boost::detail::winapi::ERROR_ALREADY_EXISTS_
        // ...

        // TODO: add more Windows errors
@@ -107,7 +107,7 @@ namespace boost

    }  // namespace windows

-# ifdef BOOST_SYSTEM_ENABLE_DEPRECATED
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
    namespace windows = windows_error;
 # endif

@@ -1,7 +1,6 @@
-//  error_code stub implementation, for compatibility only
+//  error_code support implementation file  ----------------------------------//

 //  Copyright Beman Dawes 2002, 2006
-//  Copyright Peter Dimov 2018

 //  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)
@@ -14,18 +13,8 @@
 // the library is being built (possibly exporting rather than importing code)
 #define BOOST_SYSTEM_SOURCE

-#include <boost/system/config.hpp>
+#include <boost/system/error_code.hpp>

-namespace boost
-{
-
-namespace system
-{
-
-BOOST_SYSTEM_DECL void dummy_exported_function()
-{
-}
-
-} // namespace system
-
-} // namespace boost
+#ifndef BOOST_ERROR_CODE_HEADER_ONLY
+#include <boost/system/detail/error_code.ipp>
+#endif
@@ -1,7 +1,6 @@
 # Boost System Library test Jamfile

 # Copyright Beman Dawes 2003, 2006
-# Copyright 2017, 2018 Peter Dimov

 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt
@@ -9,123 +8,58 @@
 # See library home page at http://www.boost.org/libs/system

 import testing ;
-import os ;

 project
    : requirements
      <library>/boost/system//boost_system
+      <toolset>msvc:<asynch-exceptions>on
    ;
+    
+   lib throw_test
+     : throw_test.cpp
+     : <link>shared:<define>BOOST_SYSTEM_DYN_LINK=1
+       <link>static:<define>BOOST_SYSTEM_STATIC_LINK=1
+     ;
+   

-   lib throw_test : throw_test.cpp : <link>shared:<define>THROW_DYN_LINK=1 ;
-
-   lib single_instance_lib1 : single_instance_1.cpp : <link>shared:<define>SINGLE_INSTANCE_DYN_LINK ;
-   lib single_instance_lib2 : single_instance_2.cpp : <link>shared:<define>SINGLE_INSTANCE_DYN_LINK ;
-
-   rule cxx03 ( properties * )
-   {
-      local result ;
-
-      if <toolset>gcc in $(properties)
-      {
-         result = <cxxflags>-std=c++98 ; # 4.4 has no 03
-      }
-      else if <toolset>clang in $(properties)
-      {
-         result = <cxxflags>-std=c++03 ;
-      }
-      else
-      {
-         result = <build>no ;
-      }
-
-      return $(result) ;
-   }
-
-   rule cxx11 ( properties * )
-   {
-      local result ;
-
-      if <toolset>gcc in $(properties)
-      {
-         result = <cxxflags>-std=c++0x ; # 4.6 has no 11
-      }
-      else if <toolset>clang in $(properties)
-      {
-         result = <cxxflags>-std=c++11 ;
-      }
-      else
-      {
-         result = <build>no ;
-      }
-
-      return $(result) ;
-   }
-
-   rule system-run- ( sources + )
-   {
-      local result ;
-
-      result += [ run $(sources) : : : <link>static : $(sources[1]:B)_static ] ;
-      result += [ run $(sources) : : : <link>shared : $(sources[1]:B)_shared ] ;
-      result += [ run $(sources) : : : -<library>/boost/system//boost_system <define>BOOST_ERROR_CODE_HEADER_ONLY : $(sources[1]:B)_header ] ;
-
-      return $(result) ;
-   }
-
-if [ os.environ UBSAN ]
-{
-   rule system-run ( sources + )
-   {
-      # The 03/11 tests are ODR violations, no point running them under -fsanitize=undefined
-      return [ system-run- $(sources) ] ;
-   }
-}
-else
-{
-   rule system-run ( sources + )
-   {
-      local result = [ system-run- $(sources) ] ;
-
-      # Test a source file built with -std=c++03 linked with a System library built without -std=c++03
-      result += [ run $(sources) : : : <link>static <conditional>@cxx03 : $(sources[1]:B)_static_03 ] ;
-      result += [ run $(sources) : : : <link>shared <conditional>@cxx03 : $(sources[1]:B)_shared_03 ] ;
-
-      # Test a source file built with -std=c++11 linked with a System library built without -std=c++11
-      result += [ run $(sources) : : : <link>static <conditional>@cxx11 : $(sources[1]:B)_static_11 ] ;
-      result += [ run $(sources) : : : <link>shared <conditional>@cxx11 : $(sources[1]:B)_shared_11 ] ;
-
-      return $(result) ;
-   }
-}
-
-system-run error_code_test.cpp ;
-system-run error_code_user_test.cpp ;
-system-run system_error_test.cpp ;
-
-run dynamic_link_test.cpp throw_test :  :  : <link>shared : throw_test_shared ;
-
-system-run initialization_test.cpp ;
-
-run header_only_test.cpp : : : -<library>/boost/system//boost_system ;
-run header_only_test.cpp : : : -<library>/boost/system//boost_system <define>BOOST_NO_ANSI_APIS : header_only_test_no_ansi ;
-
-run config_test.cpp : : : <test-info>always_show_run_output ;
-
-system-run- std_interop_test.cpp ;
-system-run std_mismatch_test.cpp ;
-
-system-run single_instance_test.cpp single_instance_1.cpp single_instance_2.cpp ;
-run single_instance_test.cpp single_instance_lib1 single_instance_lib2 : : : <link>static : single_instance_lib_static ;
-run single_instance_test.cpp single_instance_lib1 single_instance_lib2 : : : <link>shared : single_instance_lib_shared ;
-
-system-run before_main_test.cpp ;
-run-fail throws_assign_fail.cpp ;
-system-run- constexpr_test.cpp ;
-system-run win32_hresult_test.cpp ;
-
-system-run error_category_test.cpp ;
-system-run generic_category_test.cpp ;
-system-run system_category_test.cpp ;
-
-# Quick (CI) test
-run quick.cpp ;
+   test-suite "system"
+       : [ run error_code_test.cpp
+           : # command line
+           : # input files
+           : # requirements
+                   <link>static
+         ]
+         [ run error_code_test.cpp
+           :  :  : <link>shared : error_code_test_shared
+         ]
+         [ run error_code_user_test.cpp
+           :  :  : <link>static
+         ]
+         [ run error_code_user_test.cpp
+           :  :  : <link>shared : error_code_user_test_shared
+         ]
+         [ run system_error_test.cpp
+           :  :  : <link>static
+         ]
+         [ run system_error_test.cpp
+            :  :  : <link>shared : system_error_test_shared
+         ]
+         [ run dynamic_link_test.cpp throw_test
+           :  :  : <link>shared : throw_test_shared
+         ]
+         [ run initialization_test.cpp
+            :  :  : <link>shared : initialization_test_shared
+         ]
+         [ run header_only_test.cpp
+           :  :  : <link>static
+         ]
+         [ run config_test.cpp
+           :  :  : <test-info>always_show_run_output 
+         ]
+         [ run std_interop_test.cpp
+           :  :  : <link>static
+         ]
+         [ run std_interop_test.cpp
+            :  :  : <link>shared : std_interop_test_shared
+         ]
+         ;
@@ -1,30 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <cerrno>
-
-using namespace boost::system;
-
-static error_code e1( 1, system_category() );
-static std::string m1 = e1.message();
-
-static error_code e2( ENOENT, generic_category() );
-static std::string m2 = e2.message();
-
-int main()
-{
-    error_code e1_( 1, system_category() );
-
-    BOOST_TEST_EQ( e1, e1_ );
-    BOOST_TEST_EQ( m1, e1_.message() );
-
-    error_code e2_( ENOENT, generic_category() );
-
-    BOOST_TEST_EQ( e2, e2_ );
-    BOOST_TEST_EQ( m2, e2_.message() );
-
-    return boost::report_errors();
-}
@@ -1,68 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/config/pragma_message.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/config.hpp>
-#include <boost/config/workaround.hpp>
-
-#if !defined(BOOST_SYSTEM_HAS_CONSTEXPR)
-
-BOOST_PRAGMA_MESSAGE("Skipping constexpr test, BOOST_SYSTEM_HAS_CONSTEXPR isn't defined")
-int main() {}
-
-#else
-
-using namespace boost::system;
-
-constexpr error_code e1( 1, system_category() );
-
-BOOST_STATIC_ASSERT( e1.value() == 1 );
-BOOST_STATIC_ASSERT( e1.category() == system_category() );
-BOOST_STATIC_ASSERT( e1 );
-BOOST_STATIC_ASSERT( e1 == e1 );
-
-constexpr error_code e2( 2, generic_category() );
-
-BOOST_STATIC_ASSERT( e2.value() == 2 );
-BOOST_STATIC_ASSERT( e2.category() == generic_category() );
-BOOST_STATIC_ASSERT( e2 );
-BOOST_STATIC_ASSERT( e2 == e2 );
-
-#if !BOOST_WORKAROUND(BOOST_GCC, < 80200)
-
-BOOST_STATIC_ASSERT( e1 != e2 );
-
-#endif
-
-constexpr error_code e3;
-
-BOOST_STATIC_ASSERT( e3.value() == 0 );
-BOOST_STATIC_ASSERT( e3.category() == system_category() );
-BOOST_STATIC_ASSERT( !e3 );
-BOOST_STATIC_ASSERT( e3 == e3 );
-
-#if !BOOST_WORKAROUND(BOOST_GCC, < 80200)
-
-BOOST_STATIC_ASSERT( e1 != e3 );
-
-#endif
-
-int main()
-{
-    error_code e1_( 1, system_category() );
-    BOOST_TEST_EQ( e1, e1_ );
-
-    error_code e2_( 2, generic_category() );
-    BOOST_TEST_EQ( e2, e2_ );
-
-    error_code e3_;
-    BOOST_TEST_EQ( e3, e3_ );
-
-    return boost::report_errors();
-}
-
-#endif
@@ -19,15 +19,22 @@
 //--------------------------------------------------------------------------------------// 

 #include <boost/system/system_error.hpp>
+
 #include <iostream>

-void throw_test();
+namespace boost
+{
+  namespace system
+  {
+    BOOST_SYSTEM_DECL void throw_test();
+  }
+}

 int main()
 {
  try
  {
-    throw_test();
+    boost::system::throw_test();
  }
  catch (const boost::system::system_error& ex)
  {
@@ -35,6 +42,7 @@ int main()
    std::cout << "  what() reports " << ex.what() << '\n';
    return 0;
  }
+
  catch (const std::runtime_error& ex)
  {
    std::cout << "  error: caught std::runtime_error instead of boost::system::system_error\n";
@@ -44,4 +52,4 @@ int main()

  std::cout << "  error: failed to catch boost::system::system_error\n";
  return 1;
-}
+}
@@ -1,82 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-//
-// 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
-
-// See library home page at http://www.boost.org/libs/system
-
-// Avoid spurious VC++ warnings
-# define _CRT_SECURE_NO_WARNINGS
-
-#include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <cstdio>
-
-//
-
-namespace sys = boost::system;
-
-class user_category: public sys::error_category
-{
-public:
-
-    virtual const char * name() const BOOST_NOEXCEPT
-    {
-        return "user";
-    }
-
-    virtual std::string message( int ev ) const
-    {
-        char buffer[ 256 ];
-        std::sprintf( buffer, "user message %d", ev );
-
-        return buffer;
-    }
-
-    using sys::error_category::message;
-};
-
-static user_category s_cat_1;
-static user_category s_cat_2;
-
-int main()
-{
-    // default_error_condition
-
-    BOOST_TEST( s_cat_1.default_error_condition( 1 ) == sys::error_condition( 1, s_cat_1 ) );
-    BOOST_TEST( s_cat_2.default_error_condition( 2 ) == sys::error_condition( 2, s_cat_2 ) );
-
-    // equivalent
-
-    BOOST_TEST( s_cat_1.equivalent( 1, sys::error_condition( 1, s_cat_1 ) ) );
-    BOOST_TEST( !s_cat_1.equivalent( 1, sys::error_condition( 2, s_cat_1 ) ) );
-    BOOST_TEST( !s_cat_1.equivalent( 1, sys::error_condition( 2, s_cat_2 ) ) );
-
-    // the other equivalent
-
-    BOOST_TEST( s_cat_1.equivalent( sys::error_code( 1, s_cat_1 ), 1 ) );
-    BOOST_TEST( !s_cat_1.equivalent( sys::error_code( 1, s_cat_1 ), 2 ) );
-    BOOST_TEST( !s_cat_1.equivalent( sys::error_code( 1, s_cat_2 ), 1 ) );
-
-    // message
-
-    {
-        char buffer[ 256 ];
-        BOOST_TEST_CSTR_EQ( s_cat_1.message( 1, buffer, sizeof( buffer ) ), s_cat_1.message( 1 ).c_str() );
-    }
-
-    {
-        char buffer[ 4 ];
-        BOOST_TEST_CSTR_EQ( s_cat_1.message( 1, buffer, sizeof( buffer ) ), "use" );
-    }
-
-    // ==
-
-    BOOST_TEST_NOT( s_cat_1 == s_cat_2 );
-    BOOST_TEST( s_cat_1 != s_cat_2 );
-
-    return boost::report_errors();
-}
@@ -9,6 +9,9 @@

 //----------------------------------------------------------------------------//

+//  test without deprecated features
+#define BOOST_SYSTEM_NO_DEPRECATED
+
 #include <boost/config/warning_disable.hpp>

 #include <boost/detail/lightweight_test.hpp>
@@ -53,53 +56,6 @@ namespace
    ss >> s;
    BOOST_TEST( s == expected );
  }
-
-  //  throws_function_test  ------------------------------------------------------------//
-
-  //  usage example
-
-  int divide(int dividend, int divisor, boost::system::error_code& ec = boost::throws())
-  {
-    if (divisor == 0)                            // is there an error?
-    {
-      if (&ec == &boost::throws())               // throw on error
-        throw "oops!";                           // whatever exception you prefer
-      ec = error_code(EDOM, generic_category()); // report error via error_code
-      return 0;
-    }
-    
-    if (&ec != &boost::throws())                 // error reporting via error_code
-      ec.clear();
-    return dividend / divisor;
-  }
-
-  //  test usage example
-
-  void test_throws_usage()
-  {
-    std::cout << "Test throws() example and usage...\n";
-    error_code ec;
-
-    // no error tests
-    BOOST_TEST_EQ((divide(10, 2)), 5);        // no error, report via exception
-    ec = make_error_code(errc::argument_out_of_domain);
-    BOOST_TEST_EQ((divide(10, 5, ec)), 2);    // no error, report via error_code
-    BOOST_TEST(!ec);
-
-    ec = make_error_code(errc::argument_out_of_domain);
-    BOOST_TEST_EQ((divide(10, 0, ec)), 0);    // error, report via error_code
-    BOOST_TEST(ec);
-
-    bool exception_thrown = false;            
-    try
-      { divide(10, 0); }                      // error, report via exception
-    catch (...)
-      { exception_thrown = true; }            
-    BOOST_TEST(exception_thrown);
-
-    //error_code should_fail(boost::throws());     // should fail at runtime
-    //boost::throws() = ec;                        // should fail at runtime
-  }
 }

 //  main  ------------------------------------------------------------------------------//
@@ -123,7 +79,17 @@ int main( int, char ** )
  BOOST_TEST( generic_category() != system_category() );
  BOOST_TEST( system_category() != generic_category() );

-  BOOST_TEST_NE( generic_category() < system_category(), system_category() < generic_category() );
+  if ( std::less<const error_category*>()( &generic_category(), &system_category() ) )
+  {
+    BOOST_TEST( generic_category() < system_category() );
+    BOOST_TEST( !(system_category() < generic_category()) );
+  }
+  else
+  {
+    BOOST_TEST( system_category() < generic_category() );
+    BOOST_TEST( !(generic_category() < system_category()) );
+  }
+

  error_code ec;
  error_condition econd;
@@ -236,8 +202,6 @@ int main( int, char ** )
  BOOST_TEST( econd.message() != "" );
  BOOST_TEST( econd.message().substr( 0, 13) != "Unknown error" );

-  test_throws_usage();
-
 #ifdef BOOST_WINDOWS_API
  std::cout << "Windows tests...\n";
  // these tests probe the Windows errc decoder
@@ -14,6 +14,8 @@

 //  Motivation was a Boost posting by Christopher Kohlhoff on June 28, 2006.

+#define BOOST_SYSTEM_NO_DEPRECATED
+
 #include <boost/system/error_code.hpp>
 #include <boost/cerrno.hpp>
 #include <string>
@@ -1,41 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-//
-// 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
-
-// See library home page at http://www.boost.org/libs/system
-
-// Avoid spurious VC++ warnings
-# define _CRT_SECURE_NO_WARNINGS
-
-#include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <cstring>
-
-//
-
-namespace sys = boost::system;
-
-int main()
-{
-    sys::error_category const & cat = sys::generic_category();
-
-    // message
-
-    for( int i = -2; i < 1024; ++i )
-    {
-        {
-            BOOST_TEST_CSTR_EQ( cat.message( i ).c_str(), std::strerror( i ) );
-        }
-
-        {
-            char buffer[ 256 ];
-            BOOST_TEST_CSTR_EQ( cat.message( i, buffer, sizeof( buffer ) ), std::strerror( i ) );
-        }
-    }
-
-    return boost::report_errors();
-}
@@ -1,4 +1,4 @@
-//  header_only_test.cpp  -----------------------------------------------------//
+//  error_code_test.cpp  -----------------------------------------------------//

 //  Copyright Beman Dawes 2007

@@ -10,19 +10,19 @@
 //  This test verifiies that the error_category vtable does not suffer from
 //  order-of-initialization problems.

+#include <boost/detail/lightweight_test.hpp>
 #include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>

 struct foo
 {
  foo()
  {
    boost::system::error_code ec;
-    BOOST_TEST_NE( ec, boost::system::errc::permission_denied );
+    ec == boost::system::posix::permission_denied;
  }
 } f;

-int main()
+int main( int, char ** )
 {
-  return boost::report_errors();
+  return ::boost::report_errors();
 }
@@ -1,36 +0,0 @@
-
-// Copyright 2017 Peter Dimov.
-//
-// 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
-
-// See library home page at http://www.boost.org/libs/system
-
-#include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <cerrno>
-
-int main()
-{
-    boost::system::error_category const & bt = boost::system::generic_category();
-
-    int ev = ENOENT;
-
-    boost::system::error_code bc( ev, bt );
-
-    BOOST_TEST_EQ( bc.value(), ev );
-    BOOST_TEST_EQ( &bc.category(), &bt );
-
-    boost::system::error_condition bn = bt.default_error_condition( ev );
-
-    BOOST_TEST_EQ( bn.value(), ev );
-    BOOST_TEST_EQ( &bn.category(), &bt );
-
-    BOOST_TEST( bt.equivalent( ev, bn ) );
-
-    BOOST_TEST( bc == bn );
-
-    return boost::report_errors();
-}
@@ -1,29 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/config.hpp>
-
-#if defined(SINGLE_INSTANCE_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-#include <boost/system/error_code.hpp>
-using namespace boost::system;
-
-namespace lib1
-{
-
-EXPORT error_code get_system_code()
-{
-    return error_code( 0, system_category() );
-}
-
-EXPORT error_code get_generic_code()
-{
-    return error_code( 0, generic_category() );
-}
-
-} // namespace lib1
@@ -1,29 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/config.hpp>
-
-#if defined(SINGLE_INSTANCE_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-#include <boost/system/error_code.hpp>
-using namespace boost::system;
-
-namespace lib2
-{
-
-EXPORT error_code get_system_code()
-{
-    return error_code( 0, system_category() );
-}
-
-EXPORT error_code get_generic_code()
-{
-    return error_code( 0, generic_category() );
-}
-
-} // namespace lib2
@@ -1,47 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-using namespace boost::system;
-
-namespace lib1
-{
-
-error_code get_system_code();
-error_code get_generic_code();
-
-} // namespace lib1
-
-namespace lib2
-{
-
-error_code get_system_code();
-error_code get_generic_code();
-
-} // namespace lib2
-
-int main()
-{
-    {
-        error_code e1 = lib1::get_system_code();
-        error_code e2 = lib2::get_system_code();
-
-        BOOST_TEST_EQ( e1, e2 );
-
-        BOOST_TEST_EQ( hash_value( e1 ), hash_value( e2 ) );
-    }
-
-    {
-        error_code e1 = lib1::get_generic_code();
-        error_code e2 = lib2::get_generic_code();
-
-        BOOST_TEST_EQ( e1, e2 );
-
-        BOOST_TEST_EQ( hash_value( e1 ), hash_value( e2 ) );
-    }
-
-    return boost::report_errors();
-}
@@ -11,14 +11,10 @@
 // Avoid spurious VC++ warnings
 # define _CRT_SECURE_NO_WARNINGS

-#include <boost/system/error_code.hpp>
 #include <boost/config.hpp>
-#include <boost/config/pragma_message.hpp>
 #include <iostream>

-#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
+#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)

 int main()
 {
@@ -29,6 +25,7 @@ int main()

 #else

+#include <boost/system/error_code.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <system_error>
 #include <cerrno>
@@ -1,66 +0,0 @@
-
-// Copyright 2017 Peter Dimov.
-//
-// 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
-
-// See library home page at http://www.boost.org/libs/system
-
-// Avoid spurious VC++ warnings
-# define _CRT_SECURE_NO_WARNINGS
-
-#include <boost/system/error_code.hpp>
-#include <boost/config.hpp>
-#include <boost/config/pragma_message.hpp>
-#include <iostream>
-
-#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
-
-BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
-
-int main()
-{
-  std::cout
-    << "The version of the C++ standard library being used does not"
-    " support header <system_error> so interoperation will not be tested.\n";
-}
-
-#else
-
-#include <boost/core/lightweight_test.hpp>
-#include <system_error>
-#include <cerrno>
-#include <string>
-#include <cstdio>
-
-static void test_generic_category()
-{
-    boost::system::error_category const & bt = boost::system::generic_category();
-    std::error_category const & st = bt;
-
-    BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
-}
-
-static void test_system_category()
-{
-    boost::system::error_category const & bt = boost::system::system_category();
-    std::error_category const & st = bt;
-
-    BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
-}
-
-int main()
-{
-    std::cout
-      << "The version of the C++ standard library being used"
-      " supports header <system_error> so interoperation will be tested.\n";
-
-    test_generic_category();
-    test_system_category();
-
-    return boost::report_errors();
-}
-
-#endif
@@ -1,116 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-//
-// 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
-
-// See library home page at http://www.boost.org/libs/system
-
-// Avoid spurious VC++ warnings
-# define _CRT_SECURE_NO_WARNINGS
-
-#include <boost/system/error_code.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <cstring>
-#include <cstdio>
-
-//
-
-#if defined(BOOST_WINDOWS_API)
-
-#include <windows.h>
-
-std::string sys_strerror( int ev )
-{
-    void * lpMsgBuf = 0;
-
-    DWORD retval = FormatMessageA(
-        FORMAT_MESSAGE_ALLOCATE_BUFFER |
-        FORMAT_MESSAGE_FROM_SYSTEM |
-        FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL,
-        ev,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-        (LPSTR) &lpMsgBuf,
-        0,
-        NULL
-    );
-
-    struct local_free
-    {
-        void * p_;
-
-        ~local_free()
-        {
-            LocalFree( p_ );
-        }
-    };
-
-    local_free lf_ = { lpMsgBuf };
-
-    if( retval == 0 )
-    {
-        char buffer[ 38 ];
-
-        std::sprintf( buffer, "Unknown error (%d)", ev );
-        return buffer;
-    }
-
-    std::string str( static_cast<char const*>( lpMsgBuf ) );
-
-    while( !str.empty() && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
-    {
-        str.erase( str.size()-1 );
-    }
-
-    if( !str.empty() && str[str.size()-1] == '.' )
-    {
-        str.erase( str.size()-1 );
-    }
-
-    return str;
-}
-
-#else
-
-std::string sys_strerror( int ev )
-{
-    return std::strerror( ev );
-}
-
-#endif
-
-//
-
-namespace sys = boost::system;
-
-static void test_message( sys::error_category const & cat, int ev )
-{
-    BOOST_TEST_EQ( cat.message( ev ), sys_strerror( ev ) );
-
-    char buffer[ 2048 ]; // yes, really
-    BOOST_TEST_CSTR_EQ( cat.message( ev, buffer, sizeof( buffer ) ), sys_strerror( ev ).c_str() );
-}
-
-int main()
-{
-    sys::error_category const & cat = sys::system_category();
-
-    // message
-
-    for( int i = -2; i < 1024; ++i )
-    {
-        test_message( cat, i );
-    }
-
-    test_message( cat, 5810 );
-
-    for( int i = 10000; i < 11032; ++i )
-    {
-        test_message( cat, i );
-    }
-
-    return boost::report_errors();
-}
@@ -9,6 +9,9 @@

 //----------------------------------------------------------------------------// 

+//  test without deprecated features
+#define BOOST_SYSTEM_NO_DEPRECATED
+
 #include <boost/config/warning_disable.hpp>

 #include <boost/detail/lightweight_test.hpp>
@@ -13,16 +13,19 @@

 //--------------------------------------------------------------------------------------// 

+// define BOOST_SYSTEM_SOURCE so that <boost/system/config.hpp> knows
+// the library is being built (possibly exporting rather than importing code)
+#define BOOST_SYSTEM_SOURCE 
+
 #include <boost/system/system_error.hpp>
-#include <boost/config.hpp>

-#if defined(THROW_DYN_LINK)
-# define EXPORT BOOST_SYMBOL_EXPORT
-#else
-# define EXPORT
-#endif
-
-EXPORT void throw_test()
+namespace boost
 {
-    throw boost::system::system_error( 9999, boost::system::system_category(), "boo boo" );
+  namespace system
+  {
+    BOOST_SYSTEM_DECL void throw_test()
+    {
+      throw system_error(9999, system_category(), "boo boo");
+    }
+  }
 }
@@ -1,28 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-
-#include <boost/system/error_code.hpp>
-
-using namespace boost::system;
-
-static void f( error_code & ec )
-{
-    ec = error_code();
-}
-
-#if defined(_WIN32)
-# include <windows.h> // SetErrorMode
-#endif
-
-int main()
-{
-#if defined(_WIN32)
-
-    SetErrorMode( SetErrorMode( 0 ) | SEM_NOGPFAULTERRORBOX );
-
-#endif
-
-    // this should crash
-    f( boost::throws() );
-}
@@ -1,41 +0,0 @@
-
-// Copyright 2018 Peter Dimov.
-//
-// 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
-
-// See library home page at http://www.boost.org/libs/system
-
-#include <boost/system/error_code.hpp>
-#include <boost/config/pragma_message.hpp>
-
-#if !defined(BOOST_WINDOWS_API)
-
-BOOST_PRAGMA_MESSAGE( "Skipping test, BOOST_WINDOWS_API is not defined" )
-int main() {}
-
-#else
-
-#include <boost/core/lightweight_test.hpp>
-#include <windows.h>
-
-int main()
-{
-    namespace sys = boost::system;
-
-    HRESULT r = HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED );
-
-    sys::error_code ec( r, sys::system_category() );
-    sys::error_condition en = make_error_condition( sys::errc::permission_denied );
-
-    BOOST_TEST( ec == en );
-    BOOST_TEST( ec.default_error_condition() == en );
-
-    BOOST_TEST_EQ( ec.default_error_condition().value(), en.value() );
-
-    return boost::report_errors();
-}
-
-#endif
Author	SHA1	Message	Date
Peter Dimov	c306d479e8	Update Jamfile to generate dependencies	2017-06-24 03:45:04 +03:00
Peter Dimov	49b3580adf	Add cmake files	2017-06-24 00:38:16 +03:00