Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r48781 - in branches/proto/v4: . boost boost/archive/impl boost/asio boost/asio/ip boost/asio/ssl/detail boost/dynamic_bitset boost/exception boost/functional/detail boost/fusion/view/ext_ boost/math/special_functions boost/numeric/ublas boost/proto boost/proto/detail boost/proto/transform boost/regex/v4 boost/serialization boost/test boost/test/impl boost/test/utils/basic_cstring libs/asio/doc libs/dynamic_bitset libs/exception/doc/source libs/exception/test libs/math/test libs/proto/test libs/serialization/test libs/test/test status tools/build/v2/build
From: eric_at_[hidden]
Date: 2008-09-14 21:54:04

Next message: dgregor_at_[hidden]: "[Boost-commit] svn:boost r48782 - sandbox/committee/concepts/stdlib"
Previous message: gennadiy.rozental_at_[hidden]: "[Boost-commit] svn:boost r48780 - trunk/boost/test/impl"

Author: eric_niebler
Date: 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
New Revision: 48781
URL: http://svn.boost.org/trac/boost/changeset/48781

Log:
merged from trunk
Added:
   branches/proto/v4/libs/exception/test/1-throw_exception_test.cpp
      - copied unchanged from r48780, /trunk/libs/exception/test/1-throw_exception_test.cpp
   branches/proto/v4/libs/exception/test/2-throw_exception_no_exceptions_test.cpp
      - copied unchanged from r48780, /trunk/libs/exception/test/2-throw_exception_no_exceptions_test.cpp
   branches/proto/v4/libs/exception/test/3-throw_exception_no_integration_test.cpp
      - copied unchanged from r48780, /trunk/libs/exception/test/3-throw_exception_no_integration_test.cpp
   branches/proto/v4/libs/exception/test/4-throw_exception_no_both_test.cpp
      - copied unchanged from r48780, /trunk/libs/exception/test/4-throw_exception_no_both_test.cpp
Properties modified:
   branches/proto/v4/ (props changed)
Text files modified:
   branches/proto/v4/boost/archive/impl/basic_binary_iprimitive.ipp | 11
   branches/proto/v4/boost/archive/impl/basic_binary_oprimitive.ipp | 11
   branches/proto/v4/boost/archive/impl/basic_text_iprimitive.ipp | 22
   branches/proto/v4/boost/archive/impl/basic_text_oprimitive.ipp | 7
   branches/proto/v4/boost/asio/ip/basic_resolver.hpp | 13
   branches/proto/v4/boost/asio/ssl/detail/openssl_operation.hpp | 4
   branches/proto/v4/boost/asio/version.hpp | 2
   branches/proto/v4/boost/dynamic_bitset/dynamic_bitset.hpp | 7
   branches/proto/v4/boost/exception/exception.hpp | 18
   branches/proto/v4/boost/functional/detail/float_functions.hpp | 14
   branches/proto/v4/boost/fusion/view/ext_/segmented_iterator.hpp | 13
   branches/proto/v4/boost/math/special_functions/expm1.hpp | 4
   branches/proto/v4/boost/math/special_functions/log1p.hpp | 4
   branches/proto/v4/boost/multi_index_container.hpp | 5
   branches/proto/v4/boost/numeric/ublas/hermitian.hpp | 16
   branches/proto/v4/boost/numeric/ublas/symmetric.hpp | 8
   branches/proto/v4/boost/progress.hpp | 10
   branches/proto/v4/boost/proto/detail/as_lvalue.hpp | 22
   branches/proto/v4/boost/proto/detail/poly_function.hpp | 36
   branches/proto/v4/boost/proto/extends.hpp | 121 +
   branches/proto/v4/boost/proto/make_expr.hpp | 189 +
   branches/proto/v4/boost/proto/proto_fwd.hpp | 93
   branches/proto/v4/boost/proto/transform/arg.hpp | 4
   branches/proto/v4/boost/proto/transform/call.hpp | 40
   branches/proto/v4/boost/regex/v4/basic_regex_creator.hpp | 18
   branches/proto/v4/boost/regex/v4/cpp_regex_traits.hpp | 6
   branches/proto/v4/boost/regex/v4/perl_matcher.hpp | 14
   branches/proto/v4/boost/regex/v4/perl_matcher_non_recursive.hpp | 18
   branches/proto/v4/boost/regex/v4/perl_matcher_recursive.hpp | 2
   branches/proto/v4/boost/regex/v4/regex_traits_defaults.hpp | 4
   branches/proto/v4/boost/regex/v4/states.hpp | 2
   branches/proto/v4/boost/regex/v4/u32regex_token_iterator.hpp | 4
   branches/proto/v4/boost/regex/v4/w32_regex_traits.hpp | 24
   branches/proto/v4/boost/serialization/throw_exception.hpp | 7
   branches/proto/v4/boost/test/framework.hpp | 1
   branches/proto/v4/boost/test/impl/compiler_log_formatter.ipp | 6
   branches/proto/v4/boost/test/impl/execution_monitor.ipp | 36
   branches/proto/v4/boost/test/impl/framework.ipp | 13
   branches/proto/v4/boost/test/impl/unit_test_main.ipp | 2
   branches/proto/v4/boost/test/impl/unit_test_suite.ipp | 7
   branches/proto/v4/boost/test/impl/xml_log_formatter.ipp | 3
   branches/proto/v4/boost/test/test_case_template.hpp | 3
   branches/proto/v4/boost/test/unit_test_suite_impl.hpp | 9
   branches/proto/v4/boost/test/utils/basic_cstring/basic_cstring.hpp | 16
   branches/proto/v4/libs/asio/doc/Jamfile.v2 | 2
   branches/proto/v4/libs/asio/doc/doxy2qbk.pl | 2
   branches/proto/v4/libs/asio/doc/reference.qbk | 32
   branches/proto/v4/libs/dynamic_bitset/bitset_test.hpp | 45
   branches/proto/v4/libs/dynamic_bitset/dyn_bitset_unit_tests1.cpp | 112 +
   branches/proto/v4/libs/dynamic_bitset/dynamic_bitset.html | 103
   branches/proto/v4/libs/exception/doc/source/boost-exception.reno | 3234 ++++++++++++++++++++--------------------
   branches/proto/v4/libs/exception/test/Jamfile.v2 | 4
   branches/proto/v4/libs/math/test/Jamfile.v2 | 65
   branches/proto/v4/libs/math/test/test_ibeta.cpp | 8
   branches/proto/v4/libs/math/test/test_ibeta_inv.cpp | 8
   branches/proto/v4/libs/math/test/test_ibeta_inv_ab.cpp | 9
   branches/proto/v4/libs/proto/test/matches.cpp | 14
   branches/proto/v4/libs/serialization/test/test_binary.cpp | 36
   branches/proto/v4/libs/serialization/test/test_exported.cpp | 2
   branches/proto/v4/libs/test/test/sync_access_test.cpp | 2
   branches/proto/v4/status/explicit-failures-markup.xml | 9
   branches/proto/v4/tools/build/v2/build/build-request.jam | 21
   branches/proto/v4/tools/build/v2/build/feature.jam | 6
   63 files changed, 2543 insertions(+), 2040 deletions(-)

Modified: branches/proto/v4/boost/archive/impl/basic_binary_iprimitive.ipp
==============================================================================
--- branches/proto/v4/boost/archive/impl/basic_binary_iprimitive.ipp (original)
+++ branches/proto/v4/boost/archive/impl/basic_binary_iprimitive.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -185,11 +185,12 @@
 int result = static_cast<detail::input_streambuf_access<Elem, Tr> &>(
 m_sb
 ).sync();
- if(0 != result){
- boost::serialization::throw_exception(
- archive_exception(archive_exception::stream_error)
- );
- }
+ //destructor can't throw !
+ //if(0 != result){
+ // boost::serialization::throw_exception(
+ // archive_exception(archive_exception::stream_error)
+ // );
+ //}
}

} // namespace archive

Modified: branches/proto/v4/boost/archive/impl/basic_binary_oprimitive.ipp
==============================================================================
--- branches/proto/v4/boost/archive/impl/basic_binary_oprimitive.ipp (original)
+++ branches/proto/v4/boost/archive/impl/basic_binary_oprimitive.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -155,11 +155,12 @@
 int result = static_cast<detail::output_streambuf_access<Elem, Tr> &>(
 m_sb
 ).sync();
- if(0 != result){
- boost::serialization::throw_exception(
- archive_exception(archive_exception::stream_error)
- );
- }
+ //destructor can't throw
+ //if(0 != result){
+ // boost::serialization::throw_exception(
+ // archive_exception(archive_exception::stream_error)
+ // );
+ //}
}

} // namespace archive

Modified: branches/proto/v4/boost/archive/impl/basic_text_iprimitive.ipp
==============================================================================
--- branches/proto/v4/boost/archive/impl/basic_text_iprimitive.ipp (original)
+++ branches/proto/v4/boost/archive/impl/basic_text_iprimitive.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -33,6 +33,23 @@
namespace boost {
namespace archive {

+namespace {
+ template<class CharType>
+ bool is_whitespace(CharType c);
+
+ template<>
+ bool is_whitespace(char t){
+ return std::isspace(t);
+ }
+
+ #ifndef BOOST_NO_CWCHAR
+ template<>
+ bool is_whitespace(wchar_t t){
+ return std::iswspace(t);
+ }
+ #endif
+}
+
// translate base64 text into binary and copy into buffer
// until buffer is full.
template<class IStream>
@@ -77,7 +94,6 @@
 );

 char * caddr = static_cast<char *>(address);
- std::size_t padding = 2 - count % 3;

 // take care that we don't increment anymore than necessary
 while(--count > 0){
@@ -86,10 +102,8 @@
 }
 *caddr++ = static_cast<char>(*ti_begin);

- if(padding > 1)
+ while(! is_whitespace(*ti_begin))
 ++ti_begin;
- if(padding > 2)
- ++ti_begin;
}

template<class IStream>

Modified: branches/proto/v4/boost/archive/impl/basic_text_oprimitive.ipp
==============================================================================
--- branches/proto/v4/boost/archive/impl/basic_text_oprimitive.ipp (original)
+++ branches/proto/v4/boost/archive/impl/basic_text_oprimitive.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -64,10 +64,11 @@
 ),
 oi
 );
- std::size_t padding = 2 - count % 3;
- if(padding > 1)
+
+ std::size_t tail = count % 3;
+ if(tail > 0)
 *oi = '=';
- if(padding > 2)
+ if(tail < 2)
 *oi = '=';

}

Modified: branches/proto/v4/boost/asio/ip/basic_resolver.hpp
==============================================================================
--- branches/proto/v4/boost/asio/ip/basic_resolver.hpp (original)
+++ branches/proto/v4/boost/asio/ip/basic_resolver.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -76,7 +76,7 @@
     return this->service.cancel(this->implementation);
   }

- /// Resolve a query to a list of entries.
+ /// Perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve a query into a list of endpoint entries.
    *
@@ -100,7 +100,7 @@
     return i;
   }

- /// Resolve a query to a list of entries.
+ /// Perform forward resolution of a query to a list of entries.
   /**
    * This function is used to resolve a query into a list of endpoint entries.
    *
@@ -122,7 +122,7 @@
     return this->service.resolve(this->implementation, q, ec);
   }

- /// Asynchronously resolve a query to a list of entries.
+ /// Asynchronously perform forward resolution of a query to a list of entries.
   /**
    * This function is used to asynchronously resolve a query into a list of
    * endpoint entries.
@@ -154,7 +154,7 @@
     return this->service.async_resolve(this->implementation, q, handler);
   }

- /// Resolve an endpoint to a list of entries.
+ /// Perform reverse resolution of an endpoint to a list of entries.
   /**
    * This function is used to resolve an endpoint into a list of endpoint
    * entries.
@@ -180,7 +180,7 @@
     return i;
   }

- /// Resolve an endpoint to a list of entries.
+ /// Perform reverse resolution of an endpoint to a list of entries.
   /**
    * This function is used to resolve an endpoint into a list of endpoint
    * entries.
@@ -204,7 +204,8 @@
     return this->service.resolve(this->implementation, e, ec);
   }

- /// Asynchronously resolve an endpoint to a list of entries.
+ /// Asynchronously perform reverse resolution of an endpoint to a list of
+ /// entries.
   /**
    * This function is used to asynchronously resolve an endpoint into a list of
    * endpoint entries.

Modified: branches/proto/v4/boost/asio/ssl/detail/openssl_operation.hpp
==============================================================================
--- branches/proto/v4/boost/asio/ssl/detail/openssl_operation.hpp (original)
+++ branches/proto/v4/boost/asio/ssl/detail/openssl_operation.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -159,6 +159,10 @@
           0;
     int sys_error_code = ERR_get_error();

+ if (error_code == SSL_ERROR_SSL)
+ return handler_(boost::system::error_code(
+ error_code, boost::asio::error::get_ssl_category()), rc);
+
     bool is_read_needed = (error_code == SSL_ERROR_WANT_READ);
     bool is_write_needed = (error_code == SSL_ERROR_WANT_WRITE ||
                               ::BIO_ctrl_pending( ssl_bio_ ));

Modified: branches/proto/v4/boost/asio/version.hpp
==============================================================================
--- branches/proto/v4/boost/asio/version.hpp (original)
+++ branches/proto/v4/boost/asio/version.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -18,6 +18,6 @@
// BOOST_ASIO_VERSION % 100 is the sub-minor version
// BOOST_ASIO_VERSION / 100 % 1000 is the minor version
// BOOST_ASIO_VERSION / 100000 is the major version
-#define BOOST_ASIO_VERSION 100200 // 1.2.0
+#define BOOST_ASIO_VERSION 100300 // 1.3.0

#endif // BOOST_ASIO_VERSION_HPP

Modified: branches/proto/v4/boost/dynamic_bitset/dynamic_bitset.hpp
==============================================================================
--- branches/proto/v4/boost/dynamic_bitset/dynamic_bitset.hpp (original)
+++ branches/proto/v4/boost/dynamic_bitset/dynamic_bitset.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -81,8 +81,11 @@

 // the one and only non-copy ctor
 reference(block_type & b, block_type pos)
- :m_block(b), m_mask(block_type(1) << pos)
- { assert( pos < bits_per_block); }
+ :m_block(b),
+ m_mask( (assert(pos < bits_per_block),
+ block_type(1) << pos )
+ )
+ { }

 void operator&(); // left undefined

Modified: branches/proto/v4/boost/exception/exception.hpp
==============================================================================
--- branches/proto/v4/boost/exception/exception.hpp (original)
+++ branches/proto/v4/boost/exception/exception.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -184,7 +184,23 @@
             {
             }

- virtual ~exception() throw() = 0;
+#ifdef __HP_aCC
+ //On HP aCC, this protected copy constructor prevents throwing boost::exception.
+ //On all other platforms, the same effect is achieved by the pure virtual destructor.
+ exception( exception const & x ) throw():
+ data_(x.data_),
+ throw_function_(x.throw_function_),
+ throw_file_(x.throw_file_),
+ throw_line_(x.throw_line_)
+ {
+ }
+#endif
+
+ virtual ~exception() throw()
+#ifndef __HP_aCC
+ = 0 //Workaround for HP aCC, =0 incorrectly leads to link errors.
+#endif
+ ;

         private:

Modified: branches/proto/v4/boost/functional/detail/float_functions.hpp
==============================================================================
--- branches/proto/v4/boost/functional/detail/float_functions.hpp (original)
+++ branches/proto/v4/boost/functional/detail/float_functions.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -61,9 +61,17 @@

// Dinkumware.
#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
-// I'm not sure which versions of Dinkumware have the C++ overloads
-// but they all seem to have the C99 float functions so I'll use them.
-# define BOOST_HASH_USE_C99_FLOAT_FUNCS
+// Some versions of Visual C++ don't seem to have the C++ overloads but they
+// all seem to have the c99 float overloads
+# if defined(BOOST_MSVC)
+# define BOOST_HASH_USE_C99_FLOAT_FUNCS
+// On other platforms the C++ overloads seem to have been introduced sometime
+// before 402.
+# elif defined(_CPPLIB_VER) && (_CPPLIB_VER >= 402)
+# define BOOST_HASH_USE_OVERLOAD_FLOAT_FUNCS
+# else
+# define BOOST_HASH_USE_C99_FLOAT_FUNCS
+# endif

// Digital Mars
#elif defined(__DMC__)

Modified: branches/proto/v4/boost/fusion/view/ext_/segmented_iterator.hpp
==============================================================================
--- branches/proto/v4/boost/fusion/view/ext_/segmented_iterator.hpp (original)
+++ branches/proto/v4/boost/fusion/view/ext_/segmented_iterator.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -47,6 +47,15 @@
 : is_empty<Sequence>
 {};

+ ////////////////////////////////////////////////////////////////////////////
+ struct not_is_empty_pred
+ {
+ template<typename Sequence>
+ struct apply
+ : not_<is_empty<Sequence> >
+ {};
+ };
+
 struct segmented_range_tag;

 ////////////////////////////////////////////////////////////////////////////
@@ -64,7 +73,7 @@
 // If this is a range of segments, skip over the empty ones
 typedef typename mpl::if_<
 is_segmented
- , filter_view<Sequence, not_<is_empty<_> > >
+ , filter_view<Sequence, not_is_empty_pred>
 , Sequence
>::type sequence_non_ref_type;

@@ -196,7 +205,7 @@
 {
 typedef typename result_of::segments<Sequence>::type segments;
 typedef typename remove_reference<segments>::type sequence;
- typedef typename result_of::begin<filter_view<sequence, not_<is_empty<_> > > >::type begin;
+ typedef typename result_of::begin<filter_view<sequence, not_is_empty_pred> >::type begin;
 typedef segmented_range<sequence, begin, true> type;

 static type call(Sequence &seq)

Modified: branches/proto/v4/boost/math/special_functions/expm1.hpp
==============================================================================
--- branches/proto/v4/boost/math/special_functions/expm1.hpp (original)
+++ branches/proto/v4/boost/math/special_functions/expm1.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -81,7 +81,7 @@
 return x;
 detail::expm1_series<T> s(x);
 boost::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) && !BOOST_WORKAROUND(__EDG_VERSION__, <= 245)
 T result = tools::sum_series(s, policies::digits<T, Policy>(), max_iter);
#else
 T zero = 0;
@@ -232,7 +232,7 @@
# undef expm1
#endif

-#ifdef BOOST_HAS_EXPM1
+#if defined(BOOST_HAS_EXPM1) && !(defined(__osf__) && defined(__DECCXX_VER))
# if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
inline float expm1(float x, const policies::policy<>&){ return ::expm1f(x); }
inline long double expm1(long double x, const policies::policy<>&){ return ::expm1l(x); }

Modified: branches/proto/v4/boost/math/special_functions/log1p.hpp
==============================================================================
--- branches/proto/v4/boost/math/special_functions/log1p.hpp (original)
+++ branches/proto/v4/boost/math/special_functions/log1p.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -94,7 +94,7 @@
 return x;
 detail::log1p_series<result_type> s(x);
 boost::uintmax_t max_iter = policies::get_max_series_iterations<Policy>();
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582)) && !BOOST_WORKAROUND(__EDG_VERSION__, <= 245)
 result_type result = tools::sum_series(s, policies::digits<result_type, Policy>(), max_iter);
#else
 result_type zero = 0;
@@ -315,7 +315,7 @@
# undef log1p
#endif

-#ifdef BOOST_HAS_LOG1P
+#if defined(BOOST_HAS_LOG1P) && !(defined(__osf__) && defined(__DECCXX_VER))
# if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)) \
 || ((defined(linux) || defined(__linux) || defined(__linux__)) && !defined(__SUNPRO_CC)) \
 || (defined(__hpux) && !defined(__hppa))

Modified: branches/proto/v4/boost/multi_index_container.hpp
==============================================================================
--- branches/proto/v4/boost/multi_index_container.hpp (original)
+++ branches/proto/v4/boost/multi_index_container.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -267,11 +267,10 @@
 }

 multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
- const multi_index_container<Value,IndexSpecifierList,Allocator>& x)
+ multi_index_container<Value,IndexSpecifierList,Allocator> x)
 {
 BOOST_MULTI_INDEX_CHECK_INVARIANT;
- multi_index_container<Value,IndexSpecifierList,Allocator> tmp(x);
- this->swap(tmp);
+ this->swap(x);
 return *this;
 }

Modified: branches/proto/v4/boost/numeric/ublas/hermitian.hpp
==============================================================================
--- branches/proto/v4/boost/numeric/ublas/hermitian.hpp (original)
+++ branches/proto/v4/boost/numeric/ublas/hermitian.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -498,7 +498,9 @@
         BOOST_UBLAS_INLINE
         iterator1 find1 (int rank, size_type i, size_type j) {
             if (rank == 1)
- i = triangular_type::mutable_restrict1 (i, j);
+ i = triangular_type::mutable_restrict1 (i, j, size1(), size2());
+ if (rank == 0)
+ i = triangular_type::global_mutable_restrict1 (i, size1(), j, size2());
             return iterator1 (*this, i, j);
         }
         BOOST_UBLAS_INLINE
@@ -508,7 +510,9 @@
         BOOST_UBLAS_INLINE
         iterator2 find2 (int rank, size_type i, size_type j) {
             if (rank == 1)
- j = triangular_type::mutable_restrict2 (i, j);
+ j = triangular_type::mutable_restrict2 (i, j, size1(), size2());
+ if (rank == 0)
+ j = triangular_type::global_mutable_restrict2 (i, size1(), j, size2());
             return iterator2 (*this, i, j);
         }

@@ -1416,7 +1420,9 @@
         BOOST_UBLAS_INLINE
         iterator1 find1 (int rank, size_type i, size_type j) {
             if (rank == 1)
- i = triangular_type::mutable_restrict1 (i, j);
+ i = triangular_type::mutable_restrict1 (i, j, size1(), size2());
+ if (rank == 0)
+ i = triangular_type::global_mutable_restrict1 (i, size1(), j, size2());
             return iterator1 (*this, data ().find1 (rank, i, j));
         }
         BOOST_UBLAS_INLINE
@@ -1446,7 +1452,9 @@
         BOOST_UBLAS_INLINE
         iterator2 find2 (int rank, size_type i, size_type j) {
             if (rank == 1)
- j = triangular_type::mutable_restrict2 (i, j);
+ j = triangular_type::mutable_restrict2 (i, j, size1(), size2());
+ if (rank == 0)
+ j = triangular_type::global_mutable_restrict2 (i, size1(), j, size2());
             return iterator2 (*this, data ().find2 (rank, i, j));
         }

Modified: branches/proto/v4/boost/numeric/ublas/symmetric.hpp
==============================================================================
--- branches/proto/v4/boost/numeric/ublas/symmetric.hpp (original)
+++ branches/proto/v4/boost/numeric/ublas/symmetric.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -281,7 +281,9 @@
         BOOST_UBLAS_INLINE
         iterator1 find1 (int rank, size_type i, size_type j) {
             if (rank == 1)
- i = triangular_type::mutable_restrict1 (i, j);
+ i = triangular_type::mutable_restrict1 (i, j, size1(), size2());
+ if (rank == 0)
+ i = triangular_type::global_mutable_restrict1 (i, size1(), j, size2());
             return iterator1 (*this, i, j);
         }
         BOOST_UBLAS_INLINE
@@ -291,7 +293,9 @@
         BOOST_UBLAS_INLINE
         iterator2 find2 (int rank, size_type i, size_type j) {
             if (rank == 1)
- j = triangular_type::mutable_restrict2 (i, j);
+ j = triangular_type::mutable_restrict2 (i, j, size1(), size2());
+ if (rank == 0)
+ j = triangular_type::global_mutable_restrict2 (i, size1(), j, size2());
             return iterator2 (*this, i, j);
         }

Modified: branches/proto/v4/boost/progress.hpp
==============================================================================
--- branches/proto/v4/boost/progress.hpp (original)
+++ branches/proto/v4/boost/progress.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -77,20 +77,20 @@
class progress_display : private noncopyable
{
 public:
- explicit progress_display( unsigned long expected_count,
+ explicit progress_display( unsigned long expected_count_,
 std::ostream & os = std::cout,
 const std::string & s1 = "\n", //leading strings
 const std::string & s2 = "",
 const std::string & s3 = "" )
 // os is hint; implementation may ignore, particularly in embedded systems
- : m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { restart(expected_count); }
+ : m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { restart(expected_count_); }

- void restart( unsigned long expected_count )
+ void restart( unsigned long expected_count_ )
 // Effects: display appropriate scale
- // Postconditions: count()==0, expected_count()==expected_count
+ // Postconditions: count()==0, expected_count()==expected_count_
 {
 _count = _next_tic_count = _tic = 0;
- _expected_count = expected_count;
+ _expected_count = expected_count_;

 m_os << m_s1 << "0% 10 20 30 40 50 60 70 80 90 100%\n"
 << m_s2 << "|----|----|----|----|----|----|----|----|----|----|"

Modified: branches/proto/v4/boost/proto/detail/as_lvalue.hpp
==============================================================================
--- branches/proto/v4/boost/proto/detail/as_lvalue.hpp (original)
+++ branches/proto/v4/boost/proto/detail/as_lvalue.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -17,32 +17,14 @@
{
 namespace detail
 {
- struct int_
- {
- int_() {}
- int_(int) {}
- };
-
 template<typename T>
- T &as_lvalue(T &t, int = 0)
+ T &as_lvalue(T &t)
 {
 return t;
 }

 template<typename T>
- T const &as_lvalue(T const &t, int = 0)
- {
- return t;
- }
-
- template<typename Ret, typename T>
- Ret as_lvalue(T &t, int_ = int_() BOOST_PROTO_DISABLE_IF_IS_CONST(T))
- {
- return t;
- }
-
- template<typename Ret, typename T>
- Ret as_lvalue(T const &t, int_ = int_())
+ T const &as_lvalue(T const &t)
 {
 return t;
 }

Modified: branches/proto/v4/boost/proto/detail/poly_function.hpp
==============================================================================
--- branches/proto/v4/boost/proto/detail/poly_function.hpp (original)
+++ branches/proto/v4/boost/proto/detail/poly_function.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -25,6 +25,11 @@
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 #include <boost/proto/proto_fwd.hpp>

+ #ifdef _MSC_VER
+ # pragma warning(push)
+ # pragma warning(disable: 4181) // const applied to reference type
+ #endif
+
 namespace boost { namespace proto { namespace detail
 {

@@ -132,9 +137,14 @@
 {};

 ////////////////////////////////////////////////////////////////////////////////////////////////
+ #define BOOST_PROTO_POLY_FUNCTION() \
+ typedef void is_poly_function_base_; \
+ /**/
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
 struct poly_function_base
 {
- typedef void is_poly_function_base_;
+ BOOST_PROTO_POLY_FUNCTION()
 };

 ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -163,6 +173,10 @@
 };

 ////////////////////////////////////////////////////////////////////////////////////////////////
+ template<typename PolyFunSig, bool IsPoly>
+ struct as_mono_function_impl;
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
 template<typename PolyFunSig>
 struct as_mono_function;

@@ -171,6 +185,10 @@

 }}} // namespace boost::proto::detail

+ #ifdef _MSC_VER
+ # pragma warning(pop)
+ #endif
+
 #endif

#elif 0 == BOOST_PP_ITERATION_FLAGS()
@@ -219,8 +237,22 @@

 ////////////////////////////////////////////////////////////////////////////////////////////////
 template<typename PolyFun, BOOST_PP_ENUM_PARAMS(N, typename A)>
+ struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), true>
+ {
+ typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> type;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ template<typename PolyFun, BOOST_PP_ENUM_PARAMS(N, typename A)>
+ struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), false>
+ {
+ typedef PolyFun type;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////
+ template<typename PolyFun, BOOST_PP_ENUM_PARAMS(N, typename A)>
 struct as_mono_function<PolyFun(BOOST_PP_ENUM_PARAMS(N, A))>
- : PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, A)>
+ : as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), is_poly_function<PolyFun>::value>
 {};

 #undef N

Modified: branches/proto/v4/boost/proto/extends.hpp
==============================================================================
--- branches/proto/v4/boost/proto/extends.hpp (original)
+++ branches/proto/v4/boost/proto/extends.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -94,12 +94,41 @@

 /// INTERNAL ONLY
 ///
- #define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
+ #define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const) \
+ template<typename... A> \
+ typename boost::result_of< \
+ proto_domain( \
+ typename boost::proto::result_of::funop< \
+ proto_derived_expr BOOST_PROTO_CONST ## Const(A const &...) \
+ , proto_derived_expr \
+ , proto_domain \
+ >::type \
+ ) \
+ >::type const \
+ operator ()(A const &...a) BOOST_PROTO_CONST ## Const \
+ { \
+ typedef boost::proto::result_of::funop< \
+ proto_derived_expr BOOST_PROTO_CONST ## Const(A const &...) \
+ , proto_derived_expr \
+ , proto_domain \
+ > funop; \
+ return proto_domain()( \
+ funop::call( \
+ *static_cast<proto_derived_expr BOOST_PROTO_CONST ## Const *>(this) \
+ , a... \
+ ) \
+ ); \
+ } \
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
 BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, 1)

 /// INTERNAL ONLY
 ///
- #define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
+ #define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
 BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, 0)

 /// INTERNAL ONLY
@@ -323,35 +352,53 @@
 }; \
 /**/

- #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
- BOOST_PROTO_EXTENDS_FUNCTION_() \
- BOOST_PP_REPEAT_FROM_TO( \
- 0 \
- , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
- , BOOST_PROTO_DEFINE_FUN_OP_CONST \
- , ~ \
- ) \
- /**/
-
- #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
- BOOST_PROTO_EXTENDS_FUNCTION_() \
- BOOST_PP_REPEAT_FROM_TO( \
- 0 \
- , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
- , BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \
- , ~ \
- ) \
- /**/
-
- #define BOOST_PROTO_EXTENDS_FUNCTION() \
- BOOST_PROTO_EXTENDS_FUNCTION_() \
- BOOST_PP_REPEAT_FROM_TO( \
- 0 \
- , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
- , BOOST_PROTO_DEFINE_FUN_OP \
- , ~ \
- ) \
- /**/
+ #ifdef BOOST_HAS_VARIADIC_TMPL
+ #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
+ BOOST_PROTO_EXTENDS_FUNCTION_() \
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1) \
+ /**/
+
+ #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
+ BOOST_PROTO_EXTENDS_FUNCTION_() \
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(0) \
+ /**/
+
+ #define BOOST_PROTO_EXTENDS_FUNCTION() \
+ BOOST_PROTO_EXTENDS_FUNCTION_() \
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(0) \
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1) \
+ /**/
+ #else
+ #define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
+ BOOST_PROTO_EXTENDS_FUNCTION_() \
+ BOOST_PP_REPEAT_FROM_TO( \
+ 0 \
+ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
+ , BOOST_PROTO_DEFINE_FUN_OP_CONST \
+ , ~ \
+ ) \
+ /**/
+
+ #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
+ BOOST_PROTO_EXTENDS_FUNCTION_() \
+ BOOST_PP_REPEAT_FROM_TO( \
+ 0 \
+ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
+ , BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \
+ , ~ \
+ ) \
+ /**/
+
+ #define BOOST_PROTO_EXTENDS_FUNCTION() \
+ BOOST_PROTO_EXTENDS_FUNCTION_() \
+ BOOST_PP_REPEAT_FROM_TO( \
+ 0 \
+ , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
+ , BOOST_PROTO_DEFINE_FUN_OP \
+ , ~ \
+ ) \
+ /**/
+ #endif

 #define BOOST_PROTO_EXTENDS(Expr, Derived, Domain) \
 BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
@@ -421,6 +468,9 @@
 // the operator() overloads, which is more efficient.
 BOOST_PROTO_EXTENDS_FUNCTION_()

+ #ifdef BOOST_HAS_VARIADIC_TMPL
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
+ #else
 /// INTERNAL ONLY
 ///
 #define BOOST_PP_LOCAL_MACRO(N) \
@@ -431,6 +481,8 @@
 ///
 #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
 #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif
 };

 /// \brief extends\<\> class template for adding behaviors to a Proto expression template
@@ -459,6 +511,11 @@
 // the operator() overloads, which is more efficient.
 BOOST_PROTO_EXTENDS_FUNCTION_()

+ #ifdef BOOST_HAS_VARIADIC_TMPL
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(0)
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
+ #else
+
 /// INTERNAL ONLY
 ///
 #define BOOST_PP_LOCAL_MACRO(N) \
@@ -469,6 +526,8 @@
 ///
 #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
 #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif
 };

 /// INTERNAL ONLY

Modified: branches/proto/v4/boost/proto/make_expr.hpp
==============================================================================
--- branches/proto/v4/boost/proto/make_expr.hpp (original)
+++ branches/proto/v4/boost/proto/make_expr.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -14,6 +14,8 @@

 #include <boost/proto/detail/prefix.hpp>
 #include <boost/version.hpp>
+ #include <boost/config.hpp>
+ #include <boost/detail/workaround.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/control/if.hpp>
 #include <boost/preprocessor/control/expr_if.hpp>
@@ -54,6 +56,8 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_reference.hpp>
+ #include <boost/type_traits/remove_cv.hpp>
+ #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/proto/proto_fwd.hpp>
 #include <boost/proto/traits.hpp>
@@ -68,6 +72,7 @@
 # include <boost/spirit/fusion/sequence/value_at.hpp>
 # include <boost/spirit/fusion/sequence/size.hpp>
 #endif
+ #include <boost/proto/detail/poly_function.hpp>
 #include <boost/proto/detail/suffix.hpp>

 #ifdef _MSC_VER
@@ -298,7 +303,7 @@
 ) \
 ) \
 BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT) \
- >::call( \
+ >()( \
 BOOST_PP_SEQ_ENUM( \
 BOOST_PP_SEQ_FOR_EACH_I( \
 BOOST_PROTO_VARARG_AS_EXPR_, ~ \
@@ -482,9 +487,9 @@
 struct make_expr_<tag::terminal, Domain, A
 BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)>
 {
- typedef typename proto::detail::protoify_<A, Domain>::type type;
+ typedef typename proto::detail::protoify_<A, Domain>::type result_type;

- static type const call(typename add_reference<A>::type a)
+ result_type operator()(typename add_reference<A>::type a) const
 {
 return proto::detail::protoify_<A, Domain>::call(a);
 }
@@ -496,6 +501,73 @@
 : make_expr_<tag::terminal, default_domain, A>
 {};

+ template<typename Base, typename Expr>
+ Expr implicit_expr_wrap(Base const &expr, mpl::false_, Expr *)
+ {
+ return Expr(expr);
+ }
+
+ template<typename Base, typename Expr>
+ Expr implicit_expr_wrap(Base const &expr, mpl::true_, Expr *)
+ {
+ Expr that = {expr};
+ return that;
+ }
+
+ template<typename A0, typename Void = void>
+ struct implicit_expr_1
+ {
+ A0 &a0;
+
+ template<typename Args>
+ operator proto::expr<tag::terminal, Args, 0>() const
+ {
+ proto::expr<tag::terminal, Args, 0> that = {this->a0};
+ return that;
+ };
+
+ template<typename Expr>
+ operator Expr() const
+ {
+ typename Expr::proto_base_expr that = *this;
+ return detail::implicit_expr_wrap(that, is_aggregate<Expr>(), static_cast<Expr *>(0));
+ }
+ };
+
+ template<typename A0>
+ struct implicit_expr_1<A0, typename A0::proto_is_expr_>
+ {
+ A0 &a0;
+
+ #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(1010))
+ typedef typename remove_cv<A0>::type uncv_a0_type;
+
+ operator uncv_a0_type &() const
+ {
+ return const_cast<uncv_a0_type &>(this->a0);
+ }
+ #else
+ operator A0 &() const
+ {
+ return this->a0;
+ }
+ #endif
+
+ template<typename Tag, typename Args>
+ operator proto::expr<Tag, Args, 1>() const
+ {
+ proto::expr<Tag, Args, 1> that = {this->a0};
+ return that;
+ };
+
+ template<typename Expr>
+ operator Expr() const
+ {
+ typename Expr::proto_base_expr that = *this;
+ return detail::implicit_expr_wrap(that, is_aggregate<Expr>(), static_cast<Expr *>(0));
+ }
+ };
+
 #define BOOST_PP_ITERATION_PARAMS_1 \
 (4, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/make_expr.hpp>, 1)) \
 /**/
@@ -541,7 +613,7 @@
 Tag
 , deduce_domain
 BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
- >::type
+ >::result_type
 type;
 };

@@ -589,7 +661,7 @@
 Tag
 , Domain
 BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
- >::type
+ >::result_type
 type;
 };

@@ -665,6 +737,7 @@
 struct make_expr
 {
 BOOST_PROTO_CALLABLE()
+ BOOST_PROTO_POLY_FUNCTION()

 template<typename Sig>
 struct result;
@@ -690,14 +763,14 @@
 Tag
 , Domain
 , A0 const
- >::type const
+ >::type
 operator ()(A0 const &a0) const
 {
 return proto::detail::make_expr_<
 Tag
 , Domain
 , A0 const
- >::call(a0);
+ >()(a0);
 }

 // Additional overloads generated by the preprocessor ...
@@ -707,6 +780,23 @@
 /**/

 #include BOOST_PP_ITERATE()
+
+ /// INTERNAL ONLY
+ ///
+ template<
+ BOOST_PP_ENUM_BINARY_PARAMS(
+ BOOST_PROTO_MAX_ARITY
+ , typename A
+ , = void BOOST_PP_INTERCEPT
+ )
+ >
+ struct impl
+ : detail::make_expr_<
+ Tag
+ , Domain
+ BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, A)
+ >
+ {};
 };

 /// \brief A callable function object equivalent to the
