Release 1.37.0

[SVN r51178]

CMakeLists.txt

@@ -1,9 +1,3 @@
-#
-# Copyright Troy D. Straszheim
-#
-# Distributed under the Boost Software License, Version 1.0.
-# See http://www.boost.org/LICENSE_1_0.txt
-#
 #----------------------------------------------------------------------------
 # This file was automatically generated from the original CMakeLists.txt file
 # Add a variable to hold the headers for the library

include/boost/blank.hpp

@@ -15,11 +15,9 @@
 
 #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/detail/templated_streams.hpp"
 #include "boost/mpl/bool.hpp"
 #include "boost/type_traits/is_empty.hpp"
 #include "boost/type_traits/is_pod.hpp"
@@ -87,8 +85,6 @@ 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
@@ -99,8 +95,6 @@ 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-2009 Joaquin M Lopez Munoz.
+/* Copyright 2003-2008 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,31 +178,12 @@ 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/container_fwd.hpp

@@ -13,7 +13,13 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
-#if ((defined(__GLIBCPP__) || defined(__GLIBCXX__)) && defined(_GLIBCXX_DEBUG)) \
+#if BOOST_WORKAROUND(__GNUC__, < 3) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#define BOOST_HASH_CHAR_TRAITS string_char_traits
+#else
+#define BOOST_HASH_CHAR_TRAITS char_traits
+#endif
+
+#if (defined(__GLIBCXX__) && defined(_GLIBCXX_DEBUG)) \
     || BOOST_WORKAROUND(__BORLANDC__, > 0x551) \
     || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x842)) \
     || (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
@@ -59,13 +65,7 @@ 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
-
+    template <class charT> struct BOOST_HASH_CHAR_TRAITS;
     template <class T> class complex;
 }
 

include/boost/detail/is_incrementable.hpp

@@ -63,12 +63,7 @@ namespace is_incrementable_
   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];
   
@@ -97,11 +92,6 @@ namespace is_incrementable_
         , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
       );
   };
-
-# if defined(BOOST_MSVC)
-#  pragma warning(pop)
-# endif 
-
 }
 
 # undef BOOST_comma

include/boost/detail/lightweight_test.hpp

@@ -10,15 +10,14 @@
 //
 //  boost/detail/lightweight_test.hpp - lightweight test library
 //
-//  Copyright (c) 2002, 2009 Peter Dimov
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
 //
-//  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
+// 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)
 //
 //  BOOST_TEST(expression)
 //  BOOST_ERROR(message)
-//  BOOST_TEST_EQ(expr1, expr2)
 //
 //  int boost::report_errors()
 //
@@ -50,27 +49,13 @@ inline void error_impl(char const * msg, char const * file, int line, char const
     ++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
-    {
-        std::cerr << file << "(" << line << "): test '" << expr1 << " == " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << t << "' != '" << u << "'" << std::endl;
-        ++test_errors();
-    }
-}
-
 } // namespace detail
 
 inline int report_errors()
 {
     int errors = detail::test_errors();
 
-    if( errors == 0 )
+    if(errors == 0)
     {
         std::cerr << "No errors detected." << std::endl;
         return 0;
@@ -86,6 +71,5 @@ 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) )
 
 #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED

include/boost/detail/quick_allocator.hpp

@@ -13,11 +13,186 @@
 //  Copyright (c) 2003 David Abrahams
 //  Copyright (c) 2003 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
+// 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/smart_ptr/detail/quick_allocator.hpp>
+#include <boost/config.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

@@ -1,56 +0,0 @@
-//  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_t
-# define BOOST_SCOPED_ENUM_END };
-# define BOOST_SCOPED_ENUM(name) name::enum_t
-
-#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

@@ -79,18 +79,25 @@
 // specialized on those types for this to work.
 
 #include <locale>
-#include <cwchar>   // for mbstate_t
-#include <cstddef>  // for std::size_t
+// for mbstate_t
+#include <wchar.h>
+// for std::size_t
+#include <cstddef>
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
-#if defined(BOOST_NO_STDC_NAMESPACE)
 namespace std {
-    using ::mbstate_t;
-    using ::size_t;
-}
-#endif
+    #if defined(__LIBCOMO__)
+        using ::mbstate_t;
+    #elif defined(BOOST_DINKUMWARE_STDLIB) && !defined(__BORLANDC__)
+        using ::mbstate_t;
+    #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__)
     #define BOOST_CODECVT_DO_LENGTH_CONST const

utf8_codecvt_facet.cpp

@@ -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,6 +231,9 @@ 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) {
@@ -239,22 +242,7 @@ int get_cont_octet_out_count_impl<4>(wchar_t word){
     if (word < 0x800) {
         return 1;
     }
-
-    // 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) {
+    if (word < 0x10000) {
         return 2;
     }
     if (word < 0x200000) {
@@ -264,10 +252,6 @@ int get_cont_octet_out_count_impl<4>(wchar_t word){
         return 4;
     }
     return 5;
-    
-#else
-    return 2;
-#endif
 }
 
 } // namespace anonymous