This commit was manufactured by cvs2svn to create branch 'split-config'.

[SVN r10742]

include/boost/detail/catch_exceptions.hpp

@@ -8,6 +8,7 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 
 //  Revision History
+//   13 Jun 01 report_exception() made inline. (John Maddock, Jesse Jones)
 //   26 Feb 01 Numerous changes suggested during formal review. (Beman)
 //   25 Jan 01 catch_exceptions.hpp code factored out of cpp_main.cpp.
 //   22 Jan 01 Remove test_tools dependencies to reduce coupling.
@@ -24,7 +25,7 @@
 #include <exception>          // for exception, bad_exception
 #include <stdexcept>          // for std exception hierarchy
 #include <boost/cstdlib.hpp>  // for exit codes
-# if __GNUC__ != 2 || __GNUC_MINOR__ > 95
+# if __GNUC__ != 2 || __GNUC_MINOR__ > 96
 #   include <ostream>         // for ostream
 # else
 #   include <iostream> // workaround GNU missing ostream header
@@ -37,8 +38,8 @@ namespace boost
   namespace detail
   {
     //  A separate reporting function was requested during formal review.
-    void report_exception( std::ostream & os, 
-                           const char * name, const char * info )
+    inline void report_exception( std::ostream & os, 
+                                  const char * name, const char * info )
       { os << "\n** uncaught exception: " << name << " " << info << std::endl; }
   }
 

include/boost/detail/iterator.hpp

@@ -28,6 +28,12 @@
 // See http://www.boost.org for most recent version including documentation.
 
 // Revision History
+// 04 Mar 2001 - More attempted fixes for Intel C++ (David Abrahams)
+// 03 Mar 2001 - Put all implementation into namespace
+//               boost::detail::iterator_traits_. Some progress made on fixes
+//               for Intel compiler. (David Abrahams)
+// 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few
+//               places. (Jeremy Siek)
 // 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and
 //               no_type from type_traits.hpp; stopped trying to remove_cv
 //               before detecting is_pointer, in honor of the new type_traits
@@ -56,10 +62,14 @@
 # include <iterator>
 # include <cstddef>
 
-# if defined(BOOST_MSVC) && !defined(__SGI_STL_PORT)
+# if defined(BOOST_MSVC_STD_ITERATOR)
 #  include <xtree>
 #  include <deque>
 #  include <list>
+#  if 0 && defined(__ICL) // Re-enable this to pick up the Intel fixes where they left off
+#   include <iosfwd>
+#   include <memory>
+#  endif
 # endif
 
 