@@ -744,7 +834,7 @@
 /// \param sequence A Fusion Random Access Sequence
 /// \return <tt>proto::unpack_expr\<Tag, Domain\>(sequence)</tt>
 template<typename Sequence>
- typename result_of::unpack_expr<Tag, Domain, Sequence const>::type const
+ typename result_of::unpack_expr<Tag, Domain, Sequence const>::type
 operator ()(Sequence const &sequence) const
 {
 return proto::detail::unpack_expr_<
@@ -779,7 +869,7 @@
 };

 template<typename Sequence>
- typename proto::result_of::unpack_expr<Tag, Domain, Sequence const>::type const
+ typename proto::result_of::unpack_expr<Tag, Domain, Sequence const>::type
 operator ()(Sequence const &sequence) const
 {
 return proto::detail::unpack_expr_<
@@ -802,30 +892,6 @@

 } // namespace functional

- /// TODO document me
- template<typename Tag, typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= deduce_domain)>
- struct _make_expr : callable
- {
- template<typename Sig>
- struct result
- : functional::make_expr<Tag, Domain>::template result<Sig>
- {};
-
- #define M0(Z, N, DATA) \
- template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \
- BOOST_PP_CAT(detail::implicit_expr_, N)<BOOST_PP_ENUM_PARAMS_Z(Z, N, A)> \
- operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, &a)) const \
- { \
- BOOST_PP_CAT(detail::implicit_expr_, N)<BOOST_PP_ENUM_PARAMS_Z(Z, N, A)> that = { \
- BOOST_PP_ENUM_PARAMS_Z(Z, N, a) \
- }; \
- return that; \
- } \
- /**/
- BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~)
- #undef M0
- };
-
 /// \brief Construct an expression of the requested tag type
 /// with a domain and with the specified arguments as children.
 ///
@@ -861,7 +927,7 @@
 Tag
 , deduce_domain
 , A0 const
- >::call(a0);
+ >()(a0);
 }

 /// \overload
@@ -878,7 +944,7 @@
 Tag
 , Domain
 , B0 const
- >::call(b0);
+ >()(b0);
 }

 // Additional overloads generated by the preprocessor...
@@ -983,13 +1049,6 @@
 : mpl::true_
 {};

- /// INTERNAL ONLY
- ///
- template<typename Tag, typename Domain>
- struct is_callable<_make_expr<Tag, Domain> >
- : mpl::true_
- {};
-
 }}

 #ifdef _MSC_VER
@@ -1008,6 +1067,7 @@
 #define N BOOST_PP_ITERATION()
 #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N)

+ #if N > 1
 template<BOOST_PP_ENUM_PARAMS(N, typename A)>
 struct BOOST_PP_CAT(implicit_expr_, N)
 {
@@ -1015,21 +1075,6 @@
 BOOST_PP_REPEAT(N, M0, ~)
 #undef M0

- #if N == 1
- operator A0 &() const
- {
- return this->a0;
- }
-
- template<typename Args>
- operator proto::expr<tag::terminal, Args, 0>() const
- {
- proto::expr<tag::terminal, Args, 0> that = {this->a0};
- return that;
- };
- #endif
-
- #if N > 0
 template<typename Tag, typename Args>
 operator proto::expr<Tag, Args, N>() const
 {
@@ -1043,29 +1088,15 @@
 proto::expr<Tag, Args, N> that = {BOOST_PP_ENUM_PARAMS(N, c)};
 return that;
 };
- #endif

 template<typename Expr>
 operator Expr() const
 {
 typename Expr::proto_base_expr that = *this;
- return this->wrap(that, is_aggregate<Expr>(), static_cast<Expr *>(0));
- }
-
- private:
- template<typename Base, typename Expr>
- static Expr wrap(Base const &expr, mpl::false_, Expr *)
- {
- return Expr(expr);
- }
-
- template<typename Base, typename Expr>
- static Expr wrap(Base const &expr, mpl::true_, Expr *)
- {
- Expr that = {expr};
- return that;
+ return detail::implicit_expr_wrap(that, is_aggregate<Expr>(), static_cast<Expr *>(0));
 }
 };
+ #endif

 template<BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename T)>
 struct select_nth<BOOST_PP_DEC(N), BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, T)>
@@ -1130,9 +1161,9 @@
 , BOOST_PP_CAT(list, N)<BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_TYPE, (A, ~, Domain)) >
> expr_type;

- typedef typename Domain::template result<void(expr_type)>::type type;
+ typedef typename Domain::template result<void(expr_type)>::type result_type;

- static type const call(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a))
+ result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const
 {
 expr_type that = {
 BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD, (A, a, Domain))
@@ -1210,14 +1241,14 @@
 Tag
 , Domain
 BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
- >::type const
+ >::type
 operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) const
 {
 return proto::detail::make_expr_<
 Tag
 , Domain
 BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
- >::call(BOOST_PP_ENUM_PARAMS(N, a));
+ >()(BOOST_PP_ENUM_PARAMS(N, a));
 }

 #undef N
@@ -1242,7 +1273,7 @@
 Tag
 , deduce_domain
 BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
- >::call(BOOST_PP_ENUM_PARAMS(N, a));
+ >()(BOOST_PP_ENUM_PARAMS(N, a));
 }

 /// \overload
@@ -1259,7 +1290,7 @@
 Tag
 , Domain
 BOOST_PP_ENUM_TRAILING_PARAMS(N, const B)
- >::call(BOOST_PP_ENUM_PARAMS(N, b));
+ >()(BOOST_PP_ENUM_PARAMS(N, b));
 }

 #undef N

Modified: branches/proto/v4/boost/proto/proto_fwd.hpp
==============================================================================
--- branches/proto/v4/boost/proto/proto_fwd.hpp (original)
+++ branches/proto/v4/boost/proto/proto_fwd.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -642,54 +642,51 @@
 typedef functional::eval _eval;
 typedef functional::deep_copy _deep_copy;

- template<typename Tag, typename Domain = deduce_domain>
- struct _make_expr;
-
- typedef _make_expr<tag::terminal> _make_terminal;
- typedef _make_expr<tag::unary_plus> _make_unary_plus;
- typedef _make_expr<tag::negate> _make_negate;
- typedef _make_expr<tag::dereference> _make_dereference;
- typedef _make_expr<tag::complement> _make_complement;
- typedef _make_expr<tag::address_of> _make_address_of;
- typedef _make_expr<tag::logical_not> _make_logical_not;
- typedef _make_expr<tag::pre_inc> _make_pre_inc;
- typedef _make_expr<tag::pre_dec> _make_pre_dec;
- typedef _make_expr<tag::post_inc> _make_post_inc;
- typedef _make_expr<tag::post_dec> _make_post_dec;
- typedef _make_expr<tag::shift_left> _make_shift_left;
- typedef _make_expr<tag::shift_right> _make_shift_right;
- typedef _make_expr<tag::multiplies> _make_multiplies;
- typedef _make_expr<tag::divides> _make_divides;
- typedef _make_expr<tag::modulus> _make_modulus;
- typedef _make_expr<tag::plus> _make_plus;
- typedef _make_expr<tag::minus> _make_minus;
- typedef _make_expr<tag::less> _make_less;
- typedef _make_expr<tag::greater> _make_greater;
- typedef _make_expr<tag::less_equal> _make_less_equal;
- typedef _make_expr<tag::greater_equal> _make_greater_equal;
- typedef _make_expr<tag::equal_to> _make_equal_to;
- typedef _make_expr<tag::not_equal_to> _make_not_equal_to;
- typedef _make_expr<tag::logical_or> _make_logical_or;
- typedef _make_expr<tag::logical_and> _make_logical_and;
- typedef _make_expr<tag::bitwise_and> _make_bitwise_and;
- typedef _make_expr<tag::bitwise_or> _make_bitwise_or;
- typedef _make_expr<tag::bitwise_xor> _make_bitwise_xor;
- typedef _make_expr<tag::comma> _make_comma;
- typedef _make_expr<tag::mem_ptr> _make_mem_ptr;
- typedef _make_expr<tag::assign> _make_assign;
- typedef _make_expr<tag::shift_left_assign> _make_shift_left_assign;
- typedef _make_expr<tag::shift_right_assign> _make_shift_right_assign;
- typedef _make_expr<tag::multiplies_assign> _make_multiplies_assign;
- typedef _make_expr<tag::divides_assign> _make_divides_assign;
- typedef _make_expr<tag::modulus_assign> _make_modulus_assign;
- typedef _make_expr<tag::plus_assign> _make_plus_assign;
- typedef _make_expr<tag::minus_assign> _make_minus_assign;
- typedef _make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign;
- typedef _make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign;
- typedef _make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign;
- typedef _make_expr<tag::subscript> _make_subscript;
- typedef _make_expr<tag::if_else_> _make_if_else;
- typedef _make_expr<tag::function> _make_function;
+ typedef functional::make_expr<tag::terminal> _make_terminal;
+ typedef functional::make_expr<tag::unary_plus> _make_unary_plus;
+ typedef functional::make_expr<tag::negate> _make_negate;
+ typedef functional::make_expr<tag::dereference> _make_dereference;
+ typedef functional::make_expr<tag::complement> _make_complement;
+ typedef functional::make_expr<tag::address_of> _make_address_of;
+ typedef functional::make_expr<tag::logical_not> _make_logical_not;
+ typedef functional::make_expr<tag::pre_inc> _make_pre_inc;
+ typedef functional::make_expr<tag::pre_dec> _make_pre_dec;
+ typedef functional::make_expr<tag::post_inc> _make_post_inc;
+ typedef functional::make_expr<tag::post_dec> _make_post_dec;
+ typedef functional::make_expr<tag::shift_left> _make_shift_left;
+ typedef functional::make_expr<tag::shift_right> _make_shift_right;
+ typedef functional::make_expr<tag::multiplies> _make_multiplies;
+ typedef functional::make_expr<tag::divides> _make_divides;
+ typedef functional::make_expr<tag::modulus> _make_modulus;
+ typedef functional::make_expr<tag::plus> _make_plus;
+ typedef functional::make_expr<tag::minus> _make_minus;
+ typedef functional::make_expr<tag::less> _make_less;
+ typedef functional::make_expr<tag::greater> _make_greater;
+ typedef functional::make_expr<tag::less_equal> _make_less_equal;
+ typedef functional::make_expr<tag::greater_equal> _make_greater_equal;
+ typedef functional::make_expr<tag::equal_to> _make_equal_to;
+ typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to;
+ typedef functional::make_expr<tag::logical_or> _make_logical_or;
+ typedef functional::make_expr<tag::logical_and> _make_logical_and;
+ typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and;
+ typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or;
+ typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor;
+ typedef functional::make_expr<tag::comma> _make_comma;
+ typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr;
+ typedef functional::make_expr<tag::assign> _make_assign;
+ typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign;
+ typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign;
+ typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign;
+ typedef functional::make_expr<tag::divides_assign> _make_divides_assign;
+ typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign;
+ typedef functional::make_expr<tag::plus_assign> _make_plus_assign;
+ typedef functional::make_expr<tag::minus_assign> _make_minus_assign;
+ typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign;
+ typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign;
+ typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign;
+ typedef functional::make_expr<tag::subscript> _make_subscript;
+ typedef functional::make_expr<tag::if_else_> _make_if_else;
+ typedef functional::make_expr<tag::function> _make_function;

 template<typename T>
 struct is_callable;

