Branch for merging Boost.Build and Boost.Jam completely.

[SVN r59143]

include/boost/algorithm/string/detail/case_conv.hpp

@@ -31,7 +31,7 @@ namespace boost {
             struct to_lowerF : public std::unary_function<CharT, CharT>
             {
                 // Constructor
-                to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
+                to_lowerF( const std::locale& Loc ) : m_Loc( Loc ) {}
 
                 // Operation
                 CharT operator ()( CharT Ch ) const
@@ -39,11 +39,11 @@ namespace boost {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::tolower( Ch);
                     #else
-                        return std::tolower<CharT>( Ch, *m_Loc );
+                        return std::tolower<CharT>( Ch, m_Loc );
                     #endif
                 }
             private:
-                const std::locale* m_Loc;
+                const std::locale& m_Loc;
             };
 
             // a toupper functor
@@ -51,7 +51,7 @@ namespace boost {
             struct to_upperF : public std::unary_function<CharT, CharT>
             {
                 // Constructor
-                to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
+                to_upperF( const std::locale& Loc ) : m_Loc( Loc ) {}
 
                 // Operation
                 CharT operator ()( CharT Ch ) const
@@ -59,11 +59,11 @@ namespace boost {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                         return std::toupper( Ch);
                     #else
-                        return std::toupper<CharT>( Ch, *m_Loc );
+                        return std::toupper<CharT>( Ch, m_Loc );
                     #endif
                 }
             private:
-                const std::locale* m_Loc;
+                const std::locale& m_Loc;
             };
 
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)

include/boost/algorithm/string/detail/classification.hpp

@@ -32,8 +32,8 @@ namespace boost {
             struct is_classifiedF :
                 public predicate_facade<is_classifiedF>
             {
-                // Boost.ResultOf support
-                typedef bool result_type;
+                // Boost.Lambda support
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor from a locale
                 is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
@@ -72,8 +72,8 @@ namespace boost {
                 typedef typename ::boost::remove_const<CharT>::type set_value_type;
 
             public:     
-                // Boost.ResultOf support
-                typedef bool result_type;
+                // Boost.Lambda support
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 template<typename RangeT>
@@ -253,8 +253,8 @@ namespace boost {
             struct is_from_rangeF :
                 public predicate_facade< is_from_rangeF<CharT> >
             {
-                // Boost.ResultOf support
-                typedef bool result_type;
+                // Boost.Lambda support
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
@@ -278,8 +278,8 @@ namespace boost {
             {
             public:
 
-                // Boost.ResultOf support
-                typedef bool result_type;
+                // Boost.Lambda support
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
@@ -303,8 +303,8 @@ namespace boost {
                 public predicate_facade< pred_orF<Pred1T,Pred2T> >
             {
             public:
-                // Boost.ResultOf support
-                typedef bool result_type;
+                // Boost.Lambda support
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
@@ -328,8 +328,8 @@ namespace boost {
                 public predicate_facade< pred_notF<PredT> >
             {
             public:
-                // Boost.ResultOf support
-                typedef bool result_type;
+                // Boost.Lambda support
+                template <class Args> struct sig { typedef bool type; };
 
                 // Constructor
                 pred_notF( PredT Pred ) : m_Pred(Pred) {}

include/boost/algorithm/string/detail/find_format.hpp

@@ -49,17 +49,17 @@ namespace boost {
                 if ( !M )
                 {
                     // Match not found - return original sequence
-                    Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
+                    std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                     return Output;
                 }
 
                 // Copy the beginning of the sequence
-                Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
+                std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
                 // Format find result
                 // Copy formated result
-                Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
+                std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
                 // Copy the rest of the sequence
-                Output = std::copy( M.end(), ::boost::end(Input), Output );
+                std::copy( M.end(), ::boost::end(Input), Output );
 
                 return Output;
             }
@@ -75,16 +75,12 @@ namespace boost {
                 FormatterT Formatter,
                 const FindResultT& FindResult )
             {       
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                 return ::boost::algorithm::detail::find_format_copy_impl2( 
                     Output,
                     Input,
                     Formatter,
                     FindResult,
                     Formatter(FindResult) );
-                } else {
-                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-            }
             }
 
  
@@ -136,15 +132,11 @@ namespace boost {
                 FormatterT Formatter,
                 const FindResultT& FindResult)
             {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                 return ::boost::algorithm::detail::find_format_copy_impl2(
                     Input,
                     Formatter,
                     FindResult,
                     Formatter(FindResult) );
-                } else {
-                    return Input;
-            }
             }
 
  // replace implementation ----------------------------------------------------//
@@ -188,14 +180,12 @@ namespace boost {
                 FormatterT Formatter,
                 const FindResultT& FindResult)
             {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                 ::boost::algorithm::detail::find_format_impl2(
                     Input,
                     Formatter,
                     FindResult,
                     Formatter(FindResult) );
             }
-            }
 
         } // namespace detail
     } // namespace algorithm

include/boost/algorithm/string/detail/find_format_all.hpp

@@ -57,9 +57,9 @@ namespace boost {
                 while( M )
                 {
                     // Copy the beginning of the sequence
-                    Output = std::copy( LastMatch, M.begin(), Output );
+                    std::copy( LastMatch, M.begin(), Output );
                     // Copy formated result
-                    Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
+                    std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
 
                     // Proceed to the next match
                     LastMatch=M.end();
@@ -67,7 +67,7 @@ namespace boost {
                 }
 
                 // Copy the rest of the sequence
-                Output = std::copy( LastMatch, ::boost::end(Input), Output );
+                std::copy( LastMatch, ::boost::end(Input), Output );
 
                 return Output;
             }
@@ -85,7 +85,6 @@ namespace boost {
                 FormatterT Formatter,
                 const FindResultT& FindResult )
             {       
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                 return ::boost::algorithm::detail::find_format_all_copy_impl2( 
                     Output,
                     Input,
@@ -93,9 +92,6 @@ namespace boost {
                     Formatter,
                     FindResult,
                     Formatter(FindResult) );
-                } else {
-                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-            }
             }
 
  // find_format_all_copy implementation ----------------------------------------------//
@@ -160,16 +156,12 @@ namespace boost {
                 FormatterT Formatter,
                 const FindResultT& FindResult)
             {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                 return ::boost::algorithm::detail::find_format_all_copy_impl2(
                     Input,
                     Finder,
                     Formatter,
                     FindResult,
                     Formatter(FindResult) );
-                } else {
-                    return Input;
-            }
             }
 
  // find_format_all implementation ------------------------------------------------//
@@ -256,7 +248,6 @@ namespace boost {
                 FormatterT Formatter,
                 FindResultT FindResult)
             {
-                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                 ::boost::algorithm::detail::find_format_all_impl2(
                     Input,
                     Finder,
@@ -264,7 +255,6 @@ namespace boost {
                     FindResult,
                     Formatter(FindResult) );
             }
-            }
 
         } // namespace detail
     } // namespace algorithm

include/boost/algorithm/string/detail/find_format_store.hpp

@@ -52,9 +52,7 @@ namespace boost {
                 find_format_store& operator=( FindResultT FindResult )
                 {
                     iterator_range<ForwardIteratorT>::operator=(FindResult);
-                    if( !this->empty() ) {
                     m_FormatResult=m_Formatter(FindResult);
-                    }
                     
                     return *this;
                 }
@@ -70,15 +68,6 @@ namespace boost {
                 const formatter_type& m_Formatter;
             };
 
-            template<typename InputT, typename FindResultT>
-            bool check_find_result(InputT& Input, FindResultT& FindResult)
-            {
-                typedef BOOST_STRING_TYPENAME 
-                    range_const_iterator<InputT>::type input_iterator_type; 
-                iterator_range<input_iterator_type> ResultRange(FindResult);
-                return !ResultRange.empty();
-            }
-
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
 #pragma warning(pop)
 #endif

include/boost/algorithm/string/erase.hpp

@@ -752,7 +752,7 @@ namespace boost {
 
             \param Output An output iterator to which the result will be copied
             \param Input An input string
-            \param N Length of the tail.                 
+            \param N Length of the head.                 
                 For N>=0, at most N characters are extracted.
                 For N<0, size(Input)-|N| characters are extracted.
             \return An output iterator pointing just after the last inserted character or
@@ -797,7 +797,7 @@ namespace boost {
             considered to be the tail. The input sequence is modified in-place.
 
             \param Input An input string
-            \param N Length of the tail
+            \param N Length of the head
                 For N>=0, at most N characters are extracted.
                 For N<0, size(Input)-|N| characters are extracted.
         */

include/boost/algorithm/string/find.hpp

@@ -257,7 +257,7 @@ namespace boost {
 
         //! Find tail algorithm
         /*!
-            Get the tail of the input. Tail is a suffix of the string of the 
+            Get the head of the input. Head is a suffix of the string of the 
             given size. If the input is shorter then required, whole input if considered 
             to be the tail.
 

include/boost/algorithm/string/find_iterator.hpp

@@ -240,7 +240,7 @@ namespace boost {
                 m_Match(Other.m_Match),
                 m_Next(Other.m_Next),
                 m_End(Other.m_End),
-                m_bEof(Other.m_bEof)
+                m_bEof(false)
             {}
 
             //! Constructor

minmax/index.html

@@ -92,11 +92,11 @@ Synopsis of <tt>&lt;boost/algorithm/minmax.hpp></tt></h3>
 namespace boost {
 
   template &lt;class T>
-  tuple&lt;T const&amp;, T const&amp;>
+  tuple&lt;T const&amp;, T const&amp;> >
   minmax(const T&amp; a, const T&amp; b);
 
   template &lt;class T, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>>
-  tuple&lt;T const&amp;, T const&amp;>
+  tuple&lt;T const&amp;, T const&amp;> >
   minmax(const T&amp; a, const T&amp; b, BinaryPredicate comp);
 
 }
@@ -243,7 +243,7 @@ range
 
 <a name="complexity">
 <h3>
-Complexity</h3>
+<a NAME="Complexity"></a>Complexity</h3>
 Minmax performs a single comparison and is otherwise of constant complexity.
 The use of <tt>boost::tuple&lt;T const&amp;></tt> prevents copy
 constructors in case the arguments are passed by reference.
@@ -438,7 +438,7 @@ comparisons).</p>
 slower than
 <tt>first_min_element</tt> alone, still much less than <tt>first_min_element</tt>
 and
-<tt>last_max_element</tt> called separately.  <a href="#Note2">[2]</a>
+<tt>last_max_element</tt> called separately.  <a href="#Performance">[2]</a>
 
 <h4><b>Why algorithms and not accumulators?</b></h4>
 <p>The minmax algorithms are useful in computing the extent of a range.

string/doc/Jamfile.v2

@@ -12,7 +12,6 @@ toolset.using doxygen ;
 
 boostbook string_algo : string_algo.xml autodoc 
 	:
-        <xsl:param>boost.root=../../../../..
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
 	;
 

string/doc/design.xml

@@ -25,7 +25,7 @@
         </para>
         <para>
             <emphasis role="bold">Definition:</emphasis> A string is a 
-            <ulink url="../../libs/range/index.html">range</ulink> of characters accessible in sequential
+            <ulink url="../../libs/range/doc/range.html">range</ulink> of characters accessible in sequential
             ordered fashion. Character is any value type with "cheap" copying and assignment.                
         </para>
         <para>

string/doc/external_concepts.html

@@ -32,9 +32,7 @@
             free-standing functions and type-generators exists:</p><code>void foo( const T&, int ); <br>
                 int bar( T& ); <br>
              foo_type_of< T >::type;</code> <br> <br><hr size="1" ><h3  >Literature</h3><ul  ><li  > <a href="http://www.boost.org/more/generic_programming.html#type_generator" target="_self" >Type Generators</a> </li><li  > <a href="http://www.boost.org/more/generic_programming.html#concept" target="_self" >Concepts</a> </li><li  > <a href="http://www.sgi.com/tech/stl/stl_introduction.html" target="_self" >Concepts and SGI STL</a> </li></ul><hr size="1" ><p  >&copy; Thorsten Ottosen 2003-2004 (nesotto_AT_cs.auc.dk).
-<br>Use, modification and distribution is subject to the Boost
- Software License, Version 1.0. (See accompanying file
- <code class="filename">LICENSE_1_0.txt</code> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-</br>
-</p>
+    Permission to copy, use, modify, sell and distribute this software is granted provided this copyright notice appears
+     in all copies. This software is provided "as is" without express or implied warranty, and with no
+         claim as to its suitability for any purpose.</p><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br></body></html>
  <!-- Copyright Dezide Aps 2003-2004 -->

string/doc/string_algo.xml

@@ -33,7 +33,7 @@
         <librarypurpose>
             A set of generic string-related algorithms and utilities
         </librarypurpose> 
-        <librarycategory name="category:algorithms"/>
+        <librarycategory name="category:algoritms"/>
         <librarycategory name="category:string-text"/>
     </libraryinfo>
 

string/doc/usage.xml

@@ -57,7 +57,7 @@
                     The magic of <ulink url="../../libs/range/index.html">Boost.Range</ulink> 
                     provides a uniform way of handling different string types. 
                     If there is a need to pass a pair of iterators, 
-                    <ulink url="../../libs/range/doc/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>
+                    <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>
                     can be used to package iterators into a structure with a compatible interface.
                 </para>
             </listitem>
@@ -169,7 +169,7 @@
         <programlisting>
     string str1="     hello world!     ";
     string str2=trim_left_copy(str1);   // str2 == "hello world!     "
-    string str3=trim_right_copy(str1);  // str3 == "     hello world!"
+    string str3=trim_right_copy(str2);  // str3 == "     hello world!"
     trim(str1);                         // str1 == "hello world!"
 
     string phone="00423333444";
@@ -208,7 +208,7 @@
         </programlisting>
         <para>
             We have used <functionname>find_last()</functionname> to search the <code>text</code> for "ll".
-            The result is given in the <ulink url="../../libs/range/doc/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink>. 
+            The result is given in the <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink>. 
             This range delimits the
             part of the input which satisfies the find criteria. In our example it is the last occurrence of "ll".
             
@@ -217,7 +217,7 @@
             <ulink url="../../libs/range/index.html">Boost.Range</ulink>.
 
             The following lines transform the result. Notice that 
-            <ulink url="../../libs/range/doc/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> has familiar 
+            <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> has familiar 
             <code>begin()</code> and <code>end()</code> methods, so it can be used like any other STL container.
             Also it is convertible to bool therefore it is easy to use find algorithms for a simple containment checking.
         </para>
@@ -264,7 +264,7 @@
             the find iterator allows us to iterate over the substrings matching the specified criteria.
             This facility is using the <link linkend="string_algo.finder_concept">Finder</link> to incrementally
             search the string. 
-            Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/html/range/utilities/iterator_range.html"><code>boost::iterator_range</code></ulink> 
+            Dereferencing a find iterator yields an <ulink url="../../libs/range/doc/utility_class.html"><code>boost::iterator_range</code></ulink> 
             object, that delimits the current match.
         </para>
         <para>
@@ -339,7 +339,7 @@
     typedef vector&lt; string &gt; split_vector_type;
     
     split_vector_type SplitVec; // #2: Search for tokens
-    split( SplitVec, str1, is_any_of("-*"), token_compress_on ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
+    split( SplitVec, str1, is_any_of("-*") ); // SplitVec == { "hello abc","ABC","aBc goodbye" }
         </programlisting>
         <para>
             <code>[hello]</code> designates an <code>iterator_range</code> delimiting this substring.                       

string/test/Jamfile.v2

@@ -59,11 +59,5 @@ test-suite algorithm/string
             :   
             : regex
         ]
-      [ run 
-            find_format_test.cpp
-          : :
-            :   
-            : find_format
-        ]
     ;
 

string/test/find_format_test.cpp

@@ -1,163 +0,0 @@
-//  Boost string_algo library find_format_test.cpp file  ------------------//
-
-//  Copyright (c) 2009 Steven Watanabe
-//  Distributed under the Boost Software License, Version 1.0. (See
-//  accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org for updates, documentation, and revision history.
-
-#include <boost/algorithm/string/find_format.hpp>
-#include <boost/algorithm/string/finder.hpp>
-#include <boost/algorithm/string/formatter.hpp>
-
-// Include unit test framework
-#include <boost/test/included/test_exec_monitor.hpp>
-
-#include <boost/test/test_tools.hpp>
-
-// We're only using const_formatter.
-template<class Formatter>
-struct formatter_result {
-    typedef boost::iterator_range<const char*> type;
-};
-
-template<class Formatter>
-struct checked_formatter {
-public:
-    checked_formatter(const Formatter& formatter) : formatter_(formatter) {}
-    template< typename T >
-    typename formatter_result<Formatter>::type operator()( const T & s ) const {
-        BOOST_CHECK( !s.empty() );
-        return formatter_(s);
-    }
-private:
-    Formatter formatter_;
-};
-
-template<class Formatter>
-checked_formatter<Formatter>
-make_checked_formatter(const Formatter& formatter) {
-    return checked_formatter<Formatter>(formatter);
-}
-
-void find_format_test()
-{
-    const std::string source = "$replace $replace";
-    std::string expected = "ok $replace";
-    std::string output(80, '\0');
-
-    std::string::iterator pos =
-        boost::find_format_copy(
-            output.begin(),
-            source,
-            boost::first_finder("$replace"),
-            make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK(pos == output.begin() + expected.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, expected);
-
-    output =
-        boost::find_format_copy(
-            source,
-            boost::first_finder("$replace"),
-            make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-
-    // now try finding a string that doesn't exist
-    output.resize(80);
-    pos =
-        boost::find_format_copy(
-            output.begin(),
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK(pos == output.begin() + source.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, source);
-
-    output =
-        boost::find_format_copy(
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-
-    // in place version
-    output = source;
-    boost::find_format(
-        output,
-        boost::first_finder("$replace"),
-        make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-    output = source;
-    boost::find_format(
-        output,
-        boost::first_finder("$noreplace"),
-        make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-}
-
-void find_format_all_test()
-{
-    const std::string source = "$replace $replace";
-    std::string expected = "ok ok";
-    std::string output(80, '\0');
-
-    std::string::iterator pos =
-        boost::find_format_all_copy(output.begin(),
-                                source,
-                                boost::first_finder("$replace"),
-                                boost::const_formatter("ok"));
-    BOOST_CHECK(pos == output.begin() + expected.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, expected);
-
-    output =
-        boost::find_format_all_copy(
-            source,
-            boost::first_finder("$replace"),
-            make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-
-    // now try finding a string that doesn't exist
-    output.resize(80);
-    pos =
-        boost::find_format_all_copy(
-            output.begin(),
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK(pos == output.begin() + source.size());
-    output.erase(std::remove(output.begin(), output.end(), '\0'), output.end());
-    BOOST_CHECK_EQUAL(output, source);
-
-    output =
-        boost::find_format_all_copy(
-            source,
-            boost::first_finder("$noreplace"),
-            make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-
-    // in place version
-    output = source;
-    boost::find_format_all(
-        output,
-        boost::first_finder("$replace"),
-        make_checked_formatter(boost::const_formatter("ok")));
-    BOOST_CHECK_EQUAL(output, expected);
-    output = source;
-    boost::find_format_all(
-        output,
-        boost::first_finder("$noreplace"),
-        make_checked_formatter(boost::const_formatter("bad")));
-    BOOST_CHECK_EQUAL(output, source);
-}
-
-int test_main( int, char*[] )
-{
-    find_format_test();
-    find_format_all_test();
-
-    return 0;
-}

string/test/split_test.cpp

@@ -139,7 +139,6 @@ void iterator_test()
     ++siter;
     BOOST_CHECK(equals(*siter, "abb"));
     ++siter;
-    BOOST_CHECK(siter==split_iterator<string::iterator>(siter));
     BOOST_CHECK(siter==split_iterator<string::iterator>());
 
 }