Release 1.41.0 Beta 1

[SVN r57353]
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.
2026-04-18 07:38:38 +02:00 · 2009-11-04 12:14:07 +00:00 · 2009-10-17 01:10:45 +00:00 · 2009-10-13 13:44:42 +00:00 · 2009-08-09 17:34:58 +00:00 · 2009-07-26 00:49:56 +00:00
8 changed files with 544 additions and 192 deletions
--- a/doc/reference.html
+++ b/doc/reference.html
@@ -39,6 +39,7 @@
    <td width="100%" bgcolor="#E8F5FF">
      <a href="#Introduction">Introduction</a><br>
      <a href="#Macros">Macros</a><br>
+      <a href="#Deprecated-names">Deprecated names</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>
@@ -57,6 +58,8 @@
      &nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-constructors">Class <code>error_condition</code> constructors</a><br>
      &nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-modifiers">Class <code>error_condition</code> modifiers</a><br>
      &nbsp;&nbsp;&nbsp;<a href="#Class-error_condition-observers">Class <code>error_condition</code> observers</a><br>
+      <a href="#throws-object"><code>throws</code> object</a><br>
+      <a href="#Semantics-of-throws">Semantics of <code>throws</code> object</a><br>
      <a href="#Non-member-functions">Non-member functions</a><br>
      <a href="#Header-system_error">Header &lt;boost/system/system_error.hpp&gt;</a><br>
      &nbsp;&nbsp;&nbsp;<a href="#Class-system_error">Class <code>system_error</code></a><br>
@@ -114,6 +117,45 @@ provided, so users may ignore these macros if they prefer.</p>
    <td valign="top">Deprecated features are excluded.</td>
  </tr>
 </table>
+<h2><a name="Deprecated-names">Deprecated names</a></h2>
+<p>In the process of adding Boost.System to C++0x standard library, some of the 
+names are being changed. 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>
+  </tr>
+  <tr>
+    <td><code>namespace posix</code></td>
+    <td><code>namespace errc</code></td>
+  </tr>
+  <tr>
+    <td><code>namespace posix_error</code></td>
+    <td><code>namespace errc</code></td>
+  </tr>
+  <tr>
+    <td><code>enum posix_errno</code></td>
+    <td><code>enum errc_t</code></td>
+  </tr>
+  <tr>
+    <td><code>get_posix_category()</code></td>
+    <td><code>get_generic_category()</code></td>
+  </tr>
+  <tr>
+    <td><code>posix_category</code></td>
+    <td><code>generic_category</code></td>
+  </tr>
+  <tr>
+    <td><code>errno_ecat</code></td>
+    <td><code>generic_category</code></td>
+  </tr>
+  <tr>
+    <td><code>native_ecat</code></td>
+    <td><code>system_category</code></td>
+  </tr>
+</table>
 <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>
@@ -223,6 +265,11 @@ provided, so users may ignore these macros if they prefer.</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 );
@@ -279,7 +326,7 @@ types should create a single object of each such type. <i>
      virtual ~error_category();

      virtual const char *     name() const = 0;
-      virtual string           message( error_code::value_type ev ) const = 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;
@@ -305,7 +352,7 @@ this subclause.</p>
  <p><i>Returns: </i>a string naming the error category.</p>
  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-<pre>virtual string message( error_code::value_type ev ) const=0;</pre>
+<pre>virtual string message( int ev ) const=0;</pre>
 <blockquote>
  <p><i>Returns:</i> A string that describes the error denoted by
  <code>ev</code>.</p>
@@ -370,7 +417,7 @@ non-member functions</a></h3>
 <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 operating system error codes and portable error conditions, respectively.</p>
+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 
@@ -392,7 +439,7 @@ error_code</code> synopsis</a></h3>
      error_code();
      error_code( val, const error_category &amp; cat );
      template &lt;class <code>ErrorCodeEnum</code>&gt;
-        error_code(<code> errorCodeEnum</code> e,
+        error_code(<code> ErrorCodeEnum</code> e,
         typename enable_if&lt;is_error_code_enum&lt;<code>ErrorCodeEnum</code>&gt; &gt;::type* = 0);

      // modifiers:
@@ -411,7 +458,7 @@ error_code</code> synopsis</a></h3>

    private:
      int val_;                     // <i>exposition only</i>
-      const error_category &amp; cat_;  // <i>exposition only</i>
+      const error_category * cat_;  // <i>exposition only</i>
    };
  }
 }</pre>
@@ -442,7 +489,7 @@ error_code</code> constructors</a></h3>
 error_code</code> modifiers</a></h3>
 <pre>void assign( int val, const error_category &amp; cat );</pre>
 <blockquote>
-  <p><i>Postconditions:</i> <code>val_ == val &amp;&amp; cat_ == cat</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;typename <code>ErrorCodeEnum</code>&gt;
@@ -463,9 +510,9 @@ error_code</code> observers</a></h3>
 <p><i>Returns:</i> <code>val_</code>.</p>
  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-  <p><code>error_category category() const;</code></p>
+  <p><code>const error_category &amp; category() const;</code></p>
 <blockquote>