Modified: branches/proto/v4/boost/proto/transform/arg.hpp
==============================================================================
--- branches/proto/v4/boost/proto/transform/arg.hpp (original)
+++ branches/proto/v4/boost/proto/transform/arg.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -271,7 +271,7 @@
 /// \return <tt>t</tt>
 /// \throw nothrow
 template<typename T>
- T const &operator ()(T const &t) const
+ T operator ()(T const &t) const
 {
 return t;
 }
@@ -279,7 +279,7 @@
 /// \overload
 ///
 template<typename T>
- T &operator ()(boost::reference_wrapper<T> const &t) const
+ T operator ()(boost::reference_wrapper<T> const &t) const
 {
 return t;
 }

Modified: branches/proto/v4/boost/proto/transform/call.hpp
==============================================================================
--- branches/proto/v4/boost/proto/transform/call.hpp (original)
+++ branches/proto/v4/boost/proto/transform/call.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -26,6 +26,7 @@
 #include <boost/proto/transform/impl.hpp>
 #include <boost/proto/detail/dont_care.hpp>
 #include <boost/proto/detail/as_lvalue.hpp>
+ #include <boost/proto/detail/poly_function.hpp>
 #include <boost/proto/detail/suffix.hpp>

 namespace boost { namespace proto
@@ -142,15 +143,16 @@
 : transform_impl<Expr, State, Data>
 {
 typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
- typedef typename boost::result_of<Fun(a0)>::type result_type;
+ typedef typename detail::as_mono_function<Fun(a0)>::type mono_fun;
+ typedef typename boost::result_of<mono_fun(a0)>::type result_type;
 result_type operator ()(
 typename impl2::expr_param expr
 , typename impl2::state_param state
 , typename impl2::data_param data
 ) const
 {
- return Fun()(
- detail::as_lvalue<a0>(typename when<_, A0>::template impl<Expr, State, Data>()(expr, state, data), 0)
+ return mono_fun()(
+ detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(expr, state, data))
 );
 }
 };
@@ -212,16 +214,17 @@
 {
 typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
 typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1;
- typedef typename boost::result_of<Fun(a0, a1)>::type result_type;
+ typedef typename detail::as_mono_function<Fun(a0, a1)>::type mono_fun;
+ typedef typename boost::result_of<mono_fun(a0, a1)>::type result_type;
 result_type operator ()(
 typename impl2::expr_param expr
 , typename impl2::state_param state
 , typename impl2::data_param data
 ) const
 {
- return Fun()(
- detail::as_lvalue<a0>(typename when<_, A0>::template impl<Expr, State, Data>()(expr, state, data), 0)
- , detail::as_lvalue<a1>(typename when<_, A1>::template impl<Expr, State, Data>()(expr, state, data), 0)
+ return mono_fun()(
+ detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(expr, state, data))
+ , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(expr, state, data))
 );
 }
 };
@@ -292,17 +295,18 @@
 typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
 typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1;
 typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2;
- typedef typename boost::result_of<Fun(a0, a1, a2)>::type result_type;
+ typedef typename detail::as_mono_function<Fun(a0, a1, a2)>::type mono_fun;
+ typedef typename boost::result_of<mono_fun(a0, a1, a2)>::type result_type;
 result_type operator ()(
 typename impl2::expr_param expr
 , typename impl2::state_param state
 , typename impl2::data_param data
 ) const
 {
- return Fun()(
- detail::as_lvalue<a0>(typename when<_, A0>::template impl<Expr, State, Data>()(expr, state, data), 0)
- , detail::as_lvalue<a1>(typename when<_, A1>::template impl<Expr, State, Data>()(expr, state, data), 0)
- , detail::as_lvalue<a2>(typename when<_, A2>::template impl<Expr, State, Data>()(expr, state, data), 0)
+ return mono_fun()(
+ detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(expr, state, data))
+ , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(expr, state, data))
+ , detail::as_lvalue(typename when<_, A2>::template impl<Expr, State, Data>()(expr, state, data))
 );
 }
 };
@@ -384,7 +388,11 @@
 #undef M0

 typedef
- typename boost::result_of<Fun(BOOST_PP_ENUM_PARAMS(N, a))>::type
+ typename detail::as_mono_function<Fun(BOOST_PP_ENUM_PARAMS(N, a))>::type
+ mono_fun;
+
+ typedef
+ typename boost::result_of<mono_fun(BOOST_PP_ENUM_PARAMS(N, a))>::type
 result_type;

 /// Let \c ax be <tt>when\<_, Ax\>()(expr, state, data)</tt>
@@ -401,10 +409,10 @@
 ) const
 {
 #define M0(Z, M, DATA) \
- detail::as_lvalue<BOOST_PP_CAT(a, M)>( \
+ detail::as_lvalue( \
 typename when<_, BOOST_PP_CAT(A, M)> \
- ::template impl<Expr, State, Data>()(expr, state, data), 0) \
- return Fun()(BOOST_PP_ENUM(N, M0, ~));
+ ::template impl<Expr, State, Data>()(expr, state, data)) \
+ return mono_fun()(BOOST_PP_ENUM(N, M0, ~));
 #undef M0
 }
 };

Modified: branches/proto/v4/boost/regex/v4/basic_regex_creator.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/basic_regex_creator.hpp (original)
+++ branches/proto/v4/boost/regex/v4/basic_regex_creator.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -236,7 +236,7 @@
 m_traits; // convenience reference to traits class
 re_syntax_base* m_last_state; // the last state we added
 bool m_icase; // true for case insensitive matches
- unsigned m_repeater_id; // the id of the next repeater
+ unsigned m_repeater_id; // the state_id of the next repeater
 bool m_has_backrefs; // true if there are actually any backrefs
 unsigned m_backrefs; // bitmask of permitted backrefs
 boost::uintmax_t m_bad_repeats; // bitmask of repeats we can't deduce a startmap for;
@@ -718,8 +718,8 @@
 case syntax_element_char_rep:
 case syntax_element_short_set_rep:
 case syntax_element_long_set_rep:
- // set the id of this repeat:
- static_cast<re_repeat*>(state)->id = m_repeater_id++;
+ // set the state_id of this repeat:
+ static_cast<re_repeat*>(state)->state_id = m_repeater_id++;
 // fall through:
 case syntax_element_alt:
 std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map));
@@ -1194,11 +1194,11 @@
 case syntax_element_short_set_rep:
 case syntax_element_long_set_rep:
 {
- unsigned id = static_cast<re_repeat*>(pt)->id;
- if(id > sizeof(m_bad_repeats) * CHAR_BIT)
+ unsigned state_id = static_cast<re_repeat*>(pt)->state_id;
+ if(state_id > sizeof(m_bad_repeats) * CHAR_BIT)
 return true; // run out of bits, assume we can't traverse this one.
 static const boost::uintmax_t one = 1uL;
- return m_bad_repeats & (one << id);
+ return m_bad_repeats & (one << state_id);
 }
 default:
 return false;
@@ -1216,10 +1216,10 @@
 case syntax_element_short_set_rep:
 case syntax_element_long_set_rep:
 {
- unsigned id = static_cast<re_repeat*>(pt)->id;
+ unsigned state_id = static_cast<re_repeat*>(pt)->state_id;
 static const boost::uintmax_t one = 1uL;
- if(id <= sizeof(m_bad_repeats) * CHAR_BIT)
- m_bad_repeats |= (one << id);
+ if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT)
+ m_bad_repeats |= (one << state_id);
 }
 default:
 break;

Modified: branches/proto/v4/boost/regex/v4/cpp_regex_traits.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/cpp_regex_traits.hpp (original)
+++ branches/proto/v4/boost/regex/v4/cpp_regex_traits.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -799,9 +799,9 @@
 if(pos != m_custom_class_names.end())
 return pos->second;
 }
- std::size_t id = 1 + re_detail::get_default_class_id(p1, p2);
- BOOST_ASSERT(id < sizeof(masks) / sizeof(masks[0]));
- return masks[id];
+ std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
+ BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));
+ return masks[state_id];
}

#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET

Modified: branches/proto/v4/boost/regex/v4/perl_matcher.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/perl_matcher.hpp (original)
+++ branches/proto/v4/boost/regex/v4/perl_matcher.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -248,7 +248,7 @@
{
 repeater_count** stack;
 repeater_count* next;
- int id;
+ int state_id;
 std::size_t count; // the number of iterations so far
 BidiIterator start_pos; // where the last repeat started
public:
@@ -256,22 +256,22 @@
 {
 stack = s;
 next = 0;
- id = -1;
+ state_id = -1;
 count = 0;
 }
 repeater_count(int i, repeater_count** s, BidiIterator start)
 : start_pos(start)
 {
- id = i;
+ state_id = i;
 stack = s;
 next = *stack;
 *stack = this;
- if(id > next->id)
+ if(state_id > next->state_id)
 count = 0;
 else
 {
 repeater_count* p = next;
- while(p->id != id)
+ while(p->state_id != state_id)
 p = p->next;
 count = p->count;
 start_pos = p->start_pos;
@@ -282,7 +282,7 @@
 *stack = next;
 }
 std::size_t get_count() { return count; }
- int get_id() { return id; }
+ int get_id() { return state_id; }
 std::size_t operator++() { return ++count; }
 bool check_null_repeat(const BidiIterator& pos, std::size_t max)
 {
@@ -487,7 +487,7 @@
 void push_assertion(const re_syntax_base* ps, bool positive);
 void push_alt(const re_syntax_base* ps);
 void push_repeater_count(int i, repeater_count<BidiIterator>** s);
- void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id);
+ void push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id);
 void push_non_greedy_repeat(const re_syntax_base* ps);

Modified: branches/proto/v4/boost/regex/v4/perl_matcher_non_recursive.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/perl_matcher_non_recursive.hpp (original)
+++ branches/proto/v4/boost/regex/v4/perl_matcher_non_recursive.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -50,13 +50,13 @@
struct saved_state
{
 union{
- unsigned int id;
+ unsigned int state_id;
 // this padding ensures correct alignment on 64-bit platforms:
 std::size_t padding1;
 std::ptrdiff_t padding2;
 void* padding3;
 };
- saved_state(unsigned i) : id(i) {}
+ saved_state(unsigned i) : state_id(i) {}
};

template <class BidiIterator>
@@ -298,7 +298,7 @@
}

template <class BidiIterator, class Allocator, class traits>
-inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int id)
+inline void perl_matcher<BidiIterator, Allocator, traits>::push_single_repeat(std::size_t c, const re_repeat* r, BidiIterator last_position, int state_id)
{
 saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
 --pmp;
@@ -308,7 +308,7 @@
 pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
 --pmp;
 }
- (void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, id);
+ (void) new (pmp)saved_single_repeat<BidiIterator>(c, r, last_position, state_id);
 m_backup_state = pmp;
}

@@ -477,13 +477,13 @@
 take_second = can_start(*position, rep->_map, (unsigned char)mask_skip);
 }

- if((m_backup_state->id != saved_state_repeater_count)
- || (static_cast<saved_repeater<BidiIterator>*>(m_backup_state)->count.get_id() != rep->id)
- || (next_count->get_id() != rep->id))
+ if((m_backup_state->state_id != saved_state_repeater_count)
+ || (static_cast<saved_repeater<BidiIterator>*>(m_backup_state)->count.get_id() != rep->state_id)
+ || (next_count->get_id() != rep->state_id))
 {
 // we're moving to a different repeat from the last
 // one, so set up a counter object:
- push_repeater_count(rep->id, &next_count);
+ push_repeater_count(rep->state_id, &next_count);
 }
 //
 // If we've had at least one repeat already, and the last one
