Release 1.54.0

[SVN r84923]
System/FileSystem: merge from trunk to fix #7278 .
2013-07-01 16:53:14 +00:00 · 2013-03-24 20:20:29 +00:00 · 2012-05-21 13:39:58 +00:00 · 2011-01-11 20:49:15 +00:00 · 2010-07-06 10:47:30 +00:00 · 2010-07-04 22:38:38 +00:00
25 changed files with 814 additions and 626 deletions
@@ -1,27 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-#----------------------------------------------------------------------------
-# This file was automatically generated from the original CMakeLists.txt file
-# Add a variable to hold the headers for the library
-set (lib_headers
-    system
-)
-
-# Add a library target to the build system
-boost_library_project(
-  system
-  SRCDIRS  src
-  #  TESTDIRS 
-  HEADERS ${lib_headers}
-  #  DOCDIRS 
-  #  DESCRIPTION 
-  MODULARIZED
-  #  AUTHORS 
-  #  MAINTAINERS 
-)
-
-
@@ -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>
@@ -93,6 +93,18 @@ 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 will become part of the C++0x 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="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 +145,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 -->May 28, 2010<!--webbot bot="Timestamp" endspan i-checksum="11241" --> </font>
 </p>

 <p>© Copyright Beman Dawes, 1999</p>
@@ -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,62 @@

 <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>
-  </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 +142,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 +183,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 +287,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 +320,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 +355,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 +436,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 +463,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 +548,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 +574,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 +670,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 +812,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 -->February 27, 2013<!--webbot bot="Timestamp" endspan i-checksum="41547" --> </font>
 </p>

-<p>© Copyright Beman Dawes, 2006, 2007, 2008</p>
+<p>© 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>
@@ -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 
@@ -1,4 +1,4 @@
-//  boost/system/config.hpp  -------------------------------------------------//
+//  boost/system/config.hpp  -----------------------------------------------------------//

 //  Copyright Beman Dawes 2003, 2006

@@ -11,47 +11,41 @@
 #define BOOST_SYSTEM_CONFIG_HPP

 #include <boost/config.hpp>
+#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)
 //
@@ -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,7 +46,7 @@ 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() ); }
    }
  }
 }
@@ -23,7 +23,7 @@
 #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
@@ -31,6 +31,10 @@

 #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
@@ -129,7 +133,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
      };
@@ -183,15 +187,18 @@ namespace boost
    {
    public:
      virtual ~error_category(){}
-      virtual inline const char *    name() const;  // see implementation note below
-      virtual inline std::string     message( int ev ) const;   // see implementation note below
-      virtual inline error_condition default_error_condition( int ev ) const;
-      virtual inline bool equivalent( int code, const error_condition & condition ) const;
-      virtual inline bool equivalent( const error_code & code, int condition ) const;

-      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
+      virtual const char *     name() const BOOST_SYSTEM_NOEXCEPT = 0;
+      virtual std::string      message( int ev ) const = 0;
+      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 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 );
      }
@@ -199,18 +206,22 @@ namespace boost

    //  predefined error categories  -----------------------------------------//

-    BOOST_SYSTEM_DECL const error_category &  get_system_category();
-    BOOST_SYSTEM_DECL const error_category &  get_generic_category();
+# 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 --------------------------------------------------//

-    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();
+    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 = generic_category();
+    static const error_category &  errno_ecat     = generic_category();
+    static const error_category &  native_ecat    = system_category();
 # endif

    //  class error_condition  -----------------------------------------------//
@@ -222,52 +233,52 @@ 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 )
-      { 
+          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;
      }
@@ -276,13 +287,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.
      {
@@ -309,59 +320,59 @@ 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)
+          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.
      {
@@ -369,15 +380,15 @@ 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:
+
+    private:
      int                     m_val;
      const error_category *  m_cat;

@@ -411,43 +422,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>
@@ -469,46 +480,33 @@ namespace boost
    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  -------------------------------//

-    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;
    }

-    //  error_category implementation note: VC++ 8.0 objects to name() and
-    //  message() being pure virtual functions. Thus these implementations.
-    inline const char * error_category::name() const
-    { 
-      return "error: should never be called";
-    }
-
-    inline std::string error_category::message( int ) const
-    { 
-      static std::string s("error: should never be called");
-      return s;
-    }
-
  } // namespace system
 } // namespace boost

@@ -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
@@ -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 )
@@ -59,16 +61,17 @@ namespace boost
    {
      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();
    }
