colouringcode-passenger 0.1

data/ext/boost/token_iterator.hpp

@@ -0,0 +1,128 @@
+// Boost token_iterator.hpp  -------------------------------------------------//
+
+// Copyright John R. Bandela 2001
+// 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 http://www.boost.org/libs/tokenizer for documentation.
+
+// Revision History:
+// 16 Jul 2003   John Bandela
+//      Allowed conversions from convertible base iterators
+// 03 Jul 2003   John Bandela
+//      Converted to new iterator adapter
+
+
+
+#ifndef BOOST_TOKENIZER_POLICY_JRB070303_HPP_
+#define BOOST_TOKENIZER_POLICY_JRB070303_HPP_
+
+#include<boost/assert.hpp>
+#include<boost/iterator/iterator_adaptor.hpp>
+#include<boost/iterator/detail/minimum_category.hpp>
+#include<boost/token_functions.hpp>
+#include<utility>
+
+namespace boost
+{
+  template <class TokenizerFunc, class Iterator, class Type>
+  class token_iterator
+      : public iterator_facade<
+            token_iterator<TokenizerFunc, Iterator, Type>
+          , Type
+          , typename detail::minimum_category<
+                forward_traversal_tag
+              , typename iterator_traversal<Iterator>::type
+            >::type 
+          , const Type&
+        >
+  {
+
+      friend class iterator_core_access;
+
+      TokenizerFunc f_;
+      Iterator begin_;
+      Iterator end_;
+      bool valid_;
+      Type tok_;
+
+      void increment(){
+          BOOST_ASSERT(valid_);
+          valid_ = f_(begin_,end_,tok_);
+      }
+
+      const Type&  dereference() const {
+          BOOST_ASSERT(valid_);
+          return tok_;
+      }
+      template<class Other>
+      bool equal(const Other& a) const{
+          return (a.valid_ && valid_)
+              ?( (a.begin_==begin_) && (a.end_ == end_) )
+              :(a.valid_==valid_);
+
+      }
+
+      void initialize(){
+          if(valid_) return;
+          f_.reset();
+          valid_ = (begin_ != end_)?
+              f_(begin_,end_,tok_):false;
+      }
+  public:
+      token_iterator():begin_(),end_(),valid_(false),tok_() { }
+
+      token_iterator(TokenizerFunc f, Iterator begin, Iterator e = Iterator())
+          : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); }
+
+      token_iterator(Iterator begin, Iterator e = Iterator())
+            : f_(),begin_(begin),end_(e),valid_(false),tok_() {initialize();}
+
+      template<class OtherIter>
+      token_iterator(
+            token_iterator<TokenizerFunc, OtherIter,Type> const& t
+            , typename enable_if_convertible<OtherIter, Iterator>::type* = 0)
+            : f_(t.tokenizer_function()),begin_(t.base())
+            ,end_(t.end()),valid_(!t.at_end()),tok_(t.current_token()) {}
+
+      Iterator base()const{return begin_;}
+
+      Iterator end()const{return end_;};
+
+      TokenizerFunc tokenizer_function()const{return f_;}
+
+      Type current_token()const{return tok_;}
+
+      bool at_end()const{return !valid_;}
+
+
+
+
+  };
+    template <
+        class TokenizerFunc = char_delimiters_separator<char>, 
+        class Iterator = std::string::const_iterator,
+        class Type = std::string
+    >
+    class token_iterator_generator {
+
+    private: 
+    public:
+        typedef token_iterator<TokenizerFunc,Iterator,Type> type;
+    };
+    
+    
+    // Type has to be first because it needs to be explicitly specified
+    // because there is no way the function can deduce it.
+    template<class Type, class Iterator, class TokenizerFunc>
+        typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type 
+    make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){
+        typedef typename 
+            token_iterator_generator<TokenizerFunc,Iterator,Type>::type ret_type;
+        return ret_type(fun,begin,end);
+    }
+
+} // namespace boost
+
+#endif

data/ext/boost/tokenizer.hpp

@@ -0,0 +1,98 @@
+// Boost tokenizer.hpp  -----------------------------------------------------//
+
+// � Copyright Jeremy Siek and John R. Bandela 2001. 
+
+// 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 http://www.boost.org/libs/tokenizer for documenation
+
+// Revision History:
+// 03 Jul 2003   John Bandela
+//      Converted to new iterator adapter
+// 02 Feb 2002   Jeremy Siek
+//      Removed tabs and a little cleanup.
+
+#ifndef BOOST_TOKENIZER_JRB070303_HPP_
+#define BOOST_TOKENIZER_JRB070303_HPP_
+
+#include <boost/token_iterator.hpp>
+
+namespace boost {
+
+  
+  //===========================================================================
+  // A container-view of a tokenized "sequence"
+  template <
+    typename TokenizerFunc = char_delimiters_separator<char>, 
+    typename Iterator = std::string::const_iterator,
+    typename Type = std::string
+  >
+  class tokenizer {
+  private:
+    typedef token_iterator_generator<TokenizerFunc,Iterator,Type> TGen;
+        
+    // It seems that MSVC does not like the unqualified use of iterator,
+    // Thus we use iter internally when it is used unqualified and
+    // the users of this class will always qualify iterator.     
+    typedef typename TGen::type iter;
+    
+  public:
+    
+    typedef iter iterator;
+    typedef iter const_iterator;
+    typedef Type value_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef value_type* pointer;
+    typedef const pointer const_pointer;
+    typedef void size_type;
+    typedef void difference_type;
+
+    tokenizer(Iterator first, Iterator last,
+              const TokenizerFunc& f = TokenizerFunc()) 
+      : first_(first), last_(last), f_(f) { }
+        
+    template <typename Container>
+    tokenizer(const Container& c)
+      : first_(c.begin()), last_(c.end()), f_() { }
+    
+    template <typename Container>
+    tokenizer(const Container& c,const TokenizerFunc& f)
+      : first_(c.begin()), last_(c.end()), f_(f) { }
+    
+    void assign(Iterator first, Iterator last){
+      first_ = first;
+      last_ = last;
+    }
+    
+    void assign(Iterator first, Iterator last, const TokenizerFunc& f){
+      assign(first,last);
+      f_ = f;
+    }
+    
+    template <typename Container>
+    void assign(const Container& c){
+      assign(c.begin(),c.end());
+    }
+    
+    
+    template <typename Container>
+    void assign(const Container& c, const TokenizerFunc& f){
+      assign(c.begin(),c.end(),f);
+    }
+    
+    iter begin() const { return iter(f_,first_,last_); }
+    iter end() const { return iter(f_,last_,last_); }
+        
+  private:
+    Iterator first_;
+    Iterator last_;
+    TokenizerFunc f_;
+  };
+
+
+} // namespace boost
+
+#endif

data/ext/boost/type.hpp

@@ -0,0 +1,18 @@
+// (C) Copyright David Abrahams 2001.
+// 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_TYPE_DWA20010120_HPP
+# define BOOST_TYPE_DWA20010120_HPP
+
+namespace boost {
+
+  // Just a simple "type envelope". Useful in various contexts, mostly to work
+  // around some MSVC deficiencies.
+  template <class T>
+  struct type {};
+
+}
+
+#endif // BOOST_TYPE_DWA20010120_HPP

data/ext/boost/type_traits/add_const.hpp

@@ -0,0 +1,47 @@
+
+//  (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard
+//  Hinnant & John Maddock 2000.
+//  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_TT_ADD_CONST_HPP_INCLUDED
+#define BOOST_TT_ADD_CONST_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+// * convert a type T to const type - add_const<T>
+// this is not required since the result is always
+// the same as "T const", but it does suppress warnings
+// from some compilers:
+
+#if defined(BOOST_MSVC)
+// This bogus warning will appear when add_const is applied to a
+// const volatile reference because we can't detect const volatile
+// references with MSVC6.
+#   pragma warning(push)
+#   pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored
+#endif 
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_const,T,T const)
+
+#if defined(BOOST_MSVC)
+#   pragma warning(pop)
+#endif 
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_CONST_HPP_INCLUDED

