Quickbook: Merge from trunk.

Includes blocks in lists fixes, and some documentation changes.


[SVN r77347]

include/boost/blank.hpp

@@ -15,9 +15,11 @@
 
 #include "boost/blank_fwd.hpp"
 
+#if !defined(BOOST_NO_IOSTREAM)
 #include <iosfwd> // for std::basic_ostream forward declare
-
 #include "boost/detail/templated_streams.hpp"
+#endif // BOOST_NO_IOSTREAM
+
 #include "boost/mpl/bool.hpp"
 #include "boost/type_traits/is_empty.hpp"
 #include "boost/type_traits/is_pod.hpp"
@@ -85,6 +87,8 @@ inline bool operator>(const blank&, const blank&)
 
 // streaming support
 //
+#if !defined(BOOST_NO_IOSTREAM)
+
 BOOST_TEMPLATED_STREAM_TEMPLATE(E,T)
 inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
       BOOST_TEMPLATED_STREAM(ostream, E,T)& out
@@ -95,6 +99,8 @@ inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
     return out;
 }
 
+#endif // BOOST_NO_IOSTREAM
+
 } // namespace boost
 
 #endif // BOOST_BLANK_HPP

include/boost/detail/allocator_utilities.hpp

@@ -1,4 +1,4 @@
-/* Copyright 2003-2007 Joaqu<EFBFBD>n M L<EFBFBD>pez Mu<EFBFBD>oz.
+/* Copyright 2003-2009 Joaquin M Lopez Munoz.
  * 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)
@@ -178,12 +178,31 @@ void construct(void* p,const Type& t)
   new (p) Type(t);
 }
 
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
+/* MSVC++ issues spurious warnings about unreferencend formal parameters
+ * in destroy<Type> when Type is a class with trivial dtor.
+ */
+
+#pragma warning(push)
+#pragma warning(disable:4100)  
+#endif
+
 template<typename Type>
 void destroy(const Type* p)
 {
+
+#if BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590))
+  const_cast<Type*>(p)->~Type();
+#else
   p->~Type();
+#endif
+
 }
 
+#if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
+#pragma warning(pop)
+#endif
+
 } /* namespace boost::detail::allocator */
 
 } /* namespace boost::detail */

include/boost/detail/bitmask.hpp

@@ -0,0 +1,47 @@
+//  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/container_fwd.hpp

@@ -0,0 +1,162 @@
+
+// Copyright 2005-2011 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)
+
+// Note: if you change this include guard, you also need to change
+// container_fwd_compile_fail.cpp
+#if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP)
+#define BOOST_DETAIL_CONTAINER_FWD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020) && \
+    !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to      //
+// forward declare standard containers.                                       //
+//                                                                            //
+// BOOST_DETAIL_CONTAINER_FWD to make it foward declare containers even if it //
+// normally doesn't.                                                          //
+//                                                                            //
+// BOOST_DETAIL_NO_CONTAINER_FWD overrides BOOST_DETAIL_CONTAINER_FWD.        //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
+#  if defined(BOOST_DETAIL_CONTAINER_FWD)
+     // Force forward declarations.
+#  elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+     // STLport
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__LIBCOMO__)
+     // Comeau STL:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+     // Rogue Wave library:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(_LIBCPP_VERSION)
+     // libc++
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+     // GNU libstdc++ 3
+     //
+     // Disable forwarding for all recent versions, as the library has a
+     // versioned namespace mode, and I don't know how to detect it.
+#    if __GLIBCXX__ >= 20070513 \
+        || defined(_GLIBCXX_DEBUG) \
+        || defined(_GLIBCXX_PARALLEL) \
+        || defined(_GLIBCXX_PROFILE)
+#      define BOOST_DETAIL_NO_CONTAINER_FWD
+#    else
+#      if defined(__GLIBCXX__) && __GLIBCXX__ >= 20040530
+#        define BOOST_CONTAINER_FWD_COMPLEX_STRUCT
+#      endif
+#    endif
+#  elif defined(__STL_CONFIG_H)
+     // generic SGI STL
+     //
+     // Forward declaration seems to be okay, but it has a couple of odd
+     // implementations.
+#    define BOOST_CONTAINER_FWD_BAD_BITSET
+#    if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
+#      define BOOST_CONTAINER_FWD_BAD_DEQUE
+#     endif
+#  elif defined(__MSL_CPP__)
+     // MSL standard lib:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__IBMCPP__)
+     // The default VACPP std lib, forward declaration seems to be fine.
+#  elif defined(MSIPL_COMPILE_H)
+     // Modena C++ standard library
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+     // Dinkumware Library (this has to appear after any possible replacement
+     // libraries)
+#  else
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  endif
+#endif
+
+#if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+
+#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \
+    !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+
+#include <deque>
+#include <list>
+#include <vector>
+#include <map>
+#include <set>
+#include <bitset>
+#include <string>
+#include <complex>
+
+#else
+
+#include <cstddef>
+
+#if defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
+#include <deque>
+#endif
+
+#if defined(BOOST_CONTAINER_FWD_BAD_BITSET)
+#include <bitset>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4099) // struct/class mismatch in fwd declarations
+#endif
+
+namespace std
+{
+    template <class T> class allocator;
+    template <class charT, class traits, class Allocator> class basic_string;
+
+#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+
+    template <class charT> struct string_char_traits;
+#else
+    template <class charT> struct char_traits;
+#endif
+
+#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT)
+    template <class T> struct complex;
+#else
+    template <class T> class complex;
+#endif
+
+#if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
+    template <class T, class Allocator> class deque;
+#endif
+
+    template <class T, class Allocator> class list;
+    template <class T, class Allocator> class vector;
+    template <class Key, class T, class Compare, class Allocator> class map;
+    template <class Key, class T, class Compare, class Allocator>
+    class multimap;
+    template <class Key, class Compare, class Allocator> class set;
+    template <class Key, class Compare, class Allocator> class multiset;
+
+#if !defined(BOOST_CONTAINER_FWD_BAD_BITSET)
+    template <size_t N> class bitset;
+#endif
+    template <class T1, class T2> struct pair;
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_DETAIL_NO_CONTAINER_FWD &&
+       // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+
+#endif // BOOST_DETAIL_TEST_CONFIG_ONLY
+
+#endif

include/boost/detail/endian.hpp

@@ -1,5 +1,6 @@
 // Copyright 2005 Caleb Epstein
 // Copyright 2006 John Maddock
+// Copyright 2010 Rene Rivera
 // Distributed under the Boost Software License, Version 1.0. (See accompany-
 // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -42,15 +43,19 @@
 #  error Unknown machine endianness detected.
 # endif
 # define BOOST_BYTE_ORDER __BYTE_ORDER
-#elif defined(_BIG_ENDIAN)
+#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN) || \
+    defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) || \
+    defined(_STLP_BIG_ENDIAN) && !defined(_STLP_LITTLE_ENDIAN)
 # define BOOST_BIG_ENDIAN
 # define BOOST_BYTE_ORDER 4321
-#elif defined(_LITTLE_ENDIAN)
+#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN) || \
+    defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) || \
+    defined(_STLP_LITTLE_ENDIAN) && !defined(_STLP_BIG_ENDIAN)
 # define BOOST_LITTLE_ENDIAN
 # define BOOST_BYTE_ORDER 1234
 #elif defined(__sparc) || defined(__sparc__) \
    || defined(_POWER) || defined(__powerpc__) \
-   || defined(__ppc__) || defined(__hpux) \
+   || defined(__ppc__) || defined(__hpux) || defined(__hppa) \
    || defined(_MIPSEB) || defined(_POWER) \
    || defined(__s390__)
 # define BOOST_BIG_ENDIAN
@@ -61,7 +66,7 @@
    || defined(_M_ALPHA) || defined(__amd64) \
    || defined(__amd64__) || defined(_M_AMD64) \
    || defined(__x86_64) || defined(__x86_64__) \
-   || defined(_M_X64)
+   || defined(_M_X64) || defined(__bfin__)
 
 # define BOOST_LITTLE_ENDIAN
 # define BOOST_BYTE_ORDER 1234

include/boost/detail/fenv.hpp

@@ -0,0 +1,74 @@
+/*=============================================================================
+    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)
+=============================================================================*/
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_FENV_H)
+  #error This platform does not have a floating point environment
+#endif
+
+#if !defined(BOOST_DETAIL_FENV_HPP)
+#define BOOST_DETAIL_FENV_HPP
+
+/* If we're using clang + glibc, we have to get hacky. 
+ * See http://llvm.org/bugs/show_bug.cgi?id=6907 */
+#if defined(__clang__)       &&  (__clang_major__ < 3) &&    \
+    defined(__GNU_LIBRARY__) && /* up to version 5 */ \
+    defined(__GLIBC__) &&         /* version 6 + */ \
+    !defined(_FENV_H)
+  #define _FENV_H
+
+  #include <features.h>
+  #include <bits/fenv.h>
+
+  extern "C" {
+    extern int fegetexceptflag (fexcept_t*, int) __THROW;
+    extern int fesetexceptflag (__const fexcept_t*, int) __THROW;
+    extern int feclearexcept (int) __THROW;
+    extern int feraiseexcept (int) __THROW;
+    extern int fetestexcept (int) __THROW;
+    extern int fegetround (void) __THROW;
+    extern int fesetround (int) __THROW;
+    extern int fegetenv (fenv_t*) __THROW;
+    extern int fesetenv (__const fenv_t*) __THROW;
+    extern int feupdateenv (__const fenv_t*) __THROW;
+    extern int feholdexcept (fenv_t*) __THROW;
+
+    #ifdef __USE_GNU
+      extern int feenableexcept (int) __THROW;
+      extern int fedisableexcept (int) __THROW;
+      extern int fegetexcept (void) __THROW;
+    #endif
+  }
+
+  namespace std { namespace tr1 {
+    using ::fenv_t;
+    using ::fexcept_t;
+    using ::fegetexceptflag;
+    using ::fesetexceptflag;
+    using ::feclearexcept;
+    using ::feraiseexcept;
+    using ::fetestexcept;
+    using ::fegetround;
+    using ::fesetround;
+    using ::fegetenv;
+    using ::fesetenv;
+    using ::feupdateenv;
+    using ::feholdexcept;
+  } }
+
+#else /* if we're not using GNU's C stdlib, fenv.h should work with clang */
+  #if defined(__SUNPRO_CC) /* lol suncc */
+    #include <stdio.h>
+  #endif
+  
+  #include <fenv.h>
+
+#endif
+
+#endif /* BOOST_DETAIL_FENV_HPP */
+ 

include/boost/detail/interlocked.hpp

@@ -54,11 +54,27 @@ extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
 
 #elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
 
+#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600
+
+#include <intrin.h>
+
+#elif defined( __CLRCALL_PURE_OR_CDECL )
+
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedIncrement( long volatile * );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedDecrement( long volatile * );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( long volatile *, long, long );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchange( long volatile *, long );
+extern "C" long __CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( long volatile *, long );
+
+#else
+
 extern "C" long __cdecl _InterlockedIncrement( long volatile * );
 extern "C" long __cdecl _InterlockedDecrement( long volatile * );
 extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
-extern "C" long __cdecl _InterlockedExchange( long volatile *, long);
+extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
-extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long);
+extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
+
+#endif
 
 # pragma intrinsic( _InterlockedIncrement )
 # pragma intrinsic( _InterlockedDecrement )
@@ -92,7 +108,14 @@ extern "C" void* __cdecl _InterlockedExchangePointer( void* volatile *, void* );
 # define BOOST_INTERLOCKED_EXCHANGE _InterlockedExchange
 # define BOOST_INTERLOCKED_EXCHANGE_ADD _InterlockedExchangeAdd
 
-#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
+#elif defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ ) || defined( __CYGWIN__ )
+
+#if defined(__MINGW64__)
+#define BOOST_INTERLOCKED_IMPORT
+#else
+#define BOOST_INTERLOCKED_IMPORT __declspec(dllimport)
+#endif
+
 
 namespace boost
 {
@@ -100,11 +123,16 @@ namespace boost
 namespace detail
 {
 
-extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement( long volatile * );
+extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedIncrement( long volatile * );
-extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volatile * );
+extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedDecrement( long volatile * );
-extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long );
+extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange( long volatile *, long, long );
-extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long );
+extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchange( long volatile *, long );
-extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long );
+extern "C" BOOST_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd( long volatile *, long );
+
+# if defined(_M_IA64) || defined(_M_AMD64)
+extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer( void* volatile *, void*, void* );
+extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile *, void* );
+# endif
 
 } // namespace detail
 
@@ -116,10 +144,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_incrementable.hpp

@@ -62,13 +62,18 @@ namespace is_incrementable_
   // In case an operator++ is found that returns void, we'll use ++x,0
   tag operator,(tag,int);  
 #  define BOOST_comma(a,b) (a,b)
+# endif 
+
+# if defined(BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning(disable:4913) // Warning about operator,
 # endif 
 
   // two check overloads help us identify which operator++ was picked
-  char (& check(tag) )[2];
+  char (& check_(tag) )[2];
   
   template <class T>
-  char check(T const&);
+  char check_(T const&);
   
 
   template <class T>
@@ -78,7 +83,7 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1
+        , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1
       );
   };
 
@@ -89,9 +94,14 @@ namespace is_incrementable_
 
       BOOST_STATIC_CONSTANT(
           bool
-        , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
+        , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1
       );
   };
+
+# if defined(BOOST_MSVC)
+#  pragma warning(pop)
+# endif 
+
 }
 
 # undef BOOST_comma

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_main.hpp

@@ -0,0 +1,36 @@
+//  boost/detail/lightweight_main.hpp  -------------------------------------------------//
+
+//  Copyright Beman Dawes 2010
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#include <iostream>
+#include <exception>
+
+//--------------------------------------------------------------------------------------//
+//                                                                                      //
+//                exception reporting main() that calls cpp_main()                      //
+//                                                                                      //
+//--------------------------------------------------------------------------------------//
+
+int cpp_main(int argc, char* argv[]);
+
+int main(int argc, char* argv[])
+{
+  try
+  {
+    return cpp_main(argc, argv);
+  }
+
+  catch (const std::exception& ex)
+  {
+    std::cout
+    << "\nERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR  ERROR\n"
+    << "\n****************************** std::exception *****************************\n"
+    << ex.what()
+    << "\n***************************************************************************\n"
+    << std::endl;
+  }
+  return 1;
+}

include/boost/detail/lightweight_test.hpp

@@ -10,20 +10,29 @@
 //
 //  boost/detail/lightweight_test.hpp - lightweight test library
 //
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002, 2009 Peter Dimov
+//  Copyright (2) Beman Dawes 2010, 2011
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+//  Distributed under the Boost Software License, Version 1.0.
-// accompanying file LICENSE_1_0.txt or copy at
+//  See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  http://www.boost.org/LICENSE_1_0.txt
 //
 //  BOOST_TEST(expression)
 //  BOOST_ERROR(message)
+//  BOOST_TEST_EQ(expr1, expr2)
 //
 //  int boost::report_errors()
 //
 
-#include <boost/current_function.hpp>
 #include <iostream>
+#include <boost/current_function.hpp>
+#include <boost/assert.hpp>
+
+//  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
 {
@@ -31,38 +40,95 @@ namespace boost
 namespace detail
 {
 
+struct report_errors_reminder
+{
+  bool called_report_errors_function;
+  report_errors_reminder() : called_report_errors_function(false) {}
+ ~report_errors_reminder()
+  {
+    BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
+  }
+};
+
+inline report_errors_reminder& report_errors_remind()
+{
+  static report_errors_reminder r;
+  return r;
+}
+
 inline int & test_errors()
 {
     static int x = 0;
+    report_errors_remind();
     return x;
 }
 
 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 )
+{
+    if( t == u )
+    {
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' != '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_ne_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
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " != " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' == '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
 } // namespace detail
 
 inline int report_errors()
 {
+    detail::report_errors_remind().called_report_errors_function = true;
+
     int errors = detail::test_errors();
 
-    if(errors == 0)
+    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;
     }
 }
@@ -71,5 +137,7 @@ inline int report_errors()
 
 #define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
 #define BOOST_ERROR(msg) ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)
+#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
 
 #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED

include/boost/detail/lightweight_thread.hpp

@@ -0,0 +1,135 @@
+#ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
+#define BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  boost/detail/lightweight_thread.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2008 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <memory>
+#include <cerrno>
+
+// pthread_create, pthread_join
+
+#if defined( BOOST_HAS_PTHREADS )
+
+#include <pthread.h>
+
+#else
+
+#include <windows.h>
+#include <process.h>
+
+typedef HANDLE pthread_t;
+
+int pthread_create( pthread_t * thread, void const *, unsigned (__stdcall * start_routine) (void*), void* arg )
+{
+    HANDLE h = (HANDLE)_beginthreadex( 0, 0, start_routine, arg, 0, 0 );
+
+    if( h != 0 )
+    {
+        *thread = h;
+        return 0;
+    }
+    else
+    {
+        return EAGAIN;
+    }
+}
+
+int pthread_join( pthread_t thread, void ** /*value_ptr*/ )
+{
+    ::WaitForSingleObject( thread, INFINITE );
+    ::CloseHandle( thread );
+    return 0;
+}
+
+#endif
+
+// template<class F> int lw_thread_create( pthread_t & pt, F f );
+
+namespace boost
+{
+
+namespace detail
+{
+
+class lw_abstract_thread
+{
+public:
+
+    virtual ~lw_abstract_thread() {}
+    virtual void run() = 0;
+};
+
+#if defined( BOOST_HAS_PTHREADS )
+
+extern "C" void * lw_thread_routine( void * pv )
+{
+    std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) );
+
+    pt->run();
+
+    return 0;
+}
+
+#else
+
+unsigned __stdcall lw_thread_routine( void * pv )
+{
+    std::auto_ptr<lw_abstract_thread> pt( static_cast<lw_abstract_thread *>( pv ) );
+
+    pt->run();
+
+    return 0;
+}
+
+#endif
+
+template<class F> class lw_thread_impl: public lw_abstract_thread
+{
+public:
+
+    explicit lw_thread_impl( F f ): f_( f )
+    {
+    }
+
+    void run()
+    {
+        f_();
+    }
+
+private:
+
+    F f_;
+};
+
+template<class F> int lw_thread_create( pthread_t & pt, F f )
+{
+    std::auto_ptr<lw_abstract_thread> p( new lw_thread_impl<F>( f ) );
+
+    int r = pthread_create( &pt, 0, lw_thread_routine, p.get() );
+
+    if( r == 0 )
+    {
+        p.release();
+    }
+
+    return r;
+}
+
+} // namespace detail
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED

include/boost/detail/quick_allocator.hpp

@@ -13,186 +13,11 @@
 //  Copyright (c) 2003 David Abrahams
 //  Copyright (c) 2003 Peter Dimov
 //
-// Distributed under the Boost Software License, Version 1.0. (See
+//  Distributed under the Boost Software License, Version 1.0.
-// accompanying file LICENSE_1_0.txt or copy at
+//  See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/config.hpp>
+#include <boost/smart_ptr/detail/quick_allocator.hpp>
-
-#include <boost/detail/lightweight_mutex.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-#include <new>              // ::operator new, ::operator delete
-#include <cstddef>          // std::size_t
-
-namespace boost
-{
-
-namespace detail
-{
-
-template<unsigned size, unsigned align_> union freeblock
-{
-    typedef typename boost::type_with_alignment<align_>::type aligner_type;
-    aligner_type aligner;
-    char bytes[size];
-    freeblock * next;
-};
-
-template<unsigned size, unsigned align_> struct allocator_impl
-{
-    typedef freeblock<size, align_> block;
-
-    // It may seem odd to use such small pages.
-    //
-    // However, on a typical Windows implementation that uses
-    // the OS allocator, "normal size" pages interact with the
-    // "ordinary" operator new, slowing it down dramatically.
-    //
-    // 512 byte pages are handled by the small object allocator,
-    // and don't interfere with ::new.
-    //
-    // The other alternative is to use much bigger pages (1M.)
-    //
-    // It is surprisingly easy to hit pathological behavior by
-    // varying the page size. g++ 2.96 on Red Hat Linux 7.2,
-    // for example, passionately dislikes 496. 512 seems OK.
-
-#if defined(BOOST_QA_PAGE_SIZE)
-
-    enum { items_per_page = BOOST_QA_PAGE_SIZE / size };
-
-#else
-
-    enum { items_per_page = 512 / size }; // 1048560 / size
-
-#endif
-
-#ifdef BOOST_HAS_THREADS
-
-    static lightweight_mutex & mutex()
-    {
-        static lightweight_mutex m;
-        return m;
-    }
-
-    static lightweight_mutex * mutex_init;
-
-#endif
-
-    static block * free;
-    static block * page;
-    static unsigned last;
-
-    static inline void * alloc()
-    {
-#ifdef BOOST_HAS_THREADS
-        lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-        if(block * x = free)
-        {
-            free = x->next;
-            return x;
-        }
-        else
-        {
-            if(last == items_per_page)
-            {
-                // "Listen to me carefully: there is no memory leak"
-                // -- Scott Meyers, Eff C++ 2nd Ed Item 10
-                page = ::new block[items_per_page];
-                last = 0;
-            }
-
-            return &page[last++];
-        }
-    }
-
-    static inline void * alloc(std::size_t n)
-    {
-        if(n != size) // class-specific new called for a derived object
-        {
-            return ::operator new(n);
-        }
-        else
-        {
-#ifdef BOOST_HAS_THREADS
-            lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-            if(block * x = free)
-            {
-                free = x->next;
-                return x;
-            }
-            else
-            {
-                if(last == items_per_page)
-                {
-                    page = ::new block[items_per_page];
-                    last = 0;
-                }
-
-                return &page[last++];
-            }
-        }
-    }
-
-    static inline void dealloc(void * pv)
-    {
-        if(pv != 0) // 18.4.1.1/13
-        {
-#ifdef BOOST_HAS_THREADS
-            lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-            block * pb = static_cast<block *>(pv);
-            pb->next = free;
-            free = pb;
-        }
-    }
-
-    static inline void dealloc(void * pv, std::size_t n)
-    {
-        if(n != size) // class-specific delete called for a derived object
-        {
-            ::operator delete(pv);
-        }
-        else if(pv != 0) // 18.4.1.1/13
-        {
-#ifdef BOOST_HAS_THREADS
-            lightweight_mutex::scoped_lock lock( mutex() );
-#endif
-            block * pb = static_cast<block *>(pv);
-            pb->next = free;
-            free = pb;
-        }
-    }
-};
-
-#ifdef BOOST_HAS_THREADS
-
-template<unsigned size, unsigned align_>
-  lightweight_mutex * allocator_impl<size, align_>::mutex_init = &allocator_impl<size, align_>::mutex();
-
-#endif
-
-template<unsigned size, unsigned align_>
-  freeblock<size, align_> * allocator_impl<size, align_>::free = 0;
-
-template<unsigned size, unsigned align_>
-  freeblock<size, align_> * allocator_impl<size, align_>::page = 0;
-
-template<unsigned size, unsigned align_>
-  unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page;
-
-template<class T>
-struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value >
-{
-};
-
-} // namespace detail
-
-} // namespace boost
 
 #endif  // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED

include/boost/detail/scoped_enum_emulation.hpp

@@ -0,0 +1,56 @@
+//  scoped_enum_emulation.hpp  ---------------------------------------------------------//
+
+//  Copyright Beman Dawes, 2009
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Generates C++0x scoped enums if the feature is present, otherwise emulates C++0x
+//  scoped enums with C++03 namespaces and enums. The Boost.Config BOOST_NO_SCOPED_ENUMS
+//  macro is used to detect feature support.
+//
+//  See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf for a
+//  description of the scoped enum feature. Note that the committee changed the name
+//  from strongly typed enum to scoped enum.  
+//
+//  Caution: only the syntax is emulated; the semantics are not emulated and
+//  the syntax emulation doesn't include being able to specify the underlying
+//  representation type.
+//
+//  The emulation is via struct rather than namespace to allow use within classes.
+//  Thanks to Andrey Semashev for pointing that out.
+//
+//  Helpful comments and suggestions were also made by Kjell Elster, Phil Endecott,
+//  Joel Falcou, Mathias Gaunard, Felipe Magno de Almeida, Matt Calabrese, Vincente
+//  Botet, and Daniel James. 
+//
+//  Sample usage:
+//
+//     BOOST_SCOPED_ENUM_START(algae) { green, red, cyan }; BOOST_SCOPED_ENUM_END
+//     ...
+//     BOOST_SCOPED_ENUM(algae) sample( algae::red );
+//     void foo( BOOST_SCOPED_ENUM(algae) color );
+//     ...
+//     sample = algae::green;
+//     foo( algae::cyan );
+
+#ifndef BOOST_SCOPED_ENUM_EMULATION_HPP
+#define BOOST_SCOPED_ENUM_EMULATION_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_SCOPED_ENUMS
+
+# define BOOST_SCOPED_ENUM_START(name) struct name { enum enum_type
+# define BOOST_SCOPED_ENUM_END };
+# define BOOST_SCOPED_ENUM(name) name::enum_type
+
+#else
+
+# define BOOST_SCOPED_ENUM_START(name) enum class name
+# define BOOST_SCOPED_ENUM_END
+# define BOOST_SCOPED_ENUM(name) name
+
+#endif
+
+#endif  // BOOST_SCOPED_ENUM_EMULATION_HPP

include/boost/detail/utf8_codecvt_facet.hpp

@@ -1,4 +1,4 @@
-// Copyright <EFBFBD> 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
 // Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
 // Distributed under the Boost Software License, Version 1.0. (See accompany-
 // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -79,27 +79,21 @@
 // specialized on those types for this to work.
 
 #include <locale>
-// for mbstate_t
+#include <cwchar>   // for mbstate_t
-#include <wchar.h>
+#include <cstddef>  // for std::size_t
-// for std::size_t
-#include <cstddef>
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
+#if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std {
-    #if defined(__LIBCOMO__)
+    using ::mbstate_t;
-        using ::mbstate_t;
+    using ::size_t;
-    #elif defined(BOOST_DINKUMWARE_STDLIB) && !defined(__BORLANDC__)
+}
-        using ::mbstate_t;
+#endif
-    #elif defined(__SGI_STL_PORT)
-    #elif defined(BOOST_NO_STDC_NAMESPACE)
-        using ::mbstate_t;
-        using ::codecvt;
-    #endif
-} // namespace std
 
-#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__)
+#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__) \
+    && !defined(_LIBCPP_VERSION)
     #define BOOST_CODECVT_DO_LENGTH_CONST const
 #else
     #define BOOST_CODECVT_DO_LENGTH_CONST

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,34 @@
+//  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( UNDER_CE )
+// Windows CE define GetCurrentThread as an inline function in kfuncs.h
+inline HANDLE_ GetCurrentThread() 
+{
+	return ::GetCurrentThread();
+}
+#else
+#if defined( BOOST_USE_WINDOWS_H )
+    using ::GetCurrentThread;
+#else
+    extern "C" __declspec(dllimport) HANDLE_ WINAPI GetCurrentThread();
+#endif
+#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,35 @@
+//  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(UNDER_CE)	// Windows CE does not define GetProcessTimes
+#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
+}
+}
+}
+
+#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,72 @@
+//  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_;
+
+	#ifndef UNDER_CE	// Windows CE does not define GetSystemTimeAsFileTime
+    using ::GetSystemTimeAsFileTime;
+	#endif
+    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_;
+
+	#ifndef UNDER_CE	// Windows CE does not define GetSystemTimeAsFileTime
+    __declspec(dllimport) void WINAPI
+        GetSystemTimeAsFileTime(FILETIME_* lpFileTime);
+	#endif
+    __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

include/boost/pending/ct_if.hpp

@@ -1,43 +0,0 @@
-// (C) Copyright Jeremy Siek 2000.
-// 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)
-
-// This header replaces the implementation of ct_if that preceded the
-// introduction of Boost.MPL with a facade that defers to that reviewed and
-// accepted library.
-
-// Author: Ronald Garcia
-// Date: 20 October, 2006
-
-
-#ifndef BOOST_CT_IF_HPP
-#define BOOST_CT_IF_HPP
-
-
-// A stub implementation in terms of Boost.MPL
-
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/and.hpp>
-// true_type and false_type are used by applications of ct_if
-#include <boost/type_traits/integral_constant.hpp> 
-
-namespace boost {
-
-  template <class A, class B>
-  struct ct_and : boost::mpl::and_<A,B> {};
-
-  template <class A>
-  struct ct_not : mpl::not_<A> {};
-
-  template <bool cond, class A, class B>
-  struct ct_if : mpl::if_c<cond,A,B> {};
-
-  template <class cond, class A, class B>
-  struct ct_if_t : mpl::if_<cond,A,B> {};
-
-} // namespace boost
-
-#endif // BOOST_CT_IF_HPP
-

include/boost/pending/integer_log2.hpp

@@ -1,20 +1,16 @@
-// -------------------------------------
+// -----------------------------------------------------------
 // integer_log2.hpp
 //
 //   Gives the integer part of the logarithm, in base 2, of a
 // given number. Behavior is undefined if the argument is <= 0.
 //
-//
+//         Copyright (c) 2003-2004, 2008 Gennaro Prota
-//       (C) Copyright Gennaro Prota 2003 - 2004.
 //
 // 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)
 //
-// ------------------------------------------------------
+// -----------------------------------------------------------
-//
-// $Id$
-
 
 #ifndef BOOST_INTEGER_LOG2_HPP_GP_20030301
 #define BOOST_INTEGER_LOG2_HPP_GP_20030301
@@ -37,7 +33,7 @@ namespace boost {
 
       while (x != 1) {
 
-          const T t = x >> n;
+          const T t = static_cast<T>(x >> n);
           if (t) {
               result += n;
               x = t;

test/Jamfile

@@ -0,0 +1,23 @@
+################################################################*# 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)
+################################################################################
+
+build-project container_fwd ;
+
+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/Jamfile

@@ -0,0 +1,29 @@
+
+# Copyright 2011 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)
+
+import testing ;
+
+project detail/test/container_fwd
+  : requirements
+        <warnings>all
+        <toolset>intel:<warnings>on
+        <toolset>gcc:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
+        <toolset>darwin:<cxxflags>"-pedantic -Wstrict-aliasing -fstrict-aliasing -Wextra -Wsign-promo -Wunused-parameter -Wconversion"
+        <toolset>clang:<cxxflags>"-pedantic -Wextra -Wmismatched-tags"
+        <warnings-as-errors>on
+  ;
+
+run container_no_fwd_test.cpp ;
+run container_fwd_test.cpp : : : : container_fwd ;
+run container_fwd_test.cpp : :
+    : <define>_STLP_DEBUG <define>_GLIBCXX_DEBUG
+    : container_fwd_debug ;
+
+compile-fail correctly_disable_fail.cpp
+    : <warnings-as-errors>off
+    : correctly_disable ;
+compile-fail correctly_disable_fail.cpp
+    : <warnings-as-errors>off <define>_STLP_DEBUG <define>_GLIBCXX_DEBUG
+    : correctly_disable_debug ;

test/container_fwd/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_fwd/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/container_fwd/correctly_disable_fail.cpp

@@ -0,0 +1,43 @@
+
+// Copyright 2011 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)
+
+// This tests if container forwarding is correctly disabled. If it isn't
+// disabled it causes a compile error (which causes the test to pass).
+// If it is disabled it tries container forwarding. If it doesn't work
+// then there will be a compile error, indicating that it is correctly
+// disabled. But if there isn't a compile error that indicates that
+// container forwarding might work.
+//
+// Since this test only tries std::vector, it might get it wrong but I didn't
+// want it to fail because of some incompatibility with a trickier class.
+
+#define BOOST_DETAIL_TEST_CONFIG_ONLY
+#include <boost/detail/container_fwd.hpp>
+
+#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
+#error "Failing in order to pass test"
+#else
+#define BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD
+
+#undef BOOST_DETAIL_CONTAINER_FWD_HPP
+#undef BOOST_DETAIL_TEST_CONFIG_ONLY
+
+#include <boost/detail/container_fwd.hpp>
+
+template <class T, class Allocator>
+void test(std::vector<T, Allocator> const&)
+{
+}
+
+#include <vector>
+
+int main ()
+{
+    std::vector<int> x;
+    test(x);
+}
+
+#endif
+

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();
+}
+

utf8_codecvt_facet.cpp

@@ -1,7 +1,7 @@
 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
 // utf8_codecvt_facet.cpp
 
-// Copyright <EFBFBD> 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
 // Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). 
 // Use, modification and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -159,7 +159,7 @@ std::codecvt_base::result utf8_codecvt_facet::do_out(
             to_next = to - (i+1);
             return std::codecvt_base::partial;
         }
-        *from++;
+        ++from;
     }
     from_next = from;
     to_next = to;
@@ -231,9 +231,6 @@ int get_cont_octet_out_count_impl(wchar_t word){
     return 2;
 }
 
-// note the following code will generate on some platforms where
-// wchar_t is defined as UCS2.  The warnings are superfluous as
-// the specialization is never instantitiated with such compilers.
 template<>
 int get_cont_octet_out_count_impl<4>(wchar_t word){
     if (word < 0x80) {
@@ -242,7 +239,22 @@ int get_cont_octet_out_count_impl<4>(wchar_t word){
     if (word < 0x800) {
         return 1;
     }
-    if (word < 0x10000) {
+
+    // Note that the following code will generate warnings on some platforms
+    // where wchar_t is defined as UCS2.  The warnings are superfluous as the
+    // specialization is never instantitiated with such compilers, but this
+    // can cause problems if warnings are being treated as errors, so we guard
+    // against that.  Including <boost/detail/utf8_codecvt_facet.hpp> as we do
+    // should be enough to get WCHAR_MAX defined.
+#if !defined(WCHAR_MAX)
+#   error WCHAR_MAX not defined!
+#endif
+    // cope with VC++ 7.1 or earlier having invalid WCHAR_MAX
+#if defined(_MSC_VER) && _MSC_VER <= 1310 // 7.1 or earlier
+    return 2;
+#elif WCHAR_MAX > 0x10000
+    
+   if (word < 0x10000) {
         return 2;
     }
     if (word < 0x200000) {
@@ -252,6 +264,10 @@ int get_cont_octet_out_count_impl<4>(wchar_t word){
         return 4;
     }
     return 5;
+    
+#else
+    return 2;
+#endif
 }
 
 } // namespace anonymous