Branch at revision 46530

[SVN r46531]

include/boost/detail/allocator_utilities.hpp

@@ -1,4 +1,4 @@
-/* Copyright 2003-2005 Joaqu<71>n M L<>pez Mu<4D>oz.
+/* Copyright 2003-2007 Joaqu<71>n M L<>pez Mu<4D>oz.
  * 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)
@@ -30,13 +30,21 @@ namespace detail{
 namespace allocator{
 
 /* partial_std_allocator_wrapper inherits the functionality of a std
- * allocator while providing a templatized ctor.
+ * allocator while providing a templatized ctor and other bits missing
+ * in some stdlib implementation or another.
  */
 
 template<typename Type>
 class partial_std_allocator_wrapper:public std::allocator<Type>
 {
 public:
+  /* Oddly enough, STLport does not define std::allocator<void>::value_type
+   * when configured to work without partial template specialization.
+   * No harm in supplying the definition here unconditionally.
+   */
+
+  typedef Type value_type;
+
   partial_std_allocator_wrapper(){};
 
   template<typename Other>

include/boost/detail/endian.hpp

@@ -1,3 +1,8 @@
+// Copyright 2005 Caleb Epstein
+// Copyright 2006 John Maddock
+// 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)
+
 /*
  * Copyright (c) 1997
  * Silicon Graphics Computer Systems, Inc.
@@ -37,9 +42,15 @@
 #  error Unknown machine endianness detected.
 # endif
 # define BOOST_BYTE_ORDER __BYTE_ORDER
+#elif defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)
+# define BOOST_BIG_ENDIAN
+# define BOOST_BYTE_ORDER 4321
+#elif defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
+# define BOOST_LITTLE_ENDIAN
+# define BOOST_BYTE_ORDER 1234
 #elif defined(__sparc) || defined(__sparc__) \
    || defined(_POWER) || defined(__powerpc__) \
-   || defined(__ppc__) || defined(__hppa) \
+   || defined(__ppc__) || defined(__hpux) \
    || defined(_MIPSEB) || defined(_POWER) \
    || defined(__s390__)
 # define BOOST_BIG_ENDIAN
@@ -47,7 +58,11 @@
 #elif defined(__i386__) || defined(__alpha__) \
    || defined(__ia64) || defined(__ia64__) \
    || defined(_M_IX86) || defined(_M_IA64) \
-   || defined(_M_ALPHA)
+   || defined(_M_ALPHA) || defined(__amd64) \
+   || defined(__amd64__) || defined(_M_AMD64) \
+   || defined(__x86_64) || defined(__x86_64__) \
+   || defined(_M_X64)
+
 # define BOOST_LITTLE_ENDIAN
 # define BOOST_BYTE_ORDER 1234
 #else

include/boost/detail/has_default_constructor.hpp

@@ -0,0 +1,29 @@
+
+//  (C) Copyright Matthias Troyerk 2006.
+//  Use, modification and distribution are subject to 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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+#ifndef BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED
+#define BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED
+
+#include <boost/type_traits/has_trivial_constructor.hpp>
+
+namespace boost { namespace detail {
+
+/// type trait to check for a default constructor
+///
+/// The default implementation just checks for a trivial constructor.
+/// Using some compiler magic it might be possible to provide a better default
+
+template <class T>
+struct has_default_constructor
+ : public has_trivial_constructor<T>
+{};
+
+} } // namespace boost::detail
+
+
+#endif // BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED

include/boost/detail/identifier.hpp

@@ -0,0 +1,89 @@
+//  boost/identifier.hpp  ----------------------------------------------------//
+
+//  Copyright Beman Dawes 2006
+
+//  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)
+
+//  See documentation at http://www.boost.org/libs/utility
+
+#ifndef BOOST_IDENTIFIER_HPP
+#define BOOST_IDENTIFIER_HPP
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <iosfwd>
+
+namespace boost
+{
+  namespace detail
+  {
+    //  class template identifier  ---------------------------------------------//
+
+    //  Always used as a base class so that different instantiations result in
+    //  different class types even if instantiated with the same value type T.
+
+    //  Expected usage is that T is often an integer type, best passed by
+    //  value. There is no reason why T can't be a possibly larger class such as
+    //  std::string, best passed by const reference.
+
+    //  This implementation uses pass by value, based on expected common uses.
+
+    template <typename T, typename D>
+    class identifier
+    {
+    public:
+      typedef T value_type;
+
+      const value_type value() const           { return m_value; }
+      void  assign( value_type v )             { m_value = v; }
+
+      bool operator==( const D & rhs ) const   { return m_value == rhs.m_value; }
+      bool operator!=( const D & rhs ) const   { return m_value != rhs.m_value; }
+      bool operator< ( const D & rhs ) const   { return m_value <  rhs.m_value; }
+      bool operator<=( const D & rhs ) const   { return m_value <= rhs.m_value; }
+      bool operator> ( const D & rhs ) const   { return m_value >  rhs.m_value; }
+      bool operator>=( const D & rhs ) const   { return m_value >= rhs.m_value; }
+
+      typedef void (*unspecified_bool_type)(D); // without the D, unspecified_bool_type 
+      static void unspecified_bool_true(D){}    // conversion allows relational operators
+                                                // between different identifier types
+
+      operator unspecified_bool_type() const   { return m_value == value_type() ? 0 : unspecified_bool_true; }
+      bool operator!() const                   { return m_value == value_type(); }
+
+    // constructors are protected so that class can only be used as a base class
+    protected:
+      identifier()                             {}
+      explicit identifier( value_type v )      : m_value(v) {}
+
+  #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300  // 1300 == VC++ 7.0 bug workaround
+    private:
+  #endif
+      T m_value;
+    };
+
+  //#ifndef BOOST_NO_SFINAE
+
+  //  template <class Ostream, class Id>
+  //    typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, 
+  //      Ostream & >::type operator<<( Ostream & os, const Id & id )
+  //  {
+  //    return os << id.value();
+  //  }
+
+  //  template <class Istream, class Id>
+  //    typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, 
+  //      Istream & >::type operator>>( Istream & is, Id & id )
+  //  {
+  //    typename Id::value_type v;
+  //    is >> v;
+  //    id.value( v );
+  //    return is;
+  //  }
+  //#endif
+
+  } // namespace detail
+} // namespace boost
+
+#endif // BOOST_IDENTIFIER_HPP

include/boost/detail/indirect_traits.hpp

@@ -388,27 +388,27 @@ typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
 outer_no_type reference_to_pointer_helper(...);
 
 template <class T>
-struct is_reference_to_pointer
+struct reference_to_pointer_impl
 {
     static T t;
     BOOST_STATIC_CONSTANT(
         bool, value
-        = (is_reference<T>::value
+        = (sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
-           && sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type))
         );
     
     typedef mpl::bool_<value> type;
+};
     
+template <class T>
+struct is_reference_to_pointer
+  : mpl::eval_if<is_reference<T>, reference_to_pointer_impl<T>, mpl::false_>::type
+{   
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_pointer,(T))
 };
 
 template <class T>
 struct is_reference_to_function_pointer
-    : mpl::if_<
+  : mpl::eval_if<is_reference<T>, is_pointer_to_function_aux<T>, mpl::false_>::type
-          is_reference<T>
-        , is_pointer_to_function_aux<T>
-        , mpl::bool_<false>
-     >::type
 {
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T))
 };

include/boost/detail/interlocked.hpp

@@ -31,6 +31,27 @@
 # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER InterlockedCompareExchangePointer
 # define BOOST_INTERLOCKED_EXCHANGE_POINTER InterlockedExchangePointer
 
+#elif defined(_WIN32_WCE)
+
+// under Windows CE we still have old-style Interlocked* functions
+
+extern "C" long __cdecl InterlockedIncrement( long* );
+extern "C" long __cdecl InterlockedDecrement( long* );
+extern "C" long __cdecl InterlockedCompareExchange( long*, long, long );
+extern "C" long __cdecl InterlockedExchange( long*, long );
+extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
+
+# define BOOST_INTERLOCKED_INCREMENT InterlockedIncrement
+# define BOOST_INTERLOCKED_DECREMENT InterlockedDecrement
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE InterlockedCompareExchange
+# define BOOST_INTERLOCKED_EXCHANGE InterlockedExchange
+# define BOOST_INTERLOCKED_EXCHANGE_ADD InterlockedExchangeAdd
+
+# define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest,exchange,compare) \
+    ((void*)BOOST_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest),(long)(exchange),(long)(compare)))
+# define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest,exchange) \
+    ((void*)BOOST_INTERLOCKED_EXCHANGE((long*)(dest),(long)(exchange)))
+
 #elif defined( BOOST_MSVC ) || defined( BOOST_INTEL_WIN )
 
 extern "C" long __cdecl _InterlockedIncrement( long volatile * );
@@ -44,18 +65,25 @@ extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long);
 # pragma intrinsic( _InterlockedCompareExchange )
 # pragma intrinsic( _InterlockedExchange )
 # pragma intrinsic( _InterlockedExchangeAdd )
+
 # if defined(_M_IA64) || defined(_M_AMD64)
+
 extern "C" void* __cdecl _InterlockedCompareExchangePointer( void* volatile *, void*, void* );
 extern "C" void* __cdecl _InterlockedExchangePointer( void* volatile *, void* );
+
 #  pragma intrinsic( _InterlockedCompareExchangePointer )
 #  pragma intrinsic( _InterlockedExchangePointer )
+
 #  define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER _InterlockedCompareExchangePointer
 #  define BOOST_INTERLOCKED_EXCHANGE_POINTER _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) \
     ((void*)BOOST_INTERLOCKED_EXCHANGE((long volatile*)(dest),(long)(exchange)))
+
 # endif
 
 # define BOOST_INTERLOCKED_INCREMENT _InterlockedIncrement
@@ -64,7 +92,7 @@ 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__ )
 
 namespace boost
 {
@@ -77,6 +105,7 @@ extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement( long volat
 extern "C" __declspec(dllimport) long __stdcall InterlockedCompareExchange( long volatile *, long, long );
 extern "C" __declspec(dllimport) long __stdcall InterlockedExchange( long volatile *, long );
 extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long volatile *, long );
+
 } // namespace detail
 
 } // namespace boost
@@ -86,6 +115,7 @@ extern "C" __declspec(dllimport) long __stdcall InterlockedExchangeAdd( long vol
 # define BOOST_INTERLOCKED_COMPARE_EXCHANGE ::boost::detail::InterlockedCompareExchange
 # define BOOST_INTERLOCKED_EXCHANGE ::boost::detail::InterlockedExchange
 # define BOOST_INTERLOCKED_EXCHANGE_ADD ::boost::detail::InterlockedExchangeAdd
+
 # 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) \

include/boost/detail/is_incrementable.hpp

@@ -4,13 +4,15 @@
 #ifndef IS_INCREMENTABLE_DWA200415_HPP
 # define IS_INCREMENTABLE_DWA200415_HPP
 
-# include <boost/type_traits/detail/bool_trait_def.hpp>
 # include <boost/type_traits/detail/template_arity_spec.hpp>
 # include <boost/type_traits/remove_cv.hpp>
 # include <boost/mpl/aux_/lambda_support.hpp>
 # include <boost/mpl/bool.hpp>
 # include <boost/detail/workaround.hpp>
 
+// Must be the last include
+# include <boost/type_traits/detail/bool_trait_def.hpp>
+
 namespace boost { namespace detail { 
 
 // is_incrementable<T> metafunction
@@ -61,7 +63,12 @@ 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];
   
@@ -90,6 +97,11 @@ namespace is_incrementable_
         , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1
       );
   };
+
+# if defined(BOOST_MSVC)
+#  pragma warning(pop)
+# endif 
+
 }
 
 # undef BOOST_comma
@@ -117,5 +129,6 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1, ::boost::detail::is_postfix_incrementable)
 
 } // namespace boost
 
+# include <boost/type_traits/detail/bool_trait_undef.hpp>
 
 #endif // IS_INCREMENTABLE_DWA200415_HPP

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/utf8_codecvt_facet.hpp

@@ -1,9 +1,7 @@
-// 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). Permission to copy, 
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
-// use, modify, sell and distribute this software is granted provided this
+// Distributed under the Boost Software License, Version 1.0. (See accompany-
-// copyright notice appears in all copies. This software is provided "as is"
+// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-// without express or implied warranty, and with no claim as to its suitability
-// for any purpose.
 
 #ifndef BOOST_UTF8_CODECVT_FACET_HPP
 #define BOOST_UTF8_CODECVT_FACET_HPP
@@ -81,25 +79,16 @@
 // 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>
 
-namespace std {
+#if defined(BOOST_NO_STDC_NAMESPACE)
-    #if defined(__LIBCOMO__)
+    using ::codecvt;
-        using ::mbstate_t;
+    using ::mbstate_t;
-    #elif defined(BOOST_DINKUMWARE_STDLIB) && !defined(__BORLANDC__)
+#endif
-        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

include/boost/pending/ct_if.hpp

@@ -3,107 +3,39 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// The ct_if implementation that avoids partial specialization is
+// This header replaces the implementation of ct_if that preceded the
-// based on the IF class by Ulrich W. Eisenecker and Krzysztof
+// introduction of Boost.MPL with a facade that defers to that reviewed and
-// Czarnecki.
+// accepted library.
+
+// Author: Ronald Garcia
+// Date: 20 October, 2006
+
 
 #ifndef BOOST_CT_IF_HPP
 #define BOOST_CT_IF_HPP
 
-#include <boost/config.hpp>
 
-/*
+// A stub implementation in terms of Boost.MPL
-  There is a bug in the Borland compiler with regards to using
-  integers to specialize templates. This made it hard to use ct_if in
-  the graph library. Changing from 'ct_if' to 'ct_if_t' fixed the
-  problem.
-*/
 
-#include <boost/type_traits/integral_constant.hpp> // true_type and false_type
+#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 {
 
-  struct ct_if_error { };
-
   template <class A, class B>
-  struct ct_and { typedef false_type type; };
+  struct ct_and : boost::mpl::and_<A,B> {};
-  template <> struct ct_and<true_type,true_type> { typedef true_type type; };
 
-  template <class A> struct ct_not { typedef ct_if_error type; };
+  template <class A>
-  template <> struct ct_not<true_type> { typedef false_type type; };
+  struct ct_not : mpl::not_<A> {};
-  template <> struct ct_not<false_type> { typedef true_type type; };
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-// agurt, 15/sep/02: in certain cases Borland has problems with
-// choosing the right 'ct_if' specialization even though 'cond' 
-// _does_ equal '1'; the easiest way to fix it is to make first 
-// 'ct_if' non-type template parameter boolean.
-#if !defined(__BORLANDC__)
   template <bool cond, class A, class B>
-  struct ct_if { typedef ct_if_error type; };
+  struct ct_if : mpl::if_c<cond,A,B> {};
-  template <class A, class B>
-  struct ct_if<true, A, B> { typedef A type; };
-  template <class A, class B>
-  struct ct_if<false, A, B> { typedef B type; };
-#else
-  template <bool cond, class A, class B>
-  struct ct_if { typedef A type; };
-  template <class A, class B>
-  struct ct_if<false, A, B> { typedef B type; };
-#endif
 
   template <class cond, class A, class B>
-  struct ct_if_t { typedef ct_if_error type; };
+  struct ct_if_t : mpl::if_<cond,A,B> {};
-  template <class A, class B>
-  struct ct_if_t<true_type, A, B> { typedef A type; };
-  template <class A, class B>
-  struct ct_if_t<false_type, A, B> { typedef B type; };
-
-#else
-
-  namespace detail {
-
-    template <int condition, class A, class B> struct IF;
-    template <int condition> struct SlectSelector;
-    struct SelectFirstType;
-    struct SelectSecondType;
-    
-    struct SelectFirstType {
-      template<class A, class B>
-      struct Template {        typedef A type; };
-    };
-    
-    struct SelectSecondType {
-      template<class A, class B>
-      struct Template { typedef B type; };
-    };
-    
-    template<int condition>
-    struct SlectSelector {
-      typedef SelectFirstType type;
-    };
-    
-    template <>
-    struct SlectSelector<0> {
-      typedef SelectSecondType type;
-    };
-
-  } // namespace detail
-    
-  template<int condition, class A, class B>
-  struct ct_if
-  {
-    typedef typename detail::SlectSelector<condition>::type Selector;
-    typedef typename Selector::template Template<A, B>::type type;
-  };
-  
-  template <class cond, class A, class B>
-  struct ct_if_t { 
-    typedef typename ct_if<cond::value, A, B>::type type;
-  };
-
-#endif
 
 } // namespace boost
 

include/boost/pending/integer_log2.hpp

@@ -12,14 +12,17 @@
 //          http://www.boost.org/LICENSE_1_0.txt)
 //
 // ------------------------------------------------------
-
+//
+// $Id$
 
 
 #ifndef BOOST_INTEGER_LOG2_HPP_GP_20030301
 #define BOOST_INTEGER_LOG2_HPP_GP_20030301
 
-#include <cassert>
+#include <assert.h>
-#include <climits> // actually used for Borland only
+#ifdef __BORLANDC__
+#include <climits>
+#endif
 #include "boost/limits.hpp"
 #include "boost/config.hpp"
 

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
@@ -139,8 +139,8 @@ std::codecvt_base::result utf8_codecvt_facet::do_out(
         int shift_exponent = (cont_octet_count) *   6;
 
         // Process the first character
-        *to++ = octet1_modifier_table[cont_octet_count] +
+        *to++ = static_cast<char>(octet1_modifier_table[cont_octet_count] +
-            (unsigned char)(*from / (1 << shift_exponent));
+            (unsigned char)(*from / (1 << shift_exponent)));
 
         // Process the continuation characters 
         // Invariants: At   the start of the loop:
@@ -150,7 +150,7 @@ std::codecvt_base::result utf8_codecvt_facet::do_out(
         int i   = 0;
         while   (i != cont_octet_count && to != to_end) {
             shift_exponent -= 6;
-            *to++ = 0x80 + ((*from / (1 << shift_exponent)) % (1 << 6));
+            *to++ = static_cast<char>(0x80 + ((*from / (1 << shift_exponent)) % (1 << 6)));
             ++i;
         }
         // If   we filled up the out buffer before encoding the character
@@ -199,7 +199,7 @@ int utf8_codecvt_facet::do_length(
         last_octet_count = (get_octet_count(*from_next));
         ++char_count;
     }
-    return from_next-from_end;
+    return static_cast<int>(from_next-from_end);
 }
 
 unsigned int utf8_codecvt_facet::get_octet_count(