@@ -884,7 +884,7 @@
 //
 do
 {
- unwinder = s_unwind_table[m_backup_state->id];
+ unwinder = s_unwind_table[m_backup_state->state_id];
 cont = (this->*unwinder)(m_recursive_result);
 }while(cont);
 //

Modified: branches/proto/v4/boost/regex/v4/perl_matcher_recursive.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/perl_matcher_recursive.hpp (original)
+++ branches/proto/v4/boost/regex/v4/perl_matcher_recursive.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -291,7 +291,7 @@
 // Always copy the repeat count, so that the state is restored
 // when we exit this scope:
 //
- repeater_count<BidiIterator> r(rep->id, &next_count, position);
+ repeater_count<BidiIterator> r(rep->state_id, &next_count, position);
 //
 // If we've had at least one repeat already, and the last one
 // matched the NULL string then set the repeat count to

Modified: branches/proto/v4/boost/regex/v4/regex_traits_defaults.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/regex_traits_defaults.hpp (original)
+++ branches/proto/v4/boost/regex/v4/regex_traits_defaults.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -134,8 +134,8 @@
BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name);

//
-// get the id of a character clasification, the individual
-// traits classes then transform that id into a bitmask:
+// get the state_id of a character clasification, the individual
+// traits classes then transform that state_id into a bitmask:
//
template <class charT>
struct character_pointer_range

Modified: branches/proto/v4/boost/regex/v4/states.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/states.hpp (original)
+++ branches/proto/v4/boost/regex/v4/states.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -240,7 +240,7 @@
struct re_repeat : public re_alt
{
    std::size_t min, max; // min and max allowable repeats
- int id; // Unique identifier for this repeat
+ int state_id; // Unique identifier for this repeat
    bool leading; // True if this repeat is at the start of the machine (lets us optimize some searches)
    bool greedy; // True if this is a greedy repeat
};

Modified: branches/proto/v4/boost/regex/v4/u32regex_token_iterator.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/u32regex_token_iterator.hpp (original)
+++ branches/proto/v4/boost/regex/v4/u32regex_token_iterator.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -271,7 +271,7 @@
typedef u32regex_token_iterator<const UChar*> utf16regex_token_iterator;
typedef u32regex_token_iterator<const UChar32*> utf32regex_token_iterator;

-// construction from an integral sub_match id:
+// construction from an integral sub_match state_id:
inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, int submatch = 0, regex_constants::match_flag_type m = regex_constants::match_default)
{
return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);
@@ -333,7 +333,7 @@
}
#endif // BOOST_MSVC < 1300

-// construction from a vector of sub_match id's:
+// construction from a vector of sub_match state_id's:
inline u32regex_token_iterator<const char*> make_u32regex_token_iterator(const char* p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default)
{
return u32regex_token_iterator<const char*>(p, p+std::strlen(p), e, submatch, m);

Modified: branches/proto/v4/boost/regex/v4/w32_regex_traits.hpp
==============================================================================
--- branches/proto/v4/boost/regex/v4/w32_regex_traits.hpp (original)
+++ branches/proto/v4/boost/regex/v4/w32_regex_traits.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -76,36 +76,36 @@
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(wchar_t, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(unsigned short ca, lcid_type id);
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_lower(unsigned short ca, lcid_type state_id);
#endif
#endif
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(char, lcid_type);
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(wchar_t, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(unsigned short ca, lcid_type id);
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is_upper(unsigned short ca, lcid_type state_id);
#endif
#endif
BOOST_REGEX_DECL cat_type BOOST_REGEX_CALL w32_cat_open(const std::string& name);
-BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type id, int i, const std::string& def);
+BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type state_id, int i, const std::string& def);
#ifndef BOOST_NO_WREGEX
-BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type id, int i, const std::wstring& def);
+BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type state_id, int i, const std::wstring& def);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_cat_get(const cat_type& cat, lcid_type, int i, const std::basic_string<unsigned short>& def);
#endif
#endif
-BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_transform(lcid_type id, const char* p1, const char* p2);
+BOOST_REGEX_DECL std::string BOOST_REGEX_CALL w32_transform(lcid_type state_id, const char* p1, const char* p2);
#ifndef BOOST_NO_WREGEX
-BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_transform(lcid_type id, const wchar_t* p1, const wchar_t* p2);
+BOOST_REGEX_DECL std::wstring BOOST_REGEX_CALL w32_transform(lcid_type state_id, const wchar_t* p1, const wchar_t* p2);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_transform(lcid_type id, const unsigned short* p1, const unsigned short* p2);
+BOOST_REGEX_DECL std::basic_string<unsigned short> BOOST_REGEX_CALL w32_transform(lcid_type state_id, const unsigned short* p1, const unsigned short* p2);
#endif
#endif
BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_tolower(char c, lcid_type);
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL w32_tolower(wchar_t c, lcid_type);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_tolower(unsigned short c, lcid_type id);
+BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL w32_tolower(unsigned short c, lcid_type state_id);
#endif
#endif
BOOST_REGEX_DECL char BOOST_REGEX_CALL w32_toupper(char c, lcid_type);
@@ -116,7 +116,7 @@
#ifndef BOOST_NO_WREGEX
BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type, boost::uint32_t mask, wchar_t c);
#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type id, boost::uint32_t m, unsigned short c);
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type state_id, boost::uint32_t m, unsigned short c);
#endif
#endif
//
@@ -540,9 +540,9 @@
 if(pos != m_custom_class_names.end())
 return pos->second;
 }
- std::size_t id = 1 + re_detail::get_default_class_id(p1, p2);
- if(id < sizeof(masks) / sizeof(masks[0]))
- return masks[id];
+ std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
+ if(state_id < sizeof(masks) / sizeof(masks[0]))
+ return masks[state_id];
 return masks[0];
}

Modified: branches/proto/v4/boost/serialization/throw_exception.hpp
==============================================================================
--- branches/proto/v4/boost/serialization/throw_exception.hpp (original)
+++ branches/proto/v4/boost/serialization/throw_exception.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -26,12 +26,13 @@

#ifdef BOOST_NO_EXCEPTIONS

-void throw_exception(std::exception const & e); // user defined
+void throw_exception(std::exception const & e) {
+ ::boost::throw_exception(e);
+}

#else

-template<class E> inline void throw_exception(E const & e)
-{
+template<class E> inline void throw_exception(E const & e){
throw e;
}

Modified: branches/proto/v4/boost/test/framework.hpp
==============================================================================
--- branches/proto/v4/boost/test/framework.hpp (original)
+++ branches/proto/v4/boost/test/framework.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -54,6 +54,7 @@
// mutation access methods
BOOST_TEST_DECL void register_test_unit( test_case* tc );
BOOST_TEST_DECL void register_test_unit( test_suite* ts );
+BOOST_TEST_DECL void deregister_test_unit( test_unit* tu );

BOOST_TEST_DECL void register_observer( test_observer& );
BOOST_TEST_DECL void deregister_observer( test_observer& );

Modified: branches/proto/v4/boost/test/impl/compiler_log_formatter.ipp
==============================================================================
--- branches/proto/v4/boost/test/impl/compiler_log_formatter.ipp (original)
+++ branches/proto/v4/boost/test/impl/compiler_log_formatter.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -186,7 +186,13 @@
void
compiler_log_formatter::print_prefix( std::ostream& output, const_string file, std::size_t line )
{
+#ifdef __APPLE_CC__
+ // Xcode-compatible logging format, idea by Richard Dingwall at
+ // <http://richarddingwall.name/2008/06/01/using-the-boost-unit-test-framework-with-xcode-3/>.
+ output << file << ':' << line << ": ";
+#else
output << file << '(' << line << "): ";
+#endif
}

//____________________________________________________________________________//

Modified: branches/proto/v4/boost/test/impl/execution_monitor.ipp
==============================================================================
--- branches/proto/v4/boost/test/impl/execution_monitor.ipp (original)
+++ branches/proto/v4/boost/test/impl/execution_monitor.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -57,6 +57,11 @@
using std::va_list;
#endif

+// to use vsnprintf
+#if defined(__QNXNTO__)
+# include <stdio.h>
+#endif
+
#if defined(_WIN32) && !defined(BOOST_DISABLE_WIN32) && \
 (!defined(__COMO__) && !defined(__MWERKS__) && !defined(__GNUC__) || \
 BOOST_WORKAROUND(__MWERKS__, >= 0x3000))
@@ -139,13 +144,14 @@
# include <signal.h>
# include <setjmp.h>

-# if !defined(__CYGWIN__)
+# if !defined(__CYGWIN__) && !defined(__QNXNTO__)
# define BOOST_TEST_USE_ALT_STACK
# endif

-# if defined(SIGPOLL) && !defined(__CYGWIN__) && \
- !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) && \
- !defined(__NetBSD__)
+# if defined(SIGPOLL) && !defined(__CYGWIN__) && \
+ !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) && \
+ !defined(__NetBSD__) && \
+ !defined(__QNXNTO__)
# define BOOST_TEST_CATCH_SIGPOLL
# endif

@@ -471,11 +477,13 @@
 "high priority input available; band event %d",
 (int)m_sig_info->si_band );
 break;
+#if defined(POLL_ERR) && defined(POLL_HUP) && (POLL_ERR - POLL_HUP)
 case POLL_HUP:
 report_error( execution_exception::system_error,
 "device disconnected; band event %d",
 (int)m_sig_info->si_band );
 break;
+#endif
 }
 break;

@@ -685,9 +693,21 @@

extern "C" {

+static bool ignore_sigchild( siginfo_t* info )
+{
+ return info->si_signo == SIGCHLD && info->si_code == CLD_EXITED
+#ifdef BOOST_TEST_IGNORE_NON_ZERO_CHILD_CODE
+ ;
+#else
+ && (int)info->si_status == 0;
+#endif
+}
+
+//____________________________________________________________________________//
+
static void execution_monitor_jumping_signal_handler( int sig, siginfo_t* info, void* context )
{
- if( info->si_signo == SIGCHLD && info->si_code == CLD_EXITED && (int)info->si_status == 0 )
+ if( ignore_sigchild( info ) )
 return;

 signal_handler::sys_sig()( info, context );
@@ -699,11 +719,11 @@

static void execution_monitor_attaching_signal_handler( int sig, siginfo_t* info, void* context )
{
- if( info->si_signo == SIGCHLD && info->si_code == CLD_EXITED && (int)info->si_status == 0 )
+ if( ignore_sigchild( info ) )
 return;

 if( !debug::attach_debugger( false ) )
- execution_monitor_jumping_signal_handler( sig, info, context );
+ execution_monitor_jumping_signal_handler( sig, info, context );

 // debugger attached; it will handle the signal
 BOOST_TEST_SYS_ASSERT( ::signal( sig, SIG_DFL ) != SIG_ERR );
@@ -1016,7 +1036,7 @@

 __try {
 __try {
- ret_val = detail::do_invoke( m_custom_translators , F );
+ ret_val = detail::do_invoke( m_custom_translators, F );
 }
 __except( SSE( GetExceptionCode(), GetExceptionInformation() ) ) {
 throw SSE;

Modified: branches/proto/v4/boost/test/impl/framework.ipp
==============================================================================
--- branches/proto/v4/boost/test/impl/framework.ipp (original)
+++ branches/proto/v4/boost/test/impl/framework.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -121,7 +121,10 @@

     ~framework_impl()
     {
- BOOST_TEST_FOREACH( test_unit_store::value_type const&, tu, m_test_units ) {
+ while( !m_test_units.empty() ) {
+ test_unit_store::value_type const& tu = *m_test_units.begin();
+
+ // the delete will erase this element from map
             if( test_id_2_unit_type( tu.second->p_id ) == tut_suite )
                 delete (test_suite const*)tu.second;
             else
@@ -316,6 +319,14 @@
//____________________________________________________________________________//

void
+deregister_test_unit( test_unit* tu )
+{
+ s_frk_impl().m_test_units.erase( tu->p_id );
+}
+
+//____________________________________________________________________________//
+
+void
register_observer( test_observer& to )
{
     s_frk_impl().m_observers.insert( &to );

Modified: branches/proto/v4/boost/test/impl/unit_test_main.ipp
==============================================================================
--- branches/proto/v4/boost/test/impl/unit_test_main.ipp (original)
+++ branches/proto/v4/boost/test/impl/unit_test_main.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -131,7 +131,7 @@
 std::vector<single_filter> const& filters = m_filters[m_depth-2];

 tu.p_enabled.value =
- std::find_if( filters.begin(), filters.end(), bind( &single_filter::pass, _1, tu ) ) != filters.end();
+ std::find_if( filters.begin(), filters.end(), bind( &single_filter::pass, _1, boost::ref(tu) ) ) != filters.end();
 }

 // test tree visitor interface

Modified: branches/proto/v4/boost/test/impl/unit_test_suite.ipp
==============================================================================
--- branches/proto/v4/boost/test/impl/unit_test_suite.ipp (original)
+++ branches/proto/v4/boost/test/impl/unit_test_suite.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -60,6 +60,13 @@

//____________________________________________________________________________//

+test_unit::~test_unit()
+{
+ framework::deregister_test_unit( this );
+}
+
+//____________________________________________________________________________//
+
void
test_unit::depends_on( test_unit* tu )
{

Modified: branches/proto/v4/boost/test/impl/xml_log_formatter.ipp
==============================================================================
--- branches/proto/v4/boost/test/impl/xml_log_formatter.ipp (original)
+++ branches/proto/v4/boost/test/impl/xml_log_formatter.ipp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -112,8 +112,7 @@
void
xml_log_formatter::log_exception( std::ostream& ostr, log_checkpoint_data const& checkpoint_data, const_string explanation )
{
- ostr << "<Exception name" << attr_value() << framework::current_test_case().p_name.get() << ">"
- << pcdata() << explanation;
+ ostr << "<Exception>" << pcdata() << explanation;

if( !checkpoint_data.m_file_name.is_empty() ) {
ostr << "<LastCheckpoint file" << attr_value() << checkpoint_data.m_file_name

Modified: branches/proto/v4/boost/test/test_case_template.hpp
==============================================================================
--- branches/proto/v4/boost/test/test_case_template.hpp (original)
+++ branches/proto/v4/boost/test/test_case_template.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -16,9 +16,6 @@
#ifndef BOOST_TEST_TEST_CASE_TEMPLATE_HPP_071894GER
#define BOOST_TEST_TEST_CASE_TEMPLATE_HPP_071894GER

-// Boost.Test
-#include <boost/test/unit_test_suite.hpp>
-
// Boost
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/identity.hpp>

Modified: branches/proto/v4/boost/test/unit_test_suite_impl.hpp
==============================================================================
--- branches/proto/v4/boost/test/unit_test_suite_impl.hpp (original)
+++ branches/proto/v4/boost/test/unit_test_suite_impl.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -71,6 +71,9 @@

 void increase_exp_fail( unsigned num );

+protected:
+ ~test_unit();
+
private:
 // Data members
 std::list<test_unit_id> m_dependencies;
@@ -226,15 +229,15 @@

template<typename InstanceType,typename UserTestCase>
struct user_tc_method_invoker {
- typedef void (UserTestCase::*test_method )();
+ typedef void (UserTestCase::*TestMethod )();

- user_tc_method_invoker( shared_ptr<InstanceType> inst, test_method test_method )
+ user_tc_method_invoker( shared_ptr<InstanceType> inst, TestMethod test_method )
 : m_inst( inst ), m_test_method( test_method ) {}

 void operator()() { ((*m_inst).*m_test_method)(); }

 shared_ptr<InstanceType> m_inst;
- test_method m_test_method;
+ TestMethod m_test_method;
};

} // namespace ut_detail

Modified: branches/proto/v4/boost/test/utils/basic_cstring/basic_cstring.hpp
==============================================================================
--- branches/proto/v4/boost/test/utils/basic_cstring/basic_cstring.hpp (original)
+++ branches/proto/v4/boost/test/utils/basic_cstring/basic_cstring.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -511,16 +511,16 @@

template<typename CharT>
inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::find( basic_cstring<CharT> substr ) const
+basic_cstring<CharT>::find( basic_cstring<CharT> str ) const
{
- if( substr.is_empty() || substr.size() > size() )
+ if( str.is_empty() || str.size() > size() )
 return (size_type)npos;

 const_iterator it = begin();
- const_iterator last = end() - substr.size() + 1;
+ const_iterator last = end() - str.size() + 1;

 while( it != last ) {
- if( traits_type::compare( it, substr.begin(), substr.size() ) == 0 )
+ if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
 break;

 ++it;
@@ -533,16 +533,16 @@

template<typename CharT>
inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::rfind( basic_cstring<CharT> substr ) const
+basic_cstring<CharT>::rfind( basic_cstring<CharT> str ) const
{
- if( substr.is_empty() || substr.size() > size() )
+ if( str.is_empty() || str.size() > size() )
 return (size_type)npos;

- const_iterator it = end() - substr.size();
+ const_iterator it = end() - str.size();
 const_iterator last = begin()-1;

 while( it != last ) {
- if( traits_type::compare( it, substr.begin(), substr.size() ) == 0 )
+ if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
 break;

 --it;

Modified: branches/proto/v4/libs/asio/doc/Jamfile.v2
==============================================================================
--- branches/proto/v4/libs/asio/doc/Jamfile.v2 (original)
+++ branches/proto/v4/libs/asio/doc/Jamfile.v2 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -34,7 +34,7 @@

local example-names = allocation buffers chat echo http/client http/server
http/server2 http/server3 invocation iostreams local multicast nonblocking
- porthopper serialization services socks4 ssl timeouts timers ;
+ porthopper serialization services socks4 ssl timeouts timers windows ;

for local l in $(example-names)
{

Modified: branches/proto/v4/libs/asio/doc/doxy2qbk.pl
==============================================================================
--- branches/proto/v4/libs/asio/doc/doxy2qbk.pl (original)
+++ branches/proto/v4/libs/asio/doc/doxy2qbk.pl 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -19,4 +19,4 @@
system("xsltproc combine.xslt index.xml > all.xml");
chdir("..");
system("xsltproc tutorial.xsl xml/all.xml > tutorial.qbk");
-system("rm -rf xml");
+system("rm -rf xml reference.tags");

Modified: branches/proto/v4/libs/asio/doc/reference.qbk
==============================================================================
--- branches/proto/v4/libs/asio/doc/reference.qbk (original)
+++ branches/proto/v4/libs/asio/doc/reference.qbk 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -35483,7 +35483,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
- [Asynchronously resolve a query to a list of entries. ]
+ [Asynchronously perform forward resolution of a query to a list of entries. ]
 ]

 [
@@ -35508,7 +35508,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
- [Resolve a query to a list of entries. ]
+ [Perform forward resolution of a query to a list of entries. ]
 ]

]
@@ -35541,7 +35541,7 @@

[section:async_resolve ip::basic_resolver::async_resolve]

-[indexterm2 async_resolve..ip::basic_resolver] Asynchronously resolve a query to a list of entries.
+[indexterm2 async_resolve..ip::basic_resolver] Asynchronously perform forward resolution of a query to a list of entries.

 template<
 typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
@@ -35558,7 +35558,7 @@

[section:overload1 ip::basic_resolver::async_resolve (1 of 2 overloads)]

-Asynchronously resolve a query to a list of entries.
+Asynchronously perform forward resolution of a query to a list of entries.

 template<
 typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
@@ -35603,7 +35603,7 @@

[section:overload2 ip::basic_resolver::async_resolve (2 of 2 overloads)]

-Asynchronously resolve an endpoint to a list of entries.
+Asynchronously perform reverse resolution of an endpoint to a list of entries.

 template<
 typename ``[link boost_asio.reference.ResolveHandler ResolveHandler]``>
@@ -35818,7 +35818,7 @@

[section:resolve ip::basic_resolver::resolve]

-[indexterm2 resolve..ip::basic_resolver] Resolve a query to a list of entries.
+[indexterm2 resolve..ip::basic_resolver] Perform forward resolution of a query to a list of entries.

 iterator ``[link boost_asio.reference.ip__basic_resolver.resolve.overload1 resolve]``(
 const query & q);
@@ -35837,7 +35837,7 @@

[section:overload1 ip::basic_resolver::resolve (1 of 4 overloads)]

-Resolve a query to a list of entries.
+Perform forward resolution of a query to a list of entries.

 iterator resolve(
 const query & q);
@@ -35881,7 +35881,7 @@

[section:overload2 ip::basic_resolver::resolve (2 of 4 overloads)]

-Resolve a query to a list of entries.
+Perform forward resolution of a query to a list of entries.

 iterator resolve(
 const query & q,
@@ -35919,7 +35919,7 @@

[section:overload3 ip::basic_resolver::resolve (3 of 4 overloads)]

-Resolve an endpoint to a list of entries.
+Perform reverse resolution of an endpoint to a list of entries.

 iterator resolve(
 const endpoint_type & e);
@@ -35963,7 +35963,7 @@

[section:overload4 ip::basic_resolver::resolve (4 of 4 overloads)]

-Resolve an endpoint to a list of entries.
+Perform reverse resolution of an endpoint to a list of entries.

 iterator resolve(
 const endpoint_type & e,
@@ -37053,7 +37053,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
- [Asynchronously resolve a query to a list of entries. ]
+ [Asynchronously perform forward resolution of a query to a list of entries. ]
 ]

 [
@@ -37078,7 +37078,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
- [Resolve a query to a list of entries. ]
+ [Perform forward resolution of a query to a list of entries. ]
 ]

]
@@ -39149,7 +39149,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
- [Asynchronously resolve a query to a list of entries. ]
+ [Asynchronously perform forward resolution of a query to a list of entries. ]
 ]

 [
@@ -39174,7 +39174,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
- [Resolve a query to a list of entries. ]
+ [Perform forward resolution of a query to a list of entries. ]
 ]

]
@@ -40116,7 +40116,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.async_resolve [*async_resolve]]]
- [Asynchronously resolve a query to a list of entries. ]
+ [Asynchronously perform forward resolution of a query to a list of entries. ]
 ]

 [
@@ -40141,7 +40141,7 @@

 [
 [[link boost_asio.reference.ip__basic_resolver.resolve [*resolve]]]
- [Resolve a query to a list of entries. ]
+ [Perform forward resolution of a query to a list of entries. ]
 ]

]

Modified: branches/proto/v4/libs/dynamic_bitset/bitset_test.hpp
==============================================================================
--- branches/proto/v4/libs/dynamic_bitset/bitset_test.hpp (original)
+++ branches/proto/v4/libs/dynamic_bitset/bitset_test.hpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -1,6 +1,6 @@
// -----------------------------------------------------------
// Copyright (c) 2001 Jeremy Siek
-// Copyright (c) 2003-2006 Gennaro Prota
+// Copyright (c) 2003-2006, 2008 Gennaro Prota
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -108,32 +108,43 @@
// constructors
// default (can't do this generically)

-// from unsigned long
-
template <typename Bitset>
struct bitset_test {

 typedef typename Bitset::block_type Block;
 BOOST_STATIC_CONSTANT(int, bits_per_block = Bitset::bits_per_block);

-
- static void from_unsigned_long(std::size_t sz, unsigned long num)
+ // from unsigned long
+ //
+ // Note: this is templatized so that we check that the do-the-right-thing
+ // constructor dispatch is working correctly.
+ //
+ template <typename NumBits, typename Value>
+ static void from_unsigned_long(NumBits num_bits, Value num)
 {
- // An object of size N = sz is constructed:
- // - the first M bit positions are initialized to the corresponding bit
- // values in num (M being the smaller of N and the width of unsigned
- // long)
+ // An object of size sz = num_bits is constructed:
+ // - the first m bit positions are initialized to the corresponding
+ // bit values in num (m being the smaller of sz and ulong_width)
+ //
+ // - any remaining bit positions are initialized to zero
 //
- // - if M < N remaining bit positions are initialized to zero

- Bitset b(sz, num);
+ Bitset b(num_bits, num);
+
+ // OK, we can now cast to size_type
+ typedef typename Bitset::size_type size_type;
+ const size_type sz = static_cast<size_type>(num_bits);
+
 BOOST_CHECK(b.size() == sz);

 const std::size_t ulong_width = std::numeric_limits<unsigned long>::digits;
- std::size_t m = (std::min)(sz, ulong_width);
- std::size_t i;
- for (i = 0; i < m; ++i)
- BOOST_CHECK(b.test(i) == nth_bit(num, i));
+ size_type m = sz;
+ if (ulong_width < sz)
+ m = ulong_width;
+
+ size_type i = 0;
+ for ( ; i < m; ++i)
+ BOOST_CHECK(b.test(i) == nth_bit(static_cast<unsigned long>(num), i));
 for ( ; i < sz; ++i)
 BOOST_CHECK(b.test(i) == 0);
 }
@@ -978,7 +989,7 @@
 //-------------------------------------------------------------------------

 // operator<<( [basic_]ostream,
- template<typename Stream>
+ template <typename Stream>
 static void stream_inserter(const Bitset & b,
 Stream & s,
 const char * file_name
@@ -1058,7 +1069,7 @@
 }

 // operator>>( [basic_]istream
- template<typename Stream, typename String>
+ template <typename Stream, typename String>
 static void stream_extractor(Bitset& b,
 Stream& is,
 String& str

Modified: branches/proto/v4/libs/dynamic_bitset/dyn_bitset_unit_tests1.cpp
==============================================================================
--- branches/proto/v4/libs/dynamic_bitset/dyn_bitset_unit_tests1.cpp (original)
+++ branches/proto/v4/libs/dynamic_bitset/dyn_bitset_unit_tests1.cpp 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -15,7 +15,7 @@

#include "boost/detail/workaround.hpp"

-#define BOOST_BITSET_TEST_COUNT_OF(x) (sizeof(x)/sizeof(x[0]))
+#define BOOST_BITSET_TEST_COUNT(x) (sizeof(x)/sizeof(x[0]))

// Codewarrior 8.3 for Win fails without this.
@@ -54,6 +54,56 @@

}

+// tests the do-the-right-thing constructor dispatch
+template <typename Tests, typename T>
+void run_numeric_ctor_tests( BOOST_EXPLICIT_TEMPLATE_TYPE(Tests)
+ BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) )
+{
+
+ const int bits_per_block = Tests::bits_per_block;
+ const int width = std::numeric_limits<T>::digits;
+ const T ma = (std::numeric_limits<T>::max)();
+ const T mi = (std::numeric_limits<T>::min)();
+
+ int sizes[] = {
+ 0, 7*width/10, width, 13*width/10, 3*width,
+ 7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block
+ };
+
+ const T numbers[] = {
+ T(-1), T(-3), T(-8), T(-15), mi/2, mi,
+ 0, 1, 3, 8, 15, ma/2, ma
+ };
+
+ for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
+ for (std::size_t n = 0; n < BOOST_BITSET_TEST_COUNT(numbers); ++n ) {
+
+ // can match ctor from ulong or templated one
+ Tests::from_unsigned_long(sizes[s], numbers[n]);
+
+ typedef std::size_t compare_type;
+ const compare_type sz = sizes[s];
+ // this condition is to be sure that size is representable in T, so
+ // that for signed T's we avoid implementation-defined behavior [if ma
+ // is larger than what std::size_t can hold then this is ok for our
+ // purposes: our sizes are anyhow < max(size_t)], which in turn could
+ // make the first argument of from_unsigned_long() a small negative,
+ // later converted to a very large unsigned. Example: signed 8-bit
+ // char (CHAR_MAX=127), bits_per_block=64, sz = 192 > 127.
+ const bool fits =
+ sz <= static_cast<compare_type>(ma);
+
+ if (fits) {
+ // can match templated ctor only (so we test dispatching)
+ Tests::from_unsigned_long(static_cast<T>(sizes[s]), numbers[n]);
+ }
+
+ }
+ }
+
+}
+
+
template <typename Block>
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
{
@@ -67,24 +117,52 @@
 //=====================================================================
 // Test construction from unsigned long
 {
- typedef unsigned long source_type;
- const std::size_t source_width = std::numeric_limits<source_type>::digits;
- const source_type source_max =(std::numeric_limits<source_type>::max)();
-
- source_type numbers[] = { 0, 1, 40247, source_max >> 1, source_max };
- std::size_t sizes[] =
- { 0, 7 * source_width / 10, source_width, 13 * source_width / 10,
- 7 * bits_per_block / 10, bits_per_block, 13 * bits_per_block / 10,
- 3 * bits_per_block };
-
- const std::size_t value_count = BOOST_BITSET_TEST_COUNT_OF(numbers);
- const std::size_t size_count = BOOST_BITSET_TEST_COUNT_OF(sizes);
-
- for (std::size_t v = 0; v < value_count; ++v) {
- for (std::size_t s = 0; s < size_count; ++s) {
- Tests::from_unsigned_long(sizes[s], numbers[v]);
+ typedef typename bitset_type::size_type size_type;
+
+
+ // NOTE:
+ //
+ // 1. keep this in sync with the numeric types supported
+ // for constructor dispatch (of course)
+ // 2. bool is tested separately; ugly and inelegant, but
+ // we don't have much time to think of a better solution
+ // which is likely to work on broken compilers
+ //
+ const int sizes[] = {
+ 0, 1, 3,
+ 7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block
+ };
+
+ const bool values[] = { false, true };
+
+ for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
+ for (std::size_t v = 0; v < BOOST_BITSET_TEST_COUNT(values); ++v) {
+ Tests::from_unsigned_long(sizes[s], values[v]);
+ Tests::from_unsigned_long(sizes[s] != 0, values[v]);
 }
 }
+
+ run_numeric_ctor_tests<Tests, char>();
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+ run_numeric_ctor_tests<Tests, wchar_t>();
+#endif
+
+ run_numeric_ctor_tests<Tests, signed char>();
+ run_numeric_ctor_tests<Tests, short int>();
+ run_numeric_ctor_tests<Tests, int>();
+ run_numeric_ctor_tests<Tests, long int>();
+
+ run_numeric_ctor_tests<Tests, unsigned char>();
+ run_numeric_ctor_tests<Tests, unsigned short>();
+ run_numeric_ctor_tests<Tests, unsigned int>();
+ run_numeric_ctor_tests<Tests, unsigned long>();
+
+#if defined(BOOST_HAS_LONG_LONG)
+ run_numeric_ctor_tests<Tests, ::boost::long_long_type>();
+ run_numeric_ctor_tests<Tests, ::boost::ulong_long_type>();
+#endif
+
 }
 //=====================================================================
 // Test construction from a string

Modified: branches/proto/v4/libs/dynamic_bitset/dynamic_bitset.html
==============================================================================
--- branches/proto/v4/libs/dynamic_bitset/dynamic_bitset.html (original)
+++ branches/proto/v4/libs/dynamic_bitset/dynamic_bitset.html 2008-09-14 21:53:56 EDT (Sun, 14 Sep 2008)
@@ -574,11 +574,20 @@

Effects: Constructs a bitset from an integer. The first
<tt>M</tt> bits are initialized to the corresponding bits in
-<tt>val</tt> and all other bits, if any, to zero (where <tt>M =
+<tt>value</tt> and all other bits, if any, to zero (where <tt>M =
min(num_bits, std::numeric_limits<unsigned long>::digits)</tt>). A copy of
the <tt>alloc</tt> object will be used in subsequent bitset
-operations such as <tt>resize</tt> to allocate memory. 
- Postconditions:
+operations such as <tt>resize</tt> to allocate memory. Note that, e.g., the
+following
+ 
+<tt>
+dynamic_bitset b<>( 16, 7 );
+</tt> 
+will match the constructor from an iterator range (not this
+one), but the underlying implementation will still "do the right thing" and
+construct a bitset of 16 bits, from the value 7.
+ 
+Postconditions:

<ul>
<li><tt>this->size() == num_bits</tt></li>
@@ -620,24 +629,56 @@
const Allocator& alloc = Allocator());
</pre>

-Effects: Constructs a bitset based on a range of blocks.
-Let <tt>*first</tt> be block number 0, <tt>*++first</tt> block
-number 1, etc. Block number <tt>b</tt> is used to initialize the
-bits of the dynamic_bitset in the position range
-<tt>[b*bits_per_block, (b+1)*bits_per_block)</tt>. For each block
-number <tt>b</tt> with value <tt>bval</tt>, the bit <tt>(bval
->> i) & 1</tt> corresponds to the bit at position
-<tt>(b * bits_per_block + i)</tt> in the bitset (where <tt>i</tt>
-goes through the range <tt>[0, bits_per_block)</tt>). 
- Requires: The type <tt>BlockInputIterator</tt> must be a
-model of <a href=
-"http://www.sgi.com/tech/stl/InputIterator.html">Input
-Iterator</a> and its <tt>value_type</tt> must be the same type as
-<tt>Block</tt>. 
- Throws: An allocation error if memory is exhausted
-(<tt>std::bad_alloc</tt> if
-<tt>Allocator=std::allocator</tt>). 
-
+Effects:
+<ul>
+<li>
+If this constructor is called with a type <tt>BlockInputIterator</tt> which
+is actually an integral type, the library behaves as if the constructor
+from <tt>unsigned long</tt> had been called, with arguments
+<tt>static_cast<size_type>(first), last and alloc</tt>, in that order.
+
+Example:
+<pre>
+// b is constructed as if by calling the constructor
+//
+// dynamic_bitset(size_type num_bits,
+// unsigned long value = 0,
+// const Allocator& alloc = Allocator())
+//
+// with arguments
+//
+// static_cast<dynamic_bitset<unsigned short>::size_type>(8),
+// 7,
+// Allocator()
+//
+dynamic_bitset<unsigned short> b(8, 7);
+</pre> 
+Note: 
+This is analogous to what the standard mandates for sequence containers (namely,
+that if the type on which the template constructor is intantiated "does not
+qualify as an input iterator" then the other constructor is called; "the extent
+to which an implementation determines that a type cannot be an input iterator is
+unspecified, except that as a minimum integral types shall not qualify as input
+iterators"). 
+</li>
+<li>
+Otherwise (i.e. if the template argument is not an integral
+type), constructs—under the condition in the <tt>requires</tt>
+clause—a bitset based on a range of blocks. Let <tt>*first</tt> be block
+number 0, <tt>*++first</tt> block number 1, etc. Block number <tt>b</tt> is used
+to initialize the bits of the dynamic_bitset in the position range
+<tt>[b*bits_per_block, (b+1)*bits_per_block)</tt>. For each block number
+<tt>b</tt> with value <tt>bval</tt>, the bit <tt>(bval >> i) & 1</tt>
+corresponds to the bit at position <tt>(b * bits_per_block + i)</tt> in the
+bitset (where <tt>i</tt> goes through the range <tt>[0, bits_per_block)</tt>).
+</li>
+</ul>
+ 
+Requires: <tt>BlockInputIterator</tt> must be either an integral type or
+a model of <a href= "http://www.sgi.com/tech/stl/InputIterator.html">Input
+ Iterator</a> whose <tt>value_type</tt> is the same type as
+<tt>Block</tt>. Throws: An allocation error if memory is exhausted
+(<tt>std::bad_alloc</tt> if <tt>Allocator=std::allocator</tt>). 

<hr />
<pre>
@@ -1436,11 +1477,17 @@
<h3><a id="exception-guarantees">Exception guarantees</a></h3>

All of <tt>dynamic_bitset</tt> functions offer at least the basic
-exception guarantee.
+exception guarantee.

<hr />
<h3><a id="changes-from-previous-ver">Changes from previous version(s)</a></h3>

+<h4>Changes in Boost 1.37.0</h4>
+<ul>
+<li>The constructor from a block-range implements a do-the-right-thing
+behavior, a la standard sequences.</li>
+</ul>
+

<h4>Changes from Boost 1.31.0</h4>
<ul>
@@ -1514,9 +1561,19 @@
C/C++ Users Journal (<a
href="mailto:cda_at_[hidden]">cda_at_[hidden]</a>) </td> </tr> <tr>
-<td>Copyright © 2003-2004, 2008</td> <td>Gennaro Prota</td>
+<td>Copyright © 2003-2004, 2008</td> <td><a
+ href="http://gennaro-prota.50webs.com/">Gennaro Prota</a>
+ (name.surname yahoo.com)</td>
</tr>
</table>
+ 
+<div class="legalnotice">
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt
+ or copy at <a class="ulink" href="http://www.boost.org/LICENSE_1_0.txt">
+http://www.boost.org/LICENSE_1_0.txt>)
+</div>
+

</div>
</div>