-<p><i>Returns:</i> <code>cat_</code>.</p>
+<p><i>Returns:</i> <code>*cat_</code>.</p>
  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
  <pre>error_condition default_error_condition() const;</pre>
@@ -480,7 +527,7 @@ error_code</code> observers</a></h3>
 </blockquote>
 <p><code>operator <i>unspecified-bool-type</i>() const;</code></p>
 <blockquote>
-<p><i>Returns:</i> if <code>value() != value_type()</code>, returns a value that will evaluate
+<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 
 evaluate <code>false</code> in a boolean context. The value type returned shall 
 not be convertible to <code>int</code>.</p>
@@ -527,8 +574,8 @@ implementation specific. <i>--end note ]</i></p>
      operator unspecified-bool-type () const;

    private:
-      int val_;                     // <i>exposition only</i>
-      const error_category &amp; cat_;   // <i>exposition only</i>
+      int val_;                      // <i>exposition only</i>
+      const error_category * cat_;   // <i>exposition only</i>
    };
  }
 }</pre>
@@ -538,13 +585,13 @@ constructors</a></h3>
 <pre>error_condition(); </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_ == generic_category</code>.</p>
+  <p><i>Postconditions:</i> <code>val_ == 0 and cat_ == &amp;generic_category</code>.</p>
  <p><i>Throws:</i> Nothing.</p>
 </blockquote>
-<pre>error_condition( value_type val, const error_category &amp; cat );</pre>
+<pre>error_condition( int val, const error_category &amp; cat );</pre>
 <blockquote>
  <p><i>Effects: </i>Constructs an object of type error_condition.</p>
-  <p><i>Postconditions:</i> <code>val_ == val and cat_ == cat</code>.</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;
@@ -557,9 +604,9 @@ constructors</a></h3>
 </blockquote>
 <h3><a name="Class-error_condition-modifiers">Class <code>error_condition</code> 
 modifiers</a></h3>
-<pre>void assign( value_type val, const error_category &amp; cat ); </pre>
+<pre>void assign( int val, const error_category &amp; cat ); </pre>
 <blockquote>
-  <p><i>Postconditions:</i> <code>val_ == val and cat_ == cat</code>. </p>
+  <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;
@@ -575,14 +622,14 @@ modifiers</a></h3>
 </blockquote>
 <h3><a name="Class-error_condition-observers">Class <code>error_condition</code> 
 observers</a></h3>
-<pre>value_type value() const;</pre>
+<pre>int value() const;</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>
 <blockquote>
-  <p><i>Returns:</i> <code>cat_</code>.</p>
+  <p><i>Returns:</i> <code>*cat_</code>.</p>
  <p>Throws: Nothing.</p>
 </blockquote>
 <pre>string message() const;</pre>
@@ -603,7 +650,37 @@ observers</a></h3>
  eliminating some sources of user error. One possible implementation choice for 
  this type is pointer to member. <i>--end note</i> <i>]</i></p>
 </blockquote>
-  <h2><a name="Non-member-functions">Non-member functions</a></h2>
+  <h2><a name="throws-object"><code>throws</code> object</a></h2>
+  <pre>extern error_code throws;</pre>
+<p>The predefined <code>error_code</code> object <code>throws</code> is supplied 
+for use as a &quot;throw on error&quot; tag.</p>
+<h2><a name="Semantics-of-throws">Semantics of <code>throws</code></a> object</h2>
+<p>Functions that specify an argument in the form <code>error_code&amp; ec=throws</code>, 
+with appropriate namespace qualifiers, have the following error handling 
+semantics:</p>
+<blockquote>
+  <p><i>Postconditions:</i></p>
+  <blockquote>
+    <p>If <code>&amp;ec != &amp;throws</code> and an error occurred:</p>
+    <ul>
+      <li> <code>ec.value()</code> returns the implementation specific error 
+      number for the particular error that occurred.</li>
+      <li><code>ec.category()</code> returns the <code>
+    <a href="#Class-error_category">error_category</a></code> for <code>ec.value()</code>.</li>
+    </ul>
+    <p>if <code>&amp;ec != &amp;throws</code> and an error did not occur, <code>ec.clear()</code>.</p>
+  </blockquote>
+  <p><i>Throws:</i></p>
+  <blockquote>
+  <p>If an error occurs and <code>&amp;ec == &amp;throws</code>, throws an exception of type
+  <code><a href="#Class-system_error">system_error</a></code> or of a type 
+  derived from <code><a href="#Class-system_error">system_error</a></code>. The 
+  exception's <code>code()</code> member function returns a reference to an
+  <code>error_code</code> object with the behavior specified in <i>
+  Postconditions</i>.</p>
+  </blockquote>
+</blockquote>
+<h2><a name="Non-member-functions">Non-member functions</a></h2>
  <pre>bool operator==( const error_code &amp; lhs, const error_code &amp; rhs );</pre>
 <blockquote>
  <p><i>Returns:</i> <code>lhs.category() == rhs.category() &amp;&amp; lhs.value() == 
@@ -657,7 +734,7 @@ bool operator!=( const error_condition &amp; condition, const error_code &amp; c
 </blockquote>
 <pre>error_condition make_error_condition( errc::errc_t e );</pre>
 <blockquote>
-  <p><i>Returns:</i> <code>error_condition( 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;
@@ -677,8 +754,7 @@ bool operator!=( const error_condition &amp; condition, const error_code &amp; c
 <h3><a name="Class-system_error">Class <code>
 system_error</code></a></h3>
 <p>The class <code>system_error</code> describes an exception object used to 
-report error conditions that have an associated error code. Such error 
-conditions typically originate from the operating system or other low-level 
+report errors that have an associated <code><a href="#Class-error_code">error_code</a></code>. Such errors typically originate from operating system or other low-level 
 application program interfaces.</p>
 <blockquote>
 <pre>namespace boost
@@ -691,11 +767,11 @@ application program interfaces.</p>
      system_error( error_code ec );
      system_error( error_code ec, const char * what_arg );
      system_error( error_code ec, const std::string &amp; what_arg );
-      system_error( error_code::value_type ev, const error_category &amp; ecat,
+      system_error( int ev, const error_category &amp; ecat,
                    const char * what_arg );
-      system_error( error_code::value_type ev, const error_category &amp; ecat,
+      system_error( int ev, const error_category &amp; ecat,
                    const std::string &amp; what_arg );
-      system_error( error_code::value_type ev, const error_category &amp; ecat);
+      system_error( int ev, const error_category &amp; ecat);

      const error_code &amp; code() const throw();
      const char *       what() const throw();
@@ -721,21 +797,21 @@ application program interfaces.</p>
  <p><i>Postcondition:</i> <code>code() == ec <br>
 &nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), what_arg.c_str() ) == 0</code></p>
 </blockquote>
-<pre>system_error( error_code::value_type ev, const error_category &amp; ecat,
+<pre>system_error( int ev, const error_category &amp; ecat,
             const char * what_arg );</pre>
 <blockquote>
  <p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
  <p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
 &nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), what_arg ) == 0</code></p>
 </blockquote>
-<pre>system_error( error_code::value_type ev, const error_category &amp; ecat,
+<pre>system_error( int ev, const error_category &amp; ecat,
             const std::string &amp; what_arg );</pre>
 <blockquote>
  <p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
  <p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
 &nbsp; &amp;&amp; std::strcmp( this-&gt;runtime_error::what(), what_arg.c_str() ) == 0</code></p>
 </blockquote>
-<pre>system_error( error_code::value_type ev, const error_category &amp; ecat );</pre>
+<pre>system_error( int ev, const error_category &amp; ecat );</pre>
 <blockquote>
  <p><i>Effects:</i> Constructs an object of class <code>system_error</code>.</p>
  <p><i>Postcondition:</i> <code>code() == error_code( ev, ecat )<br>
@@ -754,14 +830,15 @@ application program interfaces.</p>
 </blockquote>
 <hr>

-<p>© Copyright Beman Dawes, 2006, 2007<br>
-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>
-
 <p>Revised 
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->June 25, 2008<!--webbot bot="Timestamp" endspan i-checksum="14296" --> </font>
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%B %d, %Y" startspan -->October 11, 2008<!--webbot bot="Timestamp" endspan i-checksum="30976" --> </font>
 </p>

+<p>© Copyright Beman Dawes, 2006, 2007, 2008</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>
+
 </body>

 </html>
--- a/include/boost/system/error_code.hpp
+++ b/include/boost/system/error_code.hpp
@@ -183,11 +183,14 @@ 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;
+
+      virtual const char *     name() const = 0;
+      virtual std::string      message( int ev ) const = 0;
+      virtual error_condition  default_error_condition( int ev ) const;
+      virtual bool             equivalent( int code, 
+                                           const error_condition & condition ) const;
+      virtual bool             equivalent( const error_code & code,
+                                           int condition ) const;

      bool operator==(const error_category & rhs) const { return this == &rhs; }
      bool operator!=(const error_category & rhs) const { return this != &rhs; }
@@ -207,6 +210,7 @@ namespace boost
    
 # 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();
@@ -214,7 +218,7 @@ namespace boost

    //  class error_condition  -----------------------------------------------//

-    //  error_conditions are portable, error_codes are system or lib specific
+    //  error_conditions are portable, error_codes are system or library specific

    class error_condition
    {
@@ -224,9 +228,9 @@ namespace boost
      error_condition() : m_val(0), m_cat(&get_generic_category()) {}
      error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}

-      template <class ConditionEnum>
-        error_condition(ConditionEnum e,
-          typename boost::enable_if<is_error_condition_enum<ConditionEnum> >::type* = 0)
+      template <class ErrorConditionEnum>
+        error_condition(ErrorConditionEnum e,
+          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0)
      {
        *this = make_error_condition(e);
      }
@@ -239,9 +243,9 @@ namespace boost
        m_cat = &cat;
      }
                                             
-      template<typename ConditionEnum>
-        typename boost::enable_if<is_error_condition_enum<ConditionEnum>, error_condition>::type &
-          operator=( ConditionEnum val )
+      template<typename ErrorConditionEnum>
+        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
+          operator=( ErrorConditionEnum val )
      { 
        *this = make_error_condition(val);
        return *this;
@@ -311,9 +315,9 @@ namespace boost
      error_code() : m_val(0), m_cat(&get_system_category()) {}
      error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}

-      template <class CodeEnum>
-        error_code(CodeEnum e,
-          typename boost::enable_if<is_error_code_enum<CodeEnum> >::type* = 0)
+      template <class ErrorCodeEnum>
+        error_code(ErrorCodeEnum e,
+          typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
      {
        *this = make_error_code(e);
      }
@@ -325,9 +329,9 @@ namespace boost
        m_cat = &cat;
      }
                                             
-      template<typename CodeEnum>
-        typename boost::enable_if<is_error_code_enum<CodeEnum>, error_code>::type &
-          operator=( CodeEnum val )
+      template<typename ErrorCodeEnum>
+        typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
+          operator=( ErrorCodeEnum val )
      { 
        *this = make_error_code(val);
        return *this;
@@ -382,6 +386,31 @@ namespace boost

    };

+    //  predefined error_code object used as "throw on error" tag
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    BOOST_SYSTEM_DECL extern error_code throws;
+# endif
+
+    //  Moving from a "throws" object to a "throws" function without breaking
+    //  existing code is a bit of a problem. The workaround is to place the
+    //  "throws" function in namespace boost rather than namespace boost::system.
+
+  }  // namespace system
+
+  namespace detail { inline system::error_code * throws() { return 0; } }
+    //  Misuse of the error_code object is turned into a noisy failure by
+    //  poisoning the reference. This particular implementation doesn't
+    //  produce warnings or errors from popular compilers, is very efficient
+    //  (as determined by inspecting generated code), and does not suffer
+    //  from order of initialization problems. In practice, it also seems
+    //  cause user function error handling implementation errors to be detected
+    //  very early in the development cycle.
+
+  inline system::error_code & throws()
+    { return *detail::throws(); }
+
+  namespace system
+  {
    //  non-member functions  ------------------------------------------------//

    inline bool operator!=( const error_code & lhs,
@@ -470,19 +499,6 @@ namespace boost
      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

--- a/src/error_code.cpp
+++ b/src/error_code.cpp
@@ -23,7 +23,7 @@
 #include <cassert>

 using namespace boost::system;
-using namespace boost::system::posix_error;
+using namespace boost::system::errc;

 #include <cstring> // for strerror/strerror_r

@@ -61,11 +61,12 @@ namespace

  const char * generic_error_category::name() const
  {
-    return "GENERIC";
+    return "generic";
  }

  std::string generic_error_category::message( int ev ) const
  {
+    static std::string unknown_err( "Unknown error" );
  // strerror_r is preferred because it is always thread safe,
  // however, we fallback to strerror in certain cases because:
  //   -- Windows doesn't provide strerror_r.
@@ -79,17 +80,22 @@ 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(__vms))
+     || (defined(__vms))\
+     || (defined(__QNXNTO__))
      const char * c_str = std::strerror( ev );
-      return std::string( c_str ? c_str : "Unknown error" );
-  # else
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
+  # else  // use strerror_r
      char buf[64];
      char * bp = buf;
      std::size_t sz = sizeof(buf);
  #  if defined(__CYGWIN__) || defined(__USE_GNU)
      // Oddball version of strerror_r
      const char * c_str = strerror_r( ev, bp, sz );
-      return std::string( c_str ? c_str : "Unknown error" );
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
  #  else
      // POSIX version of strerror_r
      int result;
@@ -100,7 +106,9 @@ namespace
  #  if defined (__sgi)
        const char * c_str = strerror( ev );
        result = 0;
-        return std::string( c_str ? c_str : "Unknown error" );
+      return  c_str
+        ? std::string( c_str )
+        : unknown_err;
  #  else
        result = strerror_r( ev, bp, sz );
  #  endif
@@ -113,26 +121,31 @@ namespace
          result = errno;
  #  endif
          if ( result !=  ERANGE ) break;
-        if ( sz > sizeof(buf) ) std::free( bp );
-        sz *= 2;
-        if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
-          return std::string( "ENOMEM" );
+          if ( sz > sizeof(buf) ) std::free( bp );
+          sz *= 2;
+          if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
+            return std::string( "ENOMEM" );
        }
      }
+      std::string msg;
      try
      {
-      std::string msg( ( result == invalid_argument ) ? "Unknown error" : bp );
-      if ( sz > sizeof(buf) ) std::free( bp );
-        sz = 0;
-      return msg;
+        msg = ( ( result == invalid_argument ) ? "Unknown error" : bp );
      }
+
+#   ifndef BOOST_NO_EXCEPTIONS
+      // See ticket #2098
      catch(...)
      {
-        if ( sz > sizeof(buf) ) std::free( bp );
-        throw;
+        // just eat the exception
      }
-  #  endif
-  # endif
+#   endif
+
+      if ( sz > sizeof(buf) ) std::free( bp );
+      sz = 0;
+      return msg;
+  #  endif   // else POSIX version of strerror_r
+  # endif  // else use strerror_r
  }
  //  system_error_category implementation  --------------------------------// 

@@ -154,7 +167,9 @@ namespace
    case EADDRNOTAVAIL: return make_error_condition( address_not_available );
    case EAFNOSUPPORT: return make_error_condition( address_family_not_supported );
    case EAGAIN: return make_error_condition( resource_unavailable_try_again );
+#   if EALREADY != EBUSY  //  EALREADY and EBUSY are the same on QNX Neutrino
    case EALREADY: return make_error_condition( connection_already_in_progress );
+#   endif
    case EBADF: return make_error_condition( bad_file_descriptor );
    case EBADMSG: return make_error_condition( bad_message );
    case EBUSY: return make_error_condition( device_or_resource_busy );
@@ -396,6 +411,14 @@ namespace boost
  namespace system
  {

+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
+                                         //  note that it doesn't matter if this
+                                         //  isn't initialized before use since
+                                         //  the only use is to take its
+                                         //  address for comparison purposes
+# endif
+
    BOOST_SYSTEM_DECL const error_category & get_system_category()
    {
      static const system_error_category  system_category_const;
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -10,7 +10,6 @@
 project
    : requirements
      <library>/boost/system//boost_system
-      <define>BOOST_ALL_NO_LIB
      <toolset>msvc:<asynch-exceptions>on
    ;

--- a/test/error_code_test.cpp
+++ b/test/error_code_test.cpp
@@ -11,7 +11,7 @@

 #include <boost/config/warning_disable.hpp>

-#include <boost/test/minimal.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <boost/system/error_code.hpp>
 #include <boost/system/cygwin_error.hpp>
 #include <boost/system/linux_error.hpp>
@@ -45,100 +45,100 @@ namespace

    ss << ec;
    ss >> s;
-    BOOST_CHECK( s == expected );
+    BOOST_TEST( s == expected );
  }
 }

-//  test_main  ---------------------------------------------------------------//
+//  main  ------------------------------------------------------------------------------//

 // TODO: add hash_value tests

-int test_main( int, char ** )
+int main( int, char ** )
 {

  std::cout << "General tests...\n";
  // unit tests:

-  BOOST_CHECK( posix_category == posix_category );
-  BOOST_CHECK( system_category == system_category );
-  BOOST_CHECK( posix_category != system_category );
-  BOOST_CHECK( system_category != posix_category );
+  BOOST_TEST( posix_category == posix_category );
+  BOOST_TEST( system_category == system_category );
+  BOOST_TEST( posix_category != system_category );
+  BOOST_TEST( system_category != posix_category );

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


  error_code ec;
  error_condition dec;
-  BOOST_CHECK( !ec );
-  BOOST_CHECK( ec.value() == 0 );
+  BOOST_TEST( !ec );
+  BOOST_TEST( ec.value() == 0 );
  dec = ec.default_error_condition();
-  BOOST_CHECK( dec.value() == 0 );
-  BOOST_CHECK( dec.category() == posix_category );
-  BOOST_CHECK( ec == posix::success );
-  BOOST_CHECK( ec.category() == system_category );
-  BOOST_CHECK( std::strcmp( ec.category().name(), "system") == 0 );
-  BOOST_CHECK( !(ec < error_code( 0, system_category )) );
-  BOOST_CHECK( !(error_code( 0, system_category ) < ec) );
-  BOOST_CHECK( ec < error_code( 1, system_category ) );
-  BOOST_CHECK( !(error_code( 1, system_category ) < ec) );
+  BOOST_TEST( dec.value() == 0 );
+  BOOST_TEST( dec.category() == posix_category );
+  BOOST_TEST( ec == posix::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) );

  error_code ec_0_system( 0, system_category );
-  BOOST_CHECK( !ec_0_system );
-  BOOST_CHECK( ec_0_system.value() == 0 );
+  BOOST_TEST( !ec_0_system );
+  BOOST_TEST( ec_0_system.value() == 0 );
  dec = ec_0_system.default_error_condition();
-  BOOST_CHECK( dec.value() == 0 );
-  BOOST_CHECK( dec.category() == posix_category );
-  BOOST_CHECK( ec_0_system == posix::success );
-  BOOST_CHECK( ec_0_system.category() == system_category );
-  BOOST_CHECK( std::strcmp( ec_0_system.category().name(), "system") == 0 );
+  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 );
+  BOOST_TEST( std::strcmp( ec_0_system.category().name(), "system") == 0 );
  check_ostream( ec_0_system, "system:0" );

-  BOOST_CHECK( ec_0_system == ec );
+  BOOST_TEST( ec_0_system == ec );

  error_code ec_1_system( 1, system_category );
-  BOOST_CHECK( ec_1_system );
-  BOOST_CHECK( ec_1_system.value() == 1 );
-  BOOST_CHECK( ec_1_system.value() != 0 );
-  BOOST_CHECK( ec != ec_1_system );
-  BOOST_CHECK( ec_0_system != ec_1_system );
+  BOOST_TEST( ec_1_system );
+  BOOST_TEST( ec_1_system.value() == 1 );
+  BOOST_TEST( ec_1_system.value() != 0 );
+  BOOST_TEST( ec != ec_1_system );
+  BOOST_TEST( ec_0_system != ec_1_system );
  check_ostream( ec_1_system, "system:1" );

  ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
-  BOOST_CHECK( ec );
-  BOOST_CHECK( ec.value() == BOOST_ACCESS_ERROR_MACRO );
+  BOOST_TEST( ec );
+  BOOST_TEST( ec.value() == BOOST_ACCESS_ERROR_MACRO );
  dec = ec.default_error_condition();
-  BOOST_CHECK( dec.value() == static_cast<int>(posix::permission_denied) );
-  BOOST_CHECK( dec.category() == posix_category );
-  BOOST_CHECK( dec == error_condition( posix::permission_denied, posix_category ) );
-  BOOST_CHECK( dec == posix::permission_denied );
-  BOOST_CHECK( posix::permission_denied == dec );
-  BOOST_CHECK( ec == posix::permission_denied );
-  BOOST_CHECK( ec.category() == system_category );
-  BOOST_CHECK( std::strcmp( ec.category().name(), "system") == 0 );
+  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 );
+  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 );
-  BOOST_CHECK( ec );
-  BOOST_CHECK( ec == posix::bad_message );
-  BOOST_CHECK( posix::bad_message == ec );
-  BOOST_CHECK( ec != posix::permission_denied );
-  BOOST_CHECK( posix::permission_denied != ec );
-  BOOST_CHECK( ec.category() == posix_category );
+  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 );

  // test the deprecated predefined error_category synonyms
-  BOOST_CHECK( &system_category == &native_ecat );
-  BOOST_CHECK( &posix_category == &errno_ecat );
-  BOOST_CHECK( system_category == native_ecat );
-  BOOST_CHECK( posix_category == errno_ecat );
+  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 error_code and error_condition message();
  // see Boost.Filesystem operations_test for code specific message() tests
@@ -146,120 +146,120 @@ int test_main( int, char ** )
  std::cout << "error_code message for -1 is \"" << ec.message() << "\"\n";
 #if defined(BOOST_WINDOWS_API)
  // Borland appends newline, so just check text
