1 files changed, 191 insertions, 154 deletions

diff --git a/contrib/libstdc++/include/bits/basic_string.tcc b/contrib/libstdc++/include/bits/basic_string.tcc
index fc90111..c2798ef 100644
--- a/contrib/libstdc++/include/bits/basic_string.tcc
+++ b/contrib/libstdc++/include/bits/basic_string.tcc
@@ -1,6 +1,7 @@
 // Components for manipulating sequences of characters -*- C++ -*-
 
-// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+// 2006, 2007
 // Free Software Foundation, Inc.
 //
 // This file is part of the GNU ISO C++ Library.  This library is free
@@ -16,7 +17,7 @@
 
 // You should have received a copy of the GNU General Public License along
 // with this library; see the file COPYING.  If not, write to the Free
-// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
 // USA.
 
 // As a special exception, you may use this file as part of a free software
@@ -28,13 +29,15 @@
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 
+/** @file basic_string.tcc
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
+ */
+
 //
 // ISO C++ 14882: 21  Strings library
 //
 
-// This file is included by <string>.  It is not meant to be included
-// separately.
-
 // Written by Jason Merrill based upon the specification by Takanori Adachi
 // in ANSI X3J16/94-0013R2.  Rewritten by Nathan Myers to ISO-14882.
 
@@ -43,8 +46,8 @@
 
 #pragma GCC system_header
 
-namespace std
-{
+_GLIBCXX_BEGIN_NAMESPACE(std)
+
   template<typename _Type>
     inline bool
     __is_null_pointer(_Type* __ptr)
@@ -101,7 +104,7 @@ namespace std
 	    ++__beg;
 	  }
 	_Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
-	traits_type::copy(__r->_M_refdata(), __buf, __len);
+	_M_copy(__r->_M_refdata(), __buf, __len);
 	try
 	  {
 	    while (__beg != __end)
@@ -110,8 +113,7 @@ namespace std
 		  {
 		    // Allocate more space.
 		    _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
-		    traits_type::copy(__another->_M_refdata(),
-				      __r->_M_refdata(), __len);
+		    _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
 		    __r->_M_destroy(__a);
 		    __r = __another;
 		  }
@@ -124,8 +126,7 @@ namespace std
 	    __r->_M_destroy(__a);
 	    __throw_exception_again;
 	  }
-	__r->_M_length = __len;
-	__r->_M_refdata()[__len] = _Rep::_S_terminal;       // grrr.
+	__r->_M_set_length_and_sharable(__len);
 	return __r->_M_refdata();
       }
 
@@ -155,8 +156,7 @@ namespace std
 	    __r->_M_destroy(__a);
 	    __throw_exception_again;
 	  }
-	__r->_M_length = __dnew;
-	__r->_M_refdata()[__dnew] = _Rep::_S_terminal;  // grrr.
+	__r->_M_set_length_and_sharable(__dnew);
 	return __r->_M_refdata();
       }
 
@@ -172,10 +172,9 @@ namespace std
       // Check for out_of_range and length_error exceptions.
       _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
       if (__n)
-	traits_type::assign(__r->_M_refdata(), __n, __c);
+	_M_assign(__r->_M_refdata(), __n, __c);
 
-      __r->_M_length = __n;
-      __r->_M_refdata()[__n] = _Rep::_S_terminal;  // grrr
+      __r->_M_set_length_and_sharable(__n);
       return __r->_M_refdata();
     }
 
@@ -259,32 +258,107 @@ namespace std
       return *this;
     }
 
