Upgrade system and filesystem to conform system_category and generic_category interface to N3090, the current C++0x working paper, section 19.5, System error support.

Refactor API macros into a new header, boost/system/api_config.hpp.

Prohibit user definition of API macros. Rationale: ensure all translation units use same definitions, cut number of environments that need to be tested.

[SVN r62313]

test/error_code_test.cpp

@@ -68,20 +68,20 @@ int main( int, char ** )
   std::cout << "General tests...\n";
   // unit tests:
 
-  BOOST_TEST( generic_category == generic_category );
-  BOOST_TEST( system_category == system_category );
-  BOOST_TEST( generic_category != system_category );
-  BOOST_TEST( system_category != generic_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*>()( &generic_category, &system_category ) )
+  if ( std::less<const error_category*>()( &generic_category(), &system_category() ) )
   {
-    BOOST_TEST( generic_category < system_category );
-    BOOST_TEST( !(system_category < generic_category) );
+    BOOST_TEST( generic_category() < system_category() );
+    BOOST_TEST( !(system_category() < generic_category()) );
   }
   else
   {
-    BOOST_TEST( system_category < generic_category );
-    BOOST_TEST( !(generic_category < system_category) );
+    BOOST_TEST( system_category() < generic_category() );
+    BOOST_TEST( !(generic_category() < system_category()) );
   }
 
 
@@ -91,29 +91,29 @@ int main( int, char ** )
   BOOST_TEST( ec.value() == 0 );
   econd = ec.default_error_condition();
   BOOST_TEST( econd.value() == 0 );
-  BOOST_TEST( econd.category() == generic_category );
+  BOOST_TEST( econd.category() == generic_category() );
   BOOST_TEST( ec == errc::success );
-  BOOST_TEST( ec.category() == system_category );
+  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 );
   econd = ec_0_system.default_error_condition();
   BOOST_TEST( econd.value() == 0 );
-  BOOST_TEST( econd.category() == generic_category );
+  BOOST_TEST( econd.category() == generic_category() );
   BOOST_TEST( ec_0_system == errc::success );
-  BOOST_TEST( ec_0_system.category() == system_category );
+  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 );
@@ -121,17 +121,17 @@ 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 );
   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.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( ec.category() == system_category() );
   BOOST_TEST( std::strcmp( ec.category().name(), "system") == 0 );
 
   // test the explicit make_error_code conversion for errc
@@ -141,17 +141,17 @@ int main( int, char ** )
   BOOST_TEST( errc::bad_message == ec );
   BOOST_TEST( ec != errc::permission_denied );
   BOOST_TEST( errc::permission_denied != ec );
-  BOOST_TEST( ec.category() == generic_category );
+  BOOST_TEST( ec.category() == generic_category() );
 
   //// 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 );
+  //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)
@@ -169,11 +169,11 @@ 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" );
 
-  econd = error_condition( -1, generic_category );
+  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";
@@ -192,7 +192,7 @@ int main( int, char ** )
   BOOST_TEST( econd.message() == "error -1" );
 #endif
 
-  econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category );
+  econd = error_condition( BOOST_ACCESS_ERROR_MACRO, generic_category() );
   BOOST_TEST( econd.message() != "" );
   BOOST_TEST( econd.message().substr( 0, 13) != "Unknown error" );
 
@@ -200,74 +200,74 @@ int main( int, char ** )
   std::cout << "Windows tests...\n";
   // 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 == errc::permission_denied );
   BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
-  BOOST_TEST( ec.default_error_condition().category() == generic_category );
+  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 == errc::file_exists );
   BOOST_TEST( ec.default_error_condition().value() == errc::file_exists );
-  BOOST_TEST( ec.default_error_condition().category() == generic_category );
+  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 == errc::no_such_device );
   BOOST_TEST( ec.default_error_condition().value() == errc::no_such_device );
-  BOOST_TEST( ec.default_error_condition().category() == generic_category );
+  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 == errc::permission_denied );
   BOOST_TEST( ec.default_error_condition().value() == errc::permission_denied );
-  BOOST_TEST( ec.default_error_condition().category() == generic_category );
+  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 == errc::operation_would_block );
   BOOST_TEST( ec.default_error_condition().value() == errc::operation_would_block );
-  BOOST_TEST( ec.default_error_condition().category() == generic_category );
+  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( errc::permission_denied, system_category ) );
-  BOOST_TEST( error_code( errc::permission_denied, system_category ) == ec );
+  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 );
+  BOOST_TEST( ec.default_error_condition().category() == generic_category() );
 
 # ifdef __CYGWIN__
 
   std::cout << "Cygwin tests...\n";
   ec = cygwin_error::no_package;
   BOOST_TEST( ec == cygwin_error::no_package );