@@ -81,11 +91,13 @@
 # endif // STLPort <= 4.1b4 && no partial specialization
 
 namespace boost { namespace detail {
-# if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+# if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR)
 using std::iterator_traits;
 using std::distance;
 # else
 
+namespace iterator_traits_ {
+
 // Workarounds for less-capable implementations
 template <bool is_ptr> struct iterator_traits_select;
 
@@ -109,7 +121,11 @@ template <> struct iterator_traits_select<true>
 };
 
 
+typedef char yes_type;
+typedef double no_type;
+
 # ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
+
 no_type bad_category_helper(...);
 template <class C, class T> yes_type bad_category_helper(std::_DBG_iter<C,T>*);
 
@@ -167,7 +183,7 @@ struct bad_output_iterator_select<false>
 };
 # endif
 
-# if defined(BOOST_MSVC) && !defined(__SGI_STL_PORT)
+# if defined(BOOST_MSVC_STD_ITERATOR)
 
 // We'll sort iterator types into one of these classifications, from which we
 // can determine the difference_type, pointer, reference, and value_type
@@ -232,9 +248,45 @@ template <> struct msvc_traits_select<msvc_stdlib_ostream_iterator>
 // falls into.
 
 // Is the iterator derived from std::iterator?
+no_type is_std_iterator_helper(...);
 template <class V, class D, class C>
 yes_type is_std_iterator_helper(const volatile std::iterator<V,D,C>*);
-no_type is_std_iterator_helper(...);
+
+#if 0 && defined(__ICL)  // re-enable this to pick up with the Intel C++ fixes where they left off
+// for some reason, it's unable to make the deduction of derivation :(
+template<class K, class Ty, class Kfn, class Pr, class A>
+yes_type is_std_iterator_helper(const volatile typename std::_Tree<K,Ty,Kfn,Pr,A>::iterator*);
+template<class Ty, class A>
+yes_type is_std_iterator_helper(const volatile typename std::list<Ty,A>::iterator*);
+template<class Ty, class A>
+yes_type is_std_iterator_helper(const volatile typename std::deque<Ty,A>::iterator*);
+
+template<class K, class Ty, class Kfn, class Pr, class A>
+yes_type is_std_iterator_helper(const volatile typename std::_Tree<K,Ty,Kfn,Pr,A>::const_iterator*);
+template<class Ty, class A>
+yes_type is_std_iterator_helper(const volatile typename std::list<Ty,A>::const_iterator*);
+template<class Ty, class A>
+yes_type is_std_iterator_helper(const volatile typename std::deque<Ty,A>::const_iterator*);
+
+template<class RI, class Ty, class Rt, class Pt, class D>
+yes_type is_std_iterator_helper(const volatile std::reverse_iterator<RI,Ty,Rt,Pt,D>*);
+template<class BI, class Ty, class Rt, class Pt, class D>
+yes_type is_std_iterator_helper(const volatile std::reverse_bidirectional_iterator<BI,Ty,Rt,Pt,D>*);
+template<class C>
+yes_type is_std_iterator_helper(const volatile std::back_insert_iterator<C>*);
+template<class C>
+yes_type is_std_iterator_helper(const volatile std::front_insert_iterator<C>*);
+template<class C>
+yes_type is_std_iterator_helper(const volatile std::insert_iterator<C>*);
+template<class U, class E, class Tr>
+yes_type is_std_iterator_helper(const volatile std::istream_iterator<U,E,Tr>*);
+template<class E, class Tr>
+yes_type is_std_iterator_helper(const volatile std::istreambuf_iterator<E,Tr>*);
+template<class E, class Tr>
+yes_type is_std_iterator_helper(const volatile std::ostreambuf_iterator<E,Tr>*);
+template<class Oi, class Ty>
+yes_type is_std_iterator_helper(const volatile std::raw_storage_iterator<Oi,Ty>*);
+#endif
 
 // Is the iterator derived from boost::iterator?
 template <class C, class T, class D, class P, class R>
@@ -243,11 +295,11 @@ no_type is_boost_iterator_helper(...);
 
 // Is the iterator one of the known mutable container iterators?
 template<class K, class Ty, class Kfn, class Pr, class A>
-yes_type is_mutable_iterator_helper(const volatile std::_Tree<K,Ty,Kfn,Pr,A>::iterator*);
+yes_type is_mutable_iterator_helper(const volatile typename std::_Tree<K,Ty,Kfn,Pr,A>::iterator*);
 template<class Ty, class A>
-yes_type is_mutable_iterator_helper(const volatile std::list<Ty,A>::iterator*);
+yes_type is_mutable_iterator_helper(const volatile typename std::list<Ty,A>::iterator*);
 template<class Ty, class A>
-yes_type is_mutable_iterator_helper(const volatile std::deque<Ty,A>::iterator*);
+yes_type is_mutable_iterator_helper(const volatile typename std::deque<Ty,A>::iterator*);
 no_type is_mutable_iterator_helper(...);
 
 // Is the iterator an ostream_iterator?
@@ -255,9 +307,18 @@ template<class T, class CharT, class Traits>
 yes_type is_ostream_iterator_helper(const volatile std::ostream_iterator<T,CharT,Traits>*);
 no_type is_ostream_iterator_helper(...);
 
+#if 0 && defined(__ICL)
+// this static assertion highlights the first of a few problems getting this to
+// work with the Intel compiler. We can get past it with the many definitions
+// for is_std_iterator_helper above, but there are other failures.
+template <bool> struct check;
+template <> struct check<true> {};
+check<(sizeof(is_std_iterator_helper((std::istream_iterator<int>*)0)) == sizeof(yes_type))> assertion;
+#endif
+
 template <class T>
 struct msvc_iterator_classification {
-    enum {
+    BOOST_STATIC_CONSTANT(unsigned,
         value = (sizeof(is_ostream_iterator_helper((T*)0)) == sizeof(yes_type))
           ? msvc_stdlib_ostream_iterator
         : (sizeof(is_mutable_iterator_helper((T*)0)) == sizeof(yes_type))
@@ -266,7 +327,7 @@ struct msvc_iterator_classification {
            && sizeof(is_boost_iterator_helper((T*)0)) == sizeof(no_type))
         ? msvc_stdlib_const_iterator
         : not_msvc_stdlib_iterator
-    };
+        );
 };
 # endif
 
@@ -275,7 +336,7 @@ template <> struct iterator_traits_select<false>
     template <class Iterator>
     struct traits
     {
-#   if defined(BOOST_MSVC) && !defined(__SGI_STL_PORT)
+#   if defined(BOOST_MSVC_STD_ITERATOR)
         typedef msvc_traits_select<(
             msvc_iterator_classification<Iterator>::value
         )>::template traits_<Iterator> inner_traits;
@@ -287,7 +348,6 @@ template <> struct iterator_traits_select<false>
 #   elif !defined(BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION)
         typedef typename Iterator::difference_type difference_type;
         typedef typename Iterator::value_type value_type;
-        typedef typename Iterator::difference_type difference_type;
         typedef typename Iterator::pointer pointer;
         typedef typename Iterator::reference reference;
 #   else
@@ -311,12 +371,14 @@ template <> struct iterator_traits_select<false>
     };
 };
 
+} // namespace boost::detail::iterator_traits_
+
 template <class Iterator>
 struct iterator_traits
-    : iterator_traits_select<is_pointer<Iterator>::value>::template traits<Iterator>
+    : iterator_traits_::iterator_traits_select<is_pointer<Iterator>::value>::template traits<Iterator>
 {
  private:
-    typedef typename iterator_traits_select<
+    typedef typename iterator_traits_::iterator_traits_select<
         is_pointer<remove_cv<Iterator>::type>::value>::template traits<Iterator> traits;
  public:
     // Why do I need to define these typedefs? It keeps MSVC happy somehow.
@@ -325,6 +387,8 @@ struct iterator_traits
     typedef typename traits::iterator_category iterator_category;
 };
 
+namespace iterator_traits_ {
+
 template <class Category>
 struct distance_select {
     template <class Iterator>
@@ -351,16 +415,18 @@ struct distance_select<std::random_access_iterator_tag> {
     }
 };
 
+} // namespace boost::detail::iterator_traits_
+
 template <class Iterator>
 inline typename ::boost::detail::iterator_traits<Iterator>::difference_type
 distance(const Iterator& first, const Iterator& last)
 {
     typedef typename ::boost::detail::iterator_traits<Iterator>::iterator_category iterator_category;
-    return distance_select<iterator_category>::distance(first, last);
+    return iterator_traits_::distance_select<iterator_category>::distance(first, last);
 }
 # endif // workarounds
 
-}}
+}} // namespace boost::detail
 
 # undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF
 # undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION

include/boost/detail/named_template_params.hpp

@@ -0,0 +1,171 @@
+// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
+// sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
+#define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
+
+#include <boost/type_traits/conversion_traits.hpp>
+#include <boost/type_traits/composite_traits.hpp> // for is_reference
+#if defined(__BORLANDC__)
+#include <boost/type_traits/ice.hpp>
+#endif
+
+namespace boost {
+  namespace detail {
+    
+    struct default_argument { };
+
+    struct dummy_default_gen {
+      template <class Base, class Traits>
+      struct bind {
+        typedef default_argument type;
+      };
+    };
+
+   // This class template is a workaround for MSVC.
+   template <class Gen> struct default_generator {
+     typedef detail::dummy_default_gen type;
+   };
+
+    template <class T> struct is_default { 
+      enum { value = false };  
+      typedef type_traits::no_type type;
+    };
+    template <> struct is_default<default_argument> { 
+      enum { value = true }; 
+      typedef type_traits::yes_type type;
+    };
+
+    struct choose_default {
+      template <class Arg, class DefaultGen, class Base, class Traits>
+      struct bind {
+        typedef typename default_generator<DefaultGen>::type Gen;
+        typedef typename Gen::template bind<Base,Traits>::type type;
+      };
+    };
+    struct choose_arg {
+      template <class Arg, class DefaultGen, class Base, class Traits>
+      struct bind {
+        typedef Arg type;
+      };
+    };
+
+#if defined(__BORLANDC__)
+    template <class UseDefault>
+    struct choose_arg_or_default { typedef choose_arg type; };
+    template <>
+    struct choose_arg_or_default<type_traits::yes_type> {
+      typedef choose_default type;
+    };
+#else
+    template <bool UseDefault>
+    struct choose_arg_or_default { typedef choose_arg type; };
+    template <>
+    struct choose_arg_or_default<true> {
+      typedef choose_default type;
+    };
+#endif
+    
+    template <class Arg, class DefaultGen, class Base, class Traits>
+    class resolve_default {
+#if defined(__BORLANDC__)
+      typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector;
+#else
+      // This usually works for Borland, but I'm seeing weird errors in
+      // iterator_adaptor_test.cpp when using this method.
+      enum { is_def = is_default<Arg>::value };
+      typedef typename choose_arg_or_default<is_def>::type Selector;
+#endif
+    public:
+      typedef typename Selector
+        ::template bind<Arg, DefaultGen, Base, Traits>::type type;
+    };
+
+    // To differentiate an unnamed parameter from a traits generator
+    // we use is_convertible<X, iter_traits_gen_base>.
+    struct named_template_param_base { };
+
+    template <class X>
+    struct is_named_param_list {
+      enum { value  = is_convertible<X, named_template_param_base>::value };
+    };
+    
+    struct choose_named_params {
+      template <class Prev> struct bind { typedef Prev type; };
+    };
+    struct choose_default_arg {
+      template <class Prev> struct bind { 
+        typedef detail::default_argument type;
+      };
+    };
+
+    template <bool Named> struct choose_default_dispatch { };
+    template <> struct choose_default_dispatch<true> {
+      typedef choose_named_params type;
+    };
+    template <> struct choose_default_dispatch<false> {
+      typedef choose_default_arg type;
+    };
+
+
+    template <class PreviousArg>
+    struct choose_default_argument {
+      enum { is_named = is_named_param_list<PreviousArg>::value };
+      typedef typename choose_default_dispatch<is_named>::type Selector;
+      typedef typename Selector::template bind<PreviousArg>::type type;
+    };
+
+    // This macro assumes that there is a class named default_##TYPE
+    // defined before the application of the macro.  This class should
+    // have a single member class template named "bind" with two
+    // template parameters: the type of the class being created (e.g.,
+    // the iterator_adaptor type when creating iterator adaptors) and
+    // a traits class. The bind class should have a single typedef
+    // named "type" that produces the default for TYPE.  See
+    // boost/iterator_adaptors.hpp for an example usage.  Also,
+    // applications of this macro must be placed in namespace
+    // boost::detail.
+
+#define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \
+    struct get_##TYPE##_from_named { \
+      template <class Base, class NamedParams, class Traits> \
+      struct bind { \
+          typedef typename NamedParams::traits NamedTraits; \
+          typedef typename NamedTraits::TYPE TYPE; \
+          typedef typename resolve_default<TYPE, \
+            default_##TYPE, Base, NamedTraits>::type type; \
+      }; \
+    }; \
+    struct pass_thru_##TYPE { \
+      template <class Base, class Arg, class Traits> struct bind { \
+          typedef typename resolve_default<Arg, \
+            default_##TYPE, Base, Traits>::type type; \
+      };\
+    }; \
+    template <int NamedParam> \
+    struct get_##TYPE##_dispatch { }; \
+    template <> struct get_##TYPE##_dispatch<1> { \
+      typedef get_##TYPE##_from_named type; \
+    }; \
+    template <> struct get_##TYPE##_dispatch<0> { \
+      typedef pass_thru_##TYPE type; \
+    }; \
+    template <class Base, class X, class Traits>  \
+    class get_##TYPE { \
+      enum { is_named = is_named_param_list<X>::value }; \
+      typedef typename get_##TYPE##_dispatch<is_named>::type Selector; \
+    public: \
+      typedef typename Selector::template bind<Base, X, Traits>::type type; \
+    }; \
+    template <> struct default_generator<default_##TYPE> { \
+      typedef default_##TYPE type; \
+    }
+
+    
+  } // namespace detail
+} // namespace boost
+
+#endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP

include/boost/detail/select_type.hpp

@@ -19,7 +19,9 @@ namespace boost { namespace detail {
   // Template class if_true -- select among 2 types based on a bool constant expression
   // Usage:
   //   typename if_true<(bool_const_expression)>::template then<true_type, false_type>::type
-  template <bool> struct if_true
+
+  // HP aCC cannot deal with missing names for template value parameters
+  template <bool b> struct if_true
   {
       template <class T, class F>
       struct then { typedef T type; };