Use STLPort instead of our stripped version. DO NOT MERGE.

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, 1429 insertions, 0 deletions

diff --git a/WebKit/android/stlport/stl/_istream.c b/WebKit/android/stlport/stl/_istream.c
new file mode 100644
index 0000000..292cab1
--- /dev/null
+++ b/WebKit/android/stlport/stl/_istream.c
@@ -0,0 +1,1429 @@
+/*
+ * Copyright (c) 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_ISTREAM_C
+#define _STLP_ISTREAM_C
+
+#ifndef _STLP_INTERNAL_ISTREAM
+#  include <stl/_istream.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LIMITS
+#  include <stl/_limits.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUM_GET_H
+#  include <stl/_num_get.h>
+#endif
+
+#if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+// no wchar_t is supported for this mode
+#  define __BIS_int_type__ int
+#  define __BIS_pos_type__ streampos
+#  define __BIS_off_type__ streamoff
+#else
+#  define __BIS_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::int_type
+#  define __BIS_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::pos_type
+#  define __BIS_off_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::off_type
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// Function object structs used by some member functions.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Traits>
+struct _Is_not_wspace {
+  typedef typename _Traits::char_type argument_type;
+  typedef bool                        result_type;
+
+  const ctype<argument_type>* _M_ctype;
+
+  _Is_not_wspace(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}
+  bool operator()(argument_type __c) const
+    { return !_M_ctype->is(ctype_base::space, __c); }
+};
+
+template <class _Traits>
+struct _Is_wspace_null {
+  typedef typename _Traits::char_type argument_type;
+  typedef bool                        result_type;
+
+  const ctype<argument_type>* _M_ctype;
+
+  _Is_wspace_null(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}
+  bool operator()(argument_type __c) const {
+    return _Traits::eq(__c, argument_type()) ||
+           _M_ctype->is(ctype_base::space, __c);
+  }
+};
+
+template <class _Traits>
+struct _Scan_for_wspace {
+  typedef typename _Traits::char_type  char_type;
+  typedef char_type*                   first_argument_type;
+  typedef char_type*                   second_argument_type;
+  typedef char_type*                   result_type;
+
+  const ctype<char_type>* _M_ctype;
+
+  _Scan_for_wspace(const ctype<char_type>* __ctype) : _M_ctype(__ctype) {}
+  const char_type*
+  operator()(const char_type* __first, const char_type* __last) const {
+    return _M_ctype->scan_is(ctype_base::space, __first, __last);
+  }
+};
+
+template <class _Traits>
+struct _Scan_wspace_null {
+  typedef typename _Traits::char_type  char_type;
+  typedef char_type*                   first_argument_type;
+  typedef char_type*                   second_argument_type;
+  typedef char_type*                   result_type;
+
+  const ctype<char_type>* _M_ctype;
+
+  _Scan_wspace_null(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}
+  const char_type*
+  operator()(const char_type* __first, const char_type* __last) const {
+    __last = find_if(__first, __last,
+                     _Eq_char_bound<_Traits>(char_type()));
+    return _M_ctype->scan_is(ctype_base::space, __first, __last);
+  }
+};
+
+template <class _Traits>
+struct _Scan_for_not_wspace {
+  typedef typename _Traits::char_type  char_type;
+  typedef char_type*                   first_argument_type;
+  typedef char_type*                   second_argument_type;
+  typedef char_type*                   result_type;
+
+  const ctype<char_type>* _M_ctype;
+
+  _Scan_for_not_wspace(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}
+  const char_type*
+  operator()(const char_type* __first, const char_type* __last) const {
+    return _M_ctype->scan_not(ctype_base::space, __first, __last);
+  }
+};
+
+template <class _Traits>
+struct _Scan_for_char_val {
+  typedef typename _Traits::char_type char_type;
+  typedef char_type*                  first_argument_type;
+  typedef char_type*                  second_argument_type;
+  typedef char_type*                  result_type;
+
+  char_type _M_val;
+
+  _Scan_for_char_val(char_type __val) : _M_val(__val) {}
+
+  const char_type*
+  operator()(const char_type* __first, const char_type* __last) const {
+    return find_if(__first, __last, _Eq_char_bound<_Traits>(_M_val));
+  }
+};
+
+template <class _Traits>
+struct _Scan_for_int_val {
+  typedef typename _Traits::char_type char_type;
+  typedef typename _Traits::int_type  int_type;
+  typedef char_type*                  first_argument_type;
+  typedef char_type*                  second_argument_type;
+  typedef char_type*                  result_type;
+
+  int_type _M_val;
+
+  _Scan_for_int_val(int_type __val) : _M_val(__val) {}
+
+  const char_type*
+  operator()(const char_type* __first, const char_type* __last) const {
+    return find_if(__first, __last,
+                   _Eq_int_bound<_Traits>(_M_val));
+  }
+};
+
+// Helper function: try to push back a character to a streambuf,
+// return true if the pushback succeeded.  Does not throw.
+
+template <class _CharT, class _Traits>
+bool _STLP_CALL
+__pushback(basic_streambuf<_CharT, _Traits>* __buf, _CharT __c) {
+  bool ret;
+  _STLP_TRY {
+    const typename _Traits::int_type __eof = _Traits::eof();
+    ret = !_Traits::eq_int_type(__buf->sputbackc(__c), __eof);
+  }
+  _STLP_CATCH_ALL {
+    ret = false;
+  }
+  return ret;
+}
+
+//----------------------------------------------------------------------
+// Definitions of basic_istream<>'s noninline member functions.
+
+// Helper function for formatted input of numbers.
+template <class _CharT, class _Traits, class _Number>
+ios_base::iostate _STLP_CALL
+__get_num(basic_istream<_CharT, _Traits>& __that, _Number& __val) {
+  typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
+  ios_base::iostate __err = 0;
+  _Sentry __sentry( __that );     // Skip whitespace.
+  if (__sentry) {
+    typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > _Num_get;
+    _STLP_TRY {
+      ((const _Num_get&)use_facet<_Num_get>(__that.getloc())).get(istreambuf_iterator<_CharT, _Traits>(__that.rdbuf()),
+                                                                  0, __that, __err, __val);
+    }
+    _STLP_CATCH_ALL {
+      __that._M_handle_exception(ios_base::badbit);
+    }
+    if (__err) __that.setstate(__err);
+  }
+  return __err;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (short& __val) {
+  long __lval;
+  _STLP_PRIV __get_num(*this, __lval);
+  if ( this->fail() ) {
+    return *this;
+  }
+  short __tmp = __STATIC_CAST(short, __lval);
+  unsigned short __uval = __STATIC_CAST(unsigned short, __lval);
+  // check if we lose digits
+  //    if ((__val != __lval) && ((unsigned short)__val != __lval))
+  if ((__tmp != __lval) && ((long)__uval != __lval))
+    this->setstate(ios_base::failbit);
+  else
+    __val = __tmp;
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (int& __val) {
+  long __lval;
+  _STLP_PRIV __get_num(*this, __lval);
+  if ( this->fail() ) {
+    return *this;
+  }
+  int __tmp = __lval;
+  unsigned int __uval = __lval;
+  // check if we lose digits
+  //    if ((__val != __lval) && ((unsigned int)__val != __lval))
+  if ((__tmp != __lval) && ((long)__uval != __lval))
+    this->setstate(ios_base::failbit);
+  else
+    __val = __tmp;
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned short& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned int& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned long& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+
+#if defined (_STLP_LONG_LONG)
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (_STLP_LONG_LONG& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned _STLP_LONG_LONG& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+#endif
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (float& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (double& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+#if !defined (_STLP_NO_LONG_DOUBLE)
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long double& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+#endif
+#if !defined (_STLP_NO_BOOL)
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (bool& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+#endif
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (void*& __val) {
+  _STLP_PRIV __get_num(*this, __val);
+  return *this;
+}
+
+// Unformatted input
+
+template <class _CharT, class _Traits>
+__BIS_int_type__
+basic_istream<_CharT, _Traits>::peek() {
+  typename _Traits::int_type __tmp = _Traits::eof();
+
+  this->_M_gcount = 0;
+  sentry __sentry(*this, _No_Skip_WS());
+
+  if (__sentry) {
+    _STLP_TRY {
+      __tmp = this->rdbuf()->sgetc();
+    }
+    _STLP_CATCH_ALL {
+      this->_M_handle_exception(ios_base::badbit);
+    }
+    if (this->_S_eof(__tmp))
+      this->setstate(ios_base::eofbit);
+  }
+
+  return __tmp;
+}
+
+
+template <class _CharT, class _Traits>
+__BIS_int_type__
+basic_istream<_CharT, _Traits>::get() {
+  typename _Traits::int_type __tmp = _Traits::eof();
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    _STLP_TRY {
+      __tmp = this->rdbuf()->sbumpc();
+    }
+    _STLP_CATCH_ALL {
+      this->_M_handle_exception(ios_base::badbit);
+    }
+
+    if (!this->_S_eof(__tmp))
+      this->_M_gcount = 1;
+  }
+
+  if (_M_gcount == 0)
+    this->setstate(ios_base::eofbit | ios_base::failbit);
+
+  return __tmp;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::get(_CharT& __c) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    typename _Traits::int_type __tmp = _Traits::eof();
+    _STLP_TRY {
+      __tmp = this->rdbuf()->sbumpc();
+    }
+    _STLP_CATCH_ALL {
+      this->_M_handle_exception(ios_base::badbit);
+    }
+
+    if (!this->_S_eof(__tmp)) {
+      this->_M_gcount = 1;
+      __c = _Traits::to_char_type(__tmp);
+    }
+  }
+
+  if (this->_M_gcount == 0)
+    this->setstate(ios_base::eofbit | ios_base::failbit);
+
+  return *this;
+}
+
+
+// Read characters and discard them.  The standard specifies a single
+// function with two arguments, each with a default.  We instead use
+// three overloded functions, because it's possible to implement the
+// first two more efficiently than the fully general third version.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::ignore() {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    int_type __c;
+    _STLP_TRY {
+      __c = this->rdbuf()->sbumpc();
+    }
+    _STLP_CATCH_ALL {
+      this->_M_handle_exception(ios_base::badbit);
+      return *this;
+    }
+
+    if (!this->_S_eof(__c))
+      this->_M_gcount = 1;
+    else
+      this->setstate(ios_base::eofbit);
+  }
+
+  return *this;
+}
+
+// Putback
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::putback(_CharT __c) {
+  this->_M_gcount = 0;
+  sentry __sentry(*this, _No_Skip_WS());
+
+  if (__sentry) {
+    typename _Traits::int_type __tmp = _Traits::eof();
+    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+//    if (!__buf || this->_S_eof(__buf->sputbackc(__c)))
+    if (__buf) {
+      _STLP_TRY {
+        __tmp = __buf->sputbackc(__c);
+      }
+      _STLP_CATCH_ALL {
+        this->_M_handle_exception(ios_base::badbit);
+      }
+    }
+    if (this->_S_eof(__tmp))
+      this->setstate(ios_base::badbit);
+  }
+  else
+    this->setstate(ios_base::failbit);
+
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::unget() {
+  this->_M_gcount = 0;
+
+  sentry __sentry(*this, _No_Skip_WS());
+
+  if (__sentry) {
+    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+    //     if (!__buf || _Traits::eq_int_type(__buf->sungetc(), _Traits::eof()))
+    if (__buf) {
+      _STLP_TRY {
+        if (this->_S_eof(__buf->sungetc()))
+          this->setstate(ios_base::badbit);
+      }
+      _STLP_CATCH_ALL {
+        this->_M_handle_exception(ios_base::badbit);
+      }
+    } else
+      this->setstate(ios_base::badbit);
+  }
+  else
+    this->setstate(ios_base::failbit);
+
+  return *this;
+}
+
+// Positioning and buffer control.
+
+template <class _CharT, class _Traits>
+int basic_istream<_CharT, _Traits>::sync() {
+  sentry __sentry(*this, _No_Skip_WS());
+
+  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+  if (__buf) {
+    if (__buf->pubsync() == -1) {
+      this->setstate(ios_base::badbit);
+      return -1;
+    }
+    else
+      return 0;
+  }
+  else
+    return -1;
+}
+
+template <class _CharT, class _Traits>
+__BIS_pos_type__
+basic_istream<_CharT, _Traits>::tellg() {
+  sentry __sentry(*this, _No_Skip_WS());
+
+  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+  return (__buf && !this->fail()) ? __buf->pubseekoff(0, ios_base::cur, ios_base::in)
+    : pos_type(-1);
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::seekg(pos_type __pos) {
+  sentry __sentry(*this, _No_Skip_WS());
+
+  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+  if (!this->fail() && __buf) {
+    if (__buf->pubseekpos(__pos) == pos_type(-1)) {
+      this->setstate(ios_base::failbit);
+    }
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) {
+  sentry __sentry(*this, _No_Skip_WS());
+
+  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+  if (!this->fail() && __buf)
+    __buf->pubseekoff(__off, __dir);
+  return *this;
+}
+
+// Formatted input of characters and character arrays.
+
+template <class _CharT, class _Traits>
+void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT& __c) {
+//  typename _Traits::int_type __tmp = _Traits::eof();
+
+  sentry __sentry(*this); // Skip whitespace.
+
+  if (__sentry) {
+    typename _Traits::int_type __tmp;// = _Traits::eof();
+
+    _STLP_TRY {
+      __tmp = this->rdbuf()->sbumpc();
+    }
+    _STLP_CATCH_ALL {
+      this->_M_handle_exception(ios_base::badbit);
+      return;
+    }
+
+    if (!this->_S_eof(__tmp))
+      __c = _Traits::to_char_type(__tmp);
+    else
+      this->setstate(ios_base::eofbit | ios_base::failbit);
+  }
+}
+
+
+//---------------------------------------------------------------------------
+// istream's helper functions.
+
+// A generic function for unbuffered input.  We stop when we reach EOF,
+// or when we have extracted _Num characters, or when the function object
+// __is_delim return true.  In the last case, it extracts the character
+// for which __is_delim is true, if and only if __extract_delim is true.
+// It appends a null character to the end of the string; this means that
+// it may store up to _Num + 1 characters.
+//
+// __is_getline governs two corner cases: reading _Num characters without
+// encountering delim or eof (in which case failbit is set if __is_getline
+// is true); and reading _Num characters where the _Num+1'st character is
+// eof (in which case eofbit is set if __is_getline is true).
+//
+// It is assumed that __is_delim never throws.
+//
+// Return value is the number of characters extracted, including the
+// delimiter if it is extracted.  Note that the number of characaters
+// extracted isn't necessarily the same as the number stored.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template < class _CharT, class _Traits, class _Is_Delim>
+streamsize _STLP_CALL
+__read_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf,
+                  streamsize _Num, _CharT* __s,
+                  _Is_Delim __is_delim,
+                  bool __extract_delim, bool __append_null,
+                  bool __is_getline) {
+  streamsize __n = 0;
+  ios_base::iostate __status = 0;
+
+  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+  // The operations that can potentially throw are sbumpc, snextc, and sgetc.
+  _STLP_TRY {
+    for (;;) {
+      int_type __c = __buf->sbumpc(); // sschwarz
+
+      if (__that->_S_eof(__c)) {
+        if (__n < _Num || __is_getline)
+          __status |= ios_base::eofbit;
+        break;
+      }
+      else if (__is_delim(_Traits::to_char_type(__c))) {
+        if (__extract_delim) { // Extract and discard current character.
+          ++__n;
+        } else if ( !__pushback(__buf, _Traits::to_char_type(__c)) ) { // leave delimiter
+          __status |= ios_base::failbit;
+        }
+        break;
+      }
+      else { // regular character
+        *__s++ = _Traits::to_char_type(__c);
+        ++__n;
+      }
+
+      if (__n == _Num) {
+        if (__is_getline) // didn't find delimiter as one of the _Num chars
+          __status |= ios_base::failbit;
+        break;
+      }
+    }
+  }
+  _STLP_CATCH_ALL {
+    __that->_M_handle_exception(ios_base::badbit);
+    *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT);
+    return __n;
+  }
+
+  if (__append_null)
+    *__s =  _STLP_DEFAULT_CONSTRUCTED(_CharT);
+  if (__status)
+    __that->setstate(__status);    // This might throw.
+  return __n;
+}
+
+// Much like __read_unbuffered, but with one additional function object:
+// __scan_delim(first, last) returns the first pointer p in [first, last)
+// such that __is_delim(p) is true.
+
+template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
+streamsize _STLP_CALL
+__read_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf,
+                 streamsize _Num, _CharT* __s,
+                 _Is_Delim __is_delim, _Scan_Delim __scan_delim,
+                 bool __extract_delim, bool __append_null,
+                 bool __is_getline) {
+  streamsize __n = 0;
+  ios_base::iostate __status = 0;
+  bool __done    = false;
+
+  _STLP_TRY {
+    while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
+      const _CharT* __first = __buf->_M_gptr();
+      const _CharT* __last  = __buf->_M_egptr();
+      //casting numeric_limits<ptrdiff_t>::max to streamsize only works is ptrdiff_t is signed or streamsize representation
+      //is larger than ptrdiff_t one.
+      _STLP_STATIC_ASSERT(((sizeof(streamsize) > sizeof(ptrdiff_t)) ||
+                           (sizeof(streamsize) == sizeof(ptrdiff_t))) && numeric_limits<ptrdiff_t>::is_signed)
+      ptrdiff_t __request = __STATIC_CAST(ptrdiff_t, (min) (__STATIC_CAST(streamsize, (numeric_limits<ptrdiff_t>::max)()), _Num - __n));
+
+      const _CharT* __p  = __scan_delim(__first, __last);
+      ptrdiff_t __chunk = (min) (ptrdiff_t(__p - __first), __request);
+      _Traits::copy(__s, __first, __chunk);
+      __s += __chunk;
+      __n += __chunk;
+      __buf->_M_gbump((int)__chunk);
+
+      // We terminated by finding delim.
+      if (__p != __last && __p - __first <= __request) {
+        if (__extract_delim) {
+          __n += 1;
+          __buf->_M_gbump(1);
+        }
+        __done = true;
+      }
+
+      // We terminated by reading all the characters we were asked for.
+      else if (__n == _Num) {
+
+        // Find out if we have reached eof.  This matters for getline.
+        if (__is_getline) {
+          if (__chunk == __last - __first) {
+            if (__that->_S_eof(__buf->sgetc()))
+              __status |= ios_base::eofbit;
+          }
+          else
+            __status |= ios_base::failbit;
+        }
+        __done   = true;
+      }
+
+      // The buffer contained fewer than _Num - __n characters.  Either we're
+      // at eof, or we should refill the buffer and try again.
+      else {
+        if (__that->_S_eof(__buf->sgetc())) {
+          __status |= ios_base::eofbit;
+          __done = true;
+        }
+      }
+    } // Close the while loop.
+  }
+  _STLP_CATCH_ALL {
+    __that->_M_handle_exception(ios_base::badbit);
+    __done = true;
+  }
+
+  if (__done) {
+    if (__append_null)
+        *__s =  _STLP_DEFAULT_CONSTRUCTED(_CharT);
+    if (__status != 0)
+      __that->setstate(__status);   // This might throw.
+    return __n;
+  }
+
+  // If execution has reached this point, then we have an empty buffer but
+  // we have not reached eof.  What that means is that the streambuf has
+  // decided to switch from buffered to unbuffered input.  We switch to
+  // to __read_unbuffered.
+
+  return __n + __read_unbuffered(__that,  __buf, _Num - __n, __s, __is_delim,
+                                 __extract_delim,__append_null,__is_getline);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::get(_CharT* __s, streamsize __n,
+                                    _CharT __delim) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    if (__n > 0) {
+      basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+
+      if (__buf->egptr() != __buf->gptr())
+        this->_M_gcount =
+          _STLP_PRIV __read_buffered(this,  __buf, __n - 1, __s,
+                                     _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+                                     _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
+                                     false, true, false);
+      else
+        this->_M_gcount =
+          _STLP_PRIV __read_unbuffered(this,  __buf, __n - 1, __s,
+                                       _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+                                       false, true, false);
+    }
+  }
+
+  if (this->_M_gcount == 0)
+    this->setstate(ios_base::failbit);
+
+  return *this;
+}
+
+// Getline is essentially identical to get, except that it extracts
+// the delimiter.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n,
+                                        _CharT __delim) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    if (__n > 0) {
+      basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+      this->_M_gcount = __buf->egptr() != __buf->gptr()
+        ? _STLP_PRIV __read_buffered(this,  __buf, __n - 1, __s,
+                                     _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+                                     _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
+                                     true, true, true)
+        : _STLP_PRIV __read_unbuffered(this,  __buf, __n - 1, __s,
+                                       _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+                                       true, true, true);
+    }
+  }
+
+  if (this->_M_gcount == 0)
+    this->setstate(ios_base::failbit);
+
+  return *this;
+}
+
+// Read n characters.  We don't look for any delimiter, and we don't
+// put in a terminating null character.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry && !this->eof()) {
+    basic_streambuf<_CharT, _Traits>*__buf = this->rdbuf();
+    if (__buf->gptr() != __buf->egptr())
+      _M_gcount
+        = _STLP_PRIV __read_buffered(this,  __buf, __n, __s,
+                                     _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+                                     _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+                                     false, false, false);
+    else
+      _M_gcount
+        = _STLP_PRIV __read_unbuffered(this,  __buf, __n, __s,
+                                       _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+                                       false, false, false);
+  }
+  else
+    this->setstate(ios_base::failbit);
+
+  if (this->eof())
+    this->setstate(ios_base::eofbit | ios_base::failbit);
+
+  return *this;
+}
+
+
+// Read n or fewer characters.  We don't look for any delimiter, and
+// we don't put in a terminating null character.
+template <class _CharT, class _Traits>
+streamsize
+basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __nmax) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry && !this->eof() && __nmax >= 0) {
+
+    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+    streamsize __avail = __buf->in_avail();
+
+    // fbp : isn't full-blown setstate required here ?
+    if (__avail == -1)
+      this->_M_setstate_nothrow(ios_base::eofbit);
+
+    else if (__avail != 0) {
+
+      if (__buf->gptr() != __buf->egptr())
+        _M_gcount
+          = _STLP_PRIV __read_buffered(this,  __buf, (min) (__avail, __nmax), __s,
+                                       _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+                                       _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+                                       false, false, false);
+      else
+        _M_gcount
+          = _STLP_PRIV __read_unbuffered(this,  __buf, (min) (__avail, __nmax), __s,
+                                         _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+                                         false, false, false);
+    }
+  }
+  else {
+    // fbp : changed so that failbit is set only there, to pass Dietmar's test
+    if (this->eof())
+      this->setstate(ios_base::eofbit | ios_base::failbit);
+    else
+      this->setstate(ios_base::failbit);
+  }
+
+  //  if (this->eof())
+  //    this->setstate(ios_base::eofbit | ios_base::failbit);
+
+  return _M_gcount;
+}
+
+template <class _CharT, class _Traits>
+void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT* __s) {
+  sentry __sentry(*this); // Skip whitespace.
+
+  if (__sentry) {
+    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+    streamsize __nmax = this->width() > 0
+      ? this->width() - 1
+      : ((numeric_limits<streamsize>::max)() / sizeof(_CharT)) - 1;
+
+    streamsize __n = __buf->gptr() != __buf->egptr()
+      ? _STLP_PRIV __read_buffered(this,  __buf, __nmax, __s,
+                                   _STLP_PRIV _Is_wspace_null<_Traits>(__STATIC_CAST(const ctype<_CharT>*, this->_M_ctype_facet())),
+                                   _STLP_PRIV _Scan_wspace_null<_Traits>(__STATIC_CAST(const ctype<_CharT>*, this->_M_ctype_facet())),
+                                   false, true, false)
+      : _STLP_PRIV __read_unbuffered(this,  __buf, __nmax, __s,
+                                     _STLP_PRIV _Is_wspace_null<_Traits>(__STATIC_CAST(const ctype<_CharT>*, this->_M_ctype_facet())),
+                                     false, true, false);
+    if (__n == 0)
+      this->setstate(ios_base::failbit);
+  }
+  this->width(0);
+}
+
+// A generic unbuffered function for ignoring characters.  We stop
+// when we reach EOF, or when the function object __is_delim returns
+// true.  In the last case, it extracts the character for which
+// __is_delim is true, if and only if __extract_delim is true.
+
+template < class _CharT, class _Traits, class _Is_Delim>
+void _STLP_CALL
+_M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that,
+                     basic_streambuf<_CharT, _Traits>* __buf,
+                     _Is_Delim __is_delim,
+                     bool __extract_delim, bool __set_failbit) {
+  bool __done = false;
+  ios_base::iostate __status = 0;
+  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+
+  _STLP_TRY {
+    while (!__done) {
+      int_type __c = __buf->sbumpc();
+
+      if (__that->_S_eof(__c)) {
+        __done = true;
+        __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
+                                  : ios_base::eofbit;
+      }
+
+      else if (__is_delim(_Traits::to_char_type(__c))) {
+        __done = true;
+        if (!__extract_delim)
+          if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
+            __status |= ios_base::failbit;
+      }
+    }
+  }
+  _STLP_CATCH_ALL {
+    __that->_M_handle_exception(ios_base::badbit);
+  }
+
+  __that->setstate(__status);
+}
+
+// A generic buffered function for ignoring characters.  Much like
+// _M_ignore_unbuffered, but with one additional function object:
+// __scan_delim(first, last) returns the first pointer p in [first,
+// last) such that __is_delim(p) is true.
+
+template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
+void _STLP_CALL
+_M_ignore_buffered(basic_istream<_CharT, _Traits>* __that,
+                   basic_streambuf<_CharT, _Traits>* __buf,
+                   _Is_Delim __is_delim, _Scan_Delim __scan_delim,
+                   bool __extract_delim, bool __set_failbit) {
+  bool __at_eof      = false;
+  bool __found_delim = false;
+
+  _STLP_TRY {
+    while (__buf->_M_egptr() != __buf->_M_gptr() && !__at_eof && !__found_delim) {
+      const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
+      __buf->_M_gbump((int)(__p - __buf->_M_gptr()));
+
+      if (__p != __buf->_M_egptr()) { // We found delim, so we're done.
+        if (__extract_delim)
+          __buf->_M_gbump(1);
+        __found_delim = true;
+      }
+
+      else                         // No delim.  Try to refil the buffer.
+        __at_eof = __that->_S_eof(__buf->sgetc());
+    }                              // Close the while loop.
+  }
+  _STLP_CATCH_ALL {
+    __that->_M_handle_exception(ios_base::badbit);
+    return;
+  }
+
+  if (__at_eof) {
+    __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
+                                   : ios_base::eofbit);
+    return;
+  }
+  if (__found_delim)
+    return;
+
+  // If execution has reached this point, then we have an empty buffer but
+  // we have not reached eof.  What that means is that the streambuf has
+  // decided to switch from a buffered to an unbuffered mode.  We switch
+  // to _M_ignore_unbuffered.
+  _M_ignore_unbuffered(__that,  __buf, __is_delim, __extract_delim, __set_failbit);
+}
+
+// Overloaded versions of _M_ignore_unbuffered and _M_ignore_unbuffered
+// with an explicit count _Num.  Return value is the number of
+// characters extracted.
+//
+// The function object __max_chars takes two arguments, _Num and __n
+// (the latter being the number of characters we have already read),
+// and returns the maximum number of characters to read from the buffer.
+// We parameterize _M_ignore_buffered so that we can use it for both
+// bounded and unbounded input; for the former the function object should
+// be minus<>, and for the latter it should return a constant maximum value.
+
+template < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim>
+streamsize _STLP_CALL
+_M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that,
+                     basic_streambuf<_CharT, _Traits>* __buf,
+                     streamsize _Num, _Max_Chars __max_chars,
+                     _Is_Delim __is_delim,
+                     bool __extract_delim, bool __set_failbit) {
+  streamsize __n = 0;
+  ios_base::iostate __status = 0;
+  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+
+  _STLP_TRY {
+    while (__max_chars(_Num, __n) > 0) {
+      int_type __c = __buf->sbumpc();
+
+      if (__that->_S_eof(__c)) {
+        __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
+                                  : ios_base::eofbit;
+        break;
+      }
+
+      else if (__is_delim(_Traits::to_char_type(__c))) {
+        if (__extract_delim)
+          ++__n;
+        else if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
+          __status |= ios_base::failbit;
+
+        break;
+      }
+      // fbp : added counter increment to pass Dietmar's test
+      ++__n;
+    }
+  }
+  _STLP_CATCH_ALL {
+    __that->_M_handle_exception(ios_base::badbit);
+  }
+
+  if (__status)
+    __that->setstate(__status);   // This might throw.
+  return __n;
+}
+
+template < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim, class _Scan_Delim>
+streamsize _STLP_CALL
+_M_ignore_buffered(basic_istream<_CharT, _Traits>* __that,
+                   basic_streambuf<_CharT, _Traits>* __buf,
+                   streamsize _Num,
+                   _Max_Chars __max_chars,
+                   _Is_Delim __is_delim, _Scan_Delim __scan_delim,
+                   bool __extract_delim, bool __set_failbit) {
+  streamsize __n = 0;
+  bool __at_eof = false;
+  bool __done   = false;
+
+  _STLP_TRY {
+    while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
+      ptrdiff_t __avail = __buf->_M_egptr() - __buf->_M_gptr();
+      streamsize __m = __max_chars(_Num, __n);
+
+      if (__avail >= __m) {       // We have more characters than we need.
+        const _CharT* __last = __buf->_M_gptr() + __STATIC_CAST(ptrdiff_t, __m);
+        const _CharT* __p = __scan_delim(__buf->_M_gptr(), __last);
+        ptrdiff_t __chunk = __p - __buf->_M_gptr();
+        __n += __chunk;
+        __buf->_M_gbump((int)__chunk);
+
+        if (__extract_delim && __p != __last) {
+          __n += 1;
+          __buf->_M_gbump(1);
+        }
+
+        __done = true;
+      }
+
+      else {
+        const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
+        ptrdiff_t __chunk = __p - __buf->_M_gptr();
+        __n += __chunk;
+        __buf->_M_gbump((int)__chunk);
+
+        if (__p != __buf->_M_egptr()) { // We found delim.
+          if (__extract_delim) {
+            __n += 1;
+            __buf->_M_gbump(1);
+          }
+
+          __done = true;
+        }
+
+        // We didn't find delim.  Try to refill the buffer.
+        else if (__that->_S_eof(__buf->sgetc())) {
+          __done   = true;
+          __at_eof = true;
+        }
+      }
+    } // Close the while loop.
+  }
+  _STLP_CATCH_ALL {
+    __that->_M_handle_exception(ios_base::badbit);
+    return __n;
+  }
+
+  if (__at_eof)
+    __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
+                                   : ios_base::eofbit);
+
+  if (__done)
+    return __n;
+
+  // If execution has reached this point, then we have an empty buffer but
+  // we have not reached eof.  What that means is that the streambuf has
+  // decided to switch from buffered to unbuffered input.  We switch to
+  // to _M_ignore_unbuffered.
+
+  return __n + _M_ignore_unbuffered(__that,  __buf, _Num, __max_chars,
+                                    __is_delim, __extract_delim, __set_failbit);
+}
+
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::ignore(streamsize __n) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+    typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
+    typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize> _Const_streamsize;
+    const streamsize __maxss = (numeric_limits<streamsize>::max)();
+
+    if (__n == (numeric_limits<int>::max)()) {
+      if (__buf->gptr() != __buf->egptr())
+        _M_gcount = _M_ignore_buffered(this,  __buf,
+                                       __maxss, _Const_streamsize(__maxss),
+                                       _Const_bool(false),
+                                       _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+                                       false, false);
+      else
+        _M_gcount = _M_ignore_unbuffered(this,  __buf,
+                                         __maxss, _Const_streamsize(__maxss),
+                                         _Const_bool(false), false, false);
+    }
+    else {
+      if (__buf->gptr() != __buf->egptr())
+        _M_gcount = _M_ignore_buffered(this,  __buf,
+                                       __n, minus<streamsize>(),
+                                       _Const_bool(false),
+                                       _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+                                       false, false);
+      else
+        _M_gcount = _M_ignore_unbuffered(this,  __buf, __n, minus<streamsize>(),
+                                         _Const_bool(false), false, false);
+    }
+  }
+
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __delim) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+    typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
+    typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize>
+      _Const_streamsize;
+    const streamsize __maxss = (numeric_limits<streamsize>::max)();
+
+    if (__n == (numeric_limits<int>::max)()) {
+      if (__buf->gptr() != __buf->egptr())
+        _M_gcount = _M_ignore_buffered(this,  __buf,
+                                       __maxss, _Const_streamsize(__maxss),
+                                       _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+                                       _STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
+                                       true, false);
+      else
+        _M_gcount = _M_ignore_unbuffered(this,  __buf,
+                                         __maxss, _Const_streamsize(__maxss),
+                                         _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+                                         true, false);
+    }
+    else {
+      if (__buf->gptr() != __buf->egptr())
+        _M_gcount = _M_ignore_buffered(this,  __buf,
+                                       __n, minus<streamsize>(),
+                                       _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+                                       _STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
+                                       true, false);
+      else
+        _M_gcount = _M_ignore_unbuffered(this,  __buf, __n, minus<streamsize>(),
+                                         _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+                                         true, false);
+    }
+  }
+
+  return *this;
+}
+
+// This member function does not construct a sentry object, because
+// it is called from sentry's constructor.
+template <class _CharT, class _Traits>
+void basic_istream<_CharT, _Traits>::_M_skip_whitespace(bool __set_failbit) {
+  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+  if (!__buf)
+    this->setstate(ios_base::badbit);
+  else if (__buf->gptr() != __buf->egptr())
+    _M_ignore_buffered(this,  __buf,
+                       _STLP_PRIV _Is_not_wspace<_Traits>(__STATIC_CAST(const ctype<_CharT>*, this->_M_ctype_facet())),
+                       _STLP_PRIV _Scan_for_not_wspace<_Traits>(__STATIC_CAST(const ctype<_CharT>*, this->_M_ctype_facet())),
+                       false, __set_failbit);
+  else
+    _M_ignore_unbuffered(this,  __buf,
+                         _STLP_PRIV _Is_not_wspace<_Traits>(__STATIC_CAST(const ctype<_CharT>*, this->_M_ctype_facet())),
+                         false, __set_failbit);
+}
+
+
+// This is a very simple loop that reads characters from __src and puts
+// them into __dest.  It looks complicated because of the (standard-
+// mandated) exception handling policy.
+//
+// We stop when we get an exception, when we fail to insert into the
+// output streambuf, or when __is_delim is true.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template < class _CharT, class _Traits, class _Is_Delim>
+streamsize _STLP_CALL
+__copy_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src,
+                  basic_streambuf<_CharT, _Traits>* __dest,
+                  _Is_Delim __is_delim,
+                  bool __extract_delim, bool __rethrow) {
+  streamsize __extracted = 0;
+  ios_base::iostate __status = 0;
+  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+  int_type __c;
+
+  _STLP_TRY {
+    for (;;) {
+      // Get a character. If there's an exception, catch and (maybe) rethrow it.
+      __c = __src->sbumpc();
+
+      // If we failed to get a character, then quit.
+      if (__that->_S_eof(__c)) {
+        __status |= ios_base::eofbit;
+        break;
+      }
+      // If it's the delimiter, then quit.
+      else if (__is_delim(_Traits::to_char_type(__c))) {
+        if (!__extract_delim && !__pushback(__src, _Traits::to_char_type(__c)))
+          __status |= ios_base::failbit;
+        break;
+      }
+      else {
+        // Try to put the character in the output streambuf.
+        bool __failed = false;
+        _STLP_TRY {
+          if (!__that->_S_eof(__dest->sputc(_Traits::to_char_type(__c))))
+            ++__extracted;
+          else
+            __failed = true;
+        }
+        _STLP_CATCH_ALL {
+          __failed = true;
+        }
+
+        // If we failed to put the character in the output streambuf, then
+        // try to push it back to the input streambuf.
+        if (__failed && !__pushback(__src, _Traits::to_char_type(__c)))
+          __status |= ios_base::failbit;
+
+        // fbp : avoiding infinite loop in io-27-6-1-2-3.exp
+        if (__failed)
+          break;
+      }
+
+    } /* for (;;) */
+
+  }
+  // fbp : this try/catch moved here in reasonable assumption
+  // __is_delim never throw (__pushback is guaranteed not to)
+  _STLP_CATCH_ALL {
+    // See 27.6.1.2.3, paragraph 13.
+    if (__rethrow && __extracted == 0)
+      __that->_M_handle_exception(ios_base::failbit);
+  }
+  __that->setstate(__status);
+  return __extracted;
+}
+
+// Buffered copying from one streambuf to another.  We copy the characters
+// in chunks, rather than one at a time.  We still have to worry about all
+// of the error conditions we checked in __copy_unbuffered, plus one more:
+// the streambuf might decide to switch from a buffered to an unbuffered mode.
+
+template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
+streamsize _STLP_CALL
+__copy_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src,
+                basic_streambuf<_CharT, _Traits>* __dest,
+                _Scan_Delim __scan_delim, _Is_Delim __is_delim,
+                bool __extract_delim, bool __rethrow) {
+  streamsize __extracted = 0;
+  ios_base::iostate __status = 0;
+  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+  //Borland compiler generates a warning if assignment because value is never used:
+  int_type __c /*= _Traits::eof()*/;
+  _CharT* __first = __src->_M_gptr();
+  ptrdiff_t __avail = __src->_M_egptr() - __first;
+  // fbp : introduced to move catch/try blocks out of the loop
+  bool __do_handle_exceptions = false;
+
+  _STLP_TRY {
+    for (;;) {
+      const _CharT* __last = __scan_delim(__first, __src->_M_egptr());
+
+      // Try to copy the entire input buffer to the output buffer.
+      streamsize __n = __dest->sputn(__first, __extract_delim && __last != __src->_M_egptr()
+                                     ? (__last - __first) + 1
+                                     : (__last - __first));
+      __src->_M_gbump((int)__n);
+      __extracted += __n;
+
+      // from this on, catch() will call _M_handle_exceptions()
+      __do_handle_exceptions = true;
+
+      if (__n < __avail)          // We found the delimiter, or else failed to
+        break;                    // copy some characters.
+
+      __c = __src->sgetc();
+
+      // Three possibilities: we succeeded in refilling the buffer, or
+      // we got EOF, or the streambuf has switched to unbuffered mode.
+      __first = __src->_M_gptr();
+      __avail = __src->_M_egptr() - __first;
+
+      if (__avail > 0)
+        {}  // dwa 1/16/00 -- suppress a Metrowerks warning
+      else if (__that->_S_eof(__c)) {
+        __status |= ios_base::eofbit;
+        break;
+      }
+      else {
+        return __extracted + __copy_unbuffered(__that,  __src, __dest, __is_delim,
+                                                __extract_delim, __rethrow);
+      }
+
+      __do_handle_exceptions = false;
+    }
+  }
+
+  _STLP_CATCH_ALL {
+    // See 27.6.1.2.3, paragraph 13.
+    if (__rethrow && __do_handle_exceptions &&  __extracted == 0)
+      __that->_M_handle_exception(ios_base::failbit);
+  }
+
+  if (__status)
+    __that->setstate(__status);   // This might throw.
+  return __extracted;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>
+  ::get(basic_streambuf<_CharT, _Traits>& __dest, _CharT __delim) {
+  sentry __sentry(*this, _No_Skip_WS());
+  this->_M_gcount = 0;
+
+  if (__sentry) {
+    basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
+
+    if (__src)
+      this->_M_gcount = __src->egptr() != __src->gptr()
+        ? _STLP_PRIV __copy_buffered(this,  __src, &__dest,
+                                     _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
+                                     _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+                                     false, false)
+        : _STLP_PRIV __copy_unbuffered(this,  __src, &__dest,
+                                       _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+                                       false, false);
+  }
+
+  if (this->_M_gcount == 0)
+    this->setstate(ios_base::failbit);
+
+  return *this;
+}
+
+// Copying characters into a streambuf.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>
+  ::operator>>(basic_streambuf<_CharT, _Traits>* __dest) {
+  streamsize __n = 0;
+  typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
+  _Sentry __sentry(*this);
+  if (__sentry) {
+    basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
+    if (__src && __dest)
+      __n = __src->egptr() != __src->gptr()
+        ? _STLP_PRIV __copy_buffered(this,  __src, __dest,
+                                     _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+                                     _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+                                     false, true)
+        : _STLP_PRIV __copy_unbuffered(this,  __src, __dest,
+                                       _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+                                       false, true);
+  }
+
+  if (__n == 0)
+    this->setstate(ios_base::failbit);
+
+  return *this;
+}
+
+// ----------------------------------------------------------------
+// basic_iostream<> class
+// ----------------------------------------------------------------
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>
+  ::basic_iostream(basic_streambuf<_CharT, _Traits>* __buf)
+    : basic_ios<_CharT, _Traits>(),
+      basic_istream<_CharT, _Traits>(__buf),
+      basic_ostream<_CharT, _Traits>(__buf) {
+  this->init(__buf);
+}
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>::~basic_iostream()
+{}
+
+_STLP_END_NAMESPACE
+
+#undef __BIS_int_type__
+#undef __BIS_pos_type__
+#undef __BIS_off_type__
+
+#endif /* _STLP_ISTREAM_C */
+
+// Local Variables:
+// mode:C++
+// End: