include/stlport/stl/_istream.c

   1 /*
   2  * Copyright (c) 1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18 #ifndef _STLP_ISTREAM_C
  19 #define _STLP_ISTREAM_C
  20
  21 #ifndef _STLP_INTERNAL_ISTREAM
  22 #  include <stl/_istream.h>
  23 #endif
  24
  25 #ifndef _STLP_INTERNAL_LIMITS
  26 #  include <stl/_limits.h>
  27 #endif
  28
  29 #ifndef _STLP_INTERNAL_NUM_GET_H
  30 #  include <stl/_num_get.h>
  31 #endif
  32
  33 #if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
  34 // no wchar_t is supported for this mode
  35 #  define __BIS_int_type__ int
  36 #  define __BIS_pos_type__ streampos
  37 #  define __BIS_off_type__ streamoff
  38 #else
  39 #  define __BIS_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::int_type
  40 #  define __BIS_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::pos_type
  41 #  define __BIS_off_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::off_type
  42 #endif
  43
  44 _STLP_BEGIN_NAMESPACE
  45
  46 //----------------------------------------------------------------------
  47 // Function object structs used by some member functions.
  48
  49 _STLP_MOVE_TO_PRIV_NAMESPACE
  50
  51 template <class _Traits>
  52 struct _Is_not_wspace {
  53   typedef typename _Traits::char_type argument_type;
  54   typedef bool                        result_type;
  55
  56   const ctype<argument_type>* _M_ctype;
  57
  58   _Is_not_wspace(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}
  59   bool operator()(argument_type __c) const
  60     { return !_M_ctype->is(ctype_base::space, __c); }
  61 };
  62
  63 template <class _Traits>
  64 struct _Is_wspace_null {
  65   typedef typename _Traits::char_type argument_type;
  66   typedef bool                        result_type;
  67
  68   const ctype<argument_type>* _M_ctype;
  69
  70   _Is_wspace_null(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}
  71   bool operator()(argument_type __c) const {
  72     return _Traits::eq(__c, argument_type()) ||
  73            _M_ctype->is(ctype_base::space, __c);
  74   }
  75 };
  76
  77 template <class _Traits>
  78 struct _Scan_for_wspace {
  79   typedef typename _Traits::char_type  char_type;
  80   typedef char_type*                   first_argument_type;
  81   typedef char_type*                   second_argument_type;
  82   typedef char_type*                   result_type;
  83
  84   const ctype<char_type>* _M_ctype;
  85
  86   _Scan_for_wspace(const ctype<char_type>* __ctype) : _M_ctype(__ctype) {}
  87   const char_type*
  88   operator()(const char_type* __first, const char_type* __last) const {
  89     return _M_ctype->scan_is(ctype_base::space, __first, __last);
  90   }
  91 };
  92
  93 template <class _Traits>
  94 struct _Scan_wspace_null {
  95   typedef typename _Traits::char_type  char_type;
  96   typedef char_type*                   first_argument_type;
  97   typedef char_type*                   second_argument_type;
  98   typedef char_type*                   result_type;
  99
 100   const ctype<char_type>* _M_ctype;
 101
 102   _Scan_wspace_null(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}
 103   const char_type*
 104   operator()(const char_type* __first, const char_type* __last) const {
 105     __last = find_if(__first, __last,
 106                      _Eq_char_bound<_Traits>(char_type()));
 107     return _M_ctype->scan_is(ctype_base::space, __first, __last);
 108   }
 109 };
 110
 111 template <class _Traits>
 112 struct _Scan_for_not_wspace {
 113   typedef typename _Traits::char_type  char_type;
 114   typedef char_type*                   first_argument_type;
 115   typedef char_type*                   second_argument_type;
 116   typedef char_type*                   result_type;
 117
 118   const ctype<char_type>* _M_ctype;
 119
 120   _Scan_for_not_wspace(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}
 121   const char_type*
 122   operator()(const char_type* __first, const char_type* __last) const {
 123     return _M_ctype->scan_not(ctype_base::space, __first, __last);
 124   }
 125 };
 126
 127 template <class _Traits>
 128 struct _Scan_for_char_val {
 129   typedef typename _Traits::char_type char_type;
 130   typedef char_type*                  first_argument_type;
 131   typedef char_type*                  second_argument_type;
 132   typedef char_type*                  result_type;
 133
 134   char_type _M_val;
 135
 136   _Scan_for_char_val(char_type __val) : _M_val(__val) {}
 137
 138   const char_type*
 139   operator()(const char_type* __first, const char_type* __last) const {
 140     return find_if(__first, __last, _Eq_char_bound<_Traits>(_M_val));
 141   }
 142 };
 143
 144 template <class _Traits>
 145 struct _Scan_for_int_val {
 146   typedef typename _Traits::char_type char_type;
 147   typedef typename _Traits::int_type  int_type;
 148   typedef char_type*                  first_argument_type;
 149   typedef char_type*                  second_argument_type;
 150   typedef char_type*                  result_type;
 151
 152   int_type _M_val;
 153
 154   _Scan_for_int_val(int_type __val) : _M_val(__val) {}
 155
 156   const char_type*
 157   operator()(const char_type* __first, const char_type* __last) const {
 158     return find_if(__first, __last,
 159                    _Eq_int_bound<_Traits>(_M_val));
 160   }
 161 };
 162
 163 // Helper function: try to push back a character to a streambuf,
 164 // return true if the pushback succeeded.  Does not throw.
 165
 166 template <class _CharT, class _Traits>
 167 bool _STLP_CALL
 168 __pushback(basic_streambuf<_CharT, _Traits>* __buf, _CharT __c) {
 169   bool ret;
 170   _STLP_TRY {
 171     const typename _Traits::int_type __eof = _Traits::eof();
 172     ret = !_Traits::eq_int_type(__buf->sputbackc(__c), __eof);
 173   }
 174   _STLP_CATCH_ALL {
 175     ret = false;
 176   }
 177   return ret;
 178 }
 179
 180 //----------------------------------------------------------------------
 181 // Definitions of basic_istream<>'s noninline member functions.
 182
 183 // Helper function for formatted input of numbers.
 184 template <class _CharT, class _Traits, class _Number>
 185 ios_base::iostate _STLP_CALL
 186 __get_num(basic_istream<_CharT, _Traits>& __that, _Number& __val) {
 187   typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
 188   ios_base::iostate __err = 0;
 189   _Sentry __sentry( __that );     // Skip whitespace.
 190   if (__sentry) {
 191     typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > _Num_get;
 192     _STLP_TRY {
 193       // Do not remove additional parenthesis around use_facet instanciation, some compilers (VC6)
 194       // require it when building the library.
 195       (use_facet<_Num_get>(__that.getloc())).get(istreambuf_iterator<_CharT, _Traits>(__that.rdbuf()),
 196                                                0, __that, __err, __val);
 197     }
 198     _STLP_CATCH_ALL {
 199       __that._M_handle_exception(ios_base::badbit);
 200     }
 201     if (__err) __that.setstate(__err);
 202   }
 203   return __err;
 204 }
 205
 206 _STLP_MOVE_TO_STD_NAMESPACE
 207
 208 template <class _CharT, class _Traits>
 209 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (short& __val) {
 210   long __lval;
 211   _STLP_PRIV __get_num(*this, __lval);
 212   if ( this->fail() ) {
 213     return *this;
 214   }
 215   short __tmp = __STATIC_CAST(short, __lval);
 216   unsigned short __uval = __STATIC_CAST(unsigned short, __lval);
 217   // check if we lose digits
 218   //    if ((__val != __lval) && ((unsigned short)__val != __lval))
 219   if ((__tmp != __lval) && ((long)__uval != __lval))
 220     this->setstate(ios_base::failbit);
 221   else
 222     __val = __tmp;
 223   return *this;
 224 }
 225
 226 template <class _CharT, class _Traits>
 227 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (int& __val) {
 228   long __lval;
 229   _STLP_PRIV __get_num(*this, __lval);
 230   if ( this->fail() ) {
 231     return *this;
 232   }
 233   int __tmp = __lval;
 234   unsigned int __uval = __lval;
 235   // check if we lose digits
 236   //    if ((__val != __lval) && ((unsigned int)__val != __lval))
 237   if ((__tmp != __lval) && ((long)__uval != __lval))
 238     this->setstate(ios_base::failbit);
 239   else
 240     __val = __tmp;
 241   return *this;
 242 }
 243
 244 template <class _CharT, class _Traits>
 245 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned short& __val) {
 246   _STLP_PRIV __get_num(*this, __val);
 247   return *this;
 248 }
 249
 250 template <class _CharT, class _Traits>
 251 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned int& __val) {
 252   _STLP_PRIV __get_num(*this, __val);
 253   return *this;
 254 }
 255
 256 template <class _CharT, class _Traits>
 257 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long& __val) {
 258   _STLP_PRIV __get_num(*this, __val);
 259   return *this;
 260 }
 261
 262 template <class _CharT, class _Traits>
 263 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned long& __val) {
 264   _STLP_PRIV __get_num(*this, __val);
 265   return *this;
 266 }
 267
 268 #if defined (_STLP_LONG_LONG)
 269 template <class _CharT, class _Traits>
 270 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (_STLP_LONG_LONG& __val) {
 271   _STLP_PRIV __get_num(*this, __val);
 272   return *this;
 273 }
 274
 275 template <class _CharT, class _Traits>
 276 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned _STLP_LONG_LONG& __val) {
 277   _STLP_PRIV __get_num(*this, __val);
 278   return *this;
 279 }
 280 #endif
 281 template <class _CharT, class _Traits>
 282 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (float& __val) {
 283   _STLP_PRIV __get_num(*this, __val);
 284   return *this;
 285 }
 286 template <class _CharT, class _Traits>
 287 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (double& __val) {
 288   _STLP_PRIV __get_num(*this, __val);
 289   return *this;
 290 }
 291 #if !defined (_STLP_NO_LONG_DOUBLE)
 292 template <class _CharT, class _Traits>
 293 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long double& __val) {
 294   _STLP_PRIV __get_num(*this, __val);
 295   return *this;
 296 }
 297 #endif
 298 #if !defined (_STLP_NO_BOOL)
 299 template <class _CharT, class _Traits>
 300 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (bool& __val) {
 301   _STLP_PRIV __get_num(*this, __val);
 302   return *this;
 303 }
 304 #endif
 305
 306 template <class _CharT, class _Traits>
 307 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (void*& __val) {
 308   _STLP_PRIV __get_num(*this, __val);
 309   return *this;
 310 }
 311
 312 // Unformatted input
 313
 314 template <class _CharT, class _Traits>
 315 __BIS_int_type__
 316 basic_istream<_CharT, _Traits>::peek() {
 317   typename _Traits::int_type __tmp = _Traits::eof();
 318
 319   this->_M_gcount = 0;
 320   sentry __sentry(*this, _No_Skip_WS());
 321
 322   if (__sentry) {
 323     _STLP_TRY {
 324       __tmp = this->rdbuf()->sgetc();
 325     }
 326     _STLP_CATCH_ALL {
 327       this->_M_handle_exception(ios_base::badbit);
 328     }
 329     if (this->_S_eof(__tmp))
 330       this->setstate(ios_base::eofbit);
 331   }
 332
 333   return __tmp;
 334 }
 335
 336
 337 template <class _CharT, class _Traits>
 338 __BIS_int_type__
 339 basic_istream<_CharT, _Traits>::get() {
 340   typename _Traits::int_type __tmp = _Traits::eof();
 341   sentry __sentry(*this, _No_Skip_WS());
 342   this->_M_gcount = 0;
 343
 344   if (__sentry) {
 345     _STLP_TRY {
 346       __tmp = this->rdbuf()->sbumpc();
 347     }
 348     _STLP_CATCH_ALL {
 349       this->_M_handle_exception(ios_base::badbit);
 350     }
 351
 352     if (!this->_S_eof(__tmp))
 353       this->_M_gcount = 1;
 354   }
 355
 356   if (_M_gcount == 0)
 357     this->setstate(ios_base::eofbit | ios_base::failbit);
 358
 359   return __tmp;
 360 }
 361
 362 template <class _CharT, class _Traits>
 363 basic_istream<_CharT, _Traits>&
 364 basic_istream<_CharT, _Traits>::get(_CharT& __c) {
 365   sentry __sentry(*this, _No_Skip_WS());
 366   this->_M_gcount = 0;
 367
 368   if (__sentry) {
 369     typename _Traits::int_type __tmp = _Traits::eof();
 370     _STLP_TRY {
 371       __tmp = this->rdbuf()->sbumpc();
 372     }
 373     _STLP_CATCH_ALL {
 374       this->_M_handle_exception(ios_base::badbit);
 375     }
 376
 377     if (!this->_S_eof(__tmp)) {
 378       this->_M_gcount = 1;
 379       __c = _Traits::to_char_type(__tmp);
 380     }
 381   }
 382
 383   if (this->_M_gcount == 0)
 384     this->setstate(ios_base::eofbit | ios_base::failbit);
 385
 386   return *this;
 387 }
 388
 389
 390 // Read characters and discard them.  The standard specifies a single
 391 // function with two arguments, each with a default.  We instead use
 392 // three overloded functions, because it's possible to implement the
 393 // first two more efficiently than the fully general third version.
 394 template <class _CharT, class _Traits>
 395 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::ignore() {
 396   sentry __sentry(*this, _No_Skip_WS());
 397   this->_M_gcount = 0;
 398
 399   if (__sentry) {
 400     int_type __c;
 401     _STLP_TRY {
 402       __c = this->rdbuf()->sbumpc();
 403     }
 404     _STLP_CATCH_ALL {
 405       this->_M_handle_exception(ios_base::badbit);
 406       return *this;
 407     }
 408
 409     if (!this->_S_eof(__c))
 410       this->_M_gcount = 1;
 411     else
 412       this->setstate(ios_base::eofbit);
 413   }
 414
 415   return *this;
 416 }
 417
 418 // Putback
 419
 420 template <class _CharT, class _Traits>
 421 basic_istream<_CharT, _Traits>&
 422 basic_istream<_CharT, _Traits>::putback(_CharT __c) {
 423   this->_M_gcount = 0;
 424   sentry __sentry(*this, _No_Skip_WS());
 425
 426   if (__sentry) {
 427     typename _Traits::int_type __tmp = _Traits::eof();
 428     basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 429 //    if (!__buf || this->_S_eof(__buf->sputbackc(__c)))
 430     if (__buf) {
 431       _STLP_TRY {
 432         __tmp = __buf->sputbackc(__c);
 433       }
 434       _STLP_CATCH_ALL {
 435         this->_M_handle_exception(ios_base::badbit);
 436       }
 437     }
 438     if (this->_S_eof(__tmp))
 439       this->setstate(ios_base::badbit);
 440   }
 441   else
 442     this->setstate(ios_base::failbit);
 443
 444   return *this;
 445 }
 446
 447 template <class _CharT, class _Traits>
 448 basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::unget() {
 449   this->_M_gcount = 0;
 450
 451   sentry __sentry(*this, _No_Skip_WS());
 452
 453   if (__sentry) {
 454     basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 455     //     if (!__buf || _Traits::eq_int_type(__buf->sungetc(), _Traits::eof()))
 456     if (__buf) {
 457       _STLP_TRY {
 458         if (this->_S_eof(__buf->sungetc()))
 459           this->setstate(ios_base::badbit);
 460       }
 461       _STLP_CATCH_ALL {
 462         this->_M_handle_exception(ios_base::badbit);
 463       }
 464     } else
 465       this->setstate(ios_base::badbit);
 466   }
 467   else
 468     this->setstate(ios_base::failbit);
 469
 470   return *this;
 471 }
 472
 473 // Positioning and buffer control.
 474
 475 template <class _CharT, class _Traits>
 476 int basic_istream<_CharT, _Traits>::sync() {
 477   sentry __sentry(*this, _No_Skip_WS());
 478
 479   basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 480   if (__buf) {
 481     if (__buf->pubsync() == -1) {
 482       this->setstate(ios_base::badbit);
 483       return -1;
 484     }
 485     else
 486       return 0;
 487   }
 488   else
 489     return -1;
 490 }
 491
 492 template <class _CharT, class _Traits>
 493 __BIS_pos_type__
 494 basic_istream<_CharT, _Traits>::tellg() {
 495   sentry __sentry(*this, _No_Skip_WS());
 496
 497   basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 498   return (__buf && !this->fail()) ? __buf->pubseekoff(0, ios_base::cur, ios_base::in)
 499     : pos_type(-1);
 500 }
 501
 502 template <class _CharT, class _Traits>
 503 basic_istream<_CharT, _Traits>&
 504 basic_istream<_CharT, _Traits>::seekg(pos_type __pos) {
 505   sentry __sentry(*this, _No_Skip_WS());
 506
 507   basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 508   if (!this->fail() && __buf) {
 509     if (__buf->pubseekpos(__pos, ios_base::in) == pos_type(-1)) {
 510       this->setstate(ios_base::failbit);
 511     }
 512   }
 513   return *this;
 514 }
 515
 516 template <class _CharT, class _Traits>
 517 basic_istream<_CharT, _Traits>&
 518 basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) {
 519   sentry __sentry(*this, _No_Skip_WS());
 520
 521   basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 522   if (!this->fail() && __buf)
 523     __buf->pubseekoff(__off, __dir, ios_base::in);
 524   return *this;
 525 }
 526
 527 // Formatted input of characters and character arrays.
 528
 529 template <class _CharT, class _Traits>
 530 void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT& __c) {
 531 //  typename _Traits::int_type __tmp = _Traits::eof();
 532
 533   sentry __sentry(*this); // Skip whitespace.
 534
 535   if (__sentry) {
 536     typename _Traits::int_type __tmp;// = _Traits::eof();
 537
 538     _STLP_TRY {
 539       __tmp = this->rdbuf()->sbumpc();
 540     }
 541     _STLP_CATCH_ALL {
 542       this->_M_handle_exception(ios_base::badbit);
 543       return;
 544     }
 545
 546     if (!this->_S_eof(__tmp))
 547       __c = _Traits::to_char_type(__tmp);
 548     else
 549       this->setstate(ios_base::eofbit | ios_base::failbit);
 550   }
 551 }
 552
 553
 554 //---------------------------------------------------------------------------
 555 // istream's helper functions.
 556
 557 // A generic function for unbuffered input.  We stop when we reach EOF,
 558 // or when we have extracted _Num characters, or when the function object
 559 // __is_delim return true.  In the last case, it extracts the character
 560 // for which __is_delim is true, if and only if __extract_delim is true.
 561 // It appends a null character to the end of the string; this means that
 562 // it may store up to _Num + 1 characters.
 563 //
 564 // __is_getline governs two corner cases: reading _Num characters without
 565 // encountering delim or eof (in which case failbit is set if __is_getline
 566 // is true); and reading _Num characters where the _Num+1'st character is
 567 // eof (in which case eofbit is set if __is_getline is true).
 568 //
 569 // It is assumed that __is_delim never throws.
 570 //
 571 // Return value is the number of characters extracted, including the
 572 // delimiter if it is extracted.  Note that the number of characaters
 573 // extracted isn't necessarily the same as the number stored.
 574
 575 _STLP_MOVE_TO_PRIV_NAMESPACE
 576
 577 template < class _CharT, class _Traits, class _Is_Delim>
 578 streamsize _STLP_CALL
 579 __read_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf,
 580                   streamsize _Num, _CharT* __s,
 581                   _Is_Delim __is_delim,
 582                   bool __extract_delim, bool __append_null,
 583                   bool __is_getline)
 584 {
 585   streamsize __n = 0;
 586   ios_base::iostate __status = 0;
 587
 588   typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
 589   // The operations that can potentially throw are sbumpc, snextc, and sgetc.
 590   _STLP_TRY {
 591     for (;;) {
 592       if (__n == _Num) {
 593         if (__is_getline) // didn't find delimiter as one of the _Num chars
 594           __status |= ios_base::failbit;
 595         break;
 596       }
 597       int_type __c = __buf->sbumpc(); // sschwarz
 598
 599       if (__that->_S_eof(__c)) {
 600         if (__n < _Num || __is_getline)
 601           __status |= ios_base::eofbit;
 602         break;
 603       } else if (__is_delim(_Traits::to_char_type(__c))) {
 604         if (__extract_delim) { // Extract and discard current character.
 605           ++__n;
 606         } else if ( !__pushback(__buf, _Traits::to_char_type(__c)) ) { // leave delimiter
 607           __status |= ios_base::failbit;
 608         }
 609         break;
 610       }
 611       // regular character
 612       *__s++ = _Traits::to_char_type(__c);
 613       ++__n;
 614     }
 615   }
 616   _STLP_CATCH_ALL {
 617     __that->_M_handle_exception(ios_base::badbit);
 618     *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT);
 619     return __n;
 620   }
 621
 622   if (__append_null)
 623     *__s =  _STLP_DEFAULT_CONSTRUCTED(_CharT);
 624   if (__status)
 625     __that->setstate(__status);    // This might throw.
 626   return __n;
 627 }
 628
 629 // Much like __read_unbuffered, but with one additional function object:
 630 // __scan_delim(first, last) returns the first pointer p in [first, last)
 631 // such that __is_delim(p) is true.
 632
 633 template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
 634 streamsize _STLP_CALL
 635 __read_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf,
 636                  streamsize _Num, _CharT* __s,
 637                  _Is_Delim __is_delim, _Scan_Delim __scan_delim,
 638                  bool __extract_delim, bool __append_null,
 639                  bool __is_getline) {
 640   streamsize __n = 0;
 641   ios_base::iostate __status = 0;
 642   bool __done    = false;
 643
 644   _STLP_TRY {
 645     while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
 646       const _CharT* __first = __buf->_M_gptr();
 647       const _CharT* __last  = __buf->_M_egptr();
 648       //casting numeric_limits<ptrdiff_t>::max to streamsize only works is ptrdiff_t is signed or streamsize representation
 649       //is larger than ptrdiff_t one.
 650       _STLP_STATIC_ASSERT((sizeof(streamsize) > sizeof(ptrdiff_t)) ||
 651                           ((sizeof(streamsize) == sizeof(ptrdiff_t)) && numeric_limits<ptrdiff_t>::is_signed))
 652       ptrdiff_t __request = __STATIC_CAST(ptrdiff_t, (min) (__STATIC_CAST(streamsize, (numeric_limits<ptrdiff_t>::max)()), _Num - __n));
 653
 654       const _CharT* __p  = __scan_delim(__first, __last);
 655       ptrdiff_t __chunk = (min) (ptrdiff_t(__p - __first), __request);
 656       _Traits::copy(__s, __first, __chunk);
 657       __s += __chunk;
 658       __n += __chunk;
 659       __buf->_M_gbump((int)__chunk);
 660
 661       // We terminated by finding delim.
 662       if (__p != __last && __p - __first <= __request) {
 663         if (__extract_delim) {
 664           __n += 1;
 665           __buf->_M_gbump(1);
 666         }
 667         __done = true;
 668       }
 669
 670       // We terminated by reading all the characters we were asked for.
 671       else if (__n == _Num) {
 672
 673         // Find out if we have reached eof.  This matters for getline.
 674         if (__is_getline) {
 675           if (__chunk == __last - __first) {
 676             if (__that->_S_eof(__buf->sgetc()))
 677               __status |= ios_base::eofbit;
 678           }
 679           else
 680             __status |= ios_base::failbit;
 681         }
 682         __done   = true;
 683       }
 684
 685       // The buffer contained fewer than _Num - __n characters.  Either we're
 686       // at eof, or we should refill the buffer and try again.
 687       else {
 688         if (__that->_S_eof(__buf->sgetc())) {
 689           __status |= ios_base::eofbit;
 690           __done = true;
 691         }
 692       }
 693     } // Close the while loop.
 694   }
 695   _STLP_CATCH_ALL {
 696     __that->_M_handle_exception(ios_base::badbit);
 697     __done = true;
 698   }
 699
 700   if (__done) {
 701     if (__append_null)
 702         *__s =  _STLP_DEFAULT_CONSTRUCTED(_CharT);
 703     if (__status != 0)
 704       __that->setstate(__status);   // This might throw.
 705     return __n;
 706   }
 707
 708   // If execution has reached this point, then we have an empty buffer but
 709   // we have not reached eof.  What that means is that the streambuf has
 710   // decided to switch from buffered to unbuffered input.  We switch to
 711   // to __read_unbuffered.
 712
 713   return __n + __read_unbuffered(__that,  __buf, _Num - __n, __s, __is_delim,
 714                                  __extract_delim,__append_null,__is_getline);
 715 }
 716
 717 _STLP_MOVE_TO_STD_NAMESPACE
 718
 719 template <class _CharT, class _Traits>
 720 basic_istream<_CharT, _Traits>&
 721 basic_istream<_CharT, _Traits>::get(_CharT* __s, streamsize __n,
 722                                     _CharT __delim) {
 723   sentry __sentry(*this, _No_Skip_WS());
 724   this->_M_gcount = 0;
 725
 726   if (__sentry) {
 727     if (__n > 0) {
 728       basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 729
 730       if (__buf->egptr() != __buf->gptr())
 731         this->_M_gcount =
 732           _STLP_PRIV __read_buffered(this,  __buf, __n - 1, __s,
 733                                      _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
 734                                      _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
 735                                      false, true, false);
 736       else
 737         this->_M_gcount =
 738           _STLP_PRIV __read_unbuffered(this,  __buf, __n - 1, __s,
 739                                        _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
 740                                        false, true, false);
 741     }
 742   }
 743
 744   if (this->_M_gcount == 0)
 745     this->setstate(ios_base::failbit);
 746
 747   return *this;
 748 }
 749
 750 // Getline is essentially identical to get, except that it extracts
 751 // the delimiter.
 752 template <class _CharT, class _Traits>
 753 basic_istream<_CharT, _Traits>&
 754 basic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n,
 755                                         _CharT __delim) {
 756   sentry __sentry(*this, _No_Skip_WS());
 757   this->_M_gcount = 0;
 758
 759   if (__sentry) {
 760     if (__n > 0) {
 761       basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 762       this->_M_gcount = __buf->egptr() != __buf->gptr()
 763         ? _STLP_PRIV __read_buffered(this,  __buf, __n - 1, __s,
 764                                      _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
 765                                      _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
 766                                      true, true, true)
 767         : _STLP_PRIV __read_unbuffered(this,  __buf, __n - 1, __s,
 768                                        _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
 769                                        true, true, true);
 770     }
 771   }
 772
 773   if (this->_M_gcount == 0)
 774     this->setstate(ios_base::failbit);
 775
 776   return *this;
 777 }
 778
 779 // Read n characters.  We don't look for any delimiter, and we don't
 780 // put in a terminating null character.
 781 template <class _CharT, class _Traits>
 782 basic_istream<_CharT, _Traits>&
 783 basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) {
 784   sentry __sentry(*this, _No_Skip_WS());
 785   this->_M_gcount = 0;
 786
 787   if (__sentry && !this->eof()) {
 788     basic_streambuf<_CharT, _Traits>*__buf = this->rdbuf();
 789     if (__buf->gptr() != __buf->egptr())
 790       _M_gcount
 791         = _STLP_PRIV __read_buffered(this,  __buf, __n, __s,
 792                                      _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
 793                                      _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
 794                                      false, false, false);
 795     else
 796       _M_gcount
 797         = _STLP_PRIV __read_unbuffered(this,  __buf, __n, __s,
 798                                        _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
 799                                        false, false, false);
 800   }
 801   else
 802     this->setstate(ios_base::failbit);
 803
 804   if (this->eof())
 805     this->setstate(ios_base::eofbit | ios_base::failbit);
 806
 807   return *this;
 808 }
 809
 810
 811 // Read n or fewer characters.  We don't look for any delimiter, and
 812 // we don't put in a terminating null character.
 813 template <class _CharT, class _Traits>
 814 streamsize
 815 basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __nmax) {
 816   sentry __sentry(*this, _No_Skip_WS());
 817   this->_M_gcount = 0;
 818
 819   if (__sentry && !this->eof() && __nmax >= 0) {
 820
 821     basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 822     streamsize __avail = __buf->in_avail();
 823
 824     // fbp : isn't full-blown setstate required here ?
 825     if (__avail == -1)
 826       this->_M_setstate_nothrow(ios_base::eofbit);
 827
 828     else if (__avail != 0) {
 829
 830       if (__buf->gptr() != __buf->egptr())
 831         _M_gcount
 832           = _STLP_PRIV __read_buffered(this,  __buf, (min) (__avail, __nmax), __s,
 833                                        _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
 834                                        _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
 835                                        false, false, false);
 836       else
 837         _M_gcount
 838           = _STLP_PRIV __read_unbuffered(this,  __buf, (min) (__avail, __nmax), __s,
 839                                          _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
 840                                          false, false, false);
 841     }
 842   }
 843   else {
 844     // fbp : changed so that failbit is set only there, to pass Dietmar's test
 845     if (this->eof())
 846       this->setstate(ios_base::eofbit | ios_base::failbit);
 847     else
 848       this->setstate(ios_base::failbit);
 849   }
 850
 851   //  if (this->eof())
 852   //    this->setstate(ios_base::eofbit | ios_base::failbit);
 853
 854   return _M_gcount;
 855 }
 856
 857 template <class _CharT, class _Traits>
 858 void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT* __s) {
 859   sentry __sentry(*this); // Skip whitespace.
 860
 861   if (__sentry) {
 862     basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
 863     streamsize __nmax = this->width() > 0
 864       ? this->width() - 1
 865       : ((numeric_limits<streamsize>::max)() / sizeof(_CharT)) - 1;
 866
 867     streamsize __n = __buf->gptr() != __buf->egptr()
 868       ? _STLP_PRIV __read_buffered(this,  __buf, __nmax, __s,
 869                                    _STLP_PRIV _Is_wspace_null<_Traits>(this->_M_ctype_facet()),
 870                                    _STLP_PRIV _Scan_wspace_null<_Traits>(this->_M_ctype_facet()),
 871                                    false, true, false)
 872       : _STLP_PRIV __read_unbuffered(this,  __buf, __nmax, __s,
 873                                      _STLP_PRIV _Is_wspace_null<_Traits>(this->_M_ctype_facet()),
 874                                      false, true, false);
 875     if (__n == 0)
 876       this->setstate(ios_base::failbit);
 877   }
 878   this->width(0);
 879 }
 880
 881 // A generic unbuffered function for ignoring characters.  We stop
 882 // when we reach EOF, or when the function object __is_delim returns
 883 // true.  In the last case, it extracts the character for which
 884 // __is_delim is true, if and only if __extract_delim is true.
 885
 886 template < class _CharT, class _Traits, class _Is_Delim>
 887 void _STLP_CALL
 888 _M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that,
 889                      basic_streambuf<_CharT, _Traits>* __buf,
 890                      _Is_Delim __is_delim,
 891                      bool __extract_delim, bool __set_failbit) {
 892   bool __done = false;
 893   ios_base::iostate __status = 0;
 894   typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
 895
 896   _STLP_TRY {
 897     while (!__done) {
 898       int_type __c = __buf->sbumpc();
 899
 900       if (__that->_S_eof(__c)) {
 901         __done = true;
 902         __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
 903                                   : ios_base::eofbit;
 904       }
 905
 906       else if (__is_delim(_Traits::to_char_type(__c))) {
 907         __done = true;
 908         if (!__extract_delim)
 909           if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
 910             __status |= ios_base::failbit;
 911       }
 912     }
 913   }
 914   _STLP_CATCH_ALL {
 915     __that->_M_handle_exception(ios_base::badbit);
 916   }
 917
 918   __that->setstate(__status);
 919 }
 920
 921 // A generic buffered function for ignoring characters.  Much like
 922 // _M_ignore_unbuffered, but with one additional function object:
 923 // __scan_delim(first, last) returns the first pointer p in [first,
 924 // last) such that __is_delim(p) is true.
 925
 926 template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
 927 void _STLP_CALL
 928 _M_ignore_buffered(basic_istream<_CharT, _Traits>* __that,
 929                    basic_streambuf<_CharT, _Traits>* __buf,
 930                    _Is_Delim __is_delim, _Scan_Delim __scan_delim,
 931                    bool __extract_delim, bool __set_failbit) {
 932   bool __at_eof      = false;
 933   bool __found_delim = false;
 934
 935   _STLP_TRY {
 936     while (__buf->_M_egptr() != __buf->_M_gptr() && !__at_eof && !__found_delim) {
 937       const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
 938       __buf->_M_gbump((int)(__p - __buf->_M_gptr()));
 939
 940       if (__p != __buf->_M_egptr()) { // We found delim, so we're done.
 941         if (__extract_delim)
 942           __buf->_M_gbump(1);
 943         __found_delim = true;
 944       }
 945
 946       else                         // No delim.  Try to refil the buffer.
 947         __at_eof = __that->_S_eof(__buf->sgetc());
 948     }                              // Close the while loop.
 949   }
 950   _STLP_CATCH_ALL {
 951     __that->_M_handle_exception(ios_base::badbit);
 952     return;
 953   }
 954
 955   if (__at_eof) {
 956     __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
 957                                    : ios_base::eofbit);
 958     return;
 959   }
 960   if (__found_delim)
 961     return;
 962
 963   // If execution has reached this point, then we have an empty buffer but
 964   // we have not reached eof.  What that means is that the streambuf has
 965   // decided to switch from a buffered to an unbuffered mode.  We switch
 966   // to _M_ignore_unbuffered.
 967   _M_ignore_unbuffered(__that,  __buf, __is_delim, __extract_delim, __set_failbit);
 968 }
 969
 970 // Overloaded versions of _M_ignore_unbuffered and _M_ignore_unbuffered
 971 // with an explicit count _Num.  Return value is the number of
 972 // characters extracted.
 973 //
 974 // The function object __max_chars takes two arguments, _Num and __n
 975 // (the latter being the number of characters we have already read),
 976 // and returns the maximum number of characters to read from the buffer.
 977 // We parameterize _M_ignore_buffered so that we can use it for both
 978 // bounded and unbounded input; for the former the function object should
 979 // be minus<>, and for the latter it should return a constant maximum value.
 980
 981 template < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim>
 982 streamsize _STLP_CALL
 983 _M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that,
 984                      basic_streambuf<_CharT, _Traits>* __buf,
 985                      streamsize _Num, _Max_Chars __max_chars,
 986                      _Is_Delim __is_delim,
 987                      bool __extract_delim, bool __set_failbit) {
 988   streamsize __n = 0;
 989   ios_base::iostate __status = 0;
 990   typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
 991
 992   _STLP_TRY {
 993     while (__max_chars(_Num, __n) > 0) {
 994       int_type __c = __buf->sbumpc();
 995
 996       if (__that->_S_eof(__c)) {
 997         __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
 998                                   : ios_base::eofbit;
 999         break;
1000       }
1001
1002       else if (__is_delim(_Traits::to_char_type(__c))) {
1003         if (__extract_delim)
1004           ++__n;
1005         else if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
1006           __status |= ios_base::failbit;
1007
1008         break;
1009       }
1010       // fbp : added counter increment to pass Dietmar's test
1011       ++__n;
1012     }
1013   }
1014   _STLP_CATCH_ALL {
1015     __that->_M_handle_exception(ios_base::badbit);
1016   }
1017
1018   if (__status)
1019     __that->setstate(__status);   // This might throw.
1020   return __n;
1021 }
1022
1023 template < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim, class _Scan_Delim>
1024 streamsize _STLP_CALL
1025 _M_ignore_buffered(basic_istream<_CharT, _Traits>* __that,
1026                    basic_streambuf<_CharT, _Traits>* __buf,
1027                    streamsize _Num,
1028                    _Max_Chars __max_chars,
1029                    _Is_Delim __is_delim, _Scan_Delim __scan_delim,
1030                    bool __extract_delim, bool __set_failbit) {
1031   streamsize __n = 0;
1032   bool __at_eof = false;
1033   bool __done   = false;
1034
1035   _STLP_TRY {
1036     while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
1037       ptrdiff_t __avail = __buf->_M_egptr() - __buf->_M_gptr();
1038       streamsize __m = __max_chars(_Num, __n);
1039
1040       if (__avail >= __m) {       // We have more characters than we need.
1041         const _CharT* __last = __buf->_M_gptr() + __STATIC_CAST(ptrdiff_t, __m);
1042         const _CharT* __p = __scan_delim(__buf->_M_gptr(), __last);
1043         ptrdiff_t __chunk = __p - __buf->_M_gptr();
1044         __n += __chunk;
1045         __buf->_M_gbump((int)__chunk);
1046
1047         if (__extract_delim && __p != __last) {
1048           __n += 1;
1049           __buf->_M_gbump(1);
1050         }
1051
1052         __done = true;
1053       }
1054
1055       else {
1056         const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
1057         ptrdiff_t __chunk = __p - __buf->_M_gptr();
1058         __n += __chunk;
1059         __buf->_M_gbump((int)__chunk);
1060
1061         if (__p != __buf->_M_egptr()) { // We found delim.
1062           if (__extract_delim) {
1063             __n += 1;
1064             __buf->_M_gbump(1);
1065           }
1066
1067           __done = true;
1068         }
1069
1070         // We didn't find delim.  Try to refill the buffer.
1071         else if (__that->_S_eof(__buf->sgetc())) {
1072           __done   = true;
1073           __at_eof = true;
1074         }
1075       }
1076     } // Close the while loop.
1077   }
1078   _STLP_CATCH_ALL {
1079     __that->_M_handle_exception(ios_base::badbit);
1080     return __n;
1081   }
1082
1083   if (__at_eof)
1084     __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
1085                                    : ios_base::eofbit);
1086
1087   if (__done)
1088     return __n;
1089
1090   // If execution has reached this point, then we have an empty buffer but
1091   // we have not reached eof.  What that means is that the streambuf has
1092   // decided to switch from buffered to unbuffered input.  We switch to
1093   // to _M_ignore_unbuffered.
1094
1095   return __n + _M_ignore_unbuffered(__that,  __buf, _Num, __max_chars,
1096                                     __is_delim, __extract_delim, __set_failbit);
1097 }
1098
1099
1100 template <class _CharT, class _Traits>
1101 basic_istream<_CharT, _Traits>&
1102 basic_istream<_CharT, _Traits>::ignore(streamsize __n) {
1103   sentry __sentry(*this, _No_Skip_WS());
1104   this->_M_gcount = 0;
1105
1106   if (__sentry) {
1107     basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
1108     typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
1109     typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize> _Const_streamsize;
1110     const streamsize __maxss = (numeric_limits<streamsize>::max)();
1111
1112     if (__n == (numeric_limits<int>::max)()) {
1113       if (__buf->gptr() != __buf->egptr())
1114         _M_gcount = _M_ignore_buffered(this,  __buf,
1115                                        __maxss, _Const_streamsize(__maxss),
1116                                        _Const_bool(false),
1117                                        _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
1118                                        false, false);
1119       else
1120         _M_gcount = _M_ignore_unbuffered(this,  __buf,
1121                                          __maxss, _Const_streamsize(__maxss),
1122                                          _Const_bool(false), false, false);
1123     }
1124     else {
1125       if (__buf->gptr() != __buf->egptr())
1126         _M_gcount = _M_ignore_buffered(this,  __buf,
1127                                        __n, minus<streamsize>(),
1128                                        _Const_bool(false),
1129                                        _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
1130                                        false, false);
1131       else
1132         _M_gcount = _M_ignore_unbuffered(this,  __buf, __n, minus<streamsize>(),
1133                                          _Const_bool(false), false, false);
1134     }
1135   }
1136
1137   return *this;
1138 }
1139
1140 template <class _CharT, class _Traits>
1141 basic_istream<_CharT, _Traits>&
1142 basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __delim) {
1143   sentry __sentry(*this, _No_Skip_WS());
1144   this->_M_gcount = 0;
1145
1146   if (__sentry) {
1147     basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
1148     typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
1149     typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize>
1150       _Const_streamsize;
1151     const streamsize __maxss = (numeric_limits<streamsize>::max)();
1152
1153     if (__n == (numeric_limits<int>::max)()) {
1154       if (__buf->gptr() != __buf->egptr())
1155         _M_gcount = _M_ignore_buffered(this,  __buf,
1156                                        __maxss, _Const_streamsize(__maxss),
1157                                        _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
1158                                        _STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
1159                                        true, false);
1160       else
1161         _M_gcount = _M_ignore_unbuffered(this,  __buf,
1162                                          __maxss, _Const_streamsize(__maxss),
1163                                          _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
1164                                          true, false);
1165     }
1166     else {
1167       if (__buf->gptr() != __buf->egptr())
1168         _M_gcount = _M_ignore_buffered(this,  __buf,
1169                                        __n, minus<streamsize>(),
1170                                        _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
1171                                        _STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
1172                                        true, false);
1173       else
1174         _M_gcount = _M_ignore_unbuffered(this,  __buf, __n, minus<streamsize>(),
1175                                          _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
1176                                          true, false);
1177     }
1178   }
1179
1180   return *this;
1181 }
1182
1183 // This member function does not construct a sentry object, because
1184 // it is called from sentry's constructor.
1185 template <class _CharT, class _Traits>
1186 void basic_istream<_CharT, _Traits>::_M_skip_whitespace(bool __set_failbit) {
1187   basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
1188   if (!__buf)
1189     this->setstate(ios_base::badbit);
1190   else if (__buf->gptr() != __buf->egptr())
1191     _M_ignore_buffered(this,  __buf,
1192                        _STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()),
1193                        _STLP_PRIV _Scan_for_not_wspace<_Traits>(this->_M_ctype_facet()),
1194                        false, __set_failbit);
1195   else
1196     _M_ignore_unbuffered(this,  __buf,
1197                          _STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()),
1198                          false, __set_failbit);
1199 }
1200
1201
1202 // This is a very simple loop that reads characters from __src and puts
1203 // them into __dest.  It looks complicated because of the (standard-
1204 // mandated) exception handling policy.
1205 //
1206 // We stop when we get an exception, when we fail to insert into the
1207 // output streambuf, or when __is_delim is true.
1208
1209 _STLP_MOVE_TO_PRIV_NAMESPACE
1210
1211 template < class _CharT, class _Traits, class _Is_Delim>
1212 streamsize _STLP_CALL
1213 __copy_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src,
1214                   basic_streambuf<_CharT, _Traits>* __dest,
1215                   _Is_Delim __is_delim,
1216                   bool __extract_delim, bool __rethrow) {
1217   streamsize __extracted = 0;
1218   ios_base::iostate __status = 0;
1219   typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
1220   int_type __c;
1221
1222   _STLP_TRY {
1223     for (;;) {
1224       // Get a character. If there's an exception, catch and (maybe) rethrow it.
1225       __c = __src->sbumpc();
1226
1227       // If we failed to get a character, then quit.
1228       if (__that->_S_eof(__c)) {
1229         __status |= ios_base::eofbit;
1230         break;
1231       }
1232       // If it's the delimiter, then quit.
1233       else if (__is_delim(_Traits::to_char_type(__c))) {
1234         if (!__extract_delim && !__pushback(__src, _Traits::to_char_type(__c)))
1235           __status |= ios_base::failbit;
1236         break;
1237       }
1238       else {
1239         // Try to put the character in the output streambuf.
1240         bool __failed = false;
1241         _STLP_TRY {
1242           if (!__that->_S_eof(__dest->sputc(_Traits::to_char_type(__c))))
1243             ++__extracted;
1244           else
1245             __failed = true;
1246         }
1247         _STLP_CATCH_ALL {
1248           __failed = true;
1249         }
1250
1251         // If we failed to put the character in the output streambuf, then
1252         // try to push it back to the input streambuf.
1253         if (__failed && !__pushback(__src, _Traits::to_char_type(__c)))
1254           __status |= ios_base::failbit;
1255
1256         // fbp : avoiding infinite loop in io-27-6-1-2-3.exp
1257         if (__failed)
1258           break;
1259       }
1260
1261     } /* for (;;) */
1262
1263   }
1264   // fbp : this try/catch moved here in reasonable assumption
1265   // __is_delim never throw (__pushback is guaranteed not to)
1266   _STLP_CATCH_ALL {
1267     // See 27.6.1.2.3, paragraph 13.
1268     if (__rethrow && __extracted == 0)
1269       __that->_M_handle_exception(ios_base::failbit);
1270   }
1271   __that->setstate(__status);
1272   return __extracted;
1273 }
1274
1275 // Buffered copying from one streambuf to another.  We copy the characters
1276 // in chunks, rather than one at a time.  We still have to worry about all
1277 // of the error conditions we checked in __copy_unbuffered, plus one more:
1278 // the streambuf might decide to switch from a buffered to an unbuffered mode.
1279
1280 template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
1281 streamsize _STLP_CALL
1282 __copy_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src,
1283                 basic_streambuf<_CharT, _Traits>* __dest,
1284                 _Scan_Delim __scan_delim, _Is_Delim __is_delim,
1285                 bool __extract_delim, bool __rethrow) {
1286   streamsize __extracted = 0;
1287   ios_base::iostate __status = 0;
1288   typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
1289   //Borland compiler generates a warning if assignment because value is never used:
1290   int_type __c /*= _Traits::eof()*/;
1291   _CharT* __first = __src->_M_gptr();
1292   ptrdiff_t __avail = __src->_M_egptr() - __first;
1293   // fbp : introduced to move catch/try blocks out of the loop
1294   bool __do_handle_exceptions = false;
1295
1296   _STLP_TRY {
1297     for (;;) {
1298       const _CharT* __last = __scan_delim(__first, __src->_M_egptr());
1299
1300       // Try to copy the entire input buffer to the output buffer.
1301       streamsize __n = __dest->sputn(__first, __extract_delim && __last != __src->_M_egptr()
1302                                      ? (__last - __first) + 1
1303                                      : (__last - __first));
1304       __src->_M_gbump((int)__n);
1305       __extracted += __n;
1306
1307       // from this on, catch() will call _M_handle_exceptions()
1308       __do_handle_exceptions = true;
1309
1310       if (__n < __avail)          // We found the delimiter, or else failed to
1311         break;                    // copy some characters.
1312
1313       __c = __src->sgetc();
1314
1315       // Three possibilities: we succeeded in refilling the buffer, or
1316       // we got EOF, or the streambuf has switched to unbuffered mode.
1317       __first = __src->_M_gptr();
1318       __avail = __src->_M_egptr() - __first;
1319
1320       if (__avail > 0)
1321         {}  // dwa 1/16/00 -- suppress a Metrowerks warning
1322       else if (__that->_S_eof(__c)) {
1323         __status |= ios_base::eofbit;
1324         break;
1325       }
1326       else {
1327         return __extracted + __copy_unbuffered(__that,  __src, __dest, __is_delim,
1328                                                 __extract_delim, __rethrow);
1329       }
1330
1331       __do_handle_exceptions = false;
1332     }
1333   }
1334
1335   _STLP_CATCH_ALL {
1336     // See 27.6.1.2.3, paragraph 13.
1337     if (__rethrow && __do_handle_exceptions &&  __extracted == 0)
1338       __that->_M_handle_exception(ios_base::failbit);
1339   }
1340
1341   if (__status)
1342     __that->setstate(__status);   // This might throw.
1343   return __extracted;
1344 }
1345
1346 _STLP_MOVE_TO_STD_NAMESPACE
1347
1348 template <class _CharT, class _Traits>
1349 basic_istream<_CharT, _Traits>&
1350 basic_istream<_CharT, _Traits>
1351   ::get(basic_streambuf<_CharT, _Traits>& __dest, _CharT __delim) {
1352   sentry __sentry(*this, _No_Skip_WS());
1353   this->_M_gcount = 0;
1354
1355   if (__sentry) {
1356     basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
1357
1358     if (__src)
1359       this->_M_gcount = __src->egptr() != __src->gptr()
1360         ? _STLP_PRIV __copy_buffered(this,  __src, &__dest,
1361                                      _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
1362                                      _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
1363                                      false, false)
1364         : _STLP_PRIV __copy_unbuffered(this,  __src, &__dest,
1365                                        _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
1366                                        false, false);
1367   }
1368
1369   if (this->_M_gcount == 0)
1370     this->setstate(ios_base::failbit);
1371
1372   return *this;
1373 }
1374
1375 // Copying characters into a streambuf.
1376 template <class _CharT, class _Traits>
1377 basic_istream<_CharT, _Traits>&
1378 basic_istream<_CharT, _Traits>
1379   ::operator>>(basic_streambuf<_CharT, _Traits>* __dest) {
1380   streamsize __n = 0;
1381   typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
1382   _Sentry __sentry(*this);
1383   if (__sentry) {
1384     basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
1385     if (__src && __dest)
1386       __n = __src->egptr() != __src->gptr()
1387         ? _STLP_PRIV __copy_buffered(this,  __src, __dest,
1388                                      _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
1389                                      _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
1390                                      false, true)
1391         : _STLP_PRIV __copy_unbuffered(this,  __src, __dest,
1392                                        _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
1393                                        false, true);
1394   }
1395
1396   if (__n == 0)
1397     this->setstate(ios_base::failbit);
1398
1399   return *this;
1400 }
1401
1402 // ----------------------------------------------------------------
1403 // basic_iostream<> class
1404 // ----------------------------------------------------------------
1405
1406 template <class _CharT, class _Traits>
1407 basic_iostream<_CharT, _Traits>
1408   ::basic_iostream(basic_streambuf<_CharT, _Traits>* __buf)
1409     : basic_ios<_CharT, _Traits>(),
1410       basic_istream<_CharT, _Traits>(__buf),
1411       basic_ostream<_CharT, _Traits>(__buf) {
1412   this->init(__buf);
1413 }
1414
1415 template <class _CharT, class _Traits>
1416 basic_iostream<_CharT, _Traits>::~basic_iostream()
1417 {}
1418
1419 _STLP_END_NAMESPACE
1420
1421 #undef __BIS_int_type__
1422 #undef __BIS_pos_type__
1423 #undef __BIS_off_type__
1424
1425 #endif /* _STLP_ISTREAM_C */
1426
1427 // Local Variables:
1428 // mode:C++
1429 // End: