Branch for working on the documentation tools documentation.

[SVN r68640]

include/boost/detail/bitmask.hpp

@@ -1,47 +0,0 @@
-//  boost/detail/bitmask.hpp  ------------------------------------------------//
-
-//  Copyright Beman Dawes 2006
-
-//  Distributed under the Boost Software License, Version 1.0
-//  http://www.boost.org/LICENSE_1_0.txt
-
-//  Usage:  enum foo { a=1, b=2, c=4 };
-//          BOOST_BITMASK( foo );
-//
-//          void f( foo arg );
-//          ...
-//          f( a | c );
-
-#ifndef BOOST_BITMASK_HPP
-#define BOOST_BITMASK_HPP
-
-#include <boost/cstdint.hpp>
-
-#define BOOST_BITMASK(Bitmask)                                            \
-                                                                          \
-  inline Bitmask operator| (Bitmask x , Bitmask y )                       \
-  { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
-      | static_cast<boost::int_least32_t>(y)); }                          \
-                                                                          \
-  inline Bitmask operator& (Bitmask x , Bitmask y )                       \
-  { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
-      & static_cast<boost::int_least32_t>(y)); }                          \
-                                                                          \
-  inline Bitmask operator^ (Bitmask x , Bitmask y )                       \
-  { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x)     \
-      ^ static_cast<boost::int_least32_t>(y)); }                          \
-                                                                          \
-  inline Bitmask operator~ (Bitmask x )                                   \
-  { return static_cast<Bitmask>(~static_cast<boost::int_least32_t>(x)); } \
-                                                                          \
-  inline Bitmask & operator&=(Bitmask & x , Bitmask y)                    \
-  { x = x & y ; return x ; }                                              \
-                                                                          \
-  inline Bitmask & operator|=(Bitmask & x , Bitmask y)                    \
-  { x = x | y ; return x ; }                                              \
-                                                                          \
-  inline Bitmask & operator^=(Bitmask & x , Bitmask y)                    \
-  { x = x ^ y ; return x ; }                                              
-
-#endif // BOOST_BITMASK_HPP
-

include/boost/detail/interlocked.hpp

@@ -118,6 +118,11 @@ extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long
 extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long );
 extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long );
 
+# if defined(_M_IA64) || defined(_M_AMD64)
+extern "C" __declspec(dllimport) void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
+extern "C" __declspec(dllimport) void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
+# endif
+
 } // namespace detail
 
 } // namespace boost
@@ -128,10 +133,15 @@ extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long vol
 # define BOOST_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange
 # define BOOST_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd
 
-# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+# if defined(_M_IA64) || defined(_M_AMD64)
+#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER ::boost::detail::InterlockedCompareExchangePointer
+#  define BOOST_INTERLOCKED_EXCHANGE_POINTER ::boost::detail::InterlockedExchangePointer
+# else
+#  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
     ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long volatile*)(dest),(long)(exchange),(long)(compare)))
-# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+#  define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
     ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
+# endif
 
 #else
 

include/boost/detail/is_sorted.hpp

@@ -0,0 +1,56 @@
+/*==============================================================================
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#ifndef BOOST_DETAIL_SORTED_HPP
+#define BOOST_DETAIL_SORTED_HPP
+
+#include <boost/detail/iterator.hpp>
+
+#include <functional>
+
+namespace boost {
+namespace detail {
+
+template<class Iterator, class Comp>
+inline Iterator is_sorted_until (Iterator first, Iterator last, Comp c) {
+  if (first == last)
+    return last;
+
+  Iterator it = first; ++it;
+
+  for (; it != last; first = it, ++it)
+    if (c(*it, *first))
+      return it;
+
+  return it;
+}
+
+template<class Iterator>
+inline Iterator is_sorted_until (Iterator first, Iterator last) {
+  typedef typename boost::detail::iterator_traits<Iterator>::value_type
+    value_type;
+
+  typedef std::less<value_type> c; 
+
+  return ::boost::detail::is_sorted_until(first, last, c()); 
+}
+
+template<class Iterator, class Comp>
+inline bool is_sorted (Iterator first, Iterator last, Comp c) {
+  return ::boost::detail::is_sorted_until(first, last, c) == last;
+} 
+
+template<class Iterator>
+inline bool is_sorted (Iterator first, Iterator last) {
+  return ::boost::detail::is_sorted_until(first, last) == last;
+} 
+
+} // detail
+} // boost
+
+#endif // BOOST_DETAIL_SORTED_HPP
+

include/boost/detail/lightweight_test.hpp

@@ -11,6 +11,7 @@
 //  boost/detail/lightweight_test.hpp - lightweight test library
 //
 //  Copyright (c) 2002, 2009 Peter Dimov
+//  Copyright (2) Beman Dawes 2010, 2011
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -23,9 +24,15 @@
 //  int boost::report_errors()
 //
 
+#include <iostream>
 #include <boost/current_function.hpp>
 #include <boost/assert.hpp>
-#include <iostream>
+
+//  IDE's like Visual Studio perform better if output goes to std::cout or
+//  some other stream, so allow user to configure output stream:
+#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM
+# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr
+#endif
 
 namespace boost
 {
@@ -58,24 +65,30 @@ inline int & test_errors()
 
 inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
 {
-    std::cerr << file << "(" << line << "): test '" << expr << "' failed in function '" << function << "'" << std::endl;
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): test '" << expr << "' failed in function '"
+      << function << "'" << std::endl;
     ++test_errors();
 }
 
 inline void error_impl(char const * msg, char const * file, int line, char const * function)
 {
-    std::cerr << file << "(" << line << "): " << msg << " in function '" << function << "'" << std::endl;
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): " << msg << " in function '"
+      << function << "'" << std::endl;
     ++test_errors();
 }
 
-template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2, char const * file, int line, char const * function, T const & t, U const & u )
+template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
 {
     if( t == u )
     {
     }
     else
     {
-        std::cerr << file << "(" << line << "): test '" << expr1 << " == " << expr2
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
             << "' failed in function '" << function << "': "
             << "'" << t << "' != '" << u << "'" << std::endl;
         ++test_errors();
@@ -92,12 +105,14 @@ inline int report_errors()
 
     if( errors == 0 )
     {
-        std::cerr << "No errors detected." << std::endl;
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << "No errors detected." << std::endl;
         return 0;
     }
     else
     {
-        std::cerr << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
         return 1;
     }
 }

include/boost/detail/win/GetCurrentProcess.hpp

@@ -0,0 +1,25 @@
+//  GetCurrentProcess.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETCURRENTPROCESS_HPP
+#define BOOST_DETAIL_WIN_GETCURRENTPROCESS_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentProcess;
+#else
+    extern "C" __declspec(dllimport) HANDLE_ WINAPI GetCurrentProcess();
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/GetCurrentThread.hpp

@@ -0,0 +1,26 @@
+//  GetCurrentThread.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETCURRENTTHREAD_HPP
+#define BOOST_DETAIL_WIN_GETCURRENTTHREAD_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentThread;
+#else
+    extern "C" __declspec(dllimport) HANDLE_ WINAPI GetCurrentThread();
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/GetLastError.hpp

@@ -0,0 +1,27 @@
+//  GetLastError.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETLASTERROR_HPP
+#define BOOST_DETAIL_WIN_GETLASTERROR_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetLastError;
+#else
+    extern "C" __declspec(dllimport) DWORD_ WINAPI
+        GetLastError();
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/GetProcessTimes.hpp

@@ -0,0 +1,33 @@
+//  GetProcessTimes.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP
+#define BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP
+
+#include <boost/detail/win/time.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetProcessTimes;
+#else
+    extern "C" __declspec(dllimport) BOOL_ WINAPI
+        GetProcessTimes(
+            HANDLE_ hProcess,
+            LPFILETIME_ lpCreationTime,
+            LPFILETIME_ lpExitTime,
+            LPFILETIME_ lpKernelTime,
+            LPFILETIME_ lpUserTime
+        );
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_GETPROCESSTIMES_HPP

include/boost/detail/win/GetThreadTimes.hpp

@@ -0,0 +1,33 @@
+//  GetThreadTimes.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_GETTHREADTIMES_HPP
+#define BOOST_DETAIL_WIN_GETTHREADTIMES_HPP
+
+#include <boost/detail/win/time.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetThreadTimes;
+#else
+    extern "C" __declspec(dllimport) BOOL_ WINAPI
+        GetThreadTimes(
+            HANDLE_ hThread,
+            LPFILETIME_ lpCreationTime,
+            LPFILETIME_ lpExitTime,
+            LPFILETIME_ lpKernelTime,
+            LPFILETIME_ lpUserTime
+        );
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_GETTHREADTIMES_HPP

include/boost/detail/win/LocalFree.hpp

@@ -0,0 +1,29 @@
+//  LocalFree.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_LOCALFREE_HPP
+#define BOOST_DETAIL_WIN_LOCALFREE_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef HANDLE_ HLOCAL_;
+
+    using ::LocalFree;
+#else
+    extern "C" typedef HANDLE_ HLOCAL_;
+    extern "C" __declspec(dllimport) HLOCAL_ WINAPI 
+        LocalFree(HLOCAL_ hMem);
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_LOCALFREE_HPP

include/boost/detail/win/basic_types.hpp

@@ -0,0 +1,111 @@
+//  basic_types.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_BASIC_TYPES_HPP
+#define BOOST_DETAIL_WIN_BASIC_TYPES_HPP
+#include <boost/config.hpp>
+#include <cstdarg>
+#include <boost/cstdint.hpp>
+#if defined( BOOST_USE_WINDOWS_H )
+# include <windows.h>
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) ||  defined(__CYGWIN__)
+# include <WinError.h>
+// @FIXME Which condition must be tested
+# ifdef UNDER_CE
+#  ifndef WINAPI
+#   ifndef _WIN32_WCE_EMULATION
+#    define WINAPI  __cdecl     // Note this doesn't match the desktop definition
+#   else
+#    define WINAPI  __stdcall
+#   endif
+#  endif
+# else
+#  ifndef WINAPI
+#    define WINAPI  __stdcall
+#  endif
+# endif
+#else
+# error "Win32 functions not available"
+#endif
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef ::BOOL BOOL_;
+    typedef ::WORD WORD_;
+    typedef ::DWORD DWORD_;
+    typedef ::HANDLE HANDLE_;
+    typedef ::LONG LONG_;
+    typedef ::LONGLONG LONGLONG_;
+    typedef ::ULONG_PTR ULONG_PTR_;
+    typedef ::LARGE_INTEGER LARGE_INTEGER_;
+    typedef ::PLARGE_INTEGER PLARGE_INTEGER_;
+    typedef ::PVOID PVOID_;
+    typedef ::LPVOID LPVOID_;
+    typedef ::CHAR CHAR_;
+    typedef ::LPSTR LPSTR_;
+    typedef ::LPCSTR LPCSTR_;
+    typedef ::WCHAR WCHAR_;
+    typedef ::LPWSTR LPWSTR_;
+    typedef ::LPCWSTR LPCWSTR_;
+#else
+extern "C" {
+    typedef int BOOL_;
+    typedef unsigned short WORD_;
+    typedef unsigned long DWORD_;
+    typedef void* HANDLE_;
+
+    typedef long LONG_;
+
+// @FIXME Which condition must be tested
+//~ #if !defined(_M_IX86)
+//~ #if defined(BOOST_NO_INT64_T)
+    //~ typedef double LONGLONG_;
+//~ #else
+    //~ typedef __int64 LONGLONG_;
+//~ #endif
+//~ #else
+    //~ typedef double LONGLONG_;
+//~ #endif
+    typedef boost::int64_t LONGLONG_;
+
+// @FIXME Which condition must be tested
+# ifdef _WIN64
+#if defined(__CYGWIN__)
+    typedef unsigned long ULONG_PTR_;
+#else
+    typedef unsigned __int64 ULONG_PTR_;
+#endif
+# else
+    typedef unsigned long ULONG_PTR_;
+# endif
+
+    typedef struct _LARGE_INTEGER {
+        LONGLONG_ QuadPart;
+    } LARGE_INTEGER_;
+    typedef LARGE_INTEGER_ *PLARGE_INTEGER_;
+
+    typedef void *PVOID_;
+    typedef void *LPVOID_;
+    typedef const void *LPCVOID_;
+
+    typedef char CHAR_;
+    typedef CHAR_ *LPSTR_;
+    typedef const CHAR_ *LPCSTR_;
+
+    typedef wchar_t WCHAR_;
+    typedef WCHAR_ *LPWSTR_;
+    typedef const WCHAR_ *LPCWSTR_;
+
+}
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/directory_management.hpp

@@ -0,0 +1,43 @@
+//  directory_management.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_DIRECTORY_MANAGEMENT_HPP
+#define BOOST_DETAIL_WIN_DIRECTORY_MANAGEMENT_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CreateDirectory;
+    using ::CreateDirectoryA;
+    using ::GetTempPathA;
+    using ::RemoveDirectoryA;
+#else
+extern "C" { 
+    __declspec(dllimport) int __stdcall 
+        CreateDirectory(LPCTSTR_, LPSECURITY_ATTRIBUTES_*);
+    __declspec(dllimport) int __stdcall 
+        CreateDirectoryA(LPCTSTR_, interprocess_security_attributes*);
+    __declspec(dllimport) int __stdcall 
+        GetTempPathA(unsigned long length, char *buffer);
+    __declspec(dllimport) int __stdcall 
+        RemoveDirectoryA(LPCTSTR_);
+    
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/dll.hpp

@@ -0,0 +1,52 @@
+//  dll.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_DLL_HPP
+#define BOOST_DETAIL_WIN_DLL_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::LoadLibrary;
+    using ::FreeLibrary;
+    using ::GetProcAddress;
+    using ::GetModuleHandleA;
+#else
+extern "C" { 
+    __declspec(dllimport) HMODULE_ __stdcall 
+        LoadLibrary(
+            LPCTSTR_ lpFileName
+    );
+    __declspec(dllimport) BOOL_ __stdcall 
+        FreeLibrary(
+            HMODULE_ hModule
+    );
+    __declspec(dllimport) FARPROC_ __stdcall 
+        GetProcAddress(
+            HMODULE_ hModule,
+            LPCSTR_ lpProcName
+    );
+    __declspec(dllimport) FARPROC_ __stdcall 
+        GetModuleHandleA(
+            LPCSTR_ lpProcName
+    );
+    
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/error_handling.hpp

@@ -0,0 +1,88 @@
+//  error_handling.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_ERROR_HANDLING_HPP
+#define BOOST_DETAIL_WIN_ERROR_HANDLING_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/GetCurrentThread.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::FormatMessageA;
+    using ::FormatMessageW;
+
+    const int FORMAT_MESSAGE_ALLOCATE_BUFFER_= FORMAT_MESSAGE_ALLOCATE_BUFFER;
+    const int FORMAT_MESSAGE_IGNORE_INSERTS_=  FORMAT_MESSAGE_IGNORE_INSERTS;
+    const int FORMAT_MESSAGE_FROM_STRING_=     FORMAT_MESSAGE_FROM_STRING;
+    const int FORMAT_MESSAGE_FROM_HMODULE_=    FORMAT_MESSAGE_FROM_HMODULE;
+    const int FORMAT_MESSAGE_FROM_SYSTEM_=     FORMAT_MESSAGE_FROM_SYSTEM;
+    const int FORMAT_MESSAGE_ARGUMENT_ARRAY_=  FORMAT_MESSAGE_ARGUMENT_ARRAY;
+    const int FORMAT_MESSAGE_MAX_WIDTH_MASK_=  FORMAT_MESSAGE_MAX_WIDTH_MASK;
+
+    const char LANG_NEUTRAL_=                  LANG_NEUTRAL;
+    const char LANG_INVARIANT_=                LANG_INVARIANT;
+
+    const char SUBLANG_DEFAULT_=               SUBLANG_DEFAULT;    // user default
+    inline WORD_ MAKELANGID_(WORD_ p, WORD_ s) {
+        return MAKELANGID(p,s);
+    }
+#else
+extern "C" {
+    //                using ::FormatMessageA;
+    __declspec(dllimport)
+    DWORD_
+    WINAPI
+    FormatMessageA(
+        DWORD_ dwFlags,
+        LPCVOID_ lpSource,
+        DWORD_ dwMessageId,
+        DWORD_ dwLanguageId,
+        LPSTR_ lpBuffer,
+        DWORD_ nSize,
+        va_list *Arguments
+        );
+
+    //                using ::FormatMessageW;
+    __declspec(dllimport)
+    DWORD_
+    WINAPI
+    FormatMessageW(
+        DWORD_ dwFlags,
+        LPCVOID_ lpSource,
+        DWORD_ dwMessageId,
+        DWORD_ dwLanguageId,
+        LPWSTR_ lpBuffer,
+        DWORD_ nSize,
+        va_list *Arguments
+        );
+
+    const int FORMAT_MESSAGE_ALLOCATE_BUFFER_= 0x00000100;
+    const int FORMAT_MESSAGE_IGNORE_INSERTS_=  0x00000200;
+    const int FORMAT_MESSAGE_FROM_STRING_=     0x00000400;
+    const int FORMAT_MESSAGE_FROM_HMODULE_=    0x00000800;
+    const int FORMAT_MESSAGE_FROM_SYSTEM_=     0x00001000;
+    const int FORMAT_MESSAGE_ARGUMENT_ARRAY_=  0x00002000;
+    const int FORMAT_MESSAGE_MAX_WIDTH_MASK_=  0x000000FF;
+
+    const char LANG_NEUTRAL_=                  0x00;
+    const char LANG_INVARIANT_=                0x7f;
+
+    const char SUBLANG_DEFAULT_=               0x01;    // user default
+    inline WORD_ MAKELANGID_(WORD_ p, WORD_ s) {
+        return ((((WORD_  )(s)) << 10) | (WORD_  )(p));
+    }
+
+}
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_ERROR_HANDLING_HPP

include/boost/detail/win/file_management.hpp

@@ -0,0 +1,126 @@
+//  thread.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_FILE_MANAGEMENT_HPP
+#define BOOST_DETAIL_WIN_FILE_MANAGEMENT_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CreateFileA;
+    using ::DeleteFileA;
+    using ::FindFirstFileA;
+    using ::FindNextFileA;
+    using ::FindClose;
+    using ::GetFileSizeEx;
+    using ::MoveFileExA;
+    using ::SetFileValidData;
+#else
+extern "C" {
+    typedef struct _OVERLAPPED {
+      ULONG_PTR Internal;
+      ULONG_PTR InternalHigh;
+      union {
+        struct {
+          DWORD Offset;
+          DWORD OffsetHigh;
+        } ;
+        PVOID  Pointer;
+      } ;
+      HANDLE    hEvent;
+    } OVERLAPPED, *LPOVERLAPPED;
+
+    
+    __declspec(dllimport) void * __stdcall 
+        CreateFileA (const char *, unsigned long, unsigned long, struct SECURITY_ATTRIBUTES_*, unsigned long, unsigned long, void *);
+    __declspec(dllimport) int __stdcall    
+        DeleteFileA (const char *);
+    __declspec(dllimport) void *__stdcall 
+        FindFirstFileA(const char *lpFileName, win32_find_data_t *lpFindFileData);
+    __declspec(dllimport) int   __stdcall 
+        FindNextFileA(void *hFindFile, win32_find_data_t *lpFindFileData);
+    __declspec(dllimport) int   __stdcall 
+        FindClose(void *hFindFile);
+    __declspec(dllimport) BOOL __stdcall 
+        GetFileSizeEx(
+            HANDLE_ hFile,
+            PLARGE_INTEGER_ lpFileSize
+    );
+    __declspec(dllimport) int __stdcall    
+        MoveFileExA (const char *, const char *, unsigned long);
+    __declspec(dllimport) BOOL_ __stdcall 
+        SetFileValidData(
+            HANDLE_ hFile,
+            LONGLONG_ ValidDataLength
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        SetEndOfFile(
+            HANDLE_ hFile
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        SetFilePointerEx(
+            HANDLE_ hFile,
+            LARGE_INTEGER_ liDistanceToMove,
+            PLARGE_INTEGER_ lpNewFilePointer,
+            DWORD_ dwMoveMethod
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        LockFile(
+            HANDLE_ hFile,
+            DWORD_ dwFileOffsetLow,
+            DWORD_ dwFileOffsetHigh,
+            DWORD_ nNumberOfBytesToLockLow,
+            DWORD_ nNumberOfBytesToLockHigh
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        UnlockFile(
+            HANDLE_ hFile,
+            DWORD_ dwFileOffsetLow,
+            DWORD_ dwFileOffsetHigh,
+            DWORD_ nNumberOfBytesToUnlockLow,
+            DWORD_ nNumberOfBytesToUnlockHigh
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        LockFileEx(
+            HANDLE_ hFile,
+            DWORD_ dwFlags,
+            DWORD_ dwReserved,
+            DWORD_ nNumberOfBytesToLockLow,
+            DWORD_ nNumberOfBytesToLockHigh,
+            LPOVERLAPPED_ lpOverlapped
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        UnlockFileEx(
+            HANDLE_ hFile,
+            DWORD_ dwReserved,
+            DWORD_ nNumberOfBytesToUnlockLow,
+            DWORD_ nNumberOfBytesToUnlockHigh,
+            LPOVERLAPPED_ lpOverlapped
+    );
+    __declspec(dllimport) BOOL_ __stdcall
+        WriteFile(
+            HANDLE_ hFile,
+            LPCVOID_ lpBuffer,
+            DWORD_ nNumberOfBytesToWrite,
+            LPDWORD_ lpNumberOfBytesWritten,
+            LPOVERLAPPED_ lpOverlapped
+    );
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/handles.hpp

@@ -0,0 +1,37 @@
+//  memory.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_HANDLES_HPP
+#define BOOST_DETAIL_WIN_HANDLES_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CloseHandle;
+    using ::DuplicateHandle;
+#else
+extern "C" { 
+    __declspec(dllimport) int __stdcall 
+        CloseHandle(void*);
+    __declspec(dllimport) int __stdcall 
+        DuplicateHandle(void*,void*,void*,void**,unsigned long,int,unsigned long);
+}
+
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_HANDLES_HPP

include/boost/detail/win/memory.hpp

@@ -0,0 +1,59 @@
+//  memory.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_MEMORY_HPP
+#define BOOST_DETAIL_WIN_MEMORY_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/security.hpp>
+#include <boost/detail/win/LocalFree.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::CreateFileMappingA;
+    using ::FlushViewOfFile;
+    using ::GetProcessHeap;
+    using ::HeapAlloc;
+    using ::HeapFree;
+    using ::MapViewOfFileEx;
+    using ::OpenFileMappingA;
+    using ::UnmapViewOfFile;
+#else
+# ifdef HeapAlloc
+# undef HeapAlloc
+# endif
+extern "C" {
+    __declspec(dllimport) void * __stdcall 
+        CreateFileMappingA (void *, SECURITY_ATTRIBUTES_*, unsigned long, unsigned long, unsigned long, const char *);
+    __declspec(dllimport) int __stdcall 
+        FlushViewOfFile (void *, std::size_t);
+    __declspec(dllimport) HANDLE_ __stdcall 
+        GetProcessHeap();
+    __declspec(dllimport) void* __stdcall 
+        HeapAlloc(HANDLE_,DWORD_,SIZE_T_);
+    __declspec(dllimport) BOOL_ __stdcall 
+        HeapFree(HANDLE_,DWORD_,LPVOID_);
+    __declspec(dllimport) void * __stdcall 
+        MapViewOfFileEx (void *, unsigned long, unsigned long, unsigned long, std::size_t, void*);
+    __declspec(dllimport) void * __stdcall 
+        OpenFileMappingA (unsigned long, int, const char *);
+    __declspec(dllimport) int __stdcall 
+        UnmapViewOfFile(void *);
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP

include/boost/detail/win/process.hpp

@@ -0,0 +1,33 @@
+//  process.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_PROCESS_HPP
+#define BOOST_DETAIL_WIN_PROCESS_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/GetCurrentProcess.hpp>
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentProcessId;
+#else
+# ifndef UNDER_CE
+extern "C" { 
+    __declspec(dllimport) unsigned long __stdcall 
+        GetCurrentProcessId(void);
+}    
+# else
+    using ::GetCurrentProcessId;
+# endif
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_PROCESS_HPP

include/boost/detail/win/security.hpp

@@ -0,0 +1,62 @@
+//  security.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_SECURITY_HPP
+#define BOOST_DETAIL_WIN_SECURITY_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+typedef ::SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES_;
+typedef ::PSECURITY_ATTRIBUTES PSECURITY_ATTRIBUTES_;
+typedef ::LPSECURITY_ATTRIBUTES LPSECURITY_ATTRIBUTES_;
+    
+#else
+extern "C" { 
+    struct SECURITY_DESCRIPTOR_;
+    typedef SECURITY_DESCRIPTOR_* PSECURITY_DESCRIPTOR_;
+    typedef struct _ACL {
+      BYTE_ AclRevision;
+      BYTE_ Sbz1;
+      WORD_ AclSize;
+      WORD_ AceCount;
+      WORD_ Sbz2;
+    } ACL_, *PACL_;
+
+    typedef struct _SECURITY_ATTRIBUTES {
+      DWORD_  nLength;
+      LPVOID_ lpSecurityDescriptor;
+      BOOL_   bInheritHandle;
+    } SECURITY_ATTRIBUTES_, *PSECURITY_ATTRIBUTES_, *LPSECURITY_ATTRIBUTES_;
+
+    __declspec(dllimport) BOOL_ __stdcall 
+        InitializeSecurityDescriptor(
+            PSECURITY_DESCRIPTOR_ pSecurityDescriptor,
+            DWORD_ dwRevision
+    );
+    __declspec(dllimport) BOOL_ __stdcall 
+        SetSecurityDescriptorDacl(
+            PSECURITY_DESCRIPTOR_ pSecurityDescriptor,
+            BOOL_ bDaclPresent,
+            PACL_ pDacl,
+            BOOL_ bDaclDefaulted
+    );
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_SECURITY_HPP

include/boost/detail/win/synchronization.hpp

@@ -0,0 +1,125 @@
+//  synchronizaion.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP
+#define BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef ::CRITICAL_SECTION CRITICAL_SECTION_;
+    typedef ::PAPCFUNC PAPCFUNC_;
+
+    using ::InitializeCriticalSection;
+    using ::EnterCriticalSection;
+    using ::TryEnterCriticalSection;
+    using ::LeaveCriticalSection;
+    using ::DeleteCriticalSection;
+    
+# ifdef BOOST_NO_ANSI_APIS
+    using ::CreateMutexW;
+    using ::CreateEventW;
+    using ::OpenEventW;
+    using ::CreateSemaphoreW;
+# else
+    using ::CreateMutexA;
+    using ::CreateEventA;
+    using ::OpenEventA;
+    using ::CreateSemaphoreA;
+# endif
+    using ::ReleaseMutex;
+    using ::ReleaseSemaphore;
+    using ::SetEvent;
+    using ::ResetEvent;
+    using ::WaitForMultipleObjects;
+    using ::WaitForSingleObject;
+            using ::QueueUserAPC;
+#else
+extern "C" {
+    struct CRITICAL_SECTION_
+    {
+        struct critical_section_debug * DebugInfo;
+        long LockCount;
+        long RecursionCount;
+        void * OwningThread;
+        void * LockSemaphore;
+    #if defined(_WIN64)
+        unsigned __int64 SpinCount;
+    #else
+        unsigned long SpinCount;
+    #endif
+    };
+
+     __declspec(dllimport) void __stdcall 
+        InitializeCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) void __stdcall 
+        EnterCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) bool __stdcall 
+        TryEnterCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) void __stdcall 
+        LeaveCriticalSection(CRITICAL_SECTION_ *);
+    __declspec(dllimport) void __stdcall 
+        DeleteCriticalSection(CRITICAL_SECTION_ *);
+    
+    struct _SECURITY_ATTRIBUTES;
+# ifdef BOOST_NO_ANSI_APIS
+    __declspec(dllimport) void* __stdcall 
+        CreateMutexW(_SECURITY_ATTRIBUTES*,int,wchar_t const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateSemaphoreW(_SECURITY_ATTRIBUTES*,long,long,wchar_t const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateEventW(_SECURITY_ATTRIBUTES*,int,int,wchar_t const*);
+    __declspec(dllimport) void* __stdcall 
+        OpenEventW(unsigned long,int,wchar_t const*);
+# else
+    __declspec(dllimport) void* __stdcall 
+        CreateMutexA(_SECURITY_ATTRIBUTES*,int,char const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateSemaphoreA(_SECURITY_ATTRIBUTES*,long,long,char const*);
+    __declspec(dllimport) void* __stdcall 
+        CreateEventA(_SECURITY_ATTRIBUTES*,int,int,char const*);
+    __declspec(dllimport) void* __stdcall 
+        OpenEventA(unsigned long,int,char const*);
+# endif
+    __declspec(dllimport) int __stdcall 
+        ReleaseMutex(void*);
+    __declspec(dllimport) unsigned long __stdcall 
+        WaitForSingleObject(void*,unsigned long);
+    __declspec(dllimport) unsigned long __stdcall 
+        WaitForMultipleObjects(unsigned long nCount,
+                void* const * lpHandles,
+                int bWaitAll,
+                unsigned long dwMilliseconds);
+    __declspec(dllimport) int __stdcall 
+        ReleaseSemaphore(void*,long,long*);
+    typedef void (__stdcall *PAPCFUNC8)(ulong_ptr);
+    __declspec(dllimport) unsigned long __stdcall 
+        QueueUserAPC(PAPCFUNC8,void*,ulong_ptr);
+# ifndef UNDER_CE
+    __declspec(dllimport) int __stdcall 
+        SetEvent(void*);
+    __declspec(dllimport) int __stdcall 
+        ResetEvent(void*);
+# else
+    using ::SetEvent;
+    using ::ResetEvent;
+# endif
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_SYNCHRONIZATION_HPP

include/boost/detail/win/system.hpp

@@ -0,0 +1,50 @@
+//  system.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_SYSTEM_HPP
+#define BOOST_DETAIL_WIN_SYSTEM_HPP
+#include <boost/config.hpp>
+#include <cstdarg>
+
+#include <boost/detail/win/basic_types.hpp>
+extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *);
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef ::SYSTEM_INFO SYSTEM_INFO_;
+#else
+extern "C" {
+    typedef struct _SYSTEM_INFO {
+      union {
+        DWORD_  dwOemId;
+        struct {
+          WORD_ wProcessorArchitecture;
+          WORD_ wReserved;
+        } dummy;
+      } ;
+      DWORD_     dwPageSize;
+      LPVOID_    lpMinimumApplicationAddress;
+      LPVOID_    lpMaximumApplicationAddress;
+      DWORD_PTR_ dwActiveProcessorMask;
+      DWORD_     dwNumberOfProcessors;
+      DWORD_     dwProcessorType;
+      DWORD_     dwAllocationGranularity;
+      WORD_      wProcessorLevel;
+      WORD_      wProcessorRevision;
+    } SYSTEM_INFO_;
+
+    __declspec(dllimport) void __stdcall 
+        GetSystemInfo (struct system_info *);
+}    
+#endif
+}
+}
+}
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/thread.hpp

@@ -0,0 +1,45 @@
+//  thread.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_THREAD_HPP
+#define BOOST_DETAIL_WIN_THREAD_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+#include <boost/detail/win/GetCurrentThread.hpp>
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentThreadId;
+    using ::SleepEx;
+    using ::Sleep;
+#else
+extern "C" { 
+# ifndef UNDER_CE
+    __declspec(dllimport) unsigned long __stdcall 
+        GetCurrentThreadId(void);
+    __declspec(dllimport) unsigned long __stdcall 
+        SleepEx(unsigned long,int);
+    __declspec(dllimport) void __stdcall 
+        Sleep(unsigned long);
+#else
+    using ::GetCurrentThreadId;
+    using ::SleepEx;
+    using ::Sleep;
+#endif    
+}    
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_THREAD_HPP

include/boost/detail/win/time.hpp

@@ -0,0 +1,68 @@
+//  time.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_TIME_HPP
+#define BOOST_DETAIL_WIN_TIME_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost {
+namespace detail {
+namespace win32 {
+#if defined( BOOST_USE_WINDOWS_H )
+    typedef FILETIME FILETIME_;
+    typedef PFILETIME PFILETIME_;
+    typedef LPFILETIME LPFILETIME_;
+
+    typedef SYSTEMTIME SYSTEMTIME_;
+    typedef SYSTEMTIME* PSYSTEMTIME_;
+
+    using ::GetSystemTimeAsFileTime;
+    using ::FileTimeToLocalFileTime;
+    using ::GetSystemTime;
+    using ::SystemTimeToFileTime;
+    using ::GetTickCount;
+
+#else
+extern "C" {
+    typedef struct _FILETIME {
+        DWORD_ dwLowDateTime;
+        DWORD_ dwHighDateTime;
+    } FILETIME_, *PFILETIME_, *LPFILETIME_;
+
+    typedef struct _SYSTEMTIME {
+      WORD_ wYear;
+      WORD_ wMonth;
+      WORD_ wDayOfWeek;
+      WORD_ wDay;
+      WORD_ wHour;
+      WORD_ wMinute;
+      WORD_ wSecond;
+      WORD_ wMilliseconds;
+    } SYSTEMTIME_, *PSYSTEMTIME_;
+
+    __declspec(dllimport) void WINAPI
+        GetSystemTimeAsFileTime(FILETIME_* lpFileTime);
+    __declspec(dllimport) int WINAPI
+        FileTimeToLocalFileTime(const FILETIME_* lpFileTime, 
+                FILETIME_* lpLocalFileTime);
+    __declspec(dllimport) void WINAPI
+        GetSystemTime(SYSTEMTIME_* lpSystemTime);
+    __declspec(dllimport) int WINAPI
+        SystemTimeToFileTime(const SYSTEMTIME_* lpSystemTime, 
+                FILETIME_* lpFileTime);
+    __declspec(dllimport) unsigned long __stdcall 
+        GetTickCount();
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIME_HPP

include/boost/detail/win/timers.hpp

@@ -0,0 +1,41 @@
+//  timers.hpp  --------------------------------------------------------------//
+
+//  Copyright 2010 Vicente J. Botet Escriba
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WIN_TIMERS_HPP
+#define BOOST_DETAIL_WIN_TIMERS_HPP
+
+#include <boost/detail/win/basic_types.hpp>
+
+
+namespace boost
+{
+namespace detail
+{
+namespace win32
+{
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::QueryPerformanceCounter;
+    using ::QueryPerformanceFrequency;
+#else
+extern "C" { 
+    __declspec(dllimport) BOOL_ WINAPI
+        QueryPerformanceCounter(
+            LARGE_INTEGER_ *lpPerformanceCount
+        );
+
+    __declspec(dllimport) BOOL_ WINAPI
+        QueryPerformanceFrequency(
+            LARGE_INTEGER_ *lpFrequency
+        );
+}
+#endif
+}
+}
+}
+
+#endif // BOOST_DETAIL_WIN_TIMERS_HPP

test/Jamfile

@@ -0,0 +1,21 @@
+################################################################*# Jam #*#######
+#   Copyright (C) 2010 Bryce Lelbach
+#
+#   Distributed under the Boost Software License, Version 1.0. (See accompanying
+#   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+################################################################################
+
+project detail/test 
+  : requirements
+    <toolset>clang:<cxxflags>-Wno-unused
+    <toolset>clang:<cxxflags>-Wno-tautological-compare
+    <toolset>clang:<cxxflags>-ftemplate-depth-300
+    <toolset>gcc:<cxxflags>-ftemplate-depth-300
+    <toolset>darwin:<cxxflags>-ftemplate-depth-300
+  ;
+
+for tests in [ glob *.cpp ] {
+  run $(tests) : : : : $(tests:B) ;
+}
+
+

test/container_fwd_test.cpp

@@ -0,0 +1,112 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/functional/detail/container_fwd.hpp>
+
+#if BOOST_WORKAROUND(__GNUC__, < 3) && \
+    !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+template <class charT, class Allocator>
+static void test(
+    std::basic_string<charT, std::string_char_traits<charT>, Allocator> const&)
+{
+}
+#else
+template <class charT, class Allocator>
+static void test(
+    std::basic_string<charT, std::char_traits<charT>, Allocator> const&)
+{
+}
+#endif
+    
+template <class T, class Allocator>
+static void test(std::deque<T, Allocator> const&)
+{
+}
+
+template <class T, class Allocator>
+static void test(std::list<T, Allocator> const&)
+{
+}
+
+template <class T, class Allocator>
+static void test(std::vector<T, Allocator> const&)
+{
+}
+
+template <class Key, class T, class Compare, class Allocator>
+static void test(std::map<Key, T, Compare, Allocator> const&)
+{
+}
+
+template <class Key, class T, class Compare, class Allocator>
+static void test(std::multimap<Key, T, Compare, Allocator> const&)
+{
+}
+
+template <class Key, class Compare, class Allocator>
+static void test(std::set<Key, Compare, Allocator> const&)
+{
+}
+
+template <class Key, class Compare, class Allocator>
+static void test(std::multiset<Key, Compare, Allocator> const&)
+{
+}
+
+template <std::size_t N>
+static void test(std::bitset<N> const&)
+{
+}
+
+template <class T>
+static void test(std::complex<T> const&)
+{
+}
+
+template <class X, class Y>
+static void test(std::pair<X, Y> const&)
+{
+}
+
+#include <deque>
+#include <list>
+#include <vector>
+#include <map>
+#include <set>
+#include <bitset>
+#include <string>
+#include <complex>
+#include <utility>
+
+int main()
+{
+    std::deque<int> x1;
+    std::list<std::string> x2;
+    std::vector<float> x3;
+    std::vector<bool> x4;
+    std::map<int, int> x5;
+    std::multimap<float, int*> x6;
+    std::set<std::string> x7;
+    std::multiset<std::vector<int> > x8;
+    std::bitset<10> x9;
+    std::string x10;
+    std::complex<double> x11;
+    std::pair<std::list<int>, char***> x12;
+
+    test(x1);
+    test(x2);
+    test(x3);
+    test(x4);
+    test(x5);
+    test(x6);
+    test(x7);
+    test(x8);
+    test(x9);
+    test(x10);
+    test(x11);
+    test(x12);
+
+    return 0;
+}

test/container_no_fwd_test.cpp

@@ -0,0 +1,14 @@
+
+// Copyright 2010 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_DETAIL_NO_CONTAINER_FWD
+
+#include <boost/detail/container_fwd.hpp>
+
+int main()
+{
+    std::set<int> x;
+    std::vector<std::string> y;
+}

test/is_sorted_test.cpp

@@ -0,0 +1,130 @@
+/*==============================================================================
+    Copyright (c) 2010-2011 Bryce Lelbach
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <ios>
+#include <boost/config.hpp>
+#include <boost/array.hpp>
+#include <boost/detail/is_sorted.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+template<class T>
+struct tracking_less: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_less (void) { }
+  ~tracking_less (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " < " << y << " == " << (x < y) << "\n"; 
+    return x < y;
+  }
+};
+
+template<class T>
+struct tracking_less_equal: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_less_equal (void) { }
+  ~tracking_less_equal (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " <= " << y << " == " << (x <= y) << "\n"; 
+    return x <= y;
+  }
+};
+
+template<class T>
+struct tracking_greater: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_greater (void) { }
+  ~tracking_greater (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " > " << y << " == " << (x > y) << "\n"; 
+    return x > y;
+  }
+};
+
+template<class T>
+struct tracking_greater_equal: std::binary_function <T, T, bool> {
+  typedef bool result_type;
+
+  #if defined(__PATHSCALE__)
+  tracking_greater_equal (void) { }
+  ~tracking_greater_equal (void) { }
+  #endif
+
+  bool operator() (T const& x, T const& y) const {
+    std::cout << x << " >= " << y << " == " << (x >= y) << "\n"; 
+    return x >= y;
+  }
+};
+
+
+int main (void) {
+  #define IS_SORTED ::boost::detail::is_sorted
+  #define IS_SORTED_UNTIL ::boost::detail::is_sorted_until
+  using boost::array;
+  using boost::report_errors;
+
+  std::cout << std::boolalpha;
+
+  array<int, 10> a = { { 0, 1, 2,  3,  4, 5, 6,  7,  8,   9  } };
+  array<int, 10> b = { { 0, 1, 1,  2,  5, 8, 13, 34, 55,  89 } };
+  array<int, 10> c = { { 0, 1, -1, 2, -3, 5, -8, 13, -21, 34 } };
+
+  tracking_less<int> lt;
+  tracking_less_equal<int> lte;
+  tracking_greater<int> gt;
+  tracking_greater_equal<int> gte;
+
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end()),          a.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lt),      a.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(a.begin(), a.end(), lte),     a.end());
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(a.rbegin(), a.rend(), gt),   *a.rend());
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(a.rbegin(), a.rend(), gte),  *a.rend());
+  
+  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end()),        true);
+  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lt),    true);
+  BOOST_TEST_EQ(IS_SORTED(a.begin(), a.end(), lte),   true);
+  BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gt),  true);
+  BOOST_TEST_EQ(IS_SORTED(a.rbegin(), a.rend(), gte), true);
+
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end()),          b.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lt),      b.end());
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(b.begin(), b.end(), lte),     &b[2]);
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(b.rbegin(), b.rend(), gt),   *b.rend());
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(b.rbegin(), b.rend(), gte),  b[2]);
+  
+  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end()),        true); 
+  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lt),    true); 
+  BOOST_TEST_EQ(IS_SORTED(b.begin(), b.end(), lte),   false); 
+  BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gt),  true);
+  BOOST_TEST_EQ(IS_SORTED(b.rbegin(), b.rend(), gte), false); 
+
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end()),          &c[2]);
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lt),      &c[2]);
+  BOOST_TEST_EQ(IS_SORTED_UNTIL(c.begin(), c.end(), lte),     &c[2]);
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(c.rbegin(), c.rend(), gt),   c[7]);
+  BOOST_TEST_EQ(*IS_SORTED_UNTIL(c.rbegin(), c.rend(), gte),  c[7]);
+  
+  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end()),        false);
+  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lt),    false);
+  BOOST_TEST_EQ(IS_SORTED(c.begin(), c.end(), lte),   false);
+  BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gt),  false);
+  BOOST_TEST_EQ(IS_SORTED(c.rbegin(), c.rend(), gte), false);
+
+  return report_errors();
+}
+