-   template<typename _CharT, typename _Traits, typename _Alloc>
-     basic_string<_CharT, _Traits, _Alloc>&
-     basic_string<_CharT, _Traits, _Alloc>::
-     assign(const _CharT* __s, size_type __n)
-     {
-       __glibcxx_requires_string_len(__s, __n);
-       if (__n > this->max_size())
-	 __throw_length_error(__N("basic_string::assign"));
-       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
-	   || less<const _CharT*>()(_M_data() + this->size(), __s))
-	 return _M_replace_safe(size_type(0), this->size(), __s, __n);
-       else
-	 {
-	   // Work in-place
-	   const size_type __pos = __s - _M_data();
-	   if (__pos >= __n)
-	     traits_type::copy(_M_data(), __s, __n);
-	   else if (__pos)
-	     traits_type::move(_M_data(), __s, __n);
-	   _M_rep()->_M_set_sharable();
-	   _M_rep()->_M_length = __n;
-	   _M_data()[__n] = _Rep::_S_terminal;  // grr.
-	   return *this;
-	 }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    assign(const _CharT* __s, size_type __n)
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      _M_check_length(this->size(), __n, "basic_string::assign");
+      if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+	return _M_replace_safe(size_type(0), this->size(), __s, __n);
+      else
+	{
+	  // Work in-place.
+	  const size_type __pos = __s - _M_data();
+	  if (__pos >= __n)
+	    _M_copy(_M_data(), __s, __n);
+	  else if (__pos)
+	    _M_move(_M_data(), __s, __n);
+	  _M_rep()->_M_set_length_and_sharable(__n);
+	  return *this;
+	}
      }
 
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(size_type __n, _CharT __c)
+    {
+      if (__n)
+	{
+	  _M_check_length(size_type(0), __n, "basic_string::append");	  
+	  const size_type __len = __n + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    this->reserve(__len);
+	  _M_assign(_M_data() + this->size(), __n, __c);
+	  _M_rep()->_M_set_length_and_sharable(__len);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const _CharT* __s, size_type __n)
+    {
+      __glibcxx_requires_string_len(__s, __n);
+      if (__n)
+	{
+	  _M_check_length(size_type(0), __n, "basic_string::append");
+	  const size_type __len = __n + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    {
+	      if (_M_disjunct(__s))
+		this->reserve(__len);
+	      else
+		{
+		  const size_type __off = __s - _M_data();
+		  this->reserve(__len);
+		  __s = _M_data() + __off;
+		}
+	    }
+	  _M_copy(_M_data() + this->size(), __s, __n);
+	  _M_rep()->_M_set_length_and_sharable(__len);
+	}
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str)
+    {
+      const size_type __size = __str.size();
+      if (__size)
+	{
+	  const size_type __len = __size + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    this->reserve(__len);
+	  _M_copy(_M_data() + this->size(), __str._M_data(), __size);
+	  _M_rep()->_M_set_length_and_sharable(__len);
+	}
+      return *this;
+    }    
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str, size_type __pos, size_type __n)
+    {
+      __str._M_check(__pos, "basic_string::append");
+      __n = __str._M_limit(__pos, __n);
+      if (__n)
+	{
+	  const size_type __len = __n + this->size();
+	  if (__len > this->capacity() || _M_rep()->_M_is_shared())
+	    this->reserve(__len);
+	  _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
+	  _M_rep()->_M_set_length_and_sharable(__len);	  
+	}
+      return *this;
+    }
+
    template<typename _CharT, typename _Traits, typename _Alloc>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
@@ -292,29 +366,25 @@ namespace std
      {
        __glibcxx_requires_string_len(__s, __n);
        _M_check(__pos, "basic_string::insert");
-       if (this->max_size() - this->size() < __n)
-	 __throw_length_error(__N("basic_string::insert"));
-       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
-           || less<const _CharT*>()(_M_data() + this->size(), __s))
+       _M_check_length(size_type(0), __n, "basic_string::insert");
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
          return _M_replace_safe(__pos, size_type(0), __s, __n);
        else
          {
-           // Work in-place. If _M_mutate reallocates the string, __s
-           // does not point anymore to valid data, therefore we save its
-           // offset, then we restore it.
+           // Work in-place.
            const size_type __off = __s - _M_data();
            _M_mutate(__pos, 0, __n);
            __s = _M_data() + __off;
            _CharT* __p = _M_data() + __pos;
            if (__s  + __n <= __p)
-             traits_type::copy(__p, __s, __n);
+             _M_copy(__p, __s, __n);
            else if (__s >= __p)
-             traits_type::copy(__p, __s + __n, __n);
+             _M_copy(__p, __s + __n, __n);
            else
              {
 	       const size_type __nleft = __p - __s;
-               traits_type::copy(__p, __s, __nleft);
-               traits_type::copy(__p + __nleft, __p + __n, __n - __nleft);
+               _M_copy(__p, __s, __nleft);
+               _M_copy(__p + __nleft, __p + __n, __n - __nleft);
              }
            return *this;
          }
@@ -329,24 +399,18 @@ namespace std
        __glibcxx_requires_string_len(__s, __n2);
        _M_check(__pos, "basic_string::replace");
        __n1 = _M_limit(__pos, __n1);
-       if (this->max_size() - (this->size() - __n1) < __n2)
-         __throw_length_error(__N("basic_string::replace"));
+       _M_check_length(__n1, __n2, "basic_string::replace");
        bool __left;
-       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
-	   || less<const _CharT*>()(_M_data() + this->size(), __s))
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
          return _M_replace_safe(__pos, __n1, __s, __n2);
        else if ((__left = __s + __n2 <= _M_data() + __pos)
 		|| _M_data() + __pos + __n1 <= __s)
 	 {
 	   // Work in-place: non-overlapping case.
-	   const size_type __off = __s - _M_data();
+	   size_type __off = __s - _M_data();
+	   __left ? __off : (__off += __n2 - __n1);
 	   _M_mutate(__pos, __n1, __n2);
-	   if (__left)
-	     traits_type::copy(_M_data() + __pos,
-			       _M_data() + __off, __n2);
-	   else
-	     traits_type::copy(_M_data() + __pos,
-			       _M_data() + __off + __n2 - __n1, __n2);
+	   _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
 	   return *this;
 	 }
        else
@@ -362,10 +426,6 @@ namespace std
     basic_string<_CharT, _Traits, _Alloc>::_Rep::
     _M_destroy(const _Alloc& __a) throw ()
     {
-#ifndef _GLIBCXX_FULLY_DYNAMIC_STRING
-      if (this == &_S_empty_rep())
-	return;
-#endif
       const size_type __size = sizeof(_Rep_base) +
 	                       (this->_M_capacity + 1) * sizeof(_CharT);
       _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
@@ -373,7 +433,8 @@ namespace std
 
   template<typename _CharT, typename _Traits, typename _Alloc>
     void
-    basic_string<_CharT, _Traits, _Alloc>::_M_leak_hard()
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_leak_hard()
     {
 #ifndef _GLIBCXX_FULLY_DYNAMIC_STRING
       if (_M_rep() == &_S_empty_rep())
@@ -393,41 +454,37 @@ namespace std
       const size_type __new_size = __old_size + __len2 - __len1;
       const size_type __how_much = __old_size - __pos - __len1;
 
-      if (__new_size > capacity() || _M_rep()->_M_is_shared())
+      if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
 	{
 	  // Must reallocate.
 	  const allocator_type __a = get_allocator();
-	  _Rep* __r = _Rep::_S_create(__new_size, capacity(), __a);
+	  _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
 
 	  if (__pos)
-	    traits_type::copy(__r->_M_refdata(), _M_data(), __pos);
+	    _M_copy(__r->_M_refdata(), _M_data(), __pos);
 	  if (__how_much)
-	    traits_type::copy(__r->_M_refdata() + __pos + __len2,
-			      _M_data() + __pos + __len1, __how_much);
+	    _M_copy(__r->_M_refdata() + __pos + __len2,
+		    _M_data() + __pos + __len1, __how_much);
 
 	  _M_rep()->_M_dispose(__a);
 	  _M_data(__r->_M_refdata());
 	}
       else if (__how_much && __len1 != __len2)
 	{
-	  // Work in-place
-	  traits_type::move(_M_data() + __pos + __len2,
-			    _M_data() + __pos + __len1, __how_much);
+	  // Work in-place.
+	  _M_move(_M_data() + __pos + __len2,
+		  _M_data() + __pos + __len1, __how_much);
 	}
-      _M_rep()->_M_set_sharable();
-      _M_rep()->_M_length = __new_size;
-      _M_data()[__new_size] = _Rep::_S_terminal; // grrr. (per 21.3.4)
-      // You cannot leave those LWG people alone for a second.
+      _M_rep()->_M_set_length_and_sharable(__new_size);
     }
 
   template<typename _CharT, typename _Traits, typename _Alloc>
     void
-    basic_string<_CharT, _Traits, _Alloc>::reserve(size_type __res)
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
     {
       if (__res != this->capacity() || _M_rep()->_M_is_shared())
         {
-	  if (__res > this->max_size())
-	    __throw_length_error(__N("basic_string::reserve"));
 	  // Make sure we don't shrink below the current size
 	  if (__res < this->size())
 	    __res = this->size();
@@ -439,7 +496,9 @@ namespace std
     }
 
   template<typename _CharT, typename _Traits, typename _Alloc>
-    void basic_string<_CharT, _Traits, _Alloc>::swap(basic_string& __s)
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s)
     {
       if (_M_rep()->_M_is_leaked())
 	_M_rep()->_M_set_sharable();
@@ -469,7 +528,6 @@ namespace std
     _S_create(size_type __capacity, size_type __old_capacity,
 	      const _Alloc& __alloc)
     {
-      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
       // _GLIBCXX_RESOLVE_LIB_DEFECTS
       // 83.  String::npos vs. string::max_size()
       if (__capacity > _S_max_size)
@@ -498,9 +556,8 @@ namespace std
       // low-balling it (especially when this algorithm is used with
       // malloc implementations that allocate memory blocks rounded up
       // to a size which is a power of 2).
-      const size_type __pagesize = 4096; // must be 2^i * __subpagesize
-      const size_type __subpagesize = 128; // should be >> __malloc_header_size
-      const size_type __malloc_header_size = 4 * sizeof (void*);
+      const size_type __pagesize = 4096;
+      const size_type __malloc_header_size = 4 * sizeof(void*);
 
       // The below implements an exponential growth policy, necessary to
       // meet amortized linear time requirements of the library: see
@@ -508,14 +565,7 @@ namespace std
       // It's active for allocations requiring an amount of memory above
       // system pagesize. This is consistent with the requirements of the
       // standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
-
-      // The biggest string which fits in a memory page
-      const size_type __page_capacity = ((__pagesize - __malloc_header_size
-					  - sizeof(_Rep) - sizeof(_CharT))
-					 / sizeof(_CharT));
-
-      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity
-	  && __capacity > __page_capacity)
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
 	__capacity = 2 * __old_capacity;
 
       // NB: Need an array of char_type[__capacity], plus a terminating
@@ -524,7 +574,7 @@ namespace std
       size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
 
       const size_type __adj_size = __size + __malloc_header_size;
-      if (__adj_size > __pagesize)
+      if (__adj_size > __pagesize && __capacity > __old_capacity)
 	{
 	  const size_type __extra = __pagesize - __adj_size % __pagesize;
 	  __capacity += __extra / sizeof(_CharT);
@@ -533,20 +583,20 @@ namespace std
 	    __capacity = _S_max_size;
 	  __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
 	}
-      else if (__size > __subpagesize)
-	{
-	  const size_type __extra = __subpagesize - __adj_size % __subpagesize;
-	  __capacity += __extra / sizeof(_CharT);
-	  __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
-	}
 
       // NB: Might throw, but no worries about a leak, mate: _Rep()
       // does not throw.
       void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
       _Rep *__p = new (__place) _Rep;
       __p->_M_capacity = __capacity;
-      __p->_M_set_sharable();  // One reference.
-      __p->_M_length = 0;
+      // ABI compatibility - 3.4.x set in _S_create both
+      // _M_refcount and _M_length.  All callers of _S_create
+      // in basic_string.tcc then set just _M_length.
+      // In 4.0.x and later both _M_refcount and _M_length
+      // are initialized in the callers, unfortunately we can
+      // have 3.4.x compiled code with _S_create callers inlined
+      // calling 4.0.x+ _S_create.
+      __p->_M_set_sharable();
       return __p;
     }
 
@@ -560,21 +610,19 @@ namespace std
       _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
 				  __alloc);
       if (this->_M_length)
-	traits_type::copy(__r->_M_refdata(), _M_refdata(),
-			  this->_M_length);
+	_M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
 
-      __r->_M_length = this->_M_length;
-      __r->_M_refdata()[this->_M_length] = _Rep::_S_terminal;
+      __r->_M_set_length_and_sharable(this->_M_length);
       return __r->_M_refdata();
     }
 
   template<typename _CharT, typename _Traits, typename _Alloc>
     void