@@ -29,7 +29,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
    {
@@ -107,7 +107,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
@@ -1 +0,0 @@
-boost_module(system DEPENDS utility)
@@ -1,13 +0,0 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
-boost_add_library(
-  boost_system
-  error_code.cpp
-  SHARED_COMPILE_FLAGS "-DBOOST_SYSTEM_DYN_LINK=1"
-  STATIC_COMPILE_FLAGS "-DBOOST_SYSTEM_STATIC_LINK=1"
-  )
-
@@ -22,29 +22,32 @@
 #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>
+#   include "local_free_on_destruction.hpp"
 #   ifndef ERROR_INCORRECT_SIZE
-#    define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
+#     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;
+    const char *   name() const BOOST_SYSTEM_NOEXCEPT;
    std::string    message( int ev ) const;
  };

@@ -52,25 +55,30 @@ namespace
  {
  public:
    system_error_category(){}
-    const char *        name() const;
+    const char *        name() const BOOST_SYSTEM_NOEXCEPT;
    std::string         message( int ev ) const;
-    error_condition     default_error_condition( 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
+  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 Sundo provide strerror_r on newer systems, but there is
+  //   -- 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.
@@ -80,6 +88,7 @@ namespace
  # 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 );
@@ -128,7 +137,9 @@ namespace
        }
      }
      std::string msg;
+#   ifndef BOOST_NO_EXCEPTIONS
      try
+#   endif
      {
        msg = ( ( result == invalid_argument ) ? "Unknown error" : bp );
      }
@@ -149,17 +160,22 @@ namespace
  }
  //  system_error_category implementation  --------------------------------// 

-  const char * system_error_category::name() const
+  const char * system_error_category::name() const BOOST_SYSTEM_NOEXCEPT
  {
    return "system";
  }

-  error_condition system_error_category::default_error_condition( int ev ) const
+  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
+
    switch ( ev )
    {
    case 0: return make_error_condition( success );
-  # if defined(BOOST_POSIX_API)
+# 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 );
@@ -193,7 +209,7 @@ namespace
    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 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 );
@@ -221,7 +237,9 @@ namespace
  # 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 );
+  # 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 );
@@ -230,7 +248,9 @@ namespace
    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 );
+  # 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 );
@@ -325,7 +345,7 @@ namespace
    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 );
+    default: return error_condition( ev, system_category() );
    }
  }

@@ -333,28 +353,14 @@ namespace

  std::string system_error_category::message( int ev ) const
  {
-    return generic_category.message( ev );
+    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;
+    LPVOID lpMsgBuf = 0;
    DWORD retval = ::FormatMessageA( 
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM | 
@@ -366,13 +372,13 @@ namespace
        0,
        NULL 
    );
+    detail::local_free_on_destruction lfod(lpMsgBuf);
    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;
+    LPVOID lpMsgBuf = 0;
    DWORD retval = ::FormatMessageW( 
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM | 
@@ -384,6 +390,7 @@ namespace
        0,
        NULL 
    );
+    detail::local_free_on_destruction lfod(lpMsgBuf);
    if (retval == 0)
        return std::string("Unknown error");
    
@@ -393,7 +400,6 @@ namespace
        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') )
@@ -406,10 +412,6 @@ namespace

 } // unnamed namespace

-namespace boost
-{
-  namespace system
-  {

 # ifndef BOOST_SYSTEM_NO_DEPRECATED
    BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
@@ -419,13 +421,13 @@ namespace boost
                                         //  address for comparison purposes
 # endif

-    BOOST_SYSTEM_DECL const error_category & get_system_category()
+    BOOST_SYSTEM_DECL const error_category & system_category() BOOST_SYSTEM_NOEXCEPT
    {
      static const system_error_category  system_category_const;
      return system_category_const;
    }

-    BOOST_SYSTEM_DECL const error_category & get_generic_category()
+    BOOST_SYSTEM_DECL const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
    {
      static const generic_error_category generic_category_const;
      return generic_category_const;
@@ -0,0 +1,40 @@
+//  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
+
+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()
+  {
+    ::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
@@ -12,6 +12,13 @@ project
      <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,21 +28,25 @@ 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
@@ -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;
+}
@@ -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>

@@ -56,55 +59,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 +121,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 +169,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

@@ -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();
 }
@@ -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();
 }
@@ -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();
 }
@@ -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,8 +36,8 @@ 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__)
@@ -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();
 }


@@ -7,12 +7,13 @@
 	<Tool
 		Name="VCCLCompilerTool"
 		AdditionalIncludeDirectories="../../../../.."
-		PreprocessorDefinitions="BOOST_ALL_NO_LIB"
+		PreprocessorDefinitions="BOOST_ALL_NO_LIB;BOOST_ALL_DYN_LINK"
 		ExceptionHandling="2"
+		WarningLevel="4"
 	/>
 	<Tool
 		Name="VCPostBuildEventTool"
-		Description="Executing test $(TargetName).exe..."
-		CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot; --result_code=no --report_level=no"
+		Description=""
+		CommandLine=""
 	/>
 </VisualStudioPropertySheet>
@@ -47,7 +47,7 @@
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
 				UsePrecompiledHeader="0"
-				WarningLevel="3"
+				WarningLevel="4"
 				DebugInformationFormat="4"
 			/>
 			<Tool
@@ -86,6 +86,8 @@
 			/>
 			<Tool
 				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot; --result_code=no --report_level=no"
 			/>
 		</Configuration>
 		<Configuration
@@ -120,7 +122,7 @@
 				RuntimeLibrary="2"
 				EnableFunctionLevelLinking="true"
 				UsePrecompiledHeader="0"
-				WarningLevel="3"
+				WarningLevel="4"
 				DebugInformationFormat="3"
 			/>
 			<Tool
@@ -161,6 +163,8 @@
 			/>
 			<Tool
 				Name="VCPostBuildEventTool"
+				Description="Executing test $(TargetName).exe..."
+				CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot; --result_code=no --report_level=no"
 			/>
 		</Configuration>
 	</Configurations>
@@ -172,10 +176,6 @@
 			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"
 				>
@@ -2,6 +2,27 @@
 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}"
+	ProjectSection(ProjectDependencies) = postProject
+		{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system_error_test", "system_error_test\system_error_test.vcproj", "{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}"
+	ProjectSection(ProjectDependencies) = postProject
+		{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dynamic_link_test", "dynamic_link_test\dynamic_link_test.vcproj", "{AD186B11-9132-48A9-9F24-3522C2310B0D}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7} = {F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}
+		{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "system_dll", "system_dll\system_dll.vcproj", "{22892211-A1F3-435B-8B97-A12E8772599E}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "throw_test_dll", "throw_test_dll\throw_test_dll.vcproj", "{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}"
+	ProjectSection(ProjectDependencies) = postProject
+		{22892211-A1F3-435B-8B97-A12E8772599E} = {22892211-A1F3-435B-8B97-A12E8772599E}
+	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -13,6 +34,22 @@ Global
 		{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
+		{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Debug|Win32.ActiveCfg = Debug|Win32
+		{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Debug|Win32.Build.0 = Debug|Win32
+		{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Release|Win32.ActiveCfg = Release|Win32
+		{CBD12E59-99E5-4F35-9B66-0554D0FBDB76}.Release|Win32.Build.0 = Release|Win32
+		{AD186B11-9132-48A9-9F24-3522C2310B0D}.Debug|Win32.ActiveCfg = Debug|Win32
+		{AD186B11-9132-48A9-9F24-3522C2310B0D}.Debug|Win32.Build.0 = Debug|Win32
+		{AD186B11-9132-48A9-9F24-3522C2310B0D}.Release|Win32.ActiveCfg = Release|Win32
+		{AD186B11-9132-48A9-9F24-3522C2310B0D}.Release|Win32.Build.0 = Release|Win32
+		{22892211-A1F3-435B-8B97-A12E8772599E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{22892211-A1F3-435B-8B97-A12E8772599E}.Debug|Win32.Build.0 = Debug|Win32
+		{22892211-A1F3-435B-8B97-A12E8772599E}.Release|Win32.ActiveCfg = Release|Win32
+		{22892211-A1F3-435B-8B97-A12E8772599E}.Release|Win32.Build.0 = Release|Win32
+		{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Debug|Win32.ActiveCfg = Debug|Win32
+		{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Debug|Win32.Build.0 = Debug|Win32
+		{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Release|Win32.ActiveCfg = Release|Win32
+		{F6D9B408-84A3-405A-93ED-DE5AA8CF84D7}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -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");
+    }
+  }
+}
Author	SHA1	Message	Date
Marshall Clow	29f6e0609a	Release 1.54.0 [SVN r84923]	2013-07-01 16:53:14 +00:00
Vicente J. Botet Escriba	ec4d3bc41e	System/FileSystem: merge from trunk to fix #7278 . [SVN r83550]	2013-03-24 20:20:29 +00:00
Beman Dawes	5430d82f9f	System: merge trunk [SVN r78528]	2012-05-21 13:39:58 +00:00
Beman Dawes	d0cd2066d4	Merge from trunk [SVN r67975]	2011-01-11 20:49:15 +00:00
Beman Dawes	7ffc036bc2	Merge trunk, including changes to come into closer conformance with C++0x FCD [SVN r63685]	2010-07-06 10:47:30 +00:00
Hartmut Kaiser	6888c0c7b8	Spirit: merging from trunk upto rev. 61489 [SVN r63640]	2010-07-04 22:38:38 +00:00
Douglas Gregor	eeb5844852	Merge standards-conformance fix for Boost.System [SVN r61862]	2010-05-09 00:33:44 +00:00
Beman Dawes	f8ddc693ae	System: merge trunk [SVN r57634]	2009-11-13 14:37:32 +00:00
Troy D. Straszheim	cf8fbe855f	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Beman Dawes	691fb5522c	system: merge trunk [SVN r56777]	2009-10-13 13:44:42 +00:00