Use STLPort instead of our stripped version.

This fixes the simulator build and allows us to get closer to sharing code with
chromium.

STLPort was copied with minor edits from the Android port of gears.

1 files changed, 1416 insertions, 0 deletions

diff --git a/WebKit/android/stlport/stl/_string.h b/WebKit/android/stlport/stl/_string.h
new file mode 100644
index 0000000..928dedd
--- /dev/null
+++ b/WebKit/android/stlport/stl/_string.h
@@ -0,0 +1,1416 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_STRING_H
+#define _STLP_INTERNAL_STRING_H
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+#  include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_STRING_FWD_H
+#  include <stl/_string_fwd.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#  include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#  include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#  include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+#  include <stl/_uninitialized.h>
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+#  include <stl/_string_sum.h>
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+#if defined (__MWERKS__) && ! defined (_STLP_USE_OWN_NAMESPACE)
+
+// MSL implementation classes expect to see the definition of streampos
+// when this header is included. We expect this to be fixed in later MSL
+// implementations
+#  if !defined( __MSL_CPP__ ) || __MSL_CPP__ < 0x4105
+#    include <stl/msl_string.h>
+#  endif
+#endif // __MWERKS__
+
+/*
+ * Standard C++ string class.  This class has performance
+ * characteristics very much like vector<>, meaning, for example, that
+ * it does not perform reference-count or copy-on-write, and that
+ * concatenation of two strings is an O(N) operation.
+
+ * There are three reasons why basic_string is not identical to
+ * vector.
+ * First, basic_string can always stores a null character
+ * at the end (macro dependent); this makes it possible for c_str to
+ * be a fast operation.
+ * Second, the C++ standard requires basic_string to copy elements
+ * using char_traits<>::assign, char_traits<>::copy, and
+ * char_traits<>::move.  This means that all of vector<>'s low-level
+ * operations must be rewritten.  Third, basic_string<> has a lot of
+ * extra functions in its interface that are convenient but, strictly
+ * speaking, redundant.
+
+ * Additionally, the C++ standard imposes a major restriction: according
+ * to the standard, the character type _CharT must be a POD type.  This
+ * implementation weakens that restriction, and allows _CharT to be a
+ * a user-defined non-POD type.  However, _CharT must still have a
+ * default constructor.
+ */
+
+#include <stl/_string_base.h>
+
+_STLP_BEGIN_NAMESPACE
+
+// ------------------------------------------------------------
+// Class basic_string.
+
+// Class invariants:
+// (1) [start, finish) is a valid range.
+// (2) Each iterator in [start, finish) points to a valid object
+//     of type value_type.
+// (3) *finish is a valid object of type value_type; when
+//     value_type is not a POD it is value_type().
+// (4) [finish + 1, end_of_storage) is a valid range.
+// (5) Each iterator in [finish + 1, end_of_storage) points to
+//     unininitialized memory.
+
+// Note one important consequence: a string of length n must manage
+// a block of memory whose size is at least n + 1.
+
+struct _String_reserve_t {};
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  define basic_string _STLP_NO_MEM_T_NAME(str)
+#elif defined (_STLP_DEBUG)
+#  define basic_string _STLP_NON_DBG_NAME(str)
+#endif
+
+#if defined (basic_string)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_string : protected _STLP_PRIV _String_base<_CharT,_Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string)
+                   , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> >
+#endif
+{
+protected:                        // Protected members inherited from base.
+  typedef _STLP_PRIV _String_base<_CharT,_Alloc> _Base;
+  typedef basic_string<_CharT, _Traits, _Alloc> _Self;
+  // fbp : used to optimize char/wchar_t cases, and to simplify
+  // _STLP_DEF_CONST_PLCT_NEW_BUG problem workaround
+  typedef typename _IsIntegral<_CharT>::_Ret _Char_Is_Integral;
+  typedef typename _IsPOD<_CharT>::_Type _Char_Is_POD;
+  typedef random_access_iterator_tag r_a_i_t;
+
+public:
+  typedef _CharT value_type;
+  typedef _Traits traits_type;
+
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef typename _Base::size_type size_type;
+  typedef ptrdiff_t difference_type;
+  typedef random_access_iterator_tag _Iterator_category;
+
+  typedef const value_type* const_iterator;
+  typedef value_type*       iterator;
+
+  _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+#include <stl/_string_npos.h>
+
+  typedef _String_reserve_t _Reserve_t;
+
+public:                         // Constructor, destructor, assignment.
+  typedef typename _Base::allocator_type allocator_type;
+
+  allocator_type get_allocator() const
+  { return _STLP_CONVERT_ALLOCATOR((const allocator_type&)this->_M_end_of_storage, _CharT); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  explicit basic_string(const allocator_type& __a = allocator_type())
+#else
+  basic_string()
+      : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), _Base::_DEFAULT_SIZE)
+  { _M_terminate_string(); }
+  explicit basic_string(const allocator_type& __a)
+#endif
+      : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, _Base::_DEFAULT_SIZE)
+  { _M_terminate_string(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(_Reserve_t, size_t __n,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(_Reserve_t, size_t __n)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1)
+  { _M_terminate_string(); }
+  basic_string(_Reserve_t, size_t __n, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1)
+  { _M_terminate_string(); }
+
+  basic_string(const _Self&);
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(const _Self& __s, size_type __pos, size_type __n = npos,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(const _Self& __s, size_type __pos)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    else
+      _M_range_initialize(__s._M_Start() + __pos, __s._M_Finish());
+  }
+  basic_string(const _Self& __s, size_type __pos, size_type __n)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    else
+      _M_range_initialize(__s._M_Start() + __pos,
+                          __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+  basic_string(const _Self& __s, size_type __pos, size_type __n,
+               const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    else
+      _M_range_initialize(__s._M_Start() + __pos,
+                          __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(const _CharT* __s, size_type __n,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(const _CharT* __s, size_type __n)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+      _STLP_FIX_LITERAL_BUG(__s)
+      _M_range_initialize(__s, __s + __n);
+    }
+  basic_string(const _CharT* __s, size_type __n, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+      _STLP_FIX_LITERAL_BUG(__s)
+      _M_range_initialize(__s, __s + __n);
+    }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(const _CharT* __s,
+               const allocator_type& __a = allocator_type());
+#else
+  basic_string(const _CharT* __s);
+  basic_string(const _CharT* __s, const allocator_type& __a);
+#endif
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+  basic_string(size_type __n, _CharT __c,
+               const allocator_type& __a = allocator_type())
+#else
+  basic_string(size_type __n, _CharT __c)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1) {
+#  if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (this->_M_using_static_buf()) {
+      _Traits::assign(this->_M_Start(), __n, __c);
+      this->_M_finish = this->_M_Start() + __n;
+    }
+    else
+#  endif
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c);
+    _M_terminate_string();
+  }
+  basic_string(size_type __n, _CharT __c, const allocator_type& __a)
+#endif
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1) {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (this->_M_using_static_buf()) {
+      _Traits::assign(this->_M_Start(), __n, __c);
+      this->_M_finish = this->_M_Start() + __n;
+    }
+    else
+#endif
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c);
+    _M_terminate_string();
+  }
+
+  basic_string(__move_source<_Self> src)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__move_source<_Base>(src.get())) {}
+
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+#if defined (_STLP_MEMBER_TEMPLATES) && !(defined (__MRC__) || (defined(__SC__) && !defined(__DMC__))) //*ty 04/30/2001 - mpw compilers choke on this ctor
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  template <class _InputIterator>
+  basic_string(_InputIterator __f, _InputIterator __l,
+               const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_initialize_dispatch(__f, __l, _Integral());
+  }
+#    if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  template <class _InputIterator>
+  basic_string(_InputIterator __f, _InputIterator __l)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+    _M_initialize_dispatch(__f, __l, _Integral());
+  }
+#    endif
+#  else
+  /* We need an additionnal constructor to build an empty string without
+   * any allocation or termination char*/
+protected:
+  struct _CalledFromWorkaround_t {};
+  basic_string(_CalledFromWorkaround_t, const allocator_type &__a)
+    : _String_base<_CharT,_Alloc>(__a) {}
+public:
+#  endif /* _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND */
+#endif /* !__MRC__ || (__SC__ && !__DMC__) */
+
+#if !(defined (_STLP_MEMBER_TEMPLATES) && !(defined (__MRC__) || (defined (__SC__) && !defined (__DMC__)))) || \
+    !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS) || \
+     defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  basic_string(const _CharT* __f, const _CharT* __l,
+               const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+    _STLP_FIX_LITERAL_BUG(__f)  _STLP_FIX_LITERAL_BUG(__l)
+    _M_range_initialize(__f, __l);
+  }
+#  if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+  basic_string(const _CharT* __f, const _CharT* __l)
+    : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+    _STLP_FIX_LITERAL_BUG(__f)  _STLP_FIX_LITERAL_BUG(__l)
+    _M_range_initialize(__f, __l);
+  }
+#  endif
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+private:
+  template <class _InputIter>
+  void _M_range_initialize(_InputIter __f, _InputIter __l,
+                           const input_iterator_tag &__tag) {
+    this->_M_allocate_block();
+    _M_construct_null(this->_M_Finish());
+    _STLP_TRY {
+      _M_appendT(__f, __l, __tag);
+    }
+    _STLP_UNWIND(this->_M_destroy_range())
+  }
+
+  template <class _ForwardIter>
+  void _M_range_initialize(_ForwardIter __f, _ForwardIter __l,
+                           const forward_iterator_tag &) {
+    difference_type __n = distance(__f, __l);
+    this->_M_allocate_block(__n + 1);
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (this->_M_using_static_buf()) {
+      _M_copyT(__f, __l, this->_M_Start());
+      this->_M_finish = this->_M_Start() + __n;
+    }
+    else
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+    this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start());
+    this->_M_terminate_string();
+  }
+
+  template <class _InputIter>
+  void _M_range_initializeT(_InputIter __f, _InputIter __l) {
+    _M_range_initialize(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+  }
+
+  template <class _Integer>
+  void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) {
+    this->_M_allocate_block(__n + 1);
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (this->_M_using_static_buf()) {
+      _Traits::assign(this->_M_Start(), __n, __x);
+      this->_M_finish = this->_M_Start() + __n;
+    }
+    else
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+    this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __x);
+    this->_M_terminate_string();
+  }
+
+  template <class _InputIter>
+  void _M_initialize_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+    _M_range_initializeT(__f, __l);
+  }
+
+public:
+  ~basic_string()
+  { this->_M_destroy_range(); }
+
+  _Self& operator=(const _Self& __s) {
+    if (&__s != this)
+      _M_assign(__s._M_Start(), __s._M_Finish());
+    return *this;
+  }
+
+  _Self& operator=(const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_assign(__s, __s + traits_type::length(__s));
+  }
+
+  _Self& operator=(_CharT __c)
+  { return assign(__STATIC_CAST(size_type,1), __c); }
+
+protected:
+
+  static _CharT _STLP_CALL _M_null()
+  { return _STLP_DEFAULT_CONSTRUCTED(_CharT); }
+
+protected:                     // Helper functions used by constructors
+                               // and elsewhere.
+  // fbp : simplify integer types (char, wchar)
+  void _M_construct_null_aux(_CharT* __p, const __false_type& /*_Is_Integral*/) const {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (this->_M_using_static_buf())
+      _Traits::assign(*__p, _M_null());
+    else
+#endif /*_STLP_USE_SHORT_STRING_OPTIM*/
+    _STLP_STD::_Construct(__p);
+  }
+  void _M_construct_null_aux(_CharT* __p, const __true_type& /*_Is_Integral*/) const
+  { *__p = 0; }
+
+  void _M_force_construct_null(_CharT*, const __true_type& /* _Is_POD */) const
+  { /*Nothing to do*/ }
+  void _M_force_construct_null(_CharT* __p, const __false_type& /* _Is_POD */) const
+  { _M_construct_null_aux(__p, _Char_Is_Integral()); }
+
+  void _M_construct_null(_CharT* __p) const {
+    typedef __false_type _Answer;
+
+    _M_force_construct_null(__p, _Answer());
+  }
+
+protected:
+  // Helper functions used by constructors.  It is a severe error for
+  // any of them to be called anywhere except from within constructors.
+  void _M_terminate_string_aux(const __false_type& __is_integral) {
+    _STLP_TRY {
+      _M_construct_null_aux(this->_M_Finish(), __is_integral);
+    }
+    _STLP_UNWIND(this->_M_destroy_range(0,0))
+  }
+
+  void _M_terminate_string_aux(const __true_type& __is_integral)
+  { _M_construct_null_aux(this->_M_Finish(), __is_integral); }
+
+  void _M_force_terminate_string(const __true_type& /* _Is_POD */)
+  { /*Nothing to do*/ }
+  void _M_force_terminate_string(const __false_type& /* _Is_POD */)
+  { _M_terminate_string_aux(_Char_Is_Integral()); }
+
+  void _M_terminate_string() {
+    typedef __false_type _Answer;
+
+    _M_force_terminate_string(_Answer());
+  }
+
+  bool _M_inside(const _CharT* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return (__s >= this->_M_Start()) && (__s < this->_M_Finish());
+  }
+
+  void _M_range_initialize(const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    ptrdiff_t __n = __l - __f;
+    this->_M_allocate_block(__n + 1);
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+    if (this->_M_using_static_buf()) {
+      _M_copy(__f, __l, this->_M_Start());
+      this->_M_finish = this->_M_Start() + __n;
+    }
+    else
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+    this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start());
+    _M_terminate_string();
+  }
+
+public:                         // Iterators.
+  iterator begin()             { return this->_M_Start(); }
+  iterator end()               { return this->_M_Finish(); }
+  const_iterator begin() const { return this->_M_Start(); }
+  const_iterator end()   const { return this->_M_Finish(); }
+
+  reverse_iterator rbegin()
+    { return reverse_iterator(this->_M_Finish()); }
+  reverse_iterator rend()
+    { return reverse_iterator(this->_M_Start()); }
+  const_reverse_iterator rbegin() const
+    { return const_reverse_iterator(this->_M_Finish()); }
+  const_reverse_iterator rend()   const
+    { return const_reverse_iterator(this->_M_Start()); }
+
+public:                         // Size, capacity, etc.
+  size_type size() const { return this->_M_Finish() - this->_M_Start(); }
+  size_type length() const { return size(); }
+  size_t max_size() const { return _Base::max_size(); }
+
+  void resize(size_type __n, _CharT __c) {
+    if (__n <= size())
+      erase(begin() + __n, end());
+    else
+      append(__n - size(), __c);
+  }
+
+  void resize(size_type __n) { resize(__n, _M_null()); }
+
+  void reserve(size_type = 0);
+
+  size_type capacity() const
+  { return (this->_M_end_of_storage._M_data - this->_M_Start()) - 1; }
+
+  void clear() {
+    if (!empty()) {
+      _Traits::assign(*(this->_M_Start()), _M_null());
+      this->_M_destroy_range(1);
+      this->_M_finish = this->_M_Start();
+    }
+  }
+
+  bool empty() const { return this->_M_Start() == this->_M_Finish(); }
+
+public:                         // Element access.
+
+  const_reference operator[](size_type __n) const
+  { return *(this->_M_Start() + __n); }
+  reference operator[](size_type __n)
+  { return *(this->_M_Start() + __n); }
+
+  const_reference at(size_type __n) const {
+    if (__n >= size())
+      this->_M_throw_out_of_range();
+    return *(this->_M_Start() + __n);
+  }
+
+  reference at(size_type __n) {
+    if (__n >= size())
+      this->_M_throw_out_of_range();
+    return *(this->_M_Start() + __n);
+  }
+
+public:                         // Append, operator+=, push_back.
+
+  _Self& operator+=(const _Self& __s) { return append(__s); }
+  _Self& operator+=(const _CharT* __s) { _STLP_FIX_LITERAL_BUG(__s) return append(__s); }
+  _Self& operator+=(_CharT __c) { push_back(__c); return *this; }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+private: // Helper functions for append.
+  template <class _InputIter>
+  _Self& _M_appendT(_InputIter __first, _InputIter __last,
+                    const input_iterator_tag &) {
+    for ( ; __first != __last ; ++__first)
+      push_back(*__first);
+    return *this;
+  }
+
+  template <class _ForwardIter>
+  _Self& _M_appendT(_ForwardIter __first, _ForwardIter __last,
+                    const forward_iterator_tag &) {
+    if (__first != __last) {
+      const size_type __old_size = this->size();
+      difference_type __n = distance(__first, __last);
+      if (__STATIC_CAST(size_type,__n) > this->max_size() || __old_size > this->max_size() - __STATIC_CAST(size_type,__n))
+        this->_M_throw_length_error();
+      if (__old_size + __n > this->capacity()) {
+        size_type __len = __old_size + (max)(__old_size, __STATIC_CAST(size_type,__n)) + 1;
+        pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
+        pointer __new_finish = __new_start;
+        _STLP_TRY {
+          __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start);
+          __new_finish = uninitialized_copy(__first, __last, __new_finish);
+          _M_construct_null(__new_finish);
+        }
+        _STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish),
+          this->_M_end_of_storage.deallocate(__new_start, __len)))
+          this->_M_destroy_range();
+        this->_M_deallocate_block();
+        this->_M_reset(__new_start, __new_finish, __new_start + __len);
+      }
+      else {
+        _ForwardIter __f1 = __first;
+        ++__f1;
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+        if (this->_M_using_static_buf())
+          _M_copyT(__f1, __last, this->_M_Finish() + 1);
+        else
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+          uninitialized_copy(__f1, __last, this->_M_Finish() + 1);
+        _STLP_TRY {
+          _M_construct_null(this->_M_Finish() + __n);
+        }
+        _STLP_UNWIND(this->_M_destroy_ptr_range(this->_M_Finish() + 1, this->_M_Finish() + __n))
+        _Traits::assign(*this->_M_finish, *__first);
+        this->_M_finish += __n;
+      }
+    }
+    return *this;
+  }
+
+  template <class _Integer>
+  _Self& _M_append_dispatch(_Integer __n, _Integer __x, const __true_type& /*Integral*/)
+  { return append((size_type) __n, (_CharT) __x); }
+
+  template <class _InputIter>
+  _Self& _M_append_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*Integral*/)
+  { return _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); }
+
+public:
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  _Self& append(_InputIter __first, _InputIter __last) {
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    return _M_append_dispatch(__first, __last, _Integral());
+  }
+#  endif
+#endif
+
+protected:
+  _Self& _M_append(const _CharT* __first, const _CharT* __last);
+
+public:
+#if !defined (_STLP_MEMBER_TEMPLATES) || \
+    !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  _Self& append(const _CharT* __first, const _CharT* __last) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    return _M_append(__first, __last);
+  }
+#  endif
+#endif
+
+  _Self& append(const _Self& __s)
+  { return _M_append(__s._M_Start(), __s._M_Finish()); }
+
+  _Self& append(const _Self& __s,
+                size_type __pos, size_type __n) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    return _M_append(__s._M_Start() + __pos,
+                     __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+
+  _Self& append(const _CharT* __s, size_type __n)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s+__n); }
+  _Self& append(const _CharT* __s)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s + traits_type::length(__s)); }
+  _Self& append(size_type __n, _CharT __c);
+
+public:
+  void push_back(_CharT __c) {
+    if (this->_M_Finish() + 1 == this->_M_end_of_storage._M_data)
+      reserve(size() + (max)(size(), __STATIC_CAST(size_type,1)));
+    _M_construct_null(this->_M_Finish() + 1);
+    _Traits::assign(*(this->_M_Finish()), __c);
+    ++this->_M_finish;
+  }
+
+  void pop_back() {
+    _Traits::assign(*(this->_M_Finish() - 1), _M_null());
+    this->_M_destroy_back();
+    --this->_M_finish;
+  }
+
+public:                         // Assign
+  _Self& assign(const _Self& __s)
+  { return _M_assign(__s._M_Start(), __s._M_Finish()); }
+
+  _Self& assign(const _Self& __s,
+                size_type __pos, size_type __n) {
+    if (__pos > __s.size())
+      this->_M_throw_out_of_range();
+    return _M_assign(__s._M_Start() + __pos,
+                     __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+  }
+
+  _Self& assign(const _CharT* __s, size_type __n)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + __n); }
+
+  _Self& assign(const _CharT* __s)
+  { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + _Traits::length(__s)); }
+
+  _Self& assign(size_type __n, _CharT __c);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+private:                        // Helper functions for assign.
+  template <class _Integer>
+  _Self& _M_assign_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/)
+  { return assign((size_type) __n, (_CharT) __x); }
+
+  template <class _InputIter>
+  _Self& _M_assign_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+    pointer __cur = this->_M_Start();
+    while (__f != __l && __cur != this->_M_Finish()) {
+      _Traits::assign(*__cur, *__f);
+      ++__f;
+      ++__cur;
+    }
+    if (__f == __l)
+      erase(__cur, this->end());
+    else
+      _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+    return *this;
+  }
+
+public:
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  _Self& assign(_InputIter __first, _InputIter __last) {
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    return _M_assign_dispatch(__first, __last, _Integral());
+  }
+#  endif
+#endif
+
+protected:
+  _Self& _M_assign(const _CharT* __f, const _CharT* __l);
+
+public:
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || \
+    !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  _Self& assign(const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    return _M_assign(__f, __l);
+  }
+#  endif
+#endif
+
+public:                         // Insert
+
+  _Self& insert(size_type __pos, const _Self& __s) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    if (size() > max_size() - __s.size())
+      this->_M_throw_length_error();
+    _M_insert(begin() + __pos, __s._M_Start(), __s._M_Finish(), &__s == this);
+    return *this;
+  }
+
+  _Self& insert(size_type __pos, const _Self& __s,
+                size_type __beg, size_type __n) {
+    if (__pos > size() || __beg > __s.size())
+      this->_M_throw_out_of_range();
+    size_type __len = (min) (__n, __s.size() - __beg);
+    if (size() > max_size() - __len)
+      this->_M_throw_length_error();
+    _M_insert(begin() + __pos,
+              __s._M_Start() + __beg, __s._M_Start() + __beg + __len, &__s == this);
+    return *this;
+  }
+  _Self& insert(size_type __pos, const _CharT* __s, size_type __n) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    if (size() > max_size() - __n)
+      this->_M_throw_length_error();
+    _M_insert(begin() + __pos, __s, __s + __n, _M_inside(__s));
+    return *this;
+  }
+
+  _Self& insert(size_type __pos, const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    size_type __len = _Traits::length(__s);
+    if (size() > max_size() - __len)
+      this->_M_throw_length_error();
+    _M_insert(this->_M_Start() + __pos, __s, __s + __len, _M_inside(__s));
+    return *this;
+  }
+
+  _Self& insert(size_type __pos, size_type __n, _CharT __c) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    if (size() > max_size() - __n)
+      this->_M_throw_length_error();
+    insert(begin() + __pos, __n, __c);
+    return *this;
+  }
+
+  iterator insert(iterator __p, _CharT __c) {
+    _STLP_FIX_LITERAL_BUG(__p)
+    if (__p == end()) {
+      push_back(__c);
+      return this->_M_Finish() - 1;
+    }
+    else
+      return _M_insert_aux(__p, __c);
+  }
+
+  void insert(iterator __p, size_t __n, _CharT __c);
+
+protected:  // Helper functions for insert.
+
+  void _M_insert(iterator __p, const _CharT* __first, const _CharT* __last, bool __self_ref);
+
+  pointer _M_insert_aux(pointer, _CharT);
+
+  void _M_copy(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _STLP_FIX_LITERAL_BUG(__res)
+    _Traits::copy(__res, __f, __l - __f);
+  }
+
+  void _M_move(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _Traits::move(__res, __f, __l - __f);
+  }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  template <class _ForwardIter>
+  void _M_insert_overflow(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+                          difference_type __n) {
+    const size_type __old_size = this->size();
+    size_type __len = __old_size + (max)(__old_size, __STATIC_CAST(size_type,__n)) + 1;
+    pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
+    pointer __new_finish = __new_start;
+    _STLP_TRY {
+      __new_finish = uninitialized_copy(this->_M_Start(), __pos, __new_start);
+      __new_finish = uninitialized_copy(__first, __last, __new_finish);
+      __new_finish = uninitialized_copy(__pos, this->_M_Finish(), __new_finish);
+      _M_construct_null(__new_finish);
+    }
+    _STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish),
+                  this->_M_end_of_storage.deallocate(__new_start, __len)))
+    this->_M_destroy_range();
+    this->_M_deallocate_block();
+    this->_M_reset(__new_start, __new_finish, __new_start + __len);
+  }
+
+  template <class _InputIter>
+  void _M_insertT(iterator __p, _InputIter __first, _InputIter __last,
+                  const input_iterator_tag &) {
+    for ( ; __first != __last; ++__first) {
+      __p = insert(__p, *__first);
+      ++__p;
+    }
+  }
+
+  template <class _ForwardIter>
+  void _M_insertT(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+                  const forward_iterator_tag &) {
+    if (__first != __last) {
+      difference_type __n = distance(__first, __last);
+      if (this->_M_end_of_storage._M_data - this->_M_finish >= __n + 1) {
+        const difference_type __elems_after = this->_M_finish - __pos;
+        if (__elems_after >= __n) {
+#    if defined (_STLP_USE_SHORT_STRING_OPTIM)
+          if (this->_M_using_static_buf())
+            _M_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1);
+          else
+#    endif /* _STLP_USE_SHORT_STRING_OPTIM */
+          uninitialized_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1);
+          this->_M_finish += __n;
+          _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+          _M_copyT(__first, __last, __pos);
+        }
+        else {
+          pointer __old_finish = this->_M_Finish();
+          _ForwardIter __mid = __first;
+          advance(__mid, __elems_after + 1);
+#    if defined (_STLP_USE_SHORT_STRING_OPTIM)
+          if (this->_M_using_static_buf())
+            _M_copyT(__mid, __last, this->_M_Finish() + 1);
+          else
+#    endif /* _STLP_USE_SHORT_STRING_OPTIM */
+          uninitialized_copy(__mid, __last, this->_M_Finish() + 1);
+          this->_M_finish += __n - __elems_after;
+          _STLP_TRY {
+#    if defined (_STLP_USE_SHORT_STRING_OPTIM)
+            if (this->_M_using_static_buf())
+              _M_copy(__pos, __old_finish + 1, this->_M_Finish());
+            else
+#    endif /* _STLP_USE_SHORT_STRING_OPTIM */
+            uninitialized_copy(__pos, __old_finish + 1, this->_M_Finish());
+            this->_M_finish += __elems_after;
+          }
+          _STLP_UNWIND((this->_M_destroy_ptr_range(__old_finish + 1, this->_M_Finish()),
+                        this->_M_finish = __old_finish))
+          _M_copyT(__first, __mid, __pos);
+        }
+      }
+      else {
+        _M_insert_overflow(__pos, __first, __last, __n);
+      }
+    }
+  }
+
+  template <class _Integer>
+  void _M_insert_dispatch(iterator __p, _Integer __n, _Integer __x,
+                          const __true_type& /*Integral*/) {
+    insert(__p, (size_type) __n, (_CharT) __x);
+  }
+
+  template <class _InputIter>
+  void _M_insert_dispatch(iterator __p, _InputIter __first, _InputIter __last,
+                          const __false_type& /*Integral*/) {
+    _STLP_FIX_LITERAL_BUG(__p)
+    /*
+     * Within the basic_string implementation we are only going to check for
+     * self referencing if iterators are string iterators or _CharT pointers.
+     * A user could encapsulate those iterator within their own iterator interface
+     * and in this case lead to a bad behavior, this is a known limitation.
+     */
+    typedef typename _AreSameUnCVTypes<_InputIter, iterator>::_Ret _IsIterator;
+    typedef typename _AreSameUnCVTypes<_InputIter, const_iterator>::_Ret _IsConstIterator;
+    typedef typename _Lor2<_IsIterator, _IsConstIterator>::_Ret _CheckInside;
+    _M_insert_aux(__p, __first, __last, _CheckInside());
+  }
+
+  template <class _RandomIter>
+  void _M_insert_aux (iterator __p, _RandomIter __first, _RandomIter __last,
+                      const __true_type& /*_CheckInside*/) {
+    _STLP_FIX_LITERAL_BUG(__p)
+    _M_insert(__p, &(*__first), &(*__last), _M_inside(&(*__first)));
+  }
+
+  template<class _InputIter>
+  void _M_insert_aux (iterator __p, _InputIter __first, _InputIter __last,
+                      const __false_type& /*_CheckInside*/) {
+    _STLP_FIX_LITERAL_BUG(__p)
+    _M_insertT(__p, __first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
+  }
+
+  template <class _InputIterator>
+  void _M_copyT(_InputIterator __first, _InputIterator __last, pointer __result) {
+    _STLP_FIX_LITERAL_BUG(__result)
+    for ( ; __first != __last; ++__first, ++__result)
+      _Traits::assign(*__result, *__first);
+  }
+
+#    if !defined (_STLP_NO_METHOD_SPECIALIZATION)
+  void _M_copyT(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _STLP_FIX_LITERAL_BUG(__res)
+    _Traits::copy(__res, __f, __l - __f);
+  }
+#    endif
+
+public:
+  // Check to see if _InputIterator is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  void insert(iterator __p, _InputIter __first, _InputIter __last) {
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    _M_insert_dispatch(__p, __first, __last, _Integral());
+  }
+#  endif
+#endif
+
+public:
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || \
+    !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+  void insert(iterator __p, const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    _M_insert(__p, __f, __l, _M_inside(__f));
+  }
+#endif
+
+public:                         // Erase.
+
+  _Self& erase(size_type __pos = 0, size_type __n = npos) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    erase(begin() + __pos, begin() + __pos + (min) (__n, size() - __pos));
+    return *this;
+  }
+
+  iterator erase(iterator __pos) {
+    // The move includes the terminating _CharT().
+    _Traits::move(__pos, __pos + 1, this->_M_Finish() - __pos);
+    this->_M_destroy_back();
+    --this->_M_finish;
+    return __pos;
+  }
+
+  iterator erase(iterator __first, iterator __last) {
+    if (__first != __last) {
+      // The move includes the terminating _CharT().
+      traits_type::move(__first, __last, (this->_M_Finish() - __last) + 1);
+      pointer __new_finish = this->_M_Finish() - (__last - __first);
+      this->_M_destroy_ptr_range(__new_finish + 1, this->_M_Finish() + 1);
+      this->_M_finish = __new_finish;
+    }
+    return __first;
+  }
+
+public:                         // Replace.  (Conceptually equivalent
+                                // to erase followed by insert.)
+  _Self& replace(size_type __pos, size_type __n, const _Self& __s) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n, size() - __pos);
+    if (size() - __len >= max_size() - __s.size())
+      this->_M_throw_length_error();
+    return _M_replace(begin() + __pos, begin() + __pos + __len,
+                      __s._M_Start(), __s._M_Finish(), &__s == this);
+  }
+
+  _Self& replace(size_type __pos1, size_type __n1, const _Self& __s,
+                 size_type __pos2, size_type __n2) {
+    if (__pos1 > size() || __pos2 > __s.size())
+      this->_M_throw_out_of_range();
+    const size_type __len1 = (min) (__n1, size() - __pos1);
+    const size_type __len2 = (min) (__n2, __s.size() - __pos2);
+    if (size() - __len1 >= max_size() - __len2)
+      this->_M_throw_length_error();
+    return _M_replace(begin() + __pos1, begin() + __pos1 + __len1,
+                      __s._M_Start() + __pos2, __s._M_Start() + __pos2 + __len2, &__s == this);
+  }
+
+  _Self& replace(size_type __pos, size_type __n1,
+                 const _CharT* __s, size_type __n2) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n1, size() - __pos);
+    if (__n2 > max_size() || size() - __len >= max_size() - __n2)
+      this->_M_throw_length_error();
+    return _M_replace(begin() + __pos, begin() + __pos + __len,
+                      __s, __s + __n2, _M_inside(__s));
+  }
+
+  _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n1, size() - __pos);
+    const size_type __n2 = _Traits::length(__s);
+    if (__n2 > max_size() || size() - __len >= max_size() - __n2)
+      this->_M_throw_length_error();
+    return _M_replace(begin() + __pos, begin() + __pos + __len,
+                      __s, __s + _Traits::length(__s), _M_inside(__s));
+  }
+
+  _Self& replace(size_type __pos, size_type __n1,
+                 size_type __n2, _CharT __c) {
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n1, size() - __pos);
+    if (__n2 > max_size() || size() - __len >= max_size() - __n2)
+      this->_M_throw_length_error();
+    return replace(begin() + __pos, begin() + __pos + __len, __n2, __c);
+  }
+
+  _Self& replace(iterator __first, iterator __last, const _Self& __s) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    return _M_replace(__first, __last, __s._M_Start(), __s._M_Finish(), &__s == this);
+  }
+
+  _Self& replace(iterator __first, iterator __last,
+                 const _CharT* __s, size_type __n) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_replace(__first, __last, __s, __s + __n, _M_inside(__s));
+  }
+
+  _Self& replace(iterator __first, iterator __last,
+                 const _CharT* __s) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_replace(__first, __last, __s, __s + _Traits::length(__s), _M_inside(__s));
+  }
+
+  _Self& replace(iterator __first, iterator __last, size_type __n, _CharT __c);
+
+protected:                        // Helper functions for replace.
+  _Self& _M_replace(iterator __first, iterator __last,
+                    const _CharT* __f, const _CharT* __l, bool __self_ref);
+
+public:
+#if defined (_STLP_MEMBER_TEMPLATES)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  template <class _Integer>
+  _Self& _M_replace_dispatch(iterator __first, iterator __last,
+                             _Integer __n, _Integer __x, const __true_type& /*IsIntegral*/) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    return replace(__first, __last, (size_type) __n, (_CharT) __x);
+  }
+
+  template <class _InputIter>
+  _Self& _M_replace_dispatch(iterator __first, iterator __last,
+                             _InputIter __f, _InputIter __l, const __false_type& /*IsIntegral*/) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    typedef typename _AreSameUnCVTypes<_InputIter, iterator>::_Ret _IsIterator;
+    typedef typename _AreSameUnCVTypes<_InputIter, const_iterator>::_Ret _IsConstIterator;
+    typedef typename _Lor2<_IsIterator, _IsConstIterator>::_Ret _CheckInside;
+    return _M_replace_aux(__first, __last, __f, __l, _CheckInside());
+  }
+
+  template <class _RandomIter>
+  _Self& _M_replace_aux(iterator __first, iterator __last,
+                        _RandomIter __f, _RandomIter __l, __true_type const& /*_CheckInside*/) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    return _M_replace(__first, __last, &(*__f), &(*__l), _M_inside(&(*__f)));
+  }
+
+  template <class _InputIter>
+  _Self& _M_replace_aux(iterator __first, iterator __last,
+                     _InputIter __f, _InputIter __l, __false_type const& /*_CheckInside*/) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    return _M_replaceT(__first, __last, __f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+  }
+
+  template <class _InputIter>
+  _Self& _M_replaceT(iterator __first, iterator __last,
+                     _InputIter __f, _InputIter __l, const input_iterator_tag&__ite_tag) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    for ( ; __first != __last && __f != __l; ++__first, ++__f)
+      _Traits::assign(*__first, *__f);
+    if (__f == __l)
+      erase(__first, __last);
+    else
+      _M_insertT(__last, __f, __l, __ite_tag);
+    return *this;
+  }
+
+  template <class _ForwardIter>
+  _Self& _M_replaceT(iterator __first, iterator __last,
+                     _ForwardIter __f, _ForwardIter __l, const forward_iterator_tag &__ite_tag) {
+    _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+    difference_type __n = distance(__f, __l);
+    const difference_type __len = __last - __first;
+    if (__len >= __n) {
+      _M_copyT(__f, __l, __first);
+      erase(__first + __n, __last);
+    }
+    else {
+      _ForwardIter __m = __f;
+      advance(__m, __len);
+      _M_copyT(__f, __m, __first);
+      _M_insertT(__last, __m, __l, __ite_tag);
+    }
+    return *this;
+  }
+
+public:
+  // Check to see if _InputIter is an integer type.  If so, then
+  // it can't be an iterator.
+  template <class _InputIter>
+  _Self& replace(iterator __first, iterator __last,
+                 _InputIter __f, _InputIter __l) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+    return _M_replace_dispatch(__first, __last, __f, __l,  _Integral());
+  }
+
+#  endif
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || \
+    !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+#  if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+  _Self& replace(iterator __first, iterator __last,
+                 const _CharT* __f, const _CharT* __l) {
+    _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+    _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+    return _M_replace(__first, __last, __f, __l, _M_inside(__f));
+  }
+#  endif
+#endif
+
+public:                         // Other modifier member functions.
+
+  size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos > size())
+      this->_M_throw_out_of_range();
+    const size_type __len = (min) (__n, size() - __pos);
+    _Traits::copy(__s, this->_M_Start() + __pos, __len);
+    return __len;
+  }
+
+  void swap(_Self& __s) {
+    this->_M_Swap(__s);
+  }
+
+public:                         // Conversion to C string.
+
+  const _CharT* c_str() const { return this->_M_Start(); }
+  const _CharT* data()  const { return this->_M_Start(); }
+
+public:                         // find.
+
+  size_type find(const _Self& __s, size_type __pos = 0) const
+    { return find(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find(const _CharT* __s, size_type __pos = 0) const
+    { _STLP_FIX_LITERAL_BUG(__s) return find(__s, __pos, _Traits::length(__s)); }
+
+  size_type find(const _CharT* __s, size_type __pos, size_type __n) const;
+
+  // WIE: Versant schema compiler 5.2.2 ICE workaround
+  size_type find(_CharT __c) const { return find(__c, 0); }
+  size_type find(_CharT __c, size_type __pos /* = 0 */) const;
+
+public:                         // rfind.
+
+  size_type rfind(const _Self& __s, size_type __pos = npos) const
+    { return rfind(__s._M_Start(), __pos, __s.size()); }
+
+  size_type rfind(const _CharT* __s, size_type __pos = npos) const
+    { _STLP_FIX_LITERAL_BUG(__s) return rfind(__s, __pos, _Traits::length(__s)); }
+
+  size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+  size_type rfind(_CharT __c, size_type __pos = npos) const;
+
+public:                         // find_first_of
+
+  size_type find_first_of(const _Self& __s, size_type __pos = 0) const
+    { return find_first_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_first_of(const _CharT* __s, size_type __pos = 0) const
+    { _STLP_FIX_LITERAL_BUG(__s) return find_first_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_first_of(const _CharT* __s, size_type __pos,
+                          size_type __n) const;
+
+  size_type find_first_of(_CharT __c, size_type __pos = 0) const
+    { return find(__c, __pos); }
+
+public:                         // find_last_of
+
+  size_type find_last_of(const _Self& __s,
+                         size_type __pos = npos) const
+    { return find_last_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_last_of(const _CharT* __s, size_type __pos = npos) const
+    { _STLP_FIX_LITERAL_BUG(__s) return find_last_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_last_of(const _CharT* __s, size_type __pos,
+                         size_type __n) const;
+
+  size_type find_last_of(_CharT __c, size_type __pos = npos) const {
+    return rfind(__c, __pos);
+  }
+
+public:                         // find_first_not_of
+
+  size_type find_first_not_of(const _Self& __s,
+                              size_type __pos = 0) const
+    { return find_first_not_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+  { _STLP_FIX_LITERAL_BUG(__s) return find_first_not_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_first_not_of(const _CharT* __s, size_type __pos,
+                              size_type __n) const;
+
+  size_type find_first_not_of(_CharT __c, size_type __pos = 0) const;
+
+public:                         // find_last_not_of
+
+  size_type find_last_not_of(const _Self& __s,
+                             size_type __pos = npos) const
+  { return find_last_not_of(__s._M_Start(), __pos, __s.size()); }
+
+  size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+    { _STLP_FIX_LITERAL_BUG(__s) return find_last_not_of(__s, __pos, _Traits::length(__s)); }
+
+  size_type find_last_not_of(const _CharT* __s, size_type __pos,
+                             size_type __n) const;
+
+  size_type find_last_not_of(_CharT __c, size_type __pos = npos) const;
+
+public:                         // Substring.
+  _Self substr(size_type __pos = 0, size_type __n = npos) const
+  { return _Self(*this, __pos, __n, get_allocator()); }
+
+public:                         // Compare
+  int compare(const _Self& __s) const
+  { return _M_compare(this->_M_Start(), this->_M_Finish(), __s._M_Start(), __s._M_Finish()); }
+
+  int compare(size_type __pos1, size_type __n1,
+              const _Self& __s) const {
+    if (__pos1 > size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s._M_Start(), __s._M_Finish());
+  }
+
+  int compare(size_type __pos1, size_type __n1,
+              const _Self& __s,
+              size_type __pos2, size_type __n2) const {
+    if (__pos1 > size() || __pos2 > __s.size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s._M_Start() + __pos2,
+                      __s._M_Start() + __pos2 + (min) (__n2, __s.size() - __pos2));
+  }
+
+  int compare(const _CharT* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    return _M_compare(this->_M_Start(), this->_M_Finish(), __s, __s + _Traits::length(__s));
+  }
+
+  int compare(size_type __pos1, size_type __n1, const _CharT* __s) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos1 > size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s, __s + _Traits::length(__s));
+  }
+
+  int compare(size_type __pos1, size_type __n1, const _CharT* __s,
+              size_type __n2) const {
+    _STLP_FIX_LITERAL_BUG(__s)
+    if (__pos1 > size())
+      this->_M_throw_out_of_range();
+    return _M_compare(this->_M_Start() + __pos1,
+                      this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+                      __s, __s + __n2);
+  }
+
+public:                        // Helper functions for compare.
+
+  static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1,
+                                   const _CharT* __f2, const _CharT* __l2) {
+    const ptrdiff_t __n1 = __l1 - __f1;
+    const ptrdiff_t __n2 = __l2 - __f2;
+    const int cmp = _Traits::compare(__f1, __f2, (min) (__n1, __n2));
+    return cmp != 0 ? cmp : (__n1 < __n2 ? -1 : (__n1 > __n2 ? 1 : 0));
+  }
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION) && !defined (_STLP_DEBUG) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  define _STLP_STRING_SUM_BASE(__reserve, __size, __alloc) _STLP_PRIV _String_base<_CharT,_Alloc>(__alloc, __size + 1)
+#  include <stl/_string_sum_methods.h>
+#  undef _STLP_STRING_SUM_BASE
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+};
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG)
+#  if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
+template <class _CharT, class _Traits, class _Alloc>
+const size_t basic_string<_CharT, _Traits, _Alloc>::npos = ~(size_t) 0;
+#  endif
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<char, char_traits<char>, allocator<char> >;
+#  if defined (_STLP_HAS_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+#  endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+#if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#  undef basic_string
+#endif
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+#  include <stl/_string_workaround.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+#  include <stl/debug/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// ------------------------------------------------------------
+// Non-member functions.
+// Swap.
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _CharT, class _Traits, class _Alloc>
+inline void _STLP_CALL
+swap(basic_string<_CharT,_Traits,_Alloc>& __x,
+     basic_string<_CharT,_Traits,_Alloc>& __y)
+{ __x.swap(__y); }
+#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _CharT, class _Traits, class _Alloc>
+struct __move_traits<basic_string<_CharT, _Traits, _Alloc> > {
+  typedef __stlp_movable implemented;
+  //Completness depends on the allocator:
+  typedef typename __move_traits<_Alloc>::complete complete;
+};
+/*#else
+ * There is no need to specialize for string and wstring in this case
+ * as the default __move_traits will already tell that string is movable
+ * but not complete. We cannot define it as complete as nothing guaranty
+ * that the STLport user hasn't specialized std::allocator for char or
+ * wchar_t.
+ */
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT, class _Traits, class _Alloc>
+void _STLP_CALL _S_string_copy(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                               _CharT* __buf, size_t __n);
+
+#if defined(_STLP_USE_WIDE_INTERFACE)
+// A couple of functions to transfer between ASCII/Unicode
+wstring __ASCIIToWide(const char *ascii);
+string __WideToASCII(const wchar_t *wide);
+#endif
+
+inline const char* _STLP_CALL
+__get_c_string(const string& __str) { return __str.c_str(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#include <stl/_string_operators.h>
+
+#if defined(_STLP_USE_NO_IOSTREAMS) || \
+    (defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION))
+#  include <stl/_string.c>
+#endif
+
+#endif /* _STLP_INTERNAL_STRING_H */
+
+/*
+ * Local Variables:
+ * mode:C++
+ * End:
+ */