-  BOOST_TEST( ec == error_code( ENOPKG, system_category ) );
-  BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category ) );
-  BOOST_TEST( ec.default_error_condition().category() == system_category );
+  BOOST_TEST( ec == error_code( ENOPKG, system_category() ) );
+  BOOST_TEST( ec == error_code( cygwin_error::no_package, system_category() ) );
+  BOOST_TEST( ec.default_error_condition().category() == system_category() );
 
 # elif defined(linux) || defined(__linux) || defined(__linux__)
 
   std::cout << "Linux tests...\n";
   ec = linux_error::dot_dot_error;
   BOOST_TEST( ec == linux_error::dot_dot_error );
-  BOOST_TEST( ec == error_code( EDOTDOT, system_category ) );
-  BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category ) );
-  BOOST_TEST( ec.default_error_condition().category() == system_category );
+  BOOST_TEST( ec == error_code( EDOTDOT, system_category() ) );
+  BOOST_TEST( ec == error_code( linux_error::dot_dot_error, system_category() ) );
+  BOOST_TEST( ec.default_error_condition().category() == system_category() );
 
 # endif
 

test/error_code_user_test.cpp

@@ -14,6 +14,8 @@
 
 //  Motivation was a Boost posting by Christopher Kohlhoff on June 28, 2006.
 
+#define BOOST_SYSTEM_NO_DEPRECATED
+
 #include <boost/system/error_code.hpp>
 #include <boost/cerrno.hpp>
 #include <string>
@@ -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.
 }
 
@@ -118,8 +120,8 @@ namespace boost
       boost::system::error_condition default_error_condition( int ev ) const
       {
         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 );
       }
@@ -180,8 +182,8 @@ namespace lib4
     boost::system::error_condition default_error_condition( int ev ) const
     {
       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 );
     }
     
@@ -237,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());
 //    }
 //    
 //  };
@@ -264,8 +266,8 @@ namespace lib4
 //
 //  void check_success(const boost::system::error_code& ec, bool expect)
 //  {
-//    BOOST_TEST( (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';
@@ -273,8 +275,8 @@ namespace lib4
 //
 //  void check_permission_denied(const boost::system::error_code& ec, bool expect)
 //  {
-//    BOOST_TEST( (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';
@@ -282,8 +284,8 @@ namespace lib4
 //
 //  void check_out_of_memory(const boost::system::error_code& ec, bool expect)
 //  {
-//    BOOST_TEST( (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';
@@ -295,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);
@@ -347,8 +349,8 @@ int main( int, char *[] )
   std::cout << "ec.value() is " << ec.value() << '\n';
 
   BOOST_TEST( ec );
-  BOOST_TEST( ec == boost::system::posix::no_such_file_or_directory );
-  BOOST_TEST( ec.category() == boost::system::system_category );
+  BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
+  BOOST_TEST( ec.category() == boost::system::system_category() );
 
   // Library 2 tests:
 
@@ -356,8 +358,8 @@ int main( int, char *[] )
   std::cout << "ec.value() is " << ec.value() << '\n';
 
   BOOST_TEST( ec );
-  BOOST_TEST( ec == boost::system::posix::no_such_file_or_directory );
-  BOOST_TEST( ec.category() == boost::system::posix_category );
+  BOOST_TEST( ec == boost::system::errc::no_such_file_or_directory );
+  BOOST_TEST( ec.category() == boost::system::generic_category() );
 
   // Library 3 tests:
 
@@ -369,7 +371,7 @@ int main( int, char *[] )
   BOOST_TEST( ec.value() == boost::lib3::boo_boo );
   BOOST_TEST( ec.category() == boost::lib3::lib3_error_category );
 
-  BOOST_TEST( 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 );
@@ -387,7 +389,7 @@ int main( int, char *[] )
   BOOST_TEST( ec.value() == lib4::boo_boo.value() );
   BOOST_TEST( ec.category() == lib4::lib4_error_category );
 
-  BOOST_TEST( 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 );

test/header_only_test.cpp

@@ -18,6 +18,6 @@
 
 int main( int, char*[] )
 {
-  boost::system::error_code ec( 0, boost::system::system_category );
+  boost::system::error_code ec( 0, boost::system::system_category() );
   return ::boost::report_errors();
 }

test/initialization_test.cpp

@@ -24,5 +24,5 @@ struct foo
 
 int main( int, char ** )
 {
-       return 0;
+  return ::boost::report_errors();
 }

test/system_error_test.cpp

@@ -37,7 +37,7 @@ namespace
   {
     std::cout << "test " << desc << "\n what() returns \"" << ex.what() << "\"\n";
     BOOST_TEST( ex.code().value() == v );
-    BOOST_TEST( ex.code().category() == system_category );
+    BOOST_TEST( ex.code().category() == system_category() );
 # ifdef BOOST_WINDOWS_API
     LANGID language_id;
 #   if !defined(__MINGW32__) && !defined(__CYGWIN__)
@@ -63,25 +63,25 @@ 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, "The operation completed successfully" );
   TEST( c1_1, 1, "Incorrect function" );

test/throw_test.cpp

@@ -25,7 +25,7 @@ namespace boost
   {
     BOOST_SYSTEM_DECL void throw_test()
     {
-      throw system_error(9999, get_system_category(), "boo boo");
+      throw system_error(9999, system_category(), "boo boo");
     }
   }
 }