data/ext/boost/type_traits/add_pointer.hpp

@@ -0,0 +1,72 @@
+
+// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  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_TT_ADD_POINTER_HPP_INCLUDED
+#define BOOST_TT_ADD_POINTER_HPP_INCLUDED
+
+#include <boost/type_traits/remove_reference.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+//
+// For some reason this implementation stops Borlands compiler
+// from dropping cv-qualifiers, it still fails with references
+// to arrays for some reason though (shrug...) (JM 20021104)
+//
+template <typename T>
+struct add_pointer_impl
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&>
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&const>
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&volatile>
+{
+    typedef T* type;
+};
+template <typename T>
+struct add_pointer_impl<T&const volatile>
+{
+    typedef T* type;
+};
+
+#else
+
+template <typename T>
+struct add_pointer_impl
+{
+    typedef typename remove_reference<T>::type no_ref_type;
+    typedef no_ref_type* type;
+};
+
+#endif
+
+} // namespace detail
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_pointer,T,typename boost::detail::add_pointer_impl<T>::type)
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED

data/ext/boost/type_traits/add_reference.hpp

@@ -0,0 +1,89 @@
+
+//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
+//  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_TT_ADD_REFERENCE_HPP_INCLUDED
+#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
+
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/config.hpp>
+
+// should be the last #include
+#include <boost/type_traits/detail/type_trait_def.hpp>
+
+namespace boost {
+
+namespace detail {
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+template <bool x>
+struct reference_adder
+{
+    template <typename T> struct result_
+    {
+        typedef T& type;
+    };
+};
+
+template <>
+struct reference_adder<true>
+{
+    template <typename T> struct result_
+    {
+        typedef T type;
+    };
+};
+
+template <typename T>
+struct add_reference_impl
+{
+    typedef typename reference_adder<
+          ::boost::is_reference<T>::value
+        >::template result_<T> result;
+
+    typedef typename result::type type;
+};
+
+#else
+
+template <typename T>
+struct add_reference_impl
+{
+    typedef T& type;
+};
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
+#endif
+
+#endif
+
+// these full specialisations are always required:
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void)
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const,void const)
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void volatile,void volatile)
+BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const volatile,void const volatile)
+#endif
+
+} // namespace detail
+
+BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_reference,T,typename boost::detail::add_reference_impl<T>::type)
+
+// agurt, 07/mar/03: workaround Borland's ill-formed sensitivity to an additional
+// level of indirection, here
+#if BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&)
+#endif
+
+} // namespace boost
+
+#include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED

data/ext/boost/type_traits/alignment_of.hpp

@@ -0,0 +1,100 @@
+
+//  (C) Copyright John Maddock 2000.
+//  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_TT_ALIGNMENT_OF_HPP_INCLUDED
+#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+// should be the last #include
+#include <boost/type_traits/detail/size_t_trait_def.hpp>
+
+#ifdef BOOST_MSVC
+#   pragma warning(push)
+#   pragma warning(disable: 4121 4512) // alignment is sensitive to packing
+#endif
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#pragma option push -Vx- -Ve-
+#endif
+
+namespace boost {
+
+template <typename T> struct alignment_of;
+
+// get the alignment of some arbitrary type:
+namespace detail {
+
+template <typename T>
+struct alignment_of_hack
+{
+    char c;
+    T t;
+    alignment_of_hack();
+};
+
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S);
+};
+
+
+template< typename T >
+struct alignment_of_impl
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value =
+        (::boost::detail::alignment_logic<
+            sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
+            sizeof(T)
+        >::value));
+};
+
+} // namespace detail
+
+BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl<T>::value)
+
+// references have to be treated specially, assume
+// that a reference is just a special pointer:
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <typename T>
+struct alignment_of<T&>
+    : alignment_of<T*>
+{
+};
+#endif
+#ifdef __BORLANDC__
+// long double gives an incorrect value of 10 (!)
+// unless we do this...
+struct long_double_wrapper{ long double ld; };
+template<> struct alignment_of<long double>
+   : public alignment_of<long_double_wrapper>{};
+#endif
+
+// void has to be treated specially:
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void,0)
+#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const,0)
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void volatile,0)
+BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const volatile,0)
+#endif
+
+} // namespace boost
+
+#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)
+#pragma option pop
+#endif
+#ifdef BOOST_MSVC
+#   pragma warning(pop)
+#endif
+
+#include <boost/type_traits/detail/size_t_trait_undef.hpp>
+
+#endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED
+