-  BOOST_CHECK( ec.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
 #elif  defined(linux) || defined(__linux) || defined(__linux__)
  // Linux appends value to message as unsigned, so it varies with # of bits
-  BOOST_CHECK( ec.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( ec.message().substr(0,13) == "Unknown error" );
 #elif defined(__hpux)
-  BOOST_CHECK( ec.message() == "" );
+  BOOST_TEST( ec.message() == "" );
 #elif defined(__osf__)
-  BOOST_CHECK( ec.message() == "Error -1 occurred." );
+  BOOST_TEST( ec.message() == "Error -1 occurred." );
 #elif defined(__vms)
-  BOOST_CHECK( ec.message() == "error -1" );
+  BOOST_TEST( ec.message() == "error -1" );
 #endif

  ec = error_code( BOOST_ACCESS_ERROR_MACRO, system_category );
-  BOOST_CHECK( ec.message() != "" );
-  BOOST_CHECK( ec.message().substr( 0, 13) != "Unknown error" );
+  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";
 #if defined(BOOST_WINDOWS_API)
  // Borland appends newline, so just check text
-  BOOST_CHECK( dec.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( dec.message().substr(0,13) == "Unknown error" );
 #elif  defined(linux) || defined(__linux) || defined(__linux__)
  // Linux appends value to message as unsigned, so it varies with # of bits
-  BOOST_CHECK( dec.message().substr(0,13) == "Unknown error" );
+  BOOST_TEST( dec.message().substr(0,13) == "Unknown error" );
 #elif defined(__hpux)
-  BOOST_CHECK( dec.message() == "" );
+  BOOST_TEST( dec.message() == "" );
 #elif defined(__osf__)
-  BOOST_CHECK( dec.message() == "Error -1 occurred." );
+  BOOST_TEST( dec.message() == "Error -1 occurred." );
 #elif defined(__vms)
-  BOOST_CHECK( dec.message() == "error -1" );
+  BOOST_TEST( dec.message() == "error -1" );
 #endif

  dec = error_condition( BOOST_ACCESS_ERROR_MACRO, posix_category );
-  BOOST_CHECK( dec.message() != "" );
-  BOOST_CHECK( dec.message().substr( 0, 13) != "Unknown error" );
+  BOOST_TEST( dec.message() != "" );
+  BOOST_TEST( dec.message().substr( 0, 13) != "Unknown error" );

 #ifdef BOOST_WINDOWS_API
  std::cout << "Windows tests...\n";
  // these tests probe the Windows posix decoder
  //   test the first entry in the decoder table:
  ec = error_code( ERROR_ACCESS_DENIED, system_category );
-  BOOST_CHECK( ec.value() == ERROR_ACCESS_DENIED );
-  BOOST_CHECK( ec == posix::permission_denied );
-  BOOST_CHECK( ec.default_error_condition().value() == posix::permission_denied );
-  BOOST_CHECK( ec.default_error_condition().category() == posix_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 );

  //   test the second entry in the decoder table:
  ec = error_code( ERROR_ALREADY_EXISTS, system_category );
-  BOOST_CHECK( ec.value() == ERROR_ALREADY_EXISTS );
-  BOOST_CHECK( ec == posix::file_exists );
-  BOOST_CHECK( ec.default_error_condition().value() == posix::file_exists );
-  BOOST_CHECK( ec.default_error_condition().category() == posix_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 );

  //   test the third entry in the decoder table:
  ec = error_code( ERROR_BAD_UNIT, system_category );
-  BOOST_CHECK( ec.value() == ERROR_BAD_UNIT );
-  BOOST_CHECK( ec == posix::no_such_device );
-  BOOST_CHECK( ec.default_error_condition().value() == posix::no_such_device );
-  BOOST_CHECK( ec.default_error_condition().category() == posix_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 );

  //   test the last non-Winsock entry in the decoder table:
  ec = error_code( ERROR_WRITE_PROTECT, system_category );
-  BOOST_CHECK( ec.value() == ERROR_WRITE_PROTECT );
-  BOOST_CHECK( ec == posix::permission_denied );
-  BOOST_CHECK( ec.default_error_condition().value() == posix::permission_denied );
-  BOOST_CHECK( ec.default_error_condition().category() == posix_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 );

  //   test the last Winsock entry in the decoder table:
  ec = error_code( WSAEWOULDBLOCK, system_category );
-  BOOST_CHECK( ec.value() == WSAEWOULDBLOCK );
-  BOOST_CHECK( ec == posix::operation_would_block );
-  BOOST_CHECK( ec.default_error_condition().value() == posix::operation_would_block );
-  BOOST_CHECK( ec.default_error_condition().category() == posix_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 );

  //   test not-in-table condition:
  ec = error_code( 1234567890, system_category );
-  BOOST_CHECK( ec.value() == 1234567890 );
-  BOOST_CHECK( ec.default_error_condition().value() == 1234567890 );
-  BOOST_CHECK( ec.default_error_condition().category() == system_category );
+  BOOST_TEST( ec.value() == 1234567890 );
+  BOOST_TEST( ec.default_error_condition().value() == 1234567890 );
+  BOOST_TEST( ec.default_error_condition().category() == system_category );

 #else // POSIX

  std::cout << "POSIX tests...\n";
  ec = error_code( EACCES, system_category );
-  BOOST_CHECK( ec == error_code( posix::permission_denied, system_category ) );
-  BOOST_CHECK( error_code( posix::permission_denied, system_category ) == ec );
-  BOOST_CHECK( ec == posix::permission_denied );
-  BOOST_CHECK( posix::permission_denied == ec );
-  BOOST_CHECK( ec.default_error_condition().value() == posix::permission_denied );
-  BOOST_CHECK( ec.default_error_condition().category() == posix_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 );

 # ifdef __CYGWIN__

  std::cout << "Cygwin tests...\n";
  ec = cygwin_error::no_package;
-  BOOST_CHECK( ec == cygwin_error::no_package );
-  BOOST_CHECK( ec == error_code( ENOPKG, system_category ) );
-  BOOST_CHECK( ec == error_code( cygwin_error::no_package, system_category ) );
-  BOOST_CHECK( ec.default_error_condition().category() == system_category );
+  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 );

 # elif defined(linux) || defined(__linux) || defined(__linux__)

  std::cout << "Linux tests...\n";
  ec = linux_error::dot_dot_error;
-  BOOST_CHECK( ec == linux_error::dot_dot_error );
-  BOOST_CHECK( ec == error_code( EDOTDOT, system_category ) );
-  BOOST_CHECK( ec == error_code( linux_error::dot_dot_error, system_category ) );
-  BOOST_CHECK( ec.default_error_condition().category() == system_category );
+  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 );

 # endif

 #endif
  
-  return 0;
+  return ::boost::report_errors();
 }


--- a/test/system_msvc/common.vsprops
+++ b/test/system_msvc/common.vsprops
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="common"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		AdditionalIncludeDirectories="../../../../.."
+		PreprocessorDefinitions="BOOST_ALL_NO_LIB"
+		ExceptionHandling="2"
+	/>
+	<Tool
+		Name="VCPostBuildEventTool"
+		Description="Executing test $(TargetName).exe..."
+		CommandLine="&quot;$(TargetDir)\$(TargetName).exe&quot; --result_code=no --report_level=no"
+	/>
+</VisualStudioPropertySheet>
--- a/test/system_msvc/error_code_test/error_code_test.vcproj
+++ b/test/system_msvc/error_code_test/error_code_test.vcproj
@@ -0,0 +1,199 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="error_code_test"
+	ProjectGUID="{81960557-E9A9-4E81-AC96-9E11C33CB058}"
+	RootNamespace="error_code_test"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			InheritedPropertySheets="..\common.vsprops"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\..\..\src\error_code.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\error_code_test.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
--- a/test/system_msvc/system_msvc.sln
+++ b/test/system_msvc/system_msvc.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual C++ Express 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "error_code_test", "error_code_test\error_code_test.vcproj", "{81960557-E9A9-4E81-AC96-9E11C33CB058}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Debug|Win32.ActiveCfg = Debug|Win32
+		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Debug|Win32.Build.0 = Debug|Win32
+		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Release|Win32.ActiveCfg = Release|Win32
+		{81960557-E9A9-4E81-AC96-9E11C33CB058}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
Author	SHA1	Message	Date
Beman Dawes	c7ab2022e8	Release 1.41.0 Beta 1 [SVN r57353]	2009-11-04 12:14:07 +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
Beman Dawes	e8e4f47902	Merge from trunk [SVN r55489]	2009-08-09 17:34:58 +00:00
Troy D. Straszheim	078a1f23c4	Copyrights on CMakeLists.txt to keep them from clogging up the inspect reports. This is essentially the same commit as r55095 on the release branch. [SVN r55159]	2009-07-26 00:49:56 +00:00
Troy D. Straszheim	accf4f8414	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Beman Dawes	3f26239374	System: fix #3113 [SVN r53460]	2009-05-30 15:13:39 +00:00
Beman Dawes	fd0605bd7e	System, Filesystem: remove boost/detail/test_framework.hpp; use boost/detail/lightweight_test.hpp instead (Thanks to Peter Dimov for pointing this out) [SVN r51966]	2009-03-25 12:11:47 +00:00
Beman Dawes	83db702d99	System: removed dependency on Boost.Test [SVN r51960]	2009-03-24 15:38:10 +00:00
Troy D. Straszheim	e6f66bfc95	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
Beman Dawes	f1cdde273a	System: move throws function to namespace boost to allow peaceful coexistence with throws object. [SVN r50727]	2009-01-22 14:47:50 +00:00
Beman Dawes	5bc362e4f3	System: provide optional throws function rather than throws object [SVN r50705]	2009-01-21 18:01:14 +00:00
Beman Dawes	40612c12db	System: merge from trunk [SVN r50700]	2009-01-21 14:08:54 +00:00
Beman Dawes	a6728e5fb9	System: add deprecated get_posix_category() to fix ticket #2461 [SVN r49717]	2008-11-13 16:05:49 +00:00
Beman Dawes	99ee7ddaab	System: rename msvc_system -> system->msvc so VC++ start page recent solutions list is easier to use [SVN r49716]	2008-11-13 15:57:04 +00:00
Michael A. Jackson	3e8a2633f4	Continuing merge of CMake build system files into trunk with the encouragement of Doug Gregor [SVN r49510]	2008-11-01 13:15:41 +00:00
Beman Dawes	888786e838	System: apply patch from ticket #2175 [SVN r49293]	2008-10-12 14:07:22 +00:00
Beman Dawes	726478b372	System: merge accumulated changes from trunk [SVN r49292]	2008-10-12 13:51:47 +00:00
Beman Dawes	dca57ac132	System: Upgrade docs to reflect N2798 (and thus CD1), fix ticket #2125 , and provide a table of deprecated names and their replacements. [SVN r49291]	2008-10-12 13:27:59 +00:00
Beman Dawes	d19e139e11	Change names to ErrorCodeEnum and ErrorConditionEnum to conform to N2798 [SVN r49290]	2008-10-12 13:07:11 +00:00
Beman Dawes	4dc986ca03	System: Only supply case EALREADY if EALREADY != EBUSY, to close a portion of ticket #2288 [SVN r49220]	2008-10-09 19:01:57 +00:00
Beman Dawes	214ed40b22	System: refine docs for semantics of throws object [SVN r49177]	2008-10-08 14:16:05 +00:00
Beman Dawes	b4cc289238	System: fix typo that is apparent cause of Mac OS X compile failures [SVN r49157]	2008-10-07 01:57:24 +00:00
Beman Dawes	a753ffd26f	System: add throws object specification, including semantics [SVN r49138]	2008-10-05 13:02:01 +00:00
Beman Dawes	ee16863a40	system: add #ifndef as requested by #2098 [SVN r49094]	2008-10-01 19:08:08 +00:00
Beman Dawes	463cefcf94	system: reduce chance of message() throwing in response to ticket #2098 [SVN r49093]	2008-10-01 18:57:48 +00:00
Beman Dawes	84ff2d0f04	Initial commit: system/test/msvc_system [SVN r49090]	2008-10-01 18:24:20 +00:00
Beman Dawes	b7cd247b64	Remove redundant Jamfile <define>s [SVN r49080]	2008-10-01 14:14:58 +00:00
Beman Dawes	d6446d1cfb	Add error_code throws [SVN r48577]	2008-09-04 17:36:56 +00:00
Beman Dawes	a97517585c	Add const char* constructors to system_error, rationalize test coverage [SVN r46678]	2008-06-25 14:16:59 +00:00
Beman Dawes	2953464e99	Apply LWG issue 805, using a namespace to emulate scoped enums. [SVN r46645]	2008-06-24 14:59:10 +00:00
Beman Dawes	69d2a2234c	Fix Ticket #1768 by including <boost/config/warning_disable.hpp> [SVN r45894]	2008-05-29 01:34:53 +00:00
Beman Dawes	98a757dbf7	Fix ticket #1609 [SVN r45830]	2008-05-27 20:01:15 +00:00
Beman Dawes	51e9c56427	Give the 1st and 2nd level index.html files a common look-and-feel. [SVN r43402]	2008-02-23 14:04:02 +00:00
Beman Dawes	fcdecd4c96	Remove extraneous defines since they are inherited from library build Jamfile [SVN r42873]	2008-01-20 02:01:35 +00:00