-    basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
     {
-      if (__n > max_size())
-	__throw_length_error(__N("basic_string::resize"));
       const size_type __size = this->size();
+      _M_check_length(__size, __n, "basic_string::resize");
       if (__size < __n)
 	this->append(__n - __size, __c);
       else if (__n < __size)
@@ -591,8 +639,7 @@ namespace std
       {
 	const basic_string __s(__k1, __k2);
 	const size_type __n1 = __i2 - __i1;
-	if (this->max_size() - (this->size() - __n1) < __s.size())
-	  __throw_length_error(__N("basic_string::_M_replace_dispatch"));
+	_M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
 	return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
 			       __s.size());
       }
@@ -600,48 +647,28 @@ namespace std
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
-    append(const basic_string& __str)
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+		   _CharT __c)
     {
-      // Iff appending itself, string needs to pre-reserve the
-      // correct size so that _M_mutate does not clobber the
-      // pointer __str._M_data() formed here.
-      const size_type __size = __str.size();
-      const size_type __len = __size + this->size();
-      if (__len > this->capacity())
-	this->reserve(__len);
-      return _M_replace_safe(this->size(), size_type(0), __str._M_data(),
-			     __str.size());
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+	_M_assign(_M_data() + __pos1, __n2, __c);
+      return *this;
     }
 
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
-    append(const basic_string& __str, size_type __pos, size_type __n)
+    _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
+		    size_type __n2)
     {
-      // Iff appending itself, string needs to pre-reserve the
-      // correct size so that _M_mutate does not clobber the
-      // pointer __str._M_data() formed here.
-      __str._M_check(__pos, "basic_string::append");
-      __n = __str._M_limit(__pos, __n);
-      const size_type __len = __n + this->size();
-      if (__len > this->capacity())
-	this->reserve(__len);
-      return _M_replace_safe(this->size(), size_type(0), __str._M_data()
-			     + __pos, __n);
-    }
-
-  template<typename _CharT, typename _Traits, typename _Alloc>
-    basic_string<_CharT, _Traits, _Alloc>&
-    basic_string<_CharT, _Traits, _Alloc>::
-    append(const _CharT* __s, size_type __n)
-    {
-      __glibcxx_requires_string_len(__s, __n);
-      const size_type __len = __n + this->size();
-      if (__len > this->capacity())
-	this->reserve(__len);
-      return _M_replace_safe(this->size(), size_type(0), __s, __n);
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+	_M_copy(_M_data() + __pos1, __s, __n2);
+      return *this;
     }
-
+   
   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>
     operator+(const _CharT* __lhs,
@@ -681,7 +708,7 @@ namespace std
       __n = _M_limit(__pos, __n);
       __glibcxx_requires_string_len(__s, __n);
       if (__n)
-	traits_type::copy(__s, _M_data() + __pos, __n);
+	_M_copy(__s, _M_data() + __pos, __n);
       // 21.3.5.7 par 3: do not append null.  (good.)
       return __n;
     }
@@ -694,9 +721,18 @@ namespace std
       __glibcxx_requires_string_len(__s, __n);
       const size_type __size = this->size();
       const _CharT* __data = _M_data();
-      for (; __pos + __n <= __size; ++__pos)
-	if (traits_type::compare(__data + __pos, __s, __n) == 0)
-	  return __pos;
+
+      if (__n == 0)
+	return __pos <= __size ? __pos : npos;
+
+      if (__n <= __size)
+	{
+	  for (; __pos <= __size - __n; ++__pos)
+	    if (traits_type::eq(__data[__pos], __s[0])
+		&& traits_type::compare(__data + __pos + 1,
+					__s + 1, __n - 1) == 0)
+	      return __pos;
+	}
       return npos;
     }
 
@@ -705,8 +741,8 @@ namespace std
     basic_string<_CharT, _Traits, _Alloc>::
     find(_CharT __c, size_type __pos) const
     {
-      const size_type __size = this->size();
       size_type __ret = npos;
+      const size_type __size = this->size();
       if (__pos < __size)
 	{
 	  const _CharT* __data = _M_data();
@@ -970,6 +1006,7 @@ namespace std
     getline(basic_istream<wchar_t>&, wstring&);
 #endif
 #endif
-} // namespace std
+
+_GLIBCXX_END_NAMESPACE
 
 #endif