data/ext/boost/type_traits/broken_compiler_spec.hpp

@@ -0,0 +1,117 @@
+
+//  Copyright 2001-2003 Aleksey Gurtovoy.
+//  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_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
+#define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/config.hpp>
+
+// these are needed regardless of BOOST_TT_NO_BROKEN_COMPILER_SPEC 
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+namespace boost { namespace detail {
+template< typename T > struct remove_const_impl     { typedef T type; };
+template< typename T > struct remove_volatile_impl  { typedef T type; };
+template< typename T > struct remove_pointer_impl   { typedef T type; };
+template< typename T > struct remove_reference_impl { typedef T type; };
+typedef int invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces;
+}}
+#endif
+
+// agurt, 27/jun/03: disable the workaround if user defined 
+// BOOST_TT_NO_BROKEN_COMPILER_SPEC
+#if    !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+    || defined(BOOST_TT_NO_BROKEN_COMPILER_SPEC)
+
+#   define BOOST_TT_BROKEN_COMPILER_SPEC(T) /**/
+
+#else
+
+// same as BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 macro, except that it
+// never gets #undef-ined
+#   define BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(trait,spec,result) \
+template<> struct trait##_impl<spec> \
+{ \
+    typedef result type; \
+}; \
+/**/
+
+#   define BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T)                         \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const,T)                    \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const volatile,T volatile)  \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T volatile,T)              \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T const volatile,T const)  \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T)                               \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*,T)                       \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const,T)                  \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*volatile,T)               \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const volatile,T)         \
+    BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_reference,T&,T)                     \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T)                               \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T)                                      \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const)                                \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T volatile)                             \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const volatile)                       \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T)                                   \
+    BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T)                                      \
+    BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T)                                \
+    /**/
+
+#   define BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T)                                   \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T*)                                         \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const*)                                   \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T volatile*)                                \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const volatile*)                          \
+    /**/
+
+#   define BOOST_TT_BROKEN_COMPILER_SPEC(T)                                         \
+    namespace boost { namespace detail {                                            \
+    typedef invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces             \
+      please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces;           \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T)                                          \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T)                                          \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T*)                                         \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const*)                                   \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T volatile*)                                \
+    BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const volatile*)                          \
+    }}                                                                              \
+    /**/
+
+#   include <boost/type_traits/detail/type_trait_undef.hpp>
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+BOOST_TT_BROKEN_COMPILER_SPEC(bool)
+BOOST_TT_BROKEN_COMPILER_SPEC(char)
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+BOOST_TT_BROKEN_COMPILER_SPEC(wchar_t)
+#endif
+BOOST_TT_BROKEN_COMPILER_SPEC(signed char)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned char)
+BOOST_TT_BROKEN_COMPILER_SPEC(signed short)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned short)
+BOOST_TT_BROKEN_COMPILER_SPEC(signed int)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned int)
+BOOST_TT_BROKEN_COMPILER_SPEC(signed long)
+BOOST_TT_BROKEN_COMPILER_SPEC(unsigned long)
+BOOST_TT_BROKEN_COMPILER_SPEC(float)
+BOOST_TT_BROKEN_COMPILER_SPEC(double)
+//BOOST_TT_BROKEN_COMPILER_SPEC(long double)
+
+// for backward compatibility
+#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \
+    BOOST_TT_BROKEN_COMPILER_SPEC(T) \
+/**/
+
+#endif // BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED