Update Jamfile to generate dependencies

Add conversions to std:: counterparts when <system_error> is available

.travis.yml

@@ -0,0 +1,307 @@
+# 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)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=c++03
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      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
+      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:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      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:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      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:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++03
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=c++11
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++03
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=c++03
+      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++11
+      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++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:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++11
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++14
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=c++1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
+
+    - os: osx
+      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:
+  - cd ..
+  - 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
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/system
+  - python tools/boostdep/depinst/depinst.py system
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER : <cxxflags>-std=$CXXSTD ;" > ~/user-config.jam
+  - ./b2 libs/system/test toolset=$TOOLSET
+
+notifications:
+  email:
+    on_success: always

CMakeLists.txt

@@ -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)

appveyor.yml

@@ -0,0 +1,69 @@
+# Copyright 2016, 2017 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)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-9.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-10.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      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
+
+install:
+  - cd ..
+  - 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
+  - git submodule update --init tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\system
+  - python tools/boostdep/depinst/depinst.py system
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - b2 libs/system/test toolset=%TOOLSET% %CXXFLAGS%

cmake/BoostVersion.cmake

@@ -0,0 +1 @@
+set(BOOST_VERSION 1.65.0)

cmake/Jamfile

@@ -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>. ;

cmake/default.cmake

@@ -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}
+)

cmake/dependencies.cmake

@@ -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)
+

cmake/sources.cmake

@@ -0,0 +1,3 @@
+set(${PROJECT_NAME}_SOURCES
+  src/error_code.cpp
+)

doc/index.html

@@ -6,7 +6,7 @@
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <title>Boost System Library</title>
-<link rel="stylesheet" type="text/css" href="../../../doc/html/minimal.css">
+<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
 </head>
 
 <body>
@@ -38,6 +38,7 @@
   <tr>
     <td width="100%" bgcolor="#E8F5FF">
       <a href="#Introduction">Introduction</a><br>
+      <a href="#Release_History">Release History</a><br>
       <a href="#Design_Rationale">Design Rationale</a><br>
       <a href="#History">History</a><br>
       <a href="#Acknowledgements">Acknowledgements</a>
@@ -93,6 +94,21 @@ supports both error reporting by exception and by error code.</p>
 error_code.hpp</code> header, system-specific headers support the Cygwin, Linux, 
 and Windows platforms. These headers are effectively no-ops if included for 
 platforms other than their intended target.</p>
+<table border="1" cellpadding="10" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td>The Boost System Library is part of the C++11 Standard Library. 
+    A number of changes, particularly to names, were made by the C++ committee 
+    during standardization. The Boost implementation is tracking those changes. 
+    See <a href="reference.html#Deprecated-names">Deprecated names</a> for 
+    synonyms provided to prevent breakage of existing user code. See
+    <a href="reference.html#Breaking-changes">Breaking changes</a> for changes 
+    that unavoidably break existing user code. All breaking changes are noisy 
+    and will cause compile-time errors.</td>
+  </tr>
+</table>
+<h2><a name="Release_History">Release History</a></h2>
+<p><code>system-2014-06-02</code>: First modular Boost release. Minor 
+maintenance changes.</p>
 <h2><a name="Design_Rationale">Design Rationale</a></h2>
 <p>Class <code>error_code</code>&nbsp; and <code>error_condition</code> are designed as a value types so 
 they can be copied 
@@ -133,7 +149,7 @@ paper. Johan Nilsson's comments led to several of the refinements in N2066 .</p>
 <hr>
 
 <p>Revised 
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->February 23, 2008<!--webbot bot="Timestamp" endspan i-checksum="41408" --> </font>
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->June 02, 2014<!--webbot bot="Timestamp" endspan i-checksum="13984" --> </font>
 </p>
 
 <p><EFBFBD> Copyright Beman Dawes, 1999</p>

doc/reference.html

@@ -6,7 +6,7 @@
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
 <title>System Library Reference</title>
-<link rel="stylesheet" type="text/css" href="../../../doc/html/minimal.css">
+<link rel="stylesheet" type="text/css" href="../../../doc/src/minimal.css">
 </head>
 
 <body>
@@ -38,8 +38,10 @@
   <tr>
     <td width="100%" bgcolor="#E8F5FF">
       <a href="#Introduction">Introduction</a><br>
+      <a href="#C++11">C++11</a><br>
       <a href="#Macros">Macros</a><br>
       <a href="#Deprecated-names">Deprecated names</a><br>
+      <a href="#Breaking-changes">Breaking changes</a><br>
       <a href="#Header-error_code">Header &lt;boost/system/error_code.hpp&gt;</a><br>
       <a href="#Class-error_category">Class <code>error_category</code></a><br>
       &nbsp;&nbsp;&nbsp;<a href="#Class-error_category-synopsis">Class <code>error_category</code> synopsis</a><br>
@@ -53,7 +55,7 @@
       &nbsp;&nbsp;&nbsp;<a href="#Class-error_code-constructors">Class <code>error_code</code> constructors</a><br>
       &nbsp;&nbsp;&nbsp;<a href="#Class-error_code-modifiers">Class <code>error_code</code> modifiers</a><br>
       &nbsp;&nbsp;&nbsp;<a href="#Class-error_code-observers">Class <code>error_code</code> observers</a><br>
-      <a href="#Class-error_condition</code>">Class <code>error_condition</code></a><br>
+      <a href="#Class-error_condition">Class <code>error_condition</code></a><br>
       &nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-synopsis">Class <code>error_condition</code> synopsis</a><br>
       &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>
@@ -69,63 +71,68 @@
 
 <h2><a name="Introduction">Introduction</a></h2>
 
-<p>This reference documentation describes components that&nbsp; 
-programs may use to report error conditions originating from the operating 
+<p>This reference documentation describes components that&nbsp;programs may use to report error conditions originating from the operating 
 system or other low-level application program interfaces.</p>
 <p>Boost.System library components never change the value of <code>
 errno</code>.</p>
+<h2><a name="C++11">C++11</a></h2>
+<p>The library is documented to use several C++11 features, including <code>
+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 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">
+<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" height="368">
   <tr>
-    <td><b><i>Macro Name</i></b></td>
-    <td><b><i>Default</i></b></td>
-    <td><b><i>Effect if defined</i></b></td>
+    <td height="16"><b><i>Macro Name</i></b></td>
+    <td height="16"><b><i>Default</i></b></td>
+    <td height="16"><b><i>Effect if defined</i></b></td>
   </tr>
   <tr>
-    <td valign="top"><code>BOOST_WINDOWS_API</code></td>
-    <td valign="top">Defined if Windows is detected by Boost.System's automatic configuration 
-    code, otherwise not defined.</td>
-    <td valign="top">Implementation uses the Microsoft Windows native 
-    application program interface (API).</td>
+    <td valign="top" height="64"><code>BOOST_ERROR_CODE_HEADER_ONLY</code></td>
+    <td valign="top" height="64">Not defined.</td>
+    <td valign="top" height="64">The implementation is header-only, and the 
+    Boost.System library is not built. Overrides other link and library macros.</td>
   </tr>
   <tr>
-    <td valign="top"><code>BOOST_POSIX_API</code></td>
-    <td valign="top">Defined if Windows is not detected by Boost.System's automatic configuration 
-    code.</td>
-    <td valign="top">Implementation uses the POSIX native 
-    application program interface (API).</td>
-  </tr>
-  <tr>
-    <td valign="top"><code>BOOST_SYSTEM_DYN_LINK</code></td>
-    <td valign="top">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined, 
+    <td valign="top" height="64"><code>BOOST_SYSTEM_DYN_LINK</code></td>
+    <td valign="top" height="64">Defined if <code>BOOST_ALL_DYN_LINK</code> is defined, 
     otherwise not defined.</td>
-    <td valign="top">Boost.System library is dynamically linked. If not defined, 
+    <td valign="top" height="64">Boost.System library is dynamically linked. If not defined, 
     static linking is assumed.</td>
   </tr>
   <tr>
-    <td valign="top"><code>BOOST_SYSTEM_NO_LIB</code></td>
-    <td valign="top">Defined if <code>BOOST_ALL_NO_LIB</code> is defined, 
+    <td valign="top" height="47"><code>BOOST_SYSTEM_NO_LIB</code></td>
+    <td valign="top" height="47">Defined if <code>BOOST_ALL_NO_LIB</code> is defined, 
     otherwise not defined.</td>
-    <td valign="top">Boost.System library does not use the Boost auto-link 
+    <td valign="top" height="47">Boost.System library does not use the Boost auto-link 
     facility.</td>
   </tr>
   <tr>
-    <td valign="top"><code>BOOST_SYSTEM_NO_DEPRECATED</code></td>
-    <td valign="top">Not defined.</td>
-    <td valign="top">Deprecated features are excluded.</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 excluded.</td>
   </tr>
-</table>
+  </table>
 <h2><a name="Deprecated-names">Deprecated names</a></h2>
-<p>In the process of adding Boost.System to C++0x standard library, some of the 
-names are being changed. To ease transition, Boost.System deprecates the old 
+<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 name, now deprecated</i></b></td>
-    <td><b><i>New name</i></b></td>
+    <td><b><i>Old usage, now deprecated</i></b></td>
+    <td><b><i>Replacement</i></b></td>
+  </tr>
+  <tr>
+    <td><code>get_generic_category()</code></td>
+    <td><code>generic_category()</code></td>
+  </tr>
+  <tr>
+    <td><code>get_system_category()</code></td>
+    <td><code>system_category()</code></td>
   </tr>
   <tr>
     <td><code>namespace posix</code></td>
@@ -141,21 +148,39 @@ is defined.</p>
   </tr>
   <tr>
     <td><code>get_posix_category()</code></td>
-    <td><code>get_generic_category()</code></td>
+    <td><code>generic_category()</code></td>
   </tr>
   <tr>
     <td><code>posix_category</code></td>
-    <td><code>generic_category</code></td>
+    <td><code>generic_category()</code></td>
   </tr>
   <tr>
     <td><code>errno_ecat</code></td>
-    <td><code>generic_category</code></td>
+    <td><code>generic_category()</code></td>
   </tr>
   <tr>
     <td><code>native_ecat</code></td>
-    <td><code>system_category</code></td>
+    <td><code>system_category()</code></td>
   </tr>
 </table>
+<h2><a name="Breaking-changes">Breaking changes</a></h2>
+<p>Two static consts are replaced by functions. These are breaking changes best 
+fixed by globally adding () to these names to turn them into function calls.</p>
+<table border="1" cellpadding="5" cellspacing="1" style="border-collapse: collapse" bordercolor="#111111">
+  <tr>
+    <td><b><i>Old usage, now broken</i></b></td>
+    <td><b><i>Replacement</i></b></td>
+  </tr>
+  <tr>
+    <td><code>generic_category</code></td>
+    <td><code>generic_category()</code></td>
+  </tr>
+  <tr>
+    <td><code>system_category</code></td>
+    <td><code>system_category()</code></td>
+  </tr>
+  </table>
+<p>User-defined BOOST_POSIX_API and BOOST_WINDOWS_API macros are no longer supported.</p>
 <h2><a name="Header-error_code">Header &lt;boost/system/error_code.hpp&gt;</a></h2>
 <h3>&lt;boost/system/error_code.hpp&gt; synopsis</h3>
 <blockquote>
@@ -164,6 +189,9 @@ is defined.</p>
   namespace system
   {
     class <a href="#Class-error_category">error_category</a>;
+    const error_category &amp;  <a href="#system_category">system_category</a>() noexcept;
+    const error_category &amp;  <a href="#generic_category">generic_category</a>() noexcept;
+
     class <a href="#Class-error_code">error_code</a>;
     class <a href="#Class-error_condition">error_condition</a>;
 
@@ -265,26 +293,23 @@ is defined.</p>
     template<> struct is_error_condition_enum<posix::posix_errno>&lt;errc::errc_t&gt;
       { static const bool value = true; };
 
-    // predefined error_code object used as &quot;throw on error&quot; tag
-    extern error_code <a href="#throws-object">throws</a>;
-
     //  <a href="#Non-member-functions">non-member functions</a>
 
-    bool operator==( const error_code &amp; lhs, const error_code &amp; rhs );
-    bool operator==( const error_code &amp; code, const error_condition &amp; condition );
-    bool operator==( const error_condition &amp; condition, const error_code &amp; code );
-    bool operator==( const error_condition &amp; lhs, const error_condition &amp; rhs );
+    bool operator==( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;
+    bool operator==( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
+    bool operator==( const error_condition &amp; condition, const error_code &amp; code ) noexcept;
+    bool operator==( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;
 
-    bool operator!=( const error_code &amp; lhs, const error_code &amp; rhs );
-    bool operator!=( const error_code &amp; code, const error_condition &amp; condition );
-    bool operator!=( const error_condition &amp; condition, const error_code &amp; code );
-    bool operator!=( const error_condition &amp; lhs, const error_condition &amp; rhs );
+    bool operator!=( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;
+    bool operator!=( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
+    bool operator!=( const error_condition &amp; condition, const error_code &amp; code ) noexcept;
+    bool operator!=( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;
 
-    bool operator&lt;( const error_code &amp; lhs, const error_code &amp; rhs );
-    bool operator&lt;( const error_condition &amp; lhs, const error_condition &amp; rhs );
+    bool operator&lt;( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;
+    bool operator&lt;( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;
 
-    error_code make_error_code( errc::errc_t e );
-    error_condition make_error_condition( errc::errc_t e );
+    error_code make_error_code( errc::errc_t e ) noexcept;
+    error_condition make_error_condition( errc::errc_t e ) noexcept;
 
     template &lt;class charT, class traits&gt;
       std::basic_ostream&lt;charT,traits&gt;&amp;
@@ -301,6 +326,17 @@ is_error_condition_enum</code> templates to indicate that a type is eligible for
 class <code>error_code</code> and <code>error_condition</code> automatic 
 conversions respectively.</p>
 
+<pre>const error_category &amp; <a name="system_category">system_category</a>();</pre>
+<blockquote>
+  <p><i>Returns:</i> A reference to a <code>error_category</code> object 
+  identifying errors originating from the operating system.</p>
+</blockquote>
+<pre>const error_category &amp; <a name="generic_category">generic_category</a>();</pre>
+<blockquote>
+  <p><i>Returns:</i> A reference to a <code>error_category</code> object 
+  identifying portable error conditions.</p>
+</blockquote>
+
 <h2><a name="Class-error_category">Class <code>error_category</code></a></h2>
 <p>The class <code>error_category</code> defines the base class for types used 
 to identify the source and encoding of a particular category of error code.</p>
@@ -325,99 +361,69 @@ types should create a single object of each such type. <i>
     public:
       virtual ~error_category();
 
-      virtual const char *     name() const = 0;
+      virtual const char *     name() const noexcept = 0;
       virtual string           message( int ev ) const = 0;
-      virtual error_condition  default_error_condition( int ev ) const;
-      virtual bool             equivalent( int code, const error_condition &amp; condition ) const;
-      virtual bool             equivalent( const error_code &amp; code, int condition ) const;
+      virtual error_condition  default_error_condition( int ev ) const noexcept;
+      virtual bool             equivalent( int code, const error_condition &amp; condition )
+                                 const noexcept;
+      virtual bool             equivalent( const error_code &amp; code, int condition ) const noexcept;
 
-      bool operator==( const error_category &amp; rhs ) const;
-      bool operator!=( const error_category &amp; rhs ) const;
-      bool operator&lt; ( const error_category &amp; rhs ) const;
+      bool operator==( const error_category &amp; rhs ) const noexcept;
+      bool operator!=( const error_category &amp; rhs ) const noexcept;
+      bool operator&lt; ( const error_category &amp; rhs ) const noexcept;
     };
-
-    const error_category &amp;  get_system_category();
-    const error_category &amp;  get_generic_category();
-
-    static const error_category &amp;  system_category = get_system_category();
-    static const error_category &amp;  generic_category = get_generic_category();
   }
 }</pre>
 </blockquote>
 <h3><a name="Class-error_category-virtual-members">Class <code>error_category</code> virtual members</a></h3>
 <p>Classes derived from <code>error_category</code> shall behave as specified in 
 this subclause.</p>
-<pre>virtual const char * name() const=0;</pre>
+<pre>virtual const char * name() const noexcept =0;</pre>
 <blockquote>
   <p><i>Returns: </i>a string naming the error category.</p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-<pre>virtual string message( int ev ) const=0;</pre>
+<pre>virtual string message( int ev ) const noexcept =0;</pre>
 <blockquote>
   <p><i>Returns:</i> A string that describes the error denoted by
   <code>ev</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-<p><code>virtual error_condition default_error_condition( int ev ) const;</code></p>
+<pre>virtual error_condition default_error_condition( int ev ) const noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i>&nbsp; <code>error_condition( ev, *this )</code>.</p>
   <blockquote>
-    <p>&nbsp;[<i>--Note:</i> Derived classes will typically convert <code>ev</code> 
-    to some portable <code>error_category</code>, such as <code>generic_category</code>, 
+    <p dir="ltr">&nbsp;[<i>--Note:</i> Derived classes will typically convert <code>ev</code> 
+    to some portable <code>error_category</code>, such as <code>generic_category()</code>, 
     and return it as an <code>error_condition</code> for that category. <i>--end 
     note</i>]</p>
   </blockquote>
-  <p><i>Throws:</i> Nothing.</p>
-</blockquote>
-<p><code>virtual bool equivalent( int code, const error_condition &amp; 
-condition ) 
-const;</code></p>
+  </blockquote>
+<pre>virtual bool equivalent( int code, const error_condition &amp; condition ) const noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>default_error_condition( code ) == condition</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
-</blockquote>
-<p><code>virtual bool equivalent( const error_code &amp; code, int condition ) const;</code></p>
+  </blockquote>
+<pre>virtual bool equivalent( const error_code &amp; code, int condition ) const noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>*this == code.category() &amp;&amp; code.value() == condition</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
-</blockquote>
+  </blockquote>
 <h3><a name="Class-error_category-non-virtual-members">Class <code>error_category</code> non-virtual members</a></h3>
-<p><code>bool operator==( const error_category &amp; rhs ) const;</code></p>
+<pre>bool operator==( const error_category &amp; rhs ) const noexcept;</pre>
 <blockquote>
 <p><i>Returns:</i> <code>this == &amp;rhs</code>.</p>
 </blockquote>
-<p><code>bool operator!=( const error_category &amp; rhs ) const;</code></p>
+<pre>bool operator!=( const error_category &amp; rhs ) const noexcept;</pre>
 <blockquote>
 <p><i>Returns:</i> <code>this != &amp;rhs</code>.</p>
 </blockquote>
 
-<pre>bool operator&lt;( const error_category &amp; rhs ) const;</pre>
+<pre>bool operator&lt;( const error_category &amp; rhs ) const noexcept;</pre>
 <blockquote>
-  <p><i>Returns:</i> <code>std::less&lt;const error_category*&gt;()( this, &amp;rhs )</code>.</p>
+  <p><i>Returns:</i> <code>std::less&lt;const error_category*&gt;()( this, &amp;rhs&nbsp; 
+  noexcept)</code>.</p>
   <blockquote>
     <p><i>[Note:</i> <code>std::less</code> provides a total ordering for 
     pointers. <i>--end note]</i></p>
   </blockquote>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-<h3><a name="Class-error_category-non-member-functions">Class <code>error_category</code> 
-non-member functions</a></h3>
-<pre>const error_category &amp; get_system_category();</pre>
-<blockquote>
-  <p><i>Returns:</i> A reference to a <code>error_category</code> object 
-  identifying errors originating from the operating system.</p>
-  <p><i>Throws:</i> Nothing.</p>
-</blockquote>
-<pre>const error_category &amp; get_generic_category();</pre>
-<blockquote>
-  <p><i>Returns:</i> A reference to a <code>error_category</code> object 
-  identifying portable error conditions.</p>
-  <p><i>Throws:</i> Nothing.</p>
-</blockquote>
-<h3><a name="Class-error_category-predefined-objects">Class <code>error_category</code> 
-predefined objects</a></h3>
-<p>Predefined objects <code>system_category</code> 
-and <code>generic_category</code> identify system specific error codes and portable error conditions, respectively.</p>
 <h2><a name="Class-error_code">Class <code>
 error_code</code></a></h2>
 <p>The class <code>error_code</code> describes an object used to hold error code 
@@ -436,23 +442,21 @@ error_code</code> synopsis</a></h3>
     public:
 
       // constructors:
-      error_code();
-      error_code( val, const error_category &amp; cat );
+      error_code() noexcept;
+      error_code( val, const error_category &amp; cat ) noexcept;
       template &lt;class <code>ErrorCodeEnum</code>&gt;
-        error_code(<code> ErrorCodeEnum</code> e,
-         typename enable_if&lt;is_error_code_enum&lt;<code>ErrorCodeEnum</code>&gt; &gt;::type* = 0);
+        error_code(<code> ErrorCodeEnum</code> e ) noexcept;
 
       // modifiers:
-      void assign( int val, const error_category &amp; cat );
+      void assign( int val, const error_category &amp; cat ) noexcept;
       template&lt;typename <code>ErrorCodeEnum</code>&gt;
-        typename enable_if&lt;is_error_code_enum&lt;<code>ErrorCodeEnum</code>&gt;, error_code&gt;::type &amp;
-          operator=( <code>ErrorCodeEnum</code> val );;
-      void clear();
+        error_code &amp; operator=( <code>ErrorCodeEnum</code> val ) noexcept;
+      void clear() noexcept;
 
       // observers:
-      int                    value() const;
-      cont error_category &amp;  category() const;
-      error_condition        default_error_condition() const;
+      int                    value() const noexcept;
+      cont error_category &amp;  category() const noexcept;
+      error_condition        default_error_condition() const noexcept;
       string                 message() const;
       operator unspecified-bool-type() const;
 
@@ -465,67 +469,63 @@ error_code</code> synopsis</a></h3>
 </blockquote>
 <h3><a name="Class-error_code-constructors">Class <code>
 error_code</code> constructors</a></h3>
-<pre>error_code();</pre>
+<pre>error_code() noexcept;</pre>
 <blockquote>
   <p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
-  <p><i>Postconditions:</i> <code>val_ == 0 &amp;&amp; cat_ == &amp;system_category</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
+  <p><i>Postconditions:</i> <code>val_ == 0 &amp;&amp; cat_ == &amp;system_category()</code>.</p>
 </blockquote>
-<pre>error_code( int val, const error_category &amp; cat );</pre>
+<pre>error_code( int val, const error_category &amp; cat ) noexcept;</pre>
 <blockquote>
   <p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
   <p><i>Postconditions:</i> <code>val_ == val &amp;&amp; cat_ == &amp;cat</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
 <pre>template &lt;class <code>ErrorCodeEnum</code>&gt;
-  error_code(<code> errorCodeEnum</code> val,
-    typename enable_if&lt;is_error_code_enum&lt;<code>ErrorCodeEnum</code>&gt; &gt;::type* = 0);</pre>
+  error_code(<code> ErrorCodeEnum</code> val ) noexcept;</pre>
 <blockquote>
   <p><i>Effects: </i>Constructs an object of type <code>error_code</code>.</p>
   <p><i>Postconditions:</i> <code>*this == make_error_code( val )</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
+  <p><i>Remarks:</i> This constructor shall not participate in overload 
+  resolution unless <code>is_error_code_enum&lt;ErrorCodeEnum&gt;::value</code> is
+  <code>true</code>.</p>
 </blockquote>
 <h3><a name="Class-error_code-modifiers">Class <code>
 error_code</code> modifiers</a></h3>
-<pre>void assign( int val, const error_category &amp; cat );</pre>
+<pre>void assign( int val, const error_category &amp; cat ) noexcept;</pre>
 <blockquote>
   <p><i>Postconditions:</i> <code>val_ == val &amp;&amp; cat_ == &amp;cat</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
 <pre>template&lt;typename <code>ErrorCodeEnum</code>&gt;
-  typename enable_if&lt;is_error_code_enum&lt;<code>ErrorCodeEnum</code>&gt;, error_code&gt;::type &amp;
-    operator=( <code>ErrorCodeEnum</code> val );</pre>
+  error_code &amp; operator=( <code>ErrorCodeEnum</code> val ) noexcept;</pre>
 <blockquote>
   <p><i>Postconditions:</i> <code>*this == make_error_code( val )</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
+  <p><i>Remarks:</i> This operator shall not participate in overload resolution 
+  unless <code>is_error_code_enum&lt;ErrorCodeEnum&gt;::value</code> is <code>true</code>.</p>
 </blockquote>
-<p><code>void clear();</code></p>
+<pre><code>void clear() noexcept;</code></pre>
 <blockquote>
-  <p><i>postcondition:</i> <code>value() == 0 &amp;&amp; category() == generic_category</code></p>
+  <p><i>postcondition:</i> <code>value() == 0 &amp;&amp; category() == 
+  system_category()</code></p>
 </blockquote>
   <h3><a name="Class-error_code-observers">Class <code>
 error_code</code> observers</a></h3>
-  <p><code>int value() const;</code></p>
+  <pre><code>int value() const noexcept;</code></pre>
 <blockquote>
 <p><i>Returns:</i> <code>val_</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
-</blockquote>
-  <p><code>const error_category &amp; category() const;</code></p>
+  </blockquote>
+<pre><code>const error_category &amp; category() const noexcept;</code></pre>
 <blockquote>
 <p><i>Returns:</i> <code>*cat_</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
-</blockquote>
-  <pre>error_condition default_error_condition() const;</pre>
+  </blockquote>
+  <pre>error_condition default_error_condition() const noexcept;</pre>
 <blockquote>
 <p><i>Returns:</i>&nbsp; <code>category().default_error_condition( value())</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-  <p><code>string message() const;</code></p>
+  <pre><code>string message() const;</code></pre>
 <blockquote>
 <p><i>Returns:</i>&nbsp; <code>category().message( value())</code>.</p>
   <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-<p><code>operator <i>unspecified-bool-type</i>() const;</code></p>
+<pre>operator unspecified-bool-type() const;</pre>
 <blockquote>
 <p><i>Returns:</i> if <code>value() != 0</code>, returns a value that will evaluate
 <code>true</code> in a boolean context; otherwise, returns a value that will 
@@ -554,24 +554,22 @@ implementation specific. <i>--end note ]</i></p>
     public:
 
       // constructors:
-      error_condition();
-      error_condition( int val, const error_category &amp; cat );
+      error_condition() noexcept;
+      error_condition( int val, const error_category &amp; cat ) noexcept;
       template &lt;class ErrorConditionEnum&gt;
-        error_condition( errorConditionEnum val,
-          typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt; &gt;::type* = 0 );
+        error_condition( errorConditionEnum val ) noexcept;
 
       // modifiers:
-      void assign( int val, const error_category &amp; cat );
+      void assign( int val, const error_category &amp; cat ) noexcept;
       template&lt;typename ErrorConditionEnum&gt;
-        typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;, error_code&gt;::type &amp;
-          operator=( ErrorConditionEnum val );
-      void clear();
+        error_condition &amp; operator=( ErrorConditionEnum val ) noexcept;
+      void clear() noexcept;
 
       // observers:
-      int value() const;
-      const error_category &amp; category() const;
+      int value() const noexcept;
+      const error_category &amp; category() const noexcept;
       string message() const;
-      operator unspecified-bool-type () const;
+      operator unspecified-bool-type () const noexcept;
 
     private:
       int val_;                      // <i>exposition only</i>
@@ -582,60 +580,57 @@ implementation specific. <i>--end note ]</i></p>
 </blockquote>
 <h3><a name="Class-error_condition-constructors">Class <code>error_condition</code> 
 constructors</a></h3>
-<pre>error_condition(); </pre>
+<pre>error_condition() noexcept; </pre>
 <blockquote>
   <p><i>Effects:</i> Constructs an object of type <code>error_condition</code>.</p>
-  <p><i>Postconditions:</i> <code>val_ == 0 and cat_ == &amp;generic_category</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
+  <p><i>Postconditions:</i> <code>val_ == 0 and cat_ == &amp;generic_category()</code>.</p>
 </blockquote>
-<pre>error_condition( int val, const error_category &amp; cat );</pre>
+<pre>error_condition( int val, const error_category &amp; cat ) noexcept;</pre>
 <blockquote>
   <p><i>Effects: </i>Constructs an object of type error_condition.</p>
   <p><i>Postconditions:</i> <code>val_ == val and cat_ == &amp;cat</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
 <pre>template &lt;class ErrorConditionEnum&gt;
-  error_condition( errorConditionEnum val,
-    typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt; &gt;::type* = 0 );</pre>
+  error_condition( ErrorConditionEnum e ) noexcept;</pre>
 <blockquote>
   <p><i>Effects:</i> Constructs an object of type <code>error_condition</code>.</p>
-  <p><i>Postconditions:</i> <code>*this == make_error_condition( val )</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
+  <p><i>Postconditions:</i> <code>*this == make_error_condition(e)</code>.</p>
+  <p><i>Remarks:</i> This constructor shall not participate in overload 
+  resolution unless <code>is_error_condition_enum&lt;ErrorConditionEnum&gt;::value</code> 
+  is <code>true</code>.</p>
 </blockquote>
 <h3><a name="Class-error_condition-modifiers">Class <code>error_condition</code> 
 modifiers</a></h3>
-<pre>void assign( int val, const error_category &amp; cat ); </pre>
+<pre>void assign( int val, const error_category &amp; cat ) noexcept; </pre>
 <blockquote>
   <p><i>Postconditions:</i> <code>val_ == val and cat_ == &amp;cat</code>. </p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
 <pre>template&lt;typename ErrorConditionEnum&gt;
-  typename enable_if&lt;is_error_condition_enum&lt;ErrorConditionEnum&gt;, error_code&gt;::type &amp;
-    operator=( ErrorConditionEnum val );</pre>
+  error_condition &amp; operator=( ErrorConditionEnum e ) noexcept;</pre>
 <blockquote>
-  <p><i>Postconditions:</i> <code>*this == make_error_condition( val )</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
+  <p><i>Postconditions:</i> <code>*this == make_error_condition( e )</code>.</p>
+  <p><i>Returns:</i> <code>*this</code>.</p>
+  <p><i>Remarks:</i> This operator shall not participate in overload resolution 
+  unless <code>is_error_condition_enum&lt;ErrorConditionEnum&gt;::value</code> is
+  <code>true</code>.</p>
 </blockquote>
-<p><code>void clear();</code></p>
+<pre>void clear() noexcept;</pre>
 <blockquote>
-  <p><i>postcondition:</i> <code>value() == 0 &amp;&amp; category() == generic_category</code></p>
+  <p><i>Postcondition:</i> <code>value() == 0 &amp;&amp; category() == generic_category()</code></p>
 </blockquote>
 <h3><a name="Class-error_condition-observers">Class <code>error_condition</code> 
 observers</a></h3>
-<pre>int value() const;</pre>
+<pre>int value() const noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>val_</code>.</p>
-  <p><i>Throws:</i> Nothing</p>
 </blockquote>
-<pre>const error_category &amp; category() const;</pre>
+<pre>const error_category &amp; category() const noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>*cat_</code>.</p>
-  <p>Throws: Nothing.</p>
 </blockquote>
 <pre>string message() const;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>category().message( value() )</code>.</p>
-  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
 <pre>operator unspecified-bool-type () const;</pre>
 <blockquote>
@@ -681,60 +676,52 @@ semantics:</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 );</pre>
+  <pre>bool operator==( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>lhs.category() == rhs.category() &amp;&amp; lhs.value() == 
   rhs.value()</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>bool operator==( const error_code &amp; code, const error_condition &amp; condition );
-bool operator==( const error_condition &amp; condition, const error_code &amp; code );</pre>
+<pre>bool operator==( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
+bool operator==( const error_condition &amp; condition, const error_code &amp; code ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>code.category().equivalent( code.value(), condition )<br>
   || condition.category().equivalent( code, condition.value() )</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>bool operator==( const error_condition &amp; lhs, const error_condition &amp; rhs );</pre>
+<pre>bool operator==( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>lhs.category() == rhs.category() &amp;&amp; lhs.value() == 
   rhs.value()</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>bool operator!=( const error_code &amp; lhs, const error_code &amp; rhs );</pre>
+<pre>bool operator!=( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>bool operator!=( const error_code &amp; code, const error_condition &amp; condition );
-bool operator!=( const error_condition &amp; condition, const error_code &amp; code );</pre>
+<pre>bool operator!=( const error_code &amp; code, const error_condition &amp; condition ) noexcept;
+bool operator!=( const error_condition &amp; condition, const error_code &amp; code ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i><code> !( code ==&nbsp; condition )</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>bool operator!=( const error_condition &amp; lhs, const error_condition &amp; rhs );</pre>
+<pre>bool operator!=( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>!(lhs == rhs )</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>bool operator&lt;( const error_code &amp; lhs, const error_code &amp; rhs );</pre>
+<pre>bool operator&lt;( const error_code &amp; lhs, const error_code &amp; rhs ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>lhs.category() &lt; rhs.category()<br>
   &nbsp; || (lhs.category() == rhs.category() &amp;&amp; lhs.value() &lt; rhs.value())</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>bool operator&lt;( const error_condition &amp; lhs, const error_condition &amp; rhs );</pre>
+<pre>bool operator&lt;( const error_condition &amp; lhs, const error_condition &amp; rhs ) noexcept;</pre>
 <blockquote>
   <p><i>Returns:</i> <code>lhs.category() &lt; rhs.category()<br>
   &nbsp; || (lhs.category() == rhs.category() &amp;&amp; lhs.value() &lt; rhs.value())</code>.</p>
-  <p><i>Throws: </i>Nothing.</p>
 </blockquote>
-<pre>error_code make_error_code( errc::errc_t e );</pre>
+<pre>error_code make_error_code( errc::errc_t e ) noexcept;</pre>
 <blockquote>
-  <p><i>Returns:</i> <code>error_code( e, generic_category)</code>.</p>
+  <p><i>Returns:</i> <code>error_code( e, generic_category())</code>.</p>
 </blockquote>
-<pre>error_condition make_error_condition( errc::errc_t e );</pre>
+<pre>error_condition make_error_condition( errc::errc_t e ) noexcept;</pre>
 <blockquote>
-  <p><i>Returns:</i> <code>error_condition( static_cast&lt;int&gt;( e ), generic_category)</code>.</p>
+  <p><i>Returns:</i> <code>error_condition( static_cast&lt;int&gt;( e ), generic_category())</code>.</p>
 </blockquote>
 
 <pre>template &lt;class charT, class traits&gt;
@@ -831,10 +818,10 @@ application program interfaces.</p>
 <hr>
 
 <p>Revised 
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->October 11, 2008<!--webbot bot="Timestamp" endspan i-checksum="30976" --> </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><EFBFBD> Copyright Beman Dawes, 2006, 2007, 2008</p>
+<p><EFBFBD> Copyright Beman Dawes, 2006, 2007, 2008, 2013</p>
 
 <p>Distributed under the Boost Software License, Version 1.0. See
 <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>

include/boost/cerrno.hpp

@@ -7,8 +7,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_CERRNO_HPP
-#define BOOST_CERRNO_HPP
+#ifndef BOOST_SYSTEM_CERRNO_HPP
+#define BOOST_SYSTEM_CERRNO_HPP
 
 #include <cerrno>
 

include/boost/system/api_config.hpp

@@ -0,0 +1,42 @@
+//  boost/system/api_config.hpp  -------------------------------------------------------//
+
+//  Copyright Beman Dawes 2003, 2006, 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org/libs/system for documentation.
+
+//--------------------------------------------------------------------------------------//
+
+//  Boost.System calls operating system API functions to implement system error category
+//  functions. Usually there is no question as to which API is to be used.
+//
+//  In the case of MinGW or Cygwin/MinGW, however, both POSIX and Windows API's are
+//  available. Chaos ensues if other code thinks one is in use when Boost.System was
+//  actually built with the other. This header centralizes the API choice and prevents
+//  user definition of API macros, thus elminating the possibility of mismatches and the
+//  need to test configurations with little or no practical value.
+//
+
+//--------------------------------------------------------------------------------------//
+
+#ifndef BOOST_SYSTEM_API_CONFIG_HPP                  
+#define BOOST_SYSTEM_API_CONFIG_HPP
+
+# if defined(BOOST_POSIX_API) || defined(BOOST_WINDOWS_API)
+#   error user defined BOOST_POSIX_API or BOOST_WINDOWS_API not supported
+# endif
+
+//  BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use
+//    Cygwin/MinGW does not predefine _WIN32.
+//    Standalone MinGW and all other known Windows compilers do predefine _WIN32
+//    Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too.
+
+# if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin
+#   define BOOST_WINDOWS_API
+# else
+#   define BOOST_POSIX_API 
+# endif
+                                     
+#endif  // BOOST_SYSTEM_API_CONFIG_HPP 

include/boost/system/config.hpp

@@ -1,4 +1,4 @@
-//  boost/system/config.hpp  -------------------------------------------------//
+//  boost/system/config.hpp  -----------------------------------------------------------//
 
 //  Copyright Beman Dawes 2003, 2006
 
@@ -11,47 +11,42 @@
 #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
 
-//  BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use.
-//  If not specified, a sensible default will be applied.
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
 
-# if defined( BOOST_WINDOWS_API ) && defined( BOOST_POSIX_API )
-#   error both BOOST_WINDOWS_API and BOOST_POSIX_API are defined
-# elif !defined( BOOST_WINDOWS_API ) && !defined( BOOST_POSIX_API )
-#   if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__)
-#     define BOOST_WINDOWS_API
-#   else
-#     define BOOST_POSIX_API 
-#   endif
-# endif
+//  normalize macros  ------------------------------------------------------------------//
 
-//  enable dynamic linking on Windows  ---------------------------------------//
-
-//#  if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__)
-//#    error Dynamic linking Boost.System does not work for Borland; use static linking instead
-//#  endif
-
-#ifdef BOOST_HAS_DECLSPEC // defined in config system
-// we need to import/export our code only if the user has specifically
-// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
-// libraries to be dynamically linked, or BOOST_SYSTEM_DYN_LINK
-// if they want just this one to be dynamically liked:
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
-// export if this is our own source, otherwise import:
-#ifdef BOOST_SYSTEM_SOURCE
-# define BOOST_SYSTEM_DECL __declspec(dllexport)
-#else
-# define BOOST_SYSTEM_DECL __declspec(dllimport)
-#endif  // BOOST_SYSTEM_SOURCE
-#endif  // DYN_LINK
-#endif  // BOOST_HAS_DECLSPEC
-//
-// if BOOST_SYSTEM_DECL isn't defined yet define it now:
-#ifndef BOOST_SYSTEM_DECL
-#define BOOST_SYSTEM_DECL
+#if !defined(BOOST_SYSTEM_DYN_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK) \
+  && !defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_ALL_STATIC_LINK)
+# define BOOST_SYSTEM_STATIC_LINK
 #endif
 
-//  enable automatic library variant selection  ------------------------------// 
+#if defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_SYSTEM_DYN_LINK)
+# define BOOST_SYSTEM_DYN_LINK 
+#elif defined(BOOST_ALL_STATIC_LINK) && !defined(BOOST_SYSTEM_STATIC_LINK)
+# define BOOST_SYSTEM_STATIC_LINK 
+#endif
+
+#if defined(BOOST_SYSTEM_DYN_LINK) && defined(BOOST_SYSTEM_STATIC_LINK)
+# error Must not define both BOOST_SYSTEM_DYN_LINK and BOOST_SYSTEM_STATIC_LINK
+#endif
+
+//  enable dynamic or static linking as requested --------------------------------------//
+
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
+# if defined(BOOST_SYSTEM_SOURCE)
+#   define BOOST_SYSTEM_DECL BOOST_SYMBOL_EXPORT
+# else 
+#   define BOOST_SYSTEM_DECL BOOST_SYMBOL_IMPORT
+# endif
+#else
+# 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)
 //

include/boost/system/cygwin_error.hpp

@@ -7,8 +7,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_CYGWIN_ERROR_HPP
-#define BOOST_CYGWIN_ERROR_HPP
+#ifndef BOOST_SYSTEM_CYGWIN_ERROR_HPP
+#define BOOST_SYSTEM_CYGWIN_ERROR_HPP
 
 //  This header is effectively empty for compiles on operating systems where
 //  it is not applicable.
@@ -23,7 +23,7 @@ namespace boost
   {
     //  To construct an error_code after a API error:
     //
-    //      error_code( errno, system_category )
+    //      error_code( errno, system_category() )
 
     //  User code should use the portable "posix" enums for POSIX errors; this
     //  allows such code to be portable to non-POSIX systems. For the non-POSIX
@@ -46,11 +46,11 @@ namespace boost
     namespace cygwin_error
     {
       inline error_code make_error_code( cygwin_errno e )
-        { return error_code( e, get_system_category() ); }
+        { return error_code( e, system_category() ); }
     }
   }
 }
 
 #endif  // __CYGWIN__
 
-#endif  // BOOST_CYGWIN_ERROR_HPP
+#endif  // BOOST_SYSTEM_CYGWIN_ERROR_HPP

include/boost/system/detail/error_code.ipp

@@ -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

include/boost/system/detail/local_free_on_destruction.hpp

@@ -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

include/boost/system/error_code.hpp

@@ -1,4 +1,4 @@
-//  boost/system/error_code.hpp  ---------------------------------------------//
+//  boost/system/error_code.hpp  -------------------------------------------------------//
 
 //  Copyright Beman Dawes 2006, 2007
 //  Copyright Christoper Kohlhoff 2007
@@ -8,13 +8,12 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_ERROR_CODE_HPP
-#define BOOST_ERROR_CODE_HPP
+#ifndef BOOST_SYSTEM_ERROR_CODE_HPP
+#define BOOST_SYSTEM_ERROR_CODE_HPP
 
 #include <boost/system/config.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/assert.hpp>
-#include <boost/operators.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <ostream>
@@ -23,23 +22,32 @@
 #include <functional>
 
 // TODO: undef these macros if not already defined
-#include <boost/cerrno.hpp> 
+#include <boost/cerrno.hpp>
 
 #if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
 #  error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
 #endif
 
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#include <system_error>
+#endif
+
 #include <boost/config/abi_prefix.hpp> // must be the last #include
 
+#ifndef BOOST_SYSTEM_NOEXCEPT
+#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
+#endif
+
 namespace boost
 {
   namespace system
   {
 
-    class error_code;
-    class error_condition;
+    class error_code;         // values defined by the operating system
+    class error_condition;    // portable generic values defined below, but ultimately
+                              // based on the POSIX standard
 
-    //  "Concept" helpers  ---------------------------------------------------//
+    //  "Concept" helpers  -------------------------------------------------------------//
 
     template< class T >
     struct is_error_code_enum { static const bool value = false; };
@@ -47,7 +55,7 @@ namespace boost
     template< class T >
     struct is_error_condition_enum { static const bool value = false; };
 
-    //  generic error_conditions  --------------------------------------------//
+    //  generic error_conditions  ------------------------------------------------------//
 
     namespace errc
     {
@@ -129,7 +137,7 @@ namespace boost
         too_many_files_open_in_system = ENFILE,
         too_many_files_open = EMFILE,
         too_many_links = EMLINK,
-        too_many_synbolic_link_levels = ELOOP,
+        too_many_symbolic_link_levels = ELOOP,
         value_too_large = EOVERFLOW,
         wrong_protocol_type = EPROTOTYPE
       };
@@ -145,9 +153,9 @@ namespace boost
       { static const bool value = true; };
 
 
-    //  ----------------------------------------------------------------------//
+    //  --------------------------------------------------------------------------------//
 
-    //  Operating system specific interfaces  --------------------------------//
+    //  Operating system specific interfaces  ------------------------------------------//
 
 
     //  The interface is divided into general and system-specific portions to
@@ -175,48 +183,109 @@ namespace boost
     //  These headers are effectively empty for compiles on operating systems
     //  where they are not applicable.
 
-    //  ----------------------------------------------------------------------//
+    //  --------------------------------------------------------------------------------//
+
+    class error_category;
+
+    //  predefined error categories  ---------------------------------------------------//
+
+#ifdef BOOST_ERROR_CODE_HEADER_ONLY
+    inline const error_category &  system_category() BOOST_SYSTEM_NOEXCEPT;
+    inline const error_category &  generic_category() BOOST_SYSTEM_NOEXCEPT;
+#else
+    BOOST_SYSTEM_DECL const error_category &  system_category() BOOST_SYSTEM_NOEXCEPT;
+    BOOST_SYSTEM_DECL const error_category &  generic_category() BOOST_SYSTEM_NOEXCEPT;
+#endif
+    //  deprecated synonyms ------------------------------------------------------------//
+
+#ifndef BOOST_SYSTEM_NO_DEPRECATED
+    inline const error_category &  get_system_category() { return system_category(); }
+    inline const error_category &  get_generic_category() { return generic_category(); }
+    inline const error_category &  get_posix_category() { return generic_category(); }
+    static const error_category &  posix_category BOOST_ATTRIBUTE_UNUSED
+      = generic_category();
+    static const error_category &  errno_ecat     BOOST_ATTRIBUTE_UNUSED
+      = generic_category();
+    static const error_category &  native_ecat    BOOST_ATTRIBUTE_UNUSED
+      = system_category();
+#endif
 
     //  class error_category  ------------------------------------------------//
 
     class error_category : public noncopyable
     {
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+    private:
+
+      class 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;
+        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;
+      };
+
+      std_category std_cat_;
+
+    public:
+
+      error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
+
+      operator std::error_category const & () const BOOST_SYSTEM_NOEXCEPT
+      {
+        // do not map generic to std::generic on purpose; occasionally,
+        // there are two std::generic categories in a program, which leads
+        // to error codes/conditions mysteriously not being equal to themselves
+        return std_cat_;
+      }
+
+#endif
+
     public:
       virtual ~error_category(){}
 
-      virtual const char *     name() const = 0;
+      virtual const char *     name() const BOOST_SYSTEM_NOEXCEPT = 0;
       virtual std::string      message( int ev ) const = 0;
-      virtual error_condition  default_error_condition( int ev ) const;
-      virtual bool             equivalent( int code, 
-                                           const error_condition & condition ) const;
-      virtual bool             equivalent( const error_code & code,
-                                           int condition ) const;
+      inline virtual error_condition  default_error_condition( int ev ) const 
+        BOOST_SYSTEM_NOEXCEPT;
+      inline virtual bool             equivalent( int code,
+                                           const error_condition & condition ) const 
+        BOOST_SYSTEM_NOEXCEPT;
+      inline virtual bool             equivalent( const error_code & code,
+                                           int condition ) const  BOOST_SYSTEM_NOEXCEPT;
 
-      bool operator==(const error_category & rhs) const { return this == &rhs; }
-      bool operator!=(const error_category & rhs) const { return this != &rhs; }
-      bool operator<( const error_category & rhs ) const
-      {
-        return std::less<const error_category*>()( this, &rhs );
-      }
+      bool operator==(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT
+        { return this == &rhs; }
+      bool operator!=(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT
+        { return this != &rhs; }
+      bool operator<( const error_category & rhs ) const BOOST_SYSTEM_NOEXCEPT
+        { return std::less<const error_category*>()( this, &rhs ); }
     };
 
-    //  predefined error categories  -----------------------------------------//
-
-    BOOST_SYSTEM_DECL const error_category &  get_system_category();
-    BOOST_SYSTEM_DECL const error_category &  get_generic_category();
-
-    static const error_category &  system_category = get_system_category();
-    static const error_category &  generic_category = get_generic_category();
-    
-# ifndef BOOST_SYSTEM_NO_DEPRECATED
-    //  deprecated synonyms
-    inline const error_category &  get_posix_category() { return get_generic_category(); }
-    static const error_category &  posix_category = get_generic_category();
-    static const error_category &  errno_ecat     = get_generic_category();
-    static const error_category &  native_ecat    = get_system_category();
-# endif
-
-    //  class error_condition  -----------------------------------------------//
+    //  class error_condition  ---------------------------------------------------------//
 
     //  error_conditions are portable, error_codes are system or library specific
 
@@ -225,52 +294,55 @@ namespace boost
     public:
 
       // constructors:
-      error_condition() : m_val(0), m_cat(&get_generic_category()) {}
-      error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
+      error_condition() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&generic_category()) {}
+      error_condition( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
+        : m_val(val), m_cat(&cat) {}
 
       template <class ErrorConditionEnum>
         error_condition(ErrorConditionEnum e,
-          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0)
+          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type*
+            = 0) BOOST_SYSTEM_NOEXCEPT
       {
         *this = make_error_condition(e);
       }
 
       // modifiers:
 
-      void assign( int val, const error_category & cat )
-      { 
+      void assign( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
+      {
         m_val = val;
         m_cat = &cat;
       }
-                                             
+
       template<typename ErrorConditionEnum>
-        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
-          operator=( ErrorConditionEnum val )
-      { 
+        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>,
+          error_condition>::type &
+          operator=( ErrorConditionEnum val ) BOOST_SYSTEM_NOEXCEPT
+      {
         *this = make_error_condition(val);
         return *this;
       }
 
-      void clear()
+      void clear() BOOST_SYSTEM_NOEXCEPT
       {
         m_val = 0;
-        m_cat = &get_generic_category();
+        m_cat = &generic_category();
       }
 
       // observers:
-      int                     value() const    { return m_val; }
-      const error_category &  category() const { return *m_cat; }
+      int                     value() const BOOST_SYSTEM_NOEXCEPT    { return m_val; }
+      const error_category &  category() const BOOST_SYSTEM_NOEXCEPT { return *m_cat; }
       std::string             message() const  { return m_cat->message(value()); }
 
       typedef void (*unspecified_bool_type)();
       static void unspecified_bool_true() {}
 
-      operator unspecified_bool_type() const  // true if error
-      { 
+      operator unspecified_bool_type() const BOOST_SYSTEM_NOEXCEPT  // true if error
+      {
         return m_val == 0 ? 0 : unspecified_bool_true;
       }
 
-      bool operator!() const  // true if no error
+      bool operator!() const BOOST_SYSTEM_NOEXCEPT  // true if no error
       {
         return m_val == 0;
       }
@@ -279,13 +351,13 @@ namespace boost
       //  the more symmetrical non-member syntax allows enum
       //  conversions work for both rhs and lhs.
       inline friend bool operator==( const error_condition & lhs,
-                                     const error_condition & rhs )
+                                     const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
       {
         return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
-      }                  
+      }
 
       inline friend bool operator<( const error_condition & lhs,
-                                    const error_condition & rhs )
+                                    const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
         //  the more symmetrical non-member syntax allows enum
         //  conversions work for both rhs and lhs.
       {
@@ -293,13 +365,22 @@ namespace boost
           || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
       }
 
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+      operator std::error_condition () const BOOST_SYSTEM_NOEXCEPT
+      {
+        return std::error_condition( value(), category() );
+      }
+
+#endif
+
     private:
       int                     m_val;
       const error_category *  m_cat;
 
     };
 
-    //  class error_code  ----------------------------------------------------//
+    //  class error_code  --------------------------------------------------------------//
 
     //  We want error_code to be a value type that can be copied without slicing
     //  and without requiring heap allocation, but we also want it to have
@@ -312,59 +393,62 @@ namespace boost
     public:
 
       // constructors:
-      error_code() : m_val(0), m_cat(&get_system_category()) {}
-      error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
+      error_code() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&system_category()) {}
+      error_code( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
+        : m_val(val), m_cat(&cat) {}
 
       template <class ErrorCodeEnum>
         error_code(ErrorCodeEnum e,
           typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
+          BOOST_SYSTEM_NOEXCEPT
       {
         *this = make_error_code(e);
       }
 
       // modifiers:
-      void assign( int val, const error_category & cat )
-      { 
+      void assign( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
+      {
         m_val = val;
         m_cat = &cat;
       }
-                                             
+
       template<typename ErrorCodeEnum>
         typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
-          operator=( ErrorCodeEnum val )
-      { 
+          operator=( ErrorCodeEnum val ) BOOST_SYSTEM_NOEXCEPT
+      {
         *this = make_error_code(val);
         return *this;
       }
 
-      void clear()
+      void clear() BOOST_SYSTEM_NOEXCEPT
       {
         m_val = 0;
-        m_cat = &get_system_category();
+        m_cat = &system_category();
       }
 
       // observers:
-      int                     value() const    { return m_val; }
-      const error_category &  category() const { return *m_cat; }
-      error_condition         default_error_condition() const  { return m_cat->default_error_condition(value()); }
+      int                     value() const  BOOST_SYSTEM_NOEXCEPT   { return m_val; }
+      const error_category &  category() const BOOST_SYSTEM_NOEXCEPT { return *m_cat; }
+      error_condition         default_error_condition() const BOOST_SYSTEM_NOEXCEPT
+        { return m_cat->default_error_condition(value()); }
       std::string             message() const  { return m_cat->message(value()); }
 
       typedef void (*unspecified_bool_type)();
       static void unspecified_bool_true() {}
 
-      operator unspecified_bool_type() const  // true if error
-      { 
+      operator unspecified_bool_type() const  BOOST_SYSTEM_NOEXCEPT // true if error
+      {
         return m_val == 0 ? 0 : unspecified_bool_true;
       }
 
-      bool operator!() const  // true if no error
+      bool operator!() const  BOOST_SYSTEM_NOEXCEPT // true if no error
       {
         return m_val == 0;
       }
 
       // relationals:
       inline friend bool operator==( const error_code & lhs,
-                                     const error_code & rhs )
+                                     const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
         //  the more symmetrical non-member syntax allows enum
         //  conversions work for both rhs and lhs.
       {
@@ -372,15 +456,24 @@ namespace boost
       }
 
       inline friend bool operator<( const error_code & lhs,
-                                    const error_code & rhs )
+                                    const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
         //  the more symmetrical non-member syntax allows enum
         //  conversions work for both rhs and lhs.
       {
         return lhs.m_cat < rhs.m_cat
           || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
       }
-                  
-      private:
+
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+      operator std::error_code () const BOOST_SYSTEM_NOEXCEPT
+      {
+        return std::error_code( value(), category() );
+      }
+
+#endif
+
+    private:
       int                     m_val;
       const error_category *  m_cat;
 
@@ -414,43 +507,43 @@ namespace boost
     //  non-member functions  ------------------------------------------------//
 
     inline bool operator!=( const error_code & lhs,
-                            const error_code & rhs )
+                            const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
     {
       return !(lhs == rhs);
     }
 
     inline bool operator!=( const error_condition & lhs,
-                            const error_condition & rhs )
+                            const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
     {
       return !(lhs == rhs);
     }
 
     inline bool operator==( const error_code & code,
-                            const error_condition & condition )
+                            const error_condition & condition ) BOOST_SYSTEM_NOEXCEPT
     {
       return code.category().equivalent( code.value(), condition )
         || condition.category().equivalent( code, condition.value() );
     }
-                
+
     inline bool operator!=( const error_code & lhs,
-                            const error_condition & rhs )
+                            const error_condition & rhs ) BOOST_SYSTEM_NOEXCEPT
     {
       return !(lhs == rhs);
     }
-                
+
     inline bool operator==( const error_condition & condition,
-                            const error_code & code )
+                            const error_code & code ) BOOST_SYSTEM_NOEXCEPT
     {
       return condition.category().equivalent( code, condition.value() )
         || code.category().equivalent( code.value(), condition );
     }
-                
+
     inline bool operator!=( const error_condition & lhs,
-                            const error_code & rhs )
+                            const error_code & rhs ) BOOST_SYSTEM_NOEXCEPT
     {
       return !(lhs == rhs);
     }
-                  
+
     // TODO: both of these may move elsewhere, but the LWG hasn't spoken yet.
 
     template <class charT, class traits>
@@ -467,47 +560,120 @@ namespace boost
         + reinterpret_cast<std::size_t>(&ec.category());
     }
 
-    //  make_* functions for errc::errc_t  -----------------------------//
+    //  make_* functions for errc::errc_t  ---------------------------------------------//
 
     namespace errc
     {
       //  explicit conversion:
-      inline error_code make_error_code( errc_t e )
-        { return error_code( e, get_generic_category() ); }
+      inline error_code make_error_code( errc_t e ) BOOST_SYSTEM_NOEXCEPT
+        { return error_code( e, generic_category() ); }
 
       //  implicit conversion:
-      inline error_condition make_error_condition( errc_t e )
-        { return error_condition( e, get_generic_category() ); }
+      inline error_condition make_error_condition( errc_t e ) BOOST_SYSTEM_NOEXCEPT
+        { return error_condition( e, generic_category() ); }
     }
 
-    //  error_category default implementation  -------------------------------//
+    //  error_category default implementation  -----------------------------------------//
 
-    inline error_condition error_category::default_error_condition( int ev ) const
-    { 
+    error_condition error_category::default_error_condition( int ev ) const
+      BOOST_SYSTEM_NOEXCEPT
+    {
       return error_condition( ev, *this );
     }
 
-    inline bool error_category::equivalent( int code,
-      const error_condition & condition ) const
+    bool error_category::equivalent( int code,
+      const error_condition & condition ) const BOOST_SYSTEM_NOEXCEPT
     {
       return default_error_condition( code ) == condition;
     }
 
-    inline bool error_category::equivalent( const error_code & code,
-      int condition ) const
+    bool error_category::equivalent( const error_code & code,
+      int condition ) const BOOST_SYSTEM_NOEXCEPT
     {
       return *this == code.category() && code.value() == condition;
     }
 
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+    inline std::error_condition error_category::std_category::default_error_condition(
+      int ev ) const BOOST_NOEXCEPT
+    {
+      return pc_->default_error_condition( ev );
+    }
+
+    inline bool error_category::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 error_category::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;
+      }
+    }
+
+#endif
+
   } // namespace system
 } // namespace boost
 
 #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
 
 # ifdef BOOST_ERROR_CODE_HEADER_ONLY
-#   include <boost/../libs/system/src/error_code.cpp>
+#   include <boost/system/detail/error_code.ipp>
 # endif
 
-#endif // BOOST_ERROR_CODE_HPP
-
-
+#endif // BOOST_SYSTEM_ERROR_CODE_HPP

include/boost/system/linux_error.hpp

@@ -7,8 +7,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_LINUX_ERROR_HPP
-#define BOOST_LINUX_ERROR_HPP
+#ifndef BOOST_SYSTEM_LINUX_ERROR_HPP
+#define BOOST_SYSTEM_LINUX_ERROR_HPP
 
 //  This header is effectively empty for compiles on operating systems where
 //  it is not applicable.
@@ -23,7 +23,7 @@ namespace boost
   {
     //  To construct an error_code after a API error:
     //
-    //      error_code( errno, system_category )
+    //      error_code( errno, system_category() )
 
     //  User code should use the portable "posix" enums for POSIX errors; this
     //  allows such code to be portable to non-POSIX systems. For the non-POSIX
@@ -99,7 +99,7 @@ namespace boost
     namespace linux_error
     {
       inline error_code make_error_code( linux_errno e )
-        { return error_code( e, get_system_category() ); }
+        { return error_code( e, system_category() ); }
     }
 
   }  // namespace system
@@ -107,4 +107,4 @@ namespace boost
 
 #endif  // Linux
 
-#endif  // BOOST_LINUX_ERROR_HPP
+#endif  // BOOST_SYSTEM_LINUX_ERROR_HPP

include/boost/system/system_error.hpp

@@ -5,8 +5,8 @@
 //  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)
 
-#ifndef BOOST_SYSTEM_ERROR_HPP
-#define BOOST_SYSTEM_ERROR_HPP
+#ifndef BOOST_SYSTEM_SYSTEM_ERROR_HPP
+#define BOOST_SYSTEM_SYSTEM_ERROR_HPP
 
 #include <string>
 #include <stdexcept>
@@ -17,9 +17,11 @@ namespace boost
 {
   namespace system
   {
-    //  class system_error  --------------------------------------------------//
+    //  class system_error  ------------------------------------------------------------//
 
-    class system_error : public std::runtime_error
+    class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error
+    // BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared
+    // library can be caught. See svn.boost.org/trac/boost/ticket/3697
     {
     public:
       system_error( error_code ec )
@@ -42,10 +44,10 @@ namespace boost
         const char * what_arg )
           : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
 
-      virtual ~system_error() throw() {}
+      virtual ~system_error() BOOST_NOEXCEPT_OR_NOTHROW {}
 
-      const error_code &  code() const throw() { return m_error_code; }
-      const char *        what() const throw();
+      const error_code &  code() const BOOST_NOEXCEPT_OR_NOTHROW { return m_error_code; }
+      const char *        what() const BOOST_NOEXCEPT_OR_NOTHROW;
 
     private:
       error_code           m_error_code;
@@ -54,21 +56,22 @@ namespace boost
 
     //  implementation  ------------------------------------------------------//
 
-    inline const char * system_error::what() const throw()
+    inline const char * system_error::what() const BOOST_NOEXCEPT_OR_NOTHROW
     // see http://www.boost.org/more/error_handling.html for lazy build rationale
     {
       if ( m_what.empty() )
       {
+#ifndef BOOST_NO_EXCEPTIONS
         try
+#endif
         {
           m_what = this->std::runtime_error::what();
-          if ( m_error_code )
-          {
-            if ( !m_what.empty() ) m_what += ": ";
-            m_what += m_error_code.message();
-          }
+          if ( !m_what.empty() ) m_what += ": ";
+          m_what += m_error_code.message();
         }
+#ifndef BOOST_NO_EXCEPTIONS
         catch (...) { return std::runtime_error::what(); }
+#endif
       }
       return m_what.c_str();
     }
@@ -76,6 +79,6 @@ namespace boost
   } // namespace system
 } // namespace boost
 
-#endif // BOOST_SYSTEM_ERROR_HPP
+#endif // BOOST_SYSTEM_SYSTEM_ERROR_HPP
 
 

include/boost/system/windows_error.hpp

@@ -7,8 +7,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_WINDOWS_ERROR_HPP
-#define BOOST_WINDOWS_ERROR_HPP
+#ifndef BOOST_SYSTEM_WINDOWS_ERROR_HPP
+#define BOOST_SYSTEM_WINDOWS_ERROR_HPP
 
 //  This header is effectively empty for compiles on operating systems where
 //  it is not applicable.
@@ -18,7 +18,17 @@
 #ifdef BOOST_WINDOWS_API
 
 #include <boost/system/error_code.hpp>
-#include <winerror.h>
+
+//// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on
+//// either of those platforms include the full windows.h
+//
+//#if defined(__MINGW32__) || defined(__CYGWIN__)
+//#include <windows.h>
+//#else
+//#include <winerror.h>
+//#endif
+
+#include <boost/detail/winapi/error_codes.hpp>
 
 namespace boost
 {
@@ -29,7 +39,7 @@ namespace boost
 
     //  To construct an error_code after a API error:
     //
-    //      error_code( ::GetLastError(), system_category )
+    //      error_code( ::GetLastError(), system_category() )
 
     namespace windows_error
     {
@@ -37,59 +47,59 @@ namespace boost
       {
         success = 0,
         // These names and values are based on Windows winerror.h
-        invalid_function = ERROR_INVALID_FUNCTION,
-        file_not_found = ERROR_FILE_NOT_FOUND,
-        path_not_found = ERROR_PATH_NOT_FOUND,
-        too_many_open_files = ERROR_TOO_MANY_OPEN_FILES,
-        access_denied = ERROR_ACCESS_DENIED,
-        invalid_handle = ERROR_INVALID_HANDLE,
-        arena_trashed = ERROR_ARENA_TRASHED,
-        not_enough_memory = ERROR_NOT_ENOUGH_MEMORY,
-        invalid_block = ERROR_INVALID_BLOCK,
-        bad_environment = ERROR_BAD_ENVIRONMENT,
-        bad_format = ERROR_BAD_FORMAT,
-        invalid_access = ERROR_INVALID_ACCESS,
-        outofmemory = ERROR_OUTOFMEMORY,
-        invalid_drive = ERROR_INVALID_DRIVE,
-        current_directory = ERROR_CURRENT_DIRECTORY,
-        not_same_device = ERROR_NOT_SAME_DEVICE,
-        no_more_files = ERROR_NO_MORE_FILES,
-        write_protect = ERROR_WRITE_PROTECT,
-        bad_unit = ERROR_BAD_UNIT,
-        not_ready = ERROR_NOT_READY,
-        bad_command = ERROR_BAD_COMMAND,
-        crc = ERROR_CRC,
-        bad_length = ERROR_BAD_LENGTH,
-        seek = ERROR_SEEK,
-        not_dos_disk = ERROR_NOT_DOS_DISK,
-        sector_not_found = ERROR_SECTOR_NOT_FOUND,
-        out_of_paper = ERROR_OUT_OF_PAPER,
-        write_fault = ERROR_WRITE_FAULT,
-        read_fault = ERROR_READ_FAULT,
-        gen_failure = ERROR_GEN_FAILURE,
-        sharing_violation = ERROR_SHARING_VIOLATION,
-        lock_violation = ERROR_LOCK_VIOLATION,
-        wrong_disk = ERROR_WRONG_DISK,
-        sharing_buffer_exceeded = ERROR_SHARING_BUFFER_EXCEEDED,
-        handle_eof = ERROR_HANDLE_EOF,
-        handle_disk_full= ERROR_HANDLE_DISK_FULL,
-        rem_not_list = ERROR_REM_NOT_LIST,
-        dup_name = ERROR_DUP_NAME,
-        bad_net_path = ERROR_BAD_NETPATH,
-        network_busy = 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 = ERROR_FILE_EXISTS,
-        cannot_make = ERROR_CANNOT_MAKE,
+        file_exists = boost::detail::winapi::ERROR_FILE_EXISTS_,
+        cannot_make = boost::detail::winapi::ERROR_CANNOT_MAKE_,
         // ...
-        broken_pipe = ERROR_BROKEN_PIPE,
-        open_failed = ERROR_OPEN_FAILED,
-        buffer_overflow = ERROR_BUFFER_OVERFLOW,
-        disk_full= 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 = ERROR_LOCK_FAILED,
-        busy = ERROR_BUSY,
-        cancel_violation = ERROR_CANCEL_VIOLATION,
-        already_exists = 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 +117,7 @@ namespace boost
     namespace windows_error
     {
       inline error_code make_error_code( windows_error_code e )
-        { return error_code( e, get_system_category() ); }
+        { return error_code( e, system_category() ); }
     }
 
   }  // namespace system
@@ -115,4 +125,4 @@ namespace boost
 
 #endif  // BOOST_WINDOWS_API
 
-#endif  // BOOST_WINDOWS_ERROR_HPP
+#endif  // BOOST_SYSTEM_WINDOWS_ERROR_HPP

meta/libraries.json

@@ -0,0 +1,11 @@
+{
+    "key": "system",
+    "name": "System",
+    "authors": [
+        "Beman Dawes"
+    ],
+    "description": "Operating system support, including the diagnostics support that will be part of the C++0x standard library.",
+    "category": [
+        "System"
+    ]
+}

src/error_code.cpp

@@ -9,427 +9,12 @@
 
 //----------------------------------------------------------------------------//
 
-#include <boost/config/warning_disable.hpp>
-
 // 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 
+#define BOOST_SYSTEM_SOURCE
 
-#include <boost/system/config.hpp>
 #include <boost/system/error_code.hpp>
-#include <boost/cerrno.hpp>
-#include <vector>
-#include <cstdlib>
-#include <cassert>
 
-using namespace boost::system;
-using namespace boost::system::errc;
-
-#include <cstring> // for strerror/strerror_r
-
-# if defined( BOOST_WINDOWS_API )
-#   include <windows.h>
-#   ifndef ERROR_INCORRECT_SIZE
-#    define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
-#   endif
-# endif
-
-//----------------------------------------------------------------------------//
-
-namespace
-{
-  //  standard error categories  ---------------------------------------------//
-
-  class generic_error_category : public error_category
-  {
-  public:
-    generic_error_category(){}
-    const char *   name() const;
-    std::string    message( int ev ) const;
-  };
-
-  class system_error_category : public error_category
-  {
-  public:
-    system_error_category(){}
-    const char *        name() const;
-    std::string         message( int ev ) const;
-    error_condition     default_error_condition( int ev ) const;
-  };
-
-  //  generic_error_category implementation  ---------------------------------//
-
-  const char * generic_error_category::name() const
-  {
-    return "generic";
-  }
-
-  std::string generic_error_category::message( int ev ) const
-  {
-    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 Sundo 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(__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;
-      try
-      {
-        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
-  {
-    return "system";
-  }
-
-  error_condition system_error_category::default_error_condition( int ev ) const
-  {
-    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_synbolic_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
-    case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable );
-    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 );
-    case EOWNERDEAD: return make_error_condition( owner_dead );
-    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
-// TODO:
-  
-//Some quick notes on the implementation (sorry for the noise if
-//someone has already mentioned them):
-//
-//- The ::LocalFree() usage isn't exception safe.
-//
-//See:
-//
-//<http://boost.cvs.sourceforge.net/boost/boost/boost/asio/system_exception.hpp?revision=1.1&view=markup>
-//
-//in the implementation of what() for an example.
-//
-//Cheers,
-//Chris
-  std::string system_error_category::message( int ev ) const
-  {
-# ifndef BOOST_NO_ANSI_APIS  
-    LPVOID lpMsgBuf;
-    DWORD retval = ::FormatMessageA( 
-        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-        FORMAT_MESSAGE_FROM_SYSTEM | 
-        FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL,
-        ev,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
-        (LPSTR) &lpMsgBuf,
-        0,
-        NULL 
-    );
-    if (retval == 0)
-        return std::string("Unknown error");
-        
-    std::string str( static_cast<LPCSTR>(lpMsgBuf) );
-    ::LocalFree( lpMsgBuf ); // free the buffer
-# else  // WinCE workaround
-    LPVOID lpMsgBuf;
-    DWORD retval = ::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 std::string("Unknown error");
-    
-    int num_chars = (wcslen( static_cast<LPCWSTR>(lpMsgBuf) ) + 1) * 2;
-    LPSTR narrow_buffer = (LPSTR)_alloca( num_chars );
-    if (::WideCharToMultiByte(CP_ACP, 0, static_cast<LPCWSTR>(lpMsgBuf), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
-        return std::string("Unknown error");
-
-    std::string str( narrow_buffer );
-    ::LocalFree( lpMsgBuf ); // free the buffer
-# 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
-
-namespace boost
-{
-  namespace system
-  {
-
-# 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
-
-    BOOST_SYSTEM_DECL const error_category & get_system_category()
-    {
-      static const system_error_category  system_category_const;
-      return system_category_const;
-    }
-
-    BOOST_SYSTEM_DECL const error_category & get_generic_category()
-    {
-      static const generic_error_category generic_category_const;
-      return generic_category_const;
-    }
-
-  } // namespace system
-} // namespace boost
+#ifndef BOOST_ERROR_CODE_HEADER_ONLY
+#include <boost/system/detail/error_code.ipp>
+#endif

test/Jamfile.v2

@@ -7,11 +7,20 @@
 
 # See library home page at http://www.boost.org/libs/system
 
+import testing ;
+
 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
+     ;
+   
 
    test-suite "system"
        : [ run error_code_test.cpp
@@ -21,23 +30,36 @@ project
                    <link>static
          ]
          [ run error_code_test.cpp
-           :  :  :  : error_code_test_dll
+           :  :  : <link>shared : error_code_test_shared
          ]
          [ run error_code_user_test.cpp
            :  :  : <link>static
          ]
          [ run error_code_user_test.cpp
-           :  :  :  : error_code_user_test_dll
+           :  :  : <link>shared : error_code_user_test_shared
          ]
          [ run system_error_test.cpp
            :  :  : <link>static
          ]
          [ run system_error_test.cpp
-            :  :  :  : system_error_test_dll
+            :  :  : <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
+         ]
          ;

test/config_test.cpp

@@ -0,0 +1,65 @@
+//  error_code_test.cpp  ---------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2014
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  See library home page at http://www.boost.org/libs/system
+
+#include <boost/system/config.hpp>
+#include <iostream>
+
+using std::cout;
+using std::endl;
+
+int main()
+{
+#ifdef BOOST_WINDOWS_API
+  std::cout << "BOOST_WINDOWS_API is defined" << std::endl;
+#else
+  std::cout << "BOOST_WINDOWS_API is not defined" << std::endl;
+#endif
+#ifdef _MSC_VER
+  std::cout << "_MSC_VER is defined as " <<  _MSC_VER << std::endl;
+#else
+  std::cout << "_MSC_VER is not defined" << std::endl;
+#endif
+#ifdef  __CYGWIN__
+  std::cout << "__CYGWIN__ is defined" << std::endl;
+#else
+  std::cout << "__CYGWIN__ is not defined" << std::endl;
+#endif
+#ifdef __MINGW32__
+  std::cout << "__MINGW32__ is defined" << std::endl;
+#else
+  std::cout << "__MINGW32__ is not defined" << std::endl;
+#endif
+#ifdef BOOST_POSIX_API
+  std::cout << "BOOST_POSIX_API is defined" << std::endl;
+#else
+  std::cout << "BOOST_POSIX_API is not defined" << std::endl;
+#endif
+#ifdef BOOST_PLAT_WINDOWS_DESKTOP
+  std::cout << "BOOST_PLAT_WINDOWS_DESKTOP is defined as "
+    << BOOST_PLAT_WINDOWS_DESKTOP << std::endl;
+#else
+  std::cout << "BOOST_PLAT_WINDOWS_DESKTOP is not defined" << std::endl;
+#endif
+#ifdef BOOST_NO_ANSI_APIS
+  std::cout << "BOOST_NO_ANSI_APIS is defined" << std::endl;
+#else
+  std::cout << "BOOST_NO_ANSI_APIS is not defined" << std::endl;
+#endif
+#ifdef BOOST_NO_CXX11_NOEXCEPT
+  std::cout << "BOOST_NO_CXX11_NOEXCEPT is defined" << std::endl;
+#else
+  std::cout << "BOOST_NO_CXX11_NOEXCEPT is not defined" << std::endl;
+#endif
+#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+  std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is defined" << std::endl;
+#else
+  std::cout << "BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS is not defined" << std::endl;
+#endif
+  return 0;
+}

test/dynamic_link_test.cpp

@@ -0,0 +1,55 @@
+//  dynamic_link_test.cpp  -------------------------------------------------------------//
+
+//  Copyright Beman Dawes 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See www.boost.org/LICENSE_1_0.txt
+
+//  Library home page is www.boost.org/libs/system
+
+//--------------------------------------------------------------------------------------// 
+
+//  Dynamic link libraries (DLL's), also know as dynamic shared objects (DSO's),
+//  can cause symbol visability problems unless carefully configured. One of the
+//  manifestations, particularly with GCC, is that a system_error exception thrown from
+//  a DLL or DSO is not caught.
+//
+//  The purpose of this program is to test for that error.
+
+//--------------------------------------------------------------------------------------// 
+
+#include <boost/system/system_error.hpp>
+
+#include <iostream>
+
+namespace boost
+{
+  namespace system
+  {
+    BOOST_SYSTEM_DECL void throw_test();
+  }
+}
+
+int main()
+{
+  try
+  {
+    boost::system::throw_test();
+  }
+  catch (const boost::system::system_error& ex)
+  {
+    std::cout << "  caught boost::system::system_error as expected\n";
+    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";
+    std::cout << "  what() reports " << ex.what() << '\n';
+    return 1;
+  }
+
+  std::cout << "  error: failed to catch boost::system::system_error\n";
+  return 1;
+}

test/error_code_test.cpp

@@ -7,7 +7,10 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-//----------------------------------------------------------------------------// 
+//----------------------------------------------------------------------------//
+
+//  test without deprecated features
+#define BOOST_SYSTEM_NO_DEPRECATED
 
 #include <boost/config/warning_disable.hpp>
 
@@ -27,14 +30,20 @@
 //  with a boost::system using directive increases use scenario coverage.
 using namespace boost::system;
 
-# if defined( BOOST_WINDOWS_API )
-#   include "winerror.h"
-#   define BOOST_ACCESS_ERROR_MACRO ERROR_ACCESS_DENIED
-# elif defined( BOOST_POSIX_API )
-#   define BOOST_ACCESS_ERROR_MACRO EACCES
-# else
-#   error "Only supported for POSIX and Windows"
-# endif
+#if defined( BOOST_WINDOWS_API )
+// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on
+// either of those platforms include the full windows.h
+#  if defined(__MINGW32__) || defined(__CYGWIN__)
+#    include <windows.h>
+#  else
+#    include <winerror.h>
+#  endif
+#  define BOOST_ACCESS_ERROR_MACRO ERROR_ACCESS_DENIED
+#elif defined( BOOST_POSIX_API )
+#  define BOOST_ACCESS_ERROR_MACRO EACCES
+#else
+#  error "Only supported for POSIX and Windows"
+#endif
 
 namespace
 {
@@ -56,55 +65,61 @@ namespace
 int main( int, char ** )
 {
 
+  std::cout << "Conversion use cases...\n";
+  error_condition x1( errc::file_exists );
+  //error_code x2( errc::file_exists ); // should fail to compile
+  make_error_code(errc::file_exists);
+  make_error_condition(errc::file_exists);
+
   std::cout << "General tests...\n";
   // unit tests:
 
-  BOOST_TEST( posix_category == posix_category );
-  BOOST_TEST( system_category == system_category );
-  BOOST_TEST( posix_category != system_category );
-  BOOST_TEST( system_category != posix_category );
+  BOOST_TEST( generic_category() == generic_category() );
+  BOOST_TEST( system_category() == system_category() );
+  BOOST_TEST( generic_category() != system_category() );
+  BOOST_TEST( system_category() != generic_category() );
 
-  if ( std::less<const error_category*>()( &posix_category, &system_category ) )
+  if ( std::less<const error_category*>()( &generic_category(), &system_category() ) )
   {
-    BOOST_TEST( posix_category < system_category );
-    BOOST_TEST( !(system_category < posix_category) );
+    BOOST_TEST( generic_category() < system_category() );
+    BOOST_TEST( !(system_category() < generic_category()) );
   }
   else
   {
-    BOOST_TEST( system_category < posix_category );
-    BOOST_TEST( !(posix_category < system_category) );
+    BOOST_TEST( system_category() < generic_category() );
+    BOOST_TEST( !(generic_category() < system_category()) );
   }
 
 
   error_code ec;
-  error_condition dec;
+  error_condition econd;
   BOOST_TEST( !ec );
   BOOST_TEST( ec.value() == 0 );
-  dec = ec.default_error_condition();
-  BOOST_TEST( dec.value() == 0 );
-  BOOST_TEST( dec.category() == posix_category );
-  BOOST_TEST( ec == posix::success );
-  BOOST_TEST( ec.category() == system_category );
+  econd = ec.default_error_condition();
+  BOOST_TEST( econd.value() == 0 );
+  BOOST_TEST( econd.category() == generic_category() );
+  BOOST_TEST( ec == errc::success );
+  BOOST_TEST( ec.category() == system_category() );
   BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
-  BOOST_TEST( !(ec < error_code( 0, system_category )) );
-  BOOST_TEST( !(error_code( 0, system_category ) < ec) );
-  BOOST_TEST( ec < error_code( 1, system_category ) );
-  BOOST_TEST( !(error_code( 1, system_category ) < ec) );
+  BOOST_TEST( !(ec < error_code( 0, system_category() )) );
+  BOOST_TEST( !(error_code( 0, system_category() ) < ec) );
+  BOOST_TEST( ec < error_code( 1, system_category() ) );
+  BOOST_TEST( !(error_code( 1, system_category() ) < ec) );
 
-  error_code ec_0_system( 0, system_category );
+  error_code ec_0_system( 0, system_category() );
   BOOST_TEST( !ec_0_system );
   BOOST_TEST( ec_0_system.value() == 0 );
-  dec = ec_0_system.default_error_condition();
-  BOOST_TEST( dec.value() == 0 );
-  BOOST_TEST( dec.category() == posix_category );
-  BOOST_TEST( ec_0_system == posix::success );
-  BOOST_TEST( ec_0_system.category() == system_category );
+  econd = ec_0_system.default_error_condition();
+  BOOST_TEST( econd.value() == 0 );
+  BOOST_TEST( econd.category() == generic_category() );
+  BOOST_TEST( ec_0_system == errc::success );
+  BOOST_TEST( ec_0_system.category() == system_category() );
   BOOST_TEST( std::strcmp( ec_0_system.category().name(), "system") == 0 );
   check_ostream( ec_0_system, "system:0" );
 
   BOOST_TEST( ec_0_system == ec );
 
-  error_code ec_1_system( 1, system_category );
+  error_code ec_1_system( 1, system_category() );
   BOOST_TEST( ec_1_system );
   BOOST_TEST( ec_1_system.value() == 1 );
   BOOST_TEST( ec_1_system.value() != 0 );
@@ -112,41 +127,43 @@ int main( int, char ** )
   BOOST_TEST( ec_0_system != ec_1_system );
   check_ostream( ec_1_system, "system:1" );
 
-  ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
+  ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
   BOOST_TEST( ec );
   BOOST_TEST( ec.value() == BOOST_ACCESS_ERROR_MACRO );
-  dec = ec.default_error_condition();
-  BOOST_TEST( dec.value() == static_cast<int>(posix::permission_denied) );
-  BOOST_TEST( dec.category() == posix_category );
-  BOOST_TEST( dec == error_condition( posix::permission_denied, posix_category ) );
-  BOOST_TEST( dec == posix::permission_denied );
-  BOOST_TEST( posix::permission_denied == dec );
-  BOOST_TEST( ec == posix::permission_denied );
-  BOOST_TEST( ec.category() == system_category );
+  econd = ec.default_error_condition();
+  BOOST_TEST( econd.value() == static_cast<int>(errc::permission_denied) );
+  BOOST_TEST( econd.category() == generic_category() );
+  BOOST_TEST( econd == error_condition( errc::permission_denied, generic_category() ) );
+  BOOST_TEST( econd == errc::permission_denied );
+  BOOST_TEST( errc::permission_denied == econd );
+  BOOST_TEST( ec == errc::permission_denied );
+  BOOST_TEST( ec.category() == system_category() );
   BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
 
-  // test the explicit make_error_code conversion for posix
-  ec = make_error_code( posix::bad_message );
+  // test the explicit make_error_code conversion for errc
+  ec = make_error_code( errc::bad_message );
   BOOST_TEST( ec );
-  BOOST_TEST( ec == posix::bad_message );
-  BOOST_TEST( posix::bad_message == ec );
-  BOOST_TEST( ec != posix::permission_denied );
-  BOOST_TEST( posix::permission_denied != ec );
-  BOOST_TEST( ec.category() == posix_category );
+  BOOST_TEST( ec == errc::bad_message );
+  BOOST_TEST( errc::bad_message == ec );
+  BOOST_TEST( ec != errc::permission_denied );
+  BOOST_TEST( errc::permission_denied != ec );
+  BOOST_TEST( ec.category() == generic_category() );
 
-  // test the deprecated predefined error_category synonyms
-  BOOST_TEST( &system_category == &native_ecat );
-  BOOST_TEST( &posix_category == &errno_ecat );
-  BOOST_TEST( system_category == native_ecat );
-  BOOST_TEST( posix_category == errno_ecat );
+  //// test the deprecated predefined error_category synonyms
+  //BOOST_TEST( &system_category() == &native_ecat );
+  //BOOST_TEST( &generic_category() == &errno_ecat );
+  //BOOST_TEST( system_category() == native_ecat );
+  //BOOST_TEST( generic_category() == errno_ecat );
 
   // test error_code and error_condition message();
   // see Boost.Filesystem operations_test for code specific message() tests
-  ec = error_code( -1, system_category );
+  ec = error_code( -1, system_category() );
   std::cout << "error_code message for -1 is \"" << ec.message() << "\"\n";
+  std::cout << "error_code message for 0 is \"" << ec_0_system.message() << "\"\n";
 #if defined(BOOST_WINDOWS_API)
   // Borland appends newline, so just check text
   BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( ec_0_system.message().substr(0,36) == "The operation completed successfully" );
 #elif  defined(linux) || defined(__linux) || defined(__linux__)
   // Linux appends value to message as unsigned, so it varies with # of bits
   BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
@@ -158,102 +175,105 @@ int main( int, char ** )
   BOOST_TEST( ec.message() == "error -1" );
 #endif
 
-  ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
+  ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category() );
   BOOST_TEST( ec.message() != "" );
   BOOST_TEST( ec.message().substr( 0, 13) != "Unknown error" );
 
-  dec = error_condition( -1, posix_category );
-  std::cout << "error_condition message for -1 is \"" << dec.message() << "\"\n";
+  econd = error_condition( -1, generic_category() );
+  error_condition econd_ok;
+  std::cout << "error_condition message for -1 is \"" << econd.message() << "\"\n";
+  std::cout << "error_condition message for 0 is \"" << econd_ok.message() << "\"\n";
 #if defined(BOOST_WINDOWS_API)
   // Borland appends newline, so just check text
-  BOOST_TEST( dec.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( econd_ok.message().substr(0,8) == "No error" );
 #elif  defined(linux) || defined(__linux) || defined(__linux__)
   // Linux appends value to message as unsigned, so it varies with # of bits
-  BOOST_TEST( dec.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( econd.message().substr(0,13) == "Unknown error" );
 #elif defined(__hpux)
-  BOOST_TEST( dec.message() == "" );
+  BOOST_TEST( econd.message() == "" );
 #elif defined(__osf__)
-  BOOST_TEST( dec.message() == "Error -1 occurred." );
+  BOOST_TEST( econd.message() == "Error -1 occurred." );
 #elif defined(__vms)
-  BOOST_TEST( dec.message() == "error -1" );
+  BOOST_TEST( econd.message() == "error -1" );
 #endif
 
-  dec = error_condition( BOOST_ACCESS_ERROR_MACRO, posix_category );
-  BOOST_TEST( dec.message() != "" );
-  BOOST_TEST( dec.message().substr( 0, 13) != "Unknown error" );
+  econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category() );
+  BOOST_TEST( econd.message() != "" );
+  BOOST_TEST( econd.message().substr( 0, 13) != "Unknown error" );
 
 #ifdef BOOST_WINDOWS_API
   std::cout << "Windows tests...\n";
-  // these tests probe the Windows posix decoder
+  // these tests probe the Windows errc decoder
   //   test the first entry in the decoder table:
-  ec = error_code( ERROR_ACCESS_DENIED, system_category );
+  ec = error_code( ERROR_ACCESS_DENIED, system_category() );
   BOOST_TEST( ec.value() == ERROR_ACCESS_DENIED );
-  BOOST_TEST( ec == posix::permission_denied );
-  BOOST_TEST( ec.default_error_condition().value() == posix::permission_denied );
-  BOOST_TEST( ec.default_error_condition().category() == posix_category );
+  BOOST_TEST( ec == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
   //   test the second entry in the decoder table:
-  ec = error_code( ERROR_ALREADY_EXISTS, system_category );
+  ec = error_code( ERROR_ALREADY_EXISTS, system_category() );
   BOOST_TEST( ec.value() == ERROR_ALREADY_EXISTS );
-  BOOST_TEST( ec == posix::file_exists );
-  BOOST_TEST( ec.default_error_condition().value() == posix::file_exists );
-  BOOST_TEST( ec.default_error_condition().category() == posix_category );
+  BOOST_TEST( ec == errc::file_exists );
+  BOOST_TEST( ec.default_error_condition().value() == errc::file_exists );
+  BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
   //   test the third entry in the decoder table:
-  ec = error_code( ERROR_BAD_UNIT, system_category );
+  ec = error_code( ERROR_BAD_UNIT, system_category() );
   BOOST_TEST( ec.value() == ERROR_BAD_UNIT );
-  BOOST_TEST( ec == posix::no_such_device );
-  BOOST_TEST( ec.default_error_condition().value() == posix::no_such_device );
-  BOOST_TEST( ec.default_error_condition().category() == posix_category );
+  BOOST_TEST( ec == errc::no_such_device );
+  BOOST_TEST( ec.default_error_condition().value() == errc::no_such_device );
+  BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
   //   test the last non-Winsock entry in the decoder table:
-  ec = error_code( ERROR_WRITE_PROTECT, system_category );
+  ec = error_code( ERROR_WRITE_PROTECT, system_category() );
   BOOST_TEST( ec.value() == ERROR_WRITE_PROTECT );
-  BOOST_TEST( ec == posix::permission_denied );
-  BOOST_TEST( ec.default_error_condition().value() == posix::permission_denied );
-  BOOST_TEST( ec.default_error_condition().category() == posix_category );
+  BOOST_TEST( ec == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
   //   test the last Winsock entry in the decoder table:
-  ec = error_code( WSAEWOULDBLOCK, system_category );
+  ec = error_code( WSAEWOULDBLOCK, system_category() );
   BOOST_TEST( ec.value() == WSAEWOULDBLOCK );
-  BOOST_TEST( ec == posix::operation_would_block );
-  BOOST_TEST( ec.default_error_condition().value() == posix::operation_would_block );
-  BOOST_TEST( ec.default_error_condition().category() == posix_category );
+  BOOST_TEST( ec == errc::operation_would_block );
+  BOOST_TEST( ec.default_error_condition().value() == errc::operation_would_block );
+  BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
   //   test not-in-table condition:
-  ec = error_code( 1234567890, system_category );
+  ec = error_code( 1234567890, system_category() );
   BOOST_TEST( ec.value() == 1234567890 );
   BOOST_TEST( ec.default_error_condition().value() == 1234567890 );
-  BOOST_TEST( ec.default_error_condition().category() == system_category );
+  BOOST_TEST( ec.default_error_condition().category() == system_category() );
 
 #else // POSIX
 
   std::cout << "POSIX tests...\n";
-  ec = error_code( EACCES, system_category );
-  BOOST_TEST( ec == error_code( posix::permission_denied, system_category ) );
-  BOOST_TEST( error_code( posix::permission_denied, system_category ) == ec );
-  BOOST_TEST( ec == posix::permission_denied );
-  BOOST_TEST( posix::permission_denied == ec );
-  BOOST_TEST( ec.default_error_condition().value() == posix::permission_denied );
-  BOOST_TEST( ec.default_error_condition().category() == posix_category );
+  ec = error_code( EACCES, system_category() );
+  BOOST_TEST( ec == error_code( errc::permission_denied, system_category() ) );
+  BOOST_TEST( error_code( errc::permission_denied, system_category() ) == ec );
+  BOOST_TEST( ec == errc::permission_denied );
+  BOOST_TEST( errc::permission_denied == ec );
+  BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
+  BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
 # ifdef __CYGWIN__
 
   std::cout << "Cygwin tests...\n";
   ec = cygwin_error::no_package;
   BOOST_TEST( ec == cygwin_error::no_package );
-  BOOST_TEST( ec == error_code( ENOPKG, system_category ) );
-  BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category ) );
-  BOOST_TEST( ec.default_error_condition().category() == system_category );
+  BOOST_TEST( ec == error_code( ENOPKG, system_category() ) );
+  BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category() ) );
+  BOOST_TEST( ec.default_error_condition().category() == system_category() );
 
 # elif defined(linux) || defined(__linux) || defined(__linux__)
 
   std::cout << "Linux tests...\n";
   ec = linux_error::dot_dot_error;
   BOOST_TEST( ec == linux_error::dot_dot_error );
-  BOOST_TEST( ec == error_code( EDOTDOT, system_category ) );
-  BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category ) );
-  BOOST_TEST( ec.default_error_condition().category() == system_category );
+  BOOST_TEST( ec == error_code( EDOTDOT, system_category() ) );
+  BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category() ) );
+  BOOST_TEST( ec.default_error_condition().category() == system_category() );
 
 # endif
 

test/error_code_user_test.cpp

@@ -14,11 +14,13 @@
 
 //  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>
 #include <cstdio>
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 
 #ifdef BOOST_POSIX_API
 # include <sys/stat.h>
@@ -40,7 +42,7 @@ boost::system::error_code my_mkdir( const std::string & path )
 #   else
       ::CreateDirectoryA( path.c_str(), 0 ) != 0 ? 0 : ::GetLastError(),
 #   endif
-      boost::system::system_category );
+      boost::system::system_category() );
 }
 
 //  ------------------------------------------------------------------------  //
@@ -53,9 +55,9 @@ boost::system::error_code my_remove( const std::string & path )
 {
   return boost::system::error_code(
     std::remove( path.c_str() ) == 0 ? 0 : errno,
-    boost::system::posix_category ); // OK for both Windows and POSIX
-                                     // Alternatively, could use posix_category
-                                     // on Windows and system_category on
+    boost::system::generic_category() ); // OK for both Windows and POSIX
+                                     // Alternatively, could use generic_category()
+                                     // on Windows and system_category() on
                                      // POSIX-based systems.
 }
 
@@ -73,7 +75,7 @@ namespace boost
   namespace lib3
   {
     // lib3 has its own error_category:
-    const boost::system::error_category & get_lib3_error_category();
+    const boost::system::error_category & get_lib3_error_category() BOOST_SYSTEM_NOEXCEPT;
     const boost::system::error_category & lib3_error_category = get_lib3_error_category();
     
     enum error
@@ -108,16 +110,18 @@ namespace boost
     class lib3_error_category_imp : public boost::system::error_category
     {
     public:
-      const char * name() const
+      lib3_error_category_imp() : boost::system::error_category() { }
+
+      const char * name() const BOOST_SYSTEM_NOEXCEPT
       {
         return "lib3";
       }
 
-      boost::system::error_condition default_error_condition( int ev ) const
+      boost::system::error_condition default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
       {
         return ev == boo_boo
-          ? boost::system::error_condition( boost::system::posix::io_error,
-              boost::system::posix_category )
+          ? boost::system::error_condition( boost::system::errc::io_error,
+              boost::system::generic_category() )
           : boost::system::error_condition( ev,
               boost::lib3::lib3_error_category );
       }
@@ -131,7 +135,7 @@ namespace boost
 
     };
 
-    const boost::system::error_category & get_lib3_error_category()
+    const boost::system::error_category & get_lib3_error_category() BOOST_SYSTEM_NOEXCEPT
     {
       static const lib3_error_category_imp l3ecat;
       return l3ecat;
@@ -152,7 +156,7 @@ namespace boost
 namespace lib4
 {
   // lib4 has its own error_category:
-  const boost::system::error_category & get_lib4_error_category();
+  const boost::system::error_category & get_lib4_error_category() BOOST_SYSTEM_NOEXCEPT;
   const boost::system::error_category & lib4_error_category = get_lib4_error_category();
   
   extern const boost::system::error_code boo_boo;
@@ -168,16 +172,18 @@ namespace lib4
   class lib4_error_category_imp : public boost::system::error_category
   {
   public:
-    const char * name() const
+    lib4_error_category_imp() : boost::system::error_category() { }
+
+    const char * name() const BOOST_SYSTEM_NOEXCEPT
     {
       return "lib4";
     }
 
-    boost::system::error_condition default_error_condition( int ev ) const
+    boost::system::error_condition default_error_condition( int ev ) const  BOOST_SYSTEM_NOEXCEPT
     {
       return ev == boo_boo.value()
-        ? boost::system::error_condition( boost::system::posix::io_error,
-            boost::system::posix_category )
+        ? boost::system::error_condition( boost::system::errc::io_error,
+            boost::system::generic_category() )
         : boost::system::error_condition( ev, lib4::lib4_error_category );
     }
     
@@ -189,7 +195,7 @@ namespace lib4
     }
   };
 
-  const boost::system::error_category & get_lib4_error_category()
+  const boost::system::error_category & get_lib4_error_category() BOOST_SYSTEM_NOEXCEPT
   {
     static const lib4_error_category_imp l4ecat;
     return l4ecat;
@@ -233,15 +239,15 @@ namespace lib4
 //      switch (ev)
 //      {
 //        case user_success:
-//          return boost::system::error_code(boost::system::posix::success, boost::system::posix_category);
+//          return boost::system::error_code(boost::system::errc::success, boost::system::generic_category());
 //        case user_permission_denied:
-//          return boost::system::error_code(boost::system::posix::permission_denied, boost::system::posix_category);
+//          return boost::system::error_code(boost::system::errc::permission_denied, boost::system::generic_category());
 //        case user_out_of_memory:
-//          return boost::system::error_code(boost::system::posix::not_enough_memory, boost::system::posix_category);
+//          return boost::system::error_code(boost::system::errc::not_enough_memory, boost::system::generic_category());
 //        default:
 //          break;
 //      }
-//      return boost::system::error_code(boost::system::posix::no_posix_equivalent, boost::system::posix_category);
+//      return boost::system::error_code(boost::system::errc::no_posix_equivalent, boost::system::generic_category());
 //    }
 //    
 //  };
@@ -260,8 +266,8 @@ namespace lib4
 //
 //  void check_success(const boost::system::error_code& ec, bool expect)
 //  {
-//    BOOST_CHECK( (ec == boost::system::posix::success) == expect );
-//    if (ec == boost::system::posix::success)
+//    BOOST_TEST( (ec == boost::system::errc::success) == expect );
+//    if (ec == boost::system::errc::success)
 //      std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
 //    else
 //      std::cout << "no...  " << (expect ? "fail" : "ok") << '\n';
@@ -269,8 +275,8 @@ namespace lib4
 //
 //  void check_permission_denied(const boost::system::error_code& ec, bool expect)
 //  {
-//    BOOST_CHECK( (ec == boost::system::posix::permission_denied) == expect );
-//    if (ec ==  boost::system::posix::permission_denied)
+//    BOOST_TEST( (ec == boost::system::errc::permission_denied) == expect );
+//    if (ec ==  boost::system::errc::permission_denied)
 //      std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
 //    else
 //      std::cout << "no...  " << (expect ? "fail" : "ok") << '\n';
@@ -278,8 +284,8 @@ namespace lib4
 //
 //  void check_out_of_memory(const boost::system::error_code& ec, bool expect)
 //  {
-//    BOOST_CHECK( (ec == boost::system::posix::not_enough_memory) == expect );
-//    if (ec ==  boost::system::posix::not_enough_memory)
+//    BOOST_TEST( (ec == boost::system::errc::not_enough_memory) == expect );
+//    if (ec ==  boost::system::errc::not_enough_memory)
 //      std::cout << "yes... " << (expect ? "ok" : "fail") << '\n';
 //    else
 //      std::cout << "no...  " << (expect ? "fail" : "ok") << '\n';
@@ -291,23 +297,23 @@ namespace lib4
 //    printf("=====\n");
 //    boost::system::error_code ec;
 //    check_success(ec, true);
-//    check_success(boost::system::posix::success, true);
-//    check_success(boost::system::posix::permission_denied, false);
-//    check_success(boost::system::posix::not_enough_memory, false);
+//    check_success(boost::system::errc::success, true);
+//    check_success(boost::system::errc::permission_denied, false);
+//    check_success(boost::system::errc::not_enough_memory, false);
 //    check_success(user_success, true);
 //    check_success(user_permission_denied, false);
 //    check_success(user_out_of_memory, false);
 //    check_permission_denied(ec, false);
-//    check_permission_denied(boost::system::posix::success, false);
-//    check_permission_denied(boost::system::posix::permission_denied, true);
-//    check_permission_denied(boost::system::posix::not_enough_memory, false);
+//    check_permission_denied(boost::system::errc::success, false);
+//    check_permission_denied(boost::system::errc::permission_denied, true);
+//    check_permission_denied(boost::system::errc::not_enough_memory, false);
 //    check_permission_denied(user_success, false);
 //    check_permission_denied(user_permission_denied, true);
 //    check_permission_denied(user_out_of_memory, false);
 //    check_out_of_memory(ec, false);
-//    check_out_of_memory(boost::system::posix::success, false);
-//    check_out_of_memory(boost::system::posix::permission_denied, false);
-//    check_out_of_memory(boost::system::posix::not_enough_memory, true);
+//    check_out_of_memory(boost::system::errc::success, false);
+//    check_out_of_memory(boost::system::errc::permission_denied, false);
+//    check_out_of_memory(boost::system::errc::not_enough_memory, true);
 //    check_out_of_memory(user_success, false);
 //    check_out_of_memory(user_permission_denied, false);
 //    check_out_of_memory(user_out_of_memory, true);
@@ -333,7 +339,7 @@ namespace lib4
 
 //  ------------------------------------------------------------------------  //
 
-int test_main( int, char *[] )
+int main( int, char *[] )
 {
   boost::system::error_code ec;
 
@@ -342,35 +348,35 @@ int test_main( int, char *[] )
   ec = my_mkdir( "/no-such-file-or-directory/will-not-succeed" );
   std::cout << "ec.value() is " << ec.value() << '\n';
 
-  BOOST_CHECK( ec );
-  BOOST_CHECK( ec == boost::system::posix::no_such_file_or_directory );
-  BOOST_CHECK( ec.category() == boost::system::system_category );
+  BOOST_TEST( ec );
+  BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
+  BOOST_TEST( ec.category() == boost::system::system_category() );
 
   // Library 2 tests:
 
   ec = my_remove( "/no-such-file-or-directory" );
   std::cout << "ec.value() is " << ec.value() << '\n';
 
-  BOOST_CHECK( ec );
-  BOOST_CHECK( ec == boost::system::posix::no_such_file_or_directory );
-  BOOST_CHECK( ec.category() == boost::system::posix_category );
+  BOOST_TEST( ec );
+  BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
+  BOOST_TEST( ec.category() == boost::system::generic_category() );
 
   // Library 3 tests:
 
   ec = boost::lib3::boo_boo;
   std::cout << "ec.value() is " << ec.value() << '\n';
 
-  BOOST_CHECK( ec );
-  BOOST_CHECK( ec == boost::lib3::boo_boo );
-  BOOST_CHECK( ec.value() == boost::lib3::boo_boo );
-  BOOST_CHECK( ec.category() == boost::lib3::lib3_error_category );
+  BOOST_TEST( ec );
+  BOOST_TEST( ec == boost::lib3::boo_boo );
+  BOOST_TEST( ec.value() == boost::lib3::boo_boo );
+  BOOST_TEST( ec.category() == boost::lib3::lib3_error_category );
 
-  BOOST_CHECK( ec == boost::system::posix::io_error );
+  BOOST_TEST( ec == boost::system::errc::io_error );
 
   boost::system::error_code ec3( boost::lib3::boo_boo+100,
     boost::lib3::lib3_error_category );
-  BOOST_CHECK( ec3.category() == boost::lib3::lib3_error_category );
-  BOOST_CHECK( ec3.default_error_condition().category()
+  BOOST_TEST( ec3.category() == boost::lib3::lib3_error_category );
+  BOOST_TEST( ec3.default_error_condition().category()
     == boost::lib3::lib3_error_category );
 
   // Library 4 tests:
@@ -378,21 +384,21 @@ int test_main( int, char *[] )
   ec = lib4::boo_boo;
   std::cout << "ec.value() is " << ec.value() << '\n';
 
-  BOOST_CHECK( ec );
-  BOOST_CHECK( ec == lib4::boo_boo );
-  BOOST_CHECK( ec.value() == lib4::boo_boo.value() );
-  BOOST_CHECK( ec.category() == lib4::lib4_error_category );
+  BOOST_TEST( ec );
+  BOOST_TEST( ec == lib4::boo_boo );
+  BOOST_TEST( ec.value() == lib4::boo_boo.value() );
+  BOOST_TEST( ec.category() == lib4::lib4_error_category );
 
-  BOOST_CHECK( ec == boost::system::posix::io_error );
+  BOOST_TEST( ec == boost::system::errc::io_error );
 
   boost::system::error_code ec4( lib4::boo_boo.value()+100,
     lib4::lib4_error_category );
-  BOOST_CHECK( ec4.default_error_condition().category()
+  BOOST_TEST( ec4.default_error_condition().category()
     == lib4::lib4_error_category );
 
   // Test 3
 
   //test3::run();
 
-  return 0;
+  return ::boost::report_errors();
 }

test/header_only_test.cpp

@@ -13,12 +13,11 @@
 
 #define BOOST_ERROR_CODE_HEADER_ONLY
 
-#include <boost/test/minimal.hpp>
-
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/system/error_code.hpp>
 
-int test_main( int, char*[] )
+int main( int, char*[] )
 {
-  boost::system::error_code ec( 0, boost::system::system_category );
-  return 0;
+  boost::system::error_code ec( 0, boost::system::system_category() );
+  return ::boost::report_errors();
 }

test/initialization_test.cpp

@@ -10,7 +10,7 @@
 //  This test verifiies that the error_category vtable does not suffer from
 //  order-of-initialization problems.
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/system/error_code.hpp>
 
 struct foo
@@ -22,7 +22,7 @@ struct foo
   }
 } f;
 
-int test_main( int, char ** )
+int main( int, char ** )
 {
-       return 0;
+  return ::boost::report_errors();
 }

test/msvc/common.props

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ImportGroup Label="PropertySheets" />
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>../../../../..</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PreprocessorDefinitions>BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ExceptionHandling>Async</ExceptionHandling>
+    </ClCompile>
+    <PostBuildEvent>
+      <Command>"$(TargetDir)\$(TargetName).exe"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemGroup />
+</Project>

test/msvc/config_test/config_test.vcxproj

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E18C2B56-DCEC-438F-9C38-3C8B08B65247}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>config_test</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <SDLCheck>true</SDLCheck>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\config_test.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\include\boost\system\api_config.hpp" />
+    <ClInclude Include="..\..\..\include\boost\system\config.hpp" />
+    <ClInclude Include="..\..\..\include\boost\system\cygwin_error.hpp" />
+    <ClInclude Include="..\..\..\include\boost\system\error_code.hpp" />
+    <ClInclude Include="..\..\..\include\boost\system\linux_error.hpp" />
+    <ClInclude Include="..\..\..\include\boost\system\system_error.hpp" />
+    <ClInclude Include="..\..\..\include\boost\system\windows_error.hpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

test/msvc/error_code_test/error_code_test.vcxproj

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{E50C14DC-547D-4C33-83EA-653C0D0D4E64}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>error_code_test</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\system-dll\system-dll.vcxproj">
+      <Project>{419402d4-f990-4b05-a459-655e2dc33dc2}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\error_code_test.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

test/msvc/header_only_error_code_test/header_only_error_code_test.vcxproj

@@ -0,0 +1,151 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>header_only_error_code_test</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions);BOOST_ERROR_CODE_HEADER_ONLY</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\error_code_test.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

test/msvc/header_only_test/header_only_test.vcxproj

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{3773451B-A618-4A26-A7F2-85554F4BD21B}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>header_only_test</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\header_only_test.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

test/msvc/std_interop_test/std_interop_test.vcxproj

@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>std_interop_test</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.14393.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\std_interop_test.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\system-dll\system-dll.vcxproj">
+      <Project>{419402d4-f990-4b05-a459-655e2dc33dc2}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

test/msvc/system-dll/system-dll.vcxproj

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{419402D4-F990-4B05-A459-655E2DC33DC2}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>systemdll</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="..\common.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;SYSTEMDLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpplatest</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+    <PostBuildEvent>
+      <Command />
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;SYSTEMDLL_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\src\error_code.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

test/msvc/system.sln

@@ -0,0 +1,83 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26430.6
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system-dll", "system-dll\system-dll.vcxproj", "{419402D4-F990-4B05-A459-655E2DC33DC2}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "error_code_test", "error_code_test\error_code_test.vcxproj", "{E50C14DC-547D-4C33-83EA-653C0D0D4E64}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "header_only_test", "header_only_test\header_only_test.vcxproj", "{3773451B-A618-4A26-A7F2-85554F4BD21B}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "config_test", "config_test\config_test.vcxproj", "{E18C2B56-DCEC-438F-9C38-3C8B08B65247}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "clang-system-dll", "clang-system-dll\clang-system-dll.vcxproj", "{30993F97-5E77-4B5A-B25F-B545C276077A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "std_interop_test", "std_interop_test\std_interop_test.vcxproj", "{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}"
+	ProjectSection(ProjectDependencies) = postProject
+		{419402D4-F990-4B05-A459-655E2DC33DC2} = {419402D4-F990-4B05-A459-655E2DC33DC2}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "header_only_error_code_test", "header_only_error_code_test\header_only_error_code_test.vcxproj", "{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{419402D4-F990-4B05-A459-655E2DC33DC2}.Debug|Win32.ActiveCfg = Debug|Win32
+		{419402D4-F990-4B05-A459-655E2DC33DC2}.Debug|Win32.Build.0 = Debug|Win32
+		{419402D4-F990-4B05-A459-655E2DC33DC2}.Debug|x64.ActiveCfg = Debug|Win32
+		{419402D4-F990-4B05-A459-655E2DC33DC2}.Release|Win32.ActiveCfg = Release|Win32
+		{419402D4-F990-4B05-A459-655E2DC33DC2}.Release|Win32.Build.0 = Release|Win32
+		{419402D4-F990-4B05-A459-655E2DC33DC2}.Release|x64.ActiveCfg = Release|Win32
+		{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Debug|Win32.Build.0 = Debug|Win32
+		{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Debug|x64.ActiveCfg = Debug|Win32
+		{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Release|Win32.ActiveCfg = Release|Win32
+		{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Release|Win32.Build.0 = Release|Win32
+		{E50C14DC-547D-4C33-83EA-653C0D0D4E64}.Release|x64.ActiveCfg = Release|Win32
+		{3773451B-A618-4A26-A7F2-85554F4BD21B}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3773451B-A618-4A26-A7F2-85554F4BD21B}.Debug|Win32.Build.0 = Debug|Win32
+		{3773451B-A618-4A26-A7F2-85554F4BD21B}.Debug|x64.ActiveCfg = Debug|Win32
+		{3773451B-A618-4A26-A7F2-85554F4BD21B}.Release|Win32.ActiveCfg = Release|Win32
+		{3773451B-A618-4A26-A7F2-85554F4BD21B}.Release|Win32.Build.0 = Release|Win32
+		{3773451B-A618-4A26-A7F2-85554F4BD21B}.Release|x64.ActiveCfg = Release|Win32
+		{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Debug|Win32.Build.0 = Debug|Win32
+		{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Debug|x64.ActiveCfg = Debug|Win32
+		{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Release|Win32.ActiveCfg = Release|Win32
+		{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Release|Win32.Build.0 = Release|Win32
+		{E18C2B56-DCEC-438F-9C38-3C8B08B65247}.Release|x64.ActiveCfg = Release|Win32
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|Win32.ActiveCfg = Debug|Win32
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|Win32.Build.0 = Debug|Win32
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|x64.ActiveCfg = Debug|x64
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Debug|x64.Build.0 = Debug|x64
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|Win32.ActiveCfg = Release|Win32
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|Win32.Build.0 = Release|Win32
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|x64.ActiveCfg = Release|x64
+		{30993F97-5E77-4B5A-B25F-B545C276077A}.Release|x64.Build.0 = Release|x64
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|Win32.ActiveCfg = Debug|Win32
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|Win32.Build.0 = Debug|Win32
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|x64.ActiveCfg = Debug|x64
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Debug|x64.Build.0 = Debug|x64
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|Win32.ActiveCfg = Release|Win32
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|Win32.Build.0 = Release|Win32
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|x64.ActiveCfg = Release|x64
+		{47B0A041-1EB5-4842-BD17-BA0DCC5E0313}.Release|x64.Build.0 = Release|x64
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|Win32.Build.0 = Debug|Win32
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|x64.ActiveCfg = Debug|x64
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Debug|x64.Build.0 = Debug|x64
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|Win32.ActiveCfg = Release|Win32
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|Win32.Build.0 = Release|Win32
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|x64.ActiveCfg = Release|x64
+		{C25D7BD7-1B99-4DA9-A1A5-3034410CBEF7}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

test/std_interop_test.cpp

@@ -0,0 +1,370 @@
+
+// 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/config.hpp>
+#include <iostream>
+
+#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
+
+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/system/error_code.hpp>
+#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() );
+
+    int ev = ENOENT;
+
+    BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+
+    {
+        boost::system::error_code bc( ev, bt );
+
+        BOOST_TEST_EQ( bc.value(), ev );
+        BOOST_TEST_EQ( &bc.category(), &bt );
+
+        std::error_code sc( bc );
+
+        BOOST_TEST_EQ( sc.value(), ev );
+        BOOST_TEST_EQ( &sc.category(), &st );
+    }
+
+    {
+        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 ) );
+
+        std::error_condition sn( bn );
+
+        BOOST_TEST_EQ( sn.value(), ev );
+        BOOST_TEST_EQ( &sn.category(), &st );
+
+        BOOST_TEST( st.equivalent( ev, sn ) );
+    }
+}
+
+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 ev = 5;
+        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+
+        {
+            boost::system::error_code bc( ev, bt );
+
+            BOOST_TEST_EQ( bc.value(), ev );
+            BOOST_TEST_EQ( &bc.category(), &bt );
+
+            std::error_code sc( bc );
+
+            BOOST_TEST_EQ( sc.value(), ev );
+            BOOST_TEST_EQ( &sc.category(), &st );
+        }
+
+        {
+            boost::system::error_condition bn = bt.default_error_condition( ev );
+            BOOST_TEST( bt.equivalent( ev, bn ) );
+
+            std::error_condition sn( bn );
+            BOOST_TEST( st.equivalent( ev, sn ) );
+        }
+    }
+
+    {
+        int ev = 4;
+        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+
+        {
+            boost::system::error_code bc( ev, bt );
+
+            BOOST_TEST_EQ( bc.value(), ev );
+            BOOST_TEST_EQ( &bc.category(), &bt );
+
+            std::error_code sc( bc );
+
+            BOOST_TEST_EQ( sc.value(), ev );
+            BOOST_TEST_EQ( &sc.category(), &st );
+        }
+
+        {
+            boost::system::error_condition bn = bt.default_error_condition( ev );
+            BOOST_TEST( bt.equivalent( ev, bn ) );
+
+            std::error_condition sn( bn );
+            BOOST_TEST( st.equivalent( ev, sn ) );
+        }
+    }
+}
+
+// test_user_category
+
+class user_category_impl: public boost::system::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;
+    }
+
+    virtual boost::system::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
+    {
+        if( ev == 4 )
+        {
+            return boost::system::error_condition( EMFILE, boost::system::generic_category() );
+        }
+        else if( ev == 5 )
+        {
+            return boost::system::error_condition( EACCES, boost::system::generic_category() );
+        }
+        else
+        {
+            return boost::system::error_condition( ev, *this );
+        }
+    }
+
+    virtual bool equivalent( int code, const boost::system::error_condition & condition ) const BOOST_NOEXCEPT
+    {
+        if( code == 4 && condition == make_error_condition( boost::system::errc::too_many_files_open_in_system ) )
+        {
+            return true;
+        }
+
+        if( code == 4 && condition == make_error_condition( boost::system::errc::too_many_files_open ) )
+        {
+            return true;
+        }
+
+        return default_error_condition( code ) == condition;
+    }
+
+    // virtual bool equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT;
+};
+
+boost::system::error_category const & user_category()
+{
+    static user_category_impl cat_;
+    return cat_;
+}
+
+static void test_user_category()
+{
+    boost::system::error_category const & bt = user_category();
+    std::error_category const & st = bt;
+
+    BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
+
+    {
+        int ev = 5;
+        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+
+        {
+            boost::system::error_code bc( ev, bt );
+
+            BOOST_TEST_EQ( bc.value(), ev );
+            BOOST_TEST_EQ( &bc.category(), &bt );
+
+            std::error_code sc( bc );
+
+            BOOST_TEST_EQ( sc.value(), ev );
+            BOOST_TEST_EQ( &sc.category(), &st );
+        }
+
+        {
+            boost::system::error_condition bn = bt.default_error_condition( ev );
+            BOOST_TEST( bt.equivalent( ev, bn ) );
+
+            std::error_condition sn( bn );
+            BOOST_TEST( st.equivalent( ev, sn ) );
+        }
+    }
+
+    {
+        int ev = 4;
+        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+
+        {
+            boost::system::error_code bc( ev, bt );
+
+            BOOST_TEST_EQ( bc.value(), ev );
+            BOOST_TEST_EQ( &bc.category(), &bt );
+
+            std::error_code sc( bc );
+
+            BOOST_TEST_EQ( sc.value(), ev );
+            BOOST_TEST_EQ( &sc.category(), &st );
+        }
+
+        {
+            boost::system::error_condition bn = bt.default_error_condition( ev );
+            BOOST_TEST( bt.equivalent( ev, bn ) );
+
+            std::error_condition sn( bn );
+            BOOST_TEST( st.equivalent( ev, sn ) );
+        }
+
+        {
+            boost::system::error_condition bn = make_error_condition( boost::system::errc::too_many_files_open_in_system );
+            BOOST_TEST( bt.equivalent( ev, bn ) );
+
+            std::error_condition sn( bn );
+            BOOST_TEST( st.equivalent( ev, sn ) );
+        }
+
+        {
+            boost::system::error_condition bn = make_error_condition( boost::system::errc::too_many_files_open );
+            BOOST_TEST( bt.equivalent( ev, bn ) );
+
+            std::error_condition sn( bn );
+            BOOST_TEST( st.equivalent( ev, sn ) );
+        }
+    }
+}
+
+// test_user2_category
+
+enum user2_errc
+{
+    my_enoent = 1,
+    my_einval,
+    my_other
+};
+
+class user2_category_impl: public boost::system::error_category
+{
+public:
+
+    virtual const char * name() const BOOST_NOEXCEPT
+    {
+        return "user2";
+    }
+
+    virtual std::string message( int ev ) const
+    {
+        char buffer[ 256 ];
+        std::sprintf( buffer, "user2 message %d", ev );
+
+        return buffer;
+    }
+
+    virtual boost::system::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
+    {
+        return boost::system::error_condition( ev, *this );
+    }
+
+    virtual bool equivalent( int code, const boost::system::error_condition & condition ) const BOOST_NOEXCEPT
+    {
+        return default_error_condition( code ) == condition;
+    }
+
+    virtual bool equivalent( const boost::system::error_code & code, int condition ) const BOOST_NOEXCEPT
+    {
+        if( code.category() == *this )
+        {
+            return condition == code.value();
+        }
+        else if( condition == my_enoent )
+        {
+            return code == boost::system::errc::no_such_file_or_directory;
+        }
+        else if( condition == my_einval )
+        {
+            return code == boost::system::errc::invalid_argument;
+        }
+        else
+        {
+            return false;
+        }
+    }
+};
+
+boost::system::error_category const & user2_category()
+{
+    static user2_category_impl cat_;
+    return cat_;
+}
+
+static void test_user2_category()
+{
+    boost::system::error_category const & bt = user2_category();
+    std::error_category const & st = bt;
+
+    int ev = my_enoent;
+
+    boost::system::error_condition bn( ev, bt );
+
+    BOOST_TEST_EQ( bn.value(), ev );
+    BOOST_TEST_EQ( &bn.category(), &bt );
+
+    boost::system::error_code bc = make_error_code( boost::system::errc::no_such_file_or_directory );
+
+    BOOST_TEST( bc == bn );
+
+    std::error_condition sn( bn );
+
+    BOOST_TEST_EQ( sn.value(), ev );
+    BOOST_TEST_EQ( &sn.category(), &st );
+
+    std::error_code sc( bc );
+
+    BOOST_TEST( sc == sn );
+}
+
+//
+
+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();
+    test_user_category();
+    test_user2_category();
+
+    return boost::report_errors();
+}
+
+#endif

test/system_error_test.cpp

@@ -1,7 +1,7 @@
 //  system_error_test.cpp  ---------------------------------------------------//
 
 //  Copyright Beman Dawes 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)
 
@@ -9,9 +9,12 @@
 
 //----------------------------------------------------------------------------// 
 
+//  test without deprecated features
+#define BOOST_SYSTEM_NO_DEPRECATED
+
 #include <boost/config/warning_disable.hpp>
 
-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/system/system_error.hpp>
 #include <iostream>
 #include <string>
@@ -33,11 +36,11 @@ namespace
     int v, const char * str )
   {
     std::cout << "test " << desc << "\n what() returns \"" << ex.what() << "\"\n";
-    BOOST_CHECK( ex.code().value() == v );
-    BOOST_CHECK( ex.code().category() == system_category );
+    BOOST_TEST( ex.code().value() == v );
+    BOOST_TEST( ex.code().category() == system_category() );
 # ifdef BOOST_WINDOWS_API
     LANGID language_id;
-#   if !defined(__MINGW32__) && !defined(__CYGWIN__)
+#   if !defined(__MINGW32__) && !defined(__CYGWIN__) && !BOOST_PLAT_WINDOWS_RUNTIME
       language_id = ::GetUserDefaultUILanguage();
 #   else
       language_id = 0x0409; // Assume US English
@@ -45,7 +48,7 @@ namespace
     // std::cout << "GetUserDefaultUILanguage() returns " << language_id << '\n';
     if ( language_id == 0x0409 )  // English (United States)
     {
-      BOOST_CHECK( std::string( ex.what() ) == str );
+      BOOST_TEST( std::string( ex.what() ) == str );
       if ( std::string( ex.what() ) != str )
         std::cout << "expected \"" << str << "\", but what() returned \""
           << ex.what() << "\"\n";
@@ -56,51 +59,51 @@ namespace
   const boost::uint_least32_t uvalue = 2u;
 }
 
-int test_main( int, char *[] )
+int main( int, char *[] )
 {
   // all constructors, in the same order as they appear in the header:
 
-  system_error c1_0( error_code(0, system_category) ); 
-  system_error c1_1( error_code(1, system_category) );
-  system_error c1_2u( error_code(uvalue, system_category) );
+  system_error c1_0( error_code(0, system_category()) ); 
+  system_error c1_1( error_code(1, system_category()) );
+  system_error c1_2u( error_code(uvalue, system_category()) );
 
-  system_error c2_0( error_code(0, system_category), string("c2_0") ); 
-  system_error c2_1( error_code(1, system_category), string("c2_1") );
+  system_error c2_0( error_code(0, system_category()), string("c2_0") ); 
+  system_error c2_1( error_code(1, system_category()), string("c2_1") );
 
-  system_error c3_0( error_code(0, system_category), "c3_0" ); 
-  system_error c3_1( error_code(1, system_category), "c3_1" );
+  system_error c3_0( error_code(0, system_category()), "c3_0" ); 
+  system_error c3_1( error_code(1, system_category()), "c3_1" );
 
-  system_error c4_0( 0, system_category ); 
-  system_error c4_1( 1, system_category );
-  system_error c4_2u( uvalue, system_category );
+  system_error c4_0( 0, system_category() ); 
+  system_error c4_1( 1, system_category() );
+  system_error c4_2u( uvalue, system_category() );
 
-  system_error c5_0( 0, system_category, string("c5_0") ); 
-  system_error c5_1( 1, system_category, string("c5_1") );
+  system_error c5_0( 0, system_category(), string("c5_0") ); 
+  system_error c5_1( 1, system_category(), string("c5_1") );
 
-  system_error c6_0( 0, system_category, "c6_0" ); 
-  system_error c6_1( 1, system_category, "c6_1" );
+  system_error c6_0( 0, system_category(), "c6_0" ); 
+  system_error c6_1( 1, system_category(), "c6_1" );
 
-  TEST( c1_0, 0, "" );
+  TEST( c1_0, 0, "The operation completed successfully" );
   TEST( c1_1, 1, "Incorrect function" );
   TEST( c1_2u, 2, "The system cannot find the file specified" );
 
-  TEST( c2_0, 0, "c2_0" );
+  TEST( c2_0, 0, "c2_0: The operation completed successfully" );
   TEST( c2_1, 1, "c2_1: Incorrect function" );
 
-  TEST( c3_0, 0, "c3_0" );
+  TEST( c3_0, 0, "c3_0: The operation completed successfully" );
   TEST( c3_1, 1, "c3_1: Incorrect function" );
 
-  TEST( c4_0, 0, "" );
+  TEST( c4_0, 0, "The operation completed successfully" );
   TEST( c4_1, 1, "Incorrect function" );
   TEST( c4_2u, 2, "The system cannot find the file specified" );
 
-  TEST( c5_0, 0, "c5_0" );
+  TEST( c5_0, 0, "c5_0: The operation completed successfully" );
   TEST( c5_1, 1, "c5_1: Incorrect function" );
 
-  TEST( c6_0, 0, "c6_0" );
+  TEST( c6_0, 0, "c6_0: The operation completed successfully" );
   TEST( c6_1, 1, "c6_1: Incorrect function" );
 
-  return 0;
+  return ::boost::report_errors();
 }
 
 

test/system_msvc/common.vsprops

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioPropertySheet
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="common"
-	>
-	<Tool
-		Name="VCCLCompilerTool"
-		AdditionalIncludeDirectories="../../../../.."
-		PreprocessorDefinitions="BOOST_ALL_NO_LIB"
-		ExceptionHandling="2"
-	/>
-	<Tool
-		Name="VCPostBuildEventTool"
-		Description="Executing test $(TargetName).exe..."
-		CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot; --result_code=no --report_level=no"
-	/>
-</VisualStudioPropertySheet>

test/system_msvc/error_code_test/error_code_test.vcproj

@@ -1,199 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="error_code_test"
-	ProjectGUID="{81960557-E9A9-4E81-AC96-9E11C33CB058}"
-	RootNamespace="error_code_test"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			InheritedPropertySheets="..\common.vsprops"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			InheritedPropertySheets="..\common.vsprops"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				EnableIntrinsicFunctions="true"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\..\..\src\error_code.cpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\error_code_test.cpp"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

test/system_msvc/system_msvc.sln

@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual C++ Express 2008
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "error_code_test", "error_code_test\error_code_test.vcproj", "{81960557-E9A9-4E81-AC96-9E11C33CB058}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Debug|Win32.ActiveCfg = Debug|Win32
-		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Debug|Win32.Build.0 = Debug|Win32
-		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Release|Win32.ActiveCfg = Release|Win32
-		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal

test/throw_test.cpp

@@ -0,0 +1,31 @@
+//  throw_test.cpp  --------------------------------------------------------===========-//
+
+//  Copyright Beman Dawes 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See www.boost.org/LICENSE_1_0.txt
+
+//  Library home page is www.boost.org/libs/system
+
+//--------------------------------------------------------------------------------------// 
+
+//  See dynamic_link_test.cpp comments for use case.
+
+//--------------------------------------------------------------------------------------// 
+
+// 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>
+
+namespace boost
+{
+  namespace system
+  {
+    BOOST_SYSTEM_DECL void throw_test()
+    {
+      throw system_error(9999, system_category(), "boo boo");
+    }
+  }
+}