istream.tcc revision 256281
1227825Stheraven// istream classes -*- C++ -*- 2227825Stheraven 3227825Stheraven// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4227825Stheraven// 2006, 2007 5227825Stheraven// Free Software Foundation, Inc. 6227825Stheraven// 7227825Stheraven// This file is part of the GNU ISO C++ Library. This library is free 8227825Stheraven// software; you can redistribute it and/or modify it under the 9227825Stheraven// terms of the GNU General Public License as published by the 10227825Stheraven// Free Software Foundation; either version 2, or (at your option) 11227825Stheraven// any later version. 12227825Stheraven 13227825Stheraven// This library is distributed in the hope that it will be useful, 14227825Stheraven// but WITHOUT ANY WARRANTY; without even the implied warranty of 15227825Stheraven// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16227825Stheraven// GNU General Public License for more details. 17227825Stheraven 18227825Stheraven// You should have received a copy of the GNU General Public License along 19227825Stheraven// with this library; see the file COPYING. If not, write to the Free 20227825Stheraven// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 21227825Stheraven// USA. 22227825Stheraven 23227825Stheraven// As a special exception, you may use this file as part of a free software 24227825Stheraven// library without restriction. Specifically, if other files instantiate 25227825Stheraven// templates or use macros or inline functions from this file, or you compile 26227825Stheraven// this file and link it with other files to produce an executable, this 27227825Stheraven// file does not by itself cause the resulting executable to be covered by 28227825Stheraven// the GNU General Public License. This exception does not however 29227825Stheraven// invalidate any other reasons why the executable file might be covered by 30227825Stheraven// the GNU General Public License. 31227825Stheraven 32227825Stheraven/** @file istream.tcc 33227825Stheraven * This is an internal header file, included by other library headers. 34227825Stheraven * You should not attempt to use it directly. 35227825Stheraven */ 36227825Stheraven 37227825Stheraven// 38227825Stheraven// ISO C++ 14882: 27.6.1 Input streams 39227825Stheraven// 40227825Stheraven 41227825Stheraven#ifndef _ISTREAM_TCC 42227825Stheraven#define _ISTREAM_TCC 1 43227825Stheraven 44227825Stheraven#pragma GCC system_header 45227825Stheraven 46227825Stheraven#include <locale> 47227825Stheraven#include <ostream> // For flush() 48227825Stheraven 49227825Stheraven_GLIBCXX_BEGIN_NAMESPACE(std) 50227825Stheraven 51227825Stheraven template<typename _CharT, typename _Traits> 52227825Stheraven basic_istream<_CharT, _Traits>::sentry:: 53227825Stheraven sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) 54227825Stheraven { 55227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 56227825Stheraven if (__in.good()) 57227825Stheraven { 58227825Stheraven if (__in.tie()) 59227825Stheraven __in.tie()->flush(); 60227825Stheraven if (!__noskip && (__in.flags() & ios_base::skipws)) 61227825Stheraven { 62227825Stheraven const __int_type __eof = traits_type::eof(); 63227825Stheraven __streambuf_type* __sb = __in.rdbuf(); 64227825Stheraven __int_type __c = __sb->sgetc(); 65227825Stheraven 66227825Stheraven const __ctype_type& __ct = __check_facet(__in._M_ctype); 67227825Stheraven while (!traits_type::eq_int_type(__c, __eof) 68227825Stheraven && __ct.is(ctype_base::space, 69227825Stheraven traits_type::to_char_type(__c))) 70227825Stheraven __c = __sb->snextc(); 71227825Stheraven 72227825Stheraven // _GLIBCXX_RESOLVE_LIB_DEFECTS 73227825Stheraven // 195. Should basic_istream::sentry's constructor ever 74227825Stheraven // set eofbit? 75227825Stheraven if (traits_type::eq_int_type(__c, __eof)) 76227825Stheraven __err |= ios_base::eofbit; 77227825Stheraven } 78227825Stheraven } 79227825Stheraven 80227825Stheraven if (__in.good() && __err == ios_base::goodbit) 81227825Stheraven _M_ok = true; 82227825Stheraven else 83227825Stheraven { 84227825Stheraven __err |= ios_base::failbit; 85227825Stheraven __in.setstate(__err); 86227825Stheraven } 87227825Stheraven } 88227825Stheraven 89227825Stheraven template<typename _CharT, typename _Traits> 90227825Stheraven template<typename _ValueT> 91227825Stheraven basic_istream<_CharT, _Traits>& 92227825Stheraven basic_istream<_CharT, _Traits>:: 93227825Stheraven _M_extract(_ValueT& __v) 94227825Stheraven { 95227825Stheraven sentry __cerb(*this, false); 96227825Stheraven if (__cerb) 97227825Stheraven { 98227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 99227825Stheraven try 100227825Stheraven { 101227825Stheraven const __num_get_type& __ng = __check_facet(this->_M_num_get); 102227825Stheraven __ng.get(*this, 0, *this, __err, __v); 103227825Stheraven } 104227825Stheraven catch(...) 105227825Stheraven { this->_M_setstate(ios_base::badbit); } 106227825Stheraven if (__err) 107227825Stheraven this->setstate(__err); 108227825Stheraven } 109227825Stheraven return *this; 110227825Stheraven } 111227825Stheraven 112227825Stheraven template<typename _CharT, typename _Traits> 113227825Stheraven basic_istream<_CharT, _Traits>& 114227825Stheraven basic_istream<_CharT, _Traits>:: 115227825Stheraven operator>>(short& __n) 116227825Stheraven { 117227825Stheraven // _GLIBCXX_RESOLVE_LIB_DEFECTS 118227825Stheraven // 118. basic_istream uses nonexistent num_get member functions. 119227825Stheraven long __l; 120227825Stheraven _M_extract(__l); 121227825Stheraven if (!this->fail()) 122227825Stheraven { 123227825Stheraven if (numeric_limits<short>::min() <= __l 124227825Stheraven && __l <= numeric_limits<short>::max()) 125227825Stheraven __n = __l; 126227825Stheraven else 127227825Stheraven this->setstate(ios_base::failbit); 128227825Stheraven } 129227825Stheraven return *this; 130227825Stheraven } 131227825Stheraven 132227825Stheraven template<typename _CharT, typename _Traits> 133227825Stheraven basic_istream<_CharT, _Traits>& 134227825Stheraven basic_istream<_CharT, _Traits>:: 135227825Stheraven operator>>(int& __n) 136227825Stheraven { 137227825Stheraven // _GLIBCXX_RESOLVE_LIB_DEFECTS 138227825Stheraven // 118. basic_istream uses nonexistent num_get member functions. 139227825Stheraven long __l; 140227825Stheraven _M_extract(__l); 141227825Stheraven if (!this->fail()) 142227825Stheraven { 143227825Stheraven if (numeric_limits<int>::min() <= __l 144227825Stheraven && __l <= numeric_limits<int>::max()) 145227825Stheraven __n = __l; 146227825Stheraven else 147227825Stheraven this->setstate(ios_base::failbit); 148227825Stheraven } 149227825Stheraven return *this; 150227825Stheraven } 151227825Stheraven 152227825Stheraven template<typename _CharT, typename _Traits> 153227825Stheraven basic_istream<_CharT, _Traits>& 154227825Stheraven basic_istream<_CharT, _Traits>:: 155227825Stheraven operator>>(__streambuf_type* __sbout) 156227825Stheraven { 157227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 158227825Stheraven sentry __cerb(*this, false); 159227825Stheraven if (__cerb && __sbout) 160227825Stheraven { 161227825Stheraven try 162227825Stheraven { 163227825Stheraven bool __ineof; 164227825Stheraven if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) 165227825Stheraven __err |= ios_base::failbit; 166227825Stheraven if (__ineof) 167227825Stheraven __err |= ios_base::eofbit; 168227825Stheraven } 169227825Stheraven catch(...) 170227825Stheraven { this->_M_setstate(ios_base::failbit); } 171227825Stheraven } 172227825Stheraven else if (!__sbout) 173227825Stheraven __err |= ios_base::failbit; 174227825Stheraven if (__err) 175227825Stheraven this->setstate(__err); 176227825Stheraven return *this; 177227825Stheraven } 178227825Stheraven 179227825Stheraven template<typename _CharT, typename _Traits> 180227825Stheraven typename basic_istream<_CharT, _Traits>::int_type 181227825Stheraven basic_istream<_CharT, _Traits>:: 182227825Stheraven get(void) 183227825Stheraven { 184227825Stheraven const int_type __eof = traits_type::eof(); 185227825Stheraven int_type __c = __eof; 186227825Stheraven _M_gcount = 0; 187227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 188227825Stheraven sentry __cerb(*this, true); 189227825Stheraven if (__cerb) 190227825Stheraven { 191227825Stheraven try 192227825Stheraven { 193227825Stheraven __c = this->rdbuf()->sbumpc(); 194227825Stheraven // 27.6.1.1 paragraph 3 195227825Stheraven if (!traits_type::eq_int_type(__c, __eof)) 196227825Stheraven _M_gcount = 1; 197227825Stheraven else 198227825Stheraven __err |= ios_base::eofbit; 199227825Stheraven } 200227825Stheraven catch(...) 201227825Stheraven { this->_M_setstate(ios_base::badbit); } 202227825Stheraven } 203227825Stheraven if (!_M_gcount) 204227825Stheraven __err |= ios_base::failbit; 205227825Stheraven if (__err) 206227825Stheraven this->setstate(__err); 207227825Stheraven return __c; 208227825Stheraven } 209227825Stheraven 210227825Stheraven template<typename _CharT, typename _Traits> 211227825Stheraven basic_istream<_CharT, _Traits>& 212227825Stheraven basic_istream<_CharT, _Traits>:: 213227825Stheraven get(char_type& __c) 214227825Stheraven { 215227825Stheraven _M_gcount = 0; 216227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 217227825Stheraven sentry __cerb(*this, true); 218227825Stheraven if (__cerb) 219227825Stheraven { 220227825Stheraven try 221227825Stheraven { 222227825Stheraven const int_type __cb = this->rdbuf()->sbumpc(); 223227825Stheraven // 27.6.1.1 paragraph 3 224227825Stheraven if (!traits_type::eq_int_type(__cb, traits_type::eof())) 225227825Stheraven { 226227825Stheraven _M_gcount = 1; 227227825Stheraven __c = traits_type::to_char_type(__cb); 228227825Stheraven } 229227825Stheraven else 230227825Stheraven __err |= ios_base::eofbit; 231227825Stheraven } 232227825Stheraven catch(...) 233227825Stheraven { this->_M_setstate(ios_base::badbit); } 234227825Stheraven } 235227825Stheraven if (!_M_gcount) 236227825Stheraven __err |= ios_base::failbit; 237227825Stheraven if (__err) 238227825Stheraven this->setstate(__err); 239227825Stheraven return *this; 240227825Stheraven } 241227825Stheraven 242227825Stheraven template<typename _CharT, typename _Traits> 243227825Stheraven basic_istream<_CharT, _Traits>& 244227825Stheraven basic_istream<_CharT, _Traits>:: 245227825Stheraven get(char_type* __s, streamsize __n, char_type __delim) 246227825Stheraven { 247227825Stheraven _M_gcount = 0; 248227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 249227825Stheraven sentry __cerb(*this, true); 250227825Stheraven if (__cerb) 251227825Stheraven { 252227825Stheraven try 253227825Stheraven { 254227825Stheraven const int_type __idelim = traits_type::to_int_type(__delim); 255227825Stheraven const int_type __eof = traits_type::eof(); 256227825Stheraven __streambuf_type* __sb = this->rdbuf(); 257227825Stheraven int_type __c = __sb->sgetc(); 258227825Stheraven 259227825Stheraven while (_M_gcount + 1 < __n 260227825Stheraven && !traits_type::eq_int_type(__c, __eof) 261227825Stheraven && !traits_type::eq_int_type(__c, __idelim)) 262227825Stheraven { 263227825Stheraven *__s++ = traits_type::to_char_type(__c); 264227825Stheraven ++_M_gcount; 265227825Stheraven __c = __sb->snextc(); 266227825Stheraven } 267227825Stheraven if (traits_type::eq_int_type(__c, __eof)) 268227825Stheraven __err |= ios_base::eofbit; 269227825Stheraven } 270227825Stheraven catch(...) 271227825Stheraven { this->_M_setstate(ios_base::badbit); } 272227825Stheraven } 273227825Stheraven // _GLIBCXX_RESOLVE_LIB_DEFECTS 274227825Stheraven // 243. get and getline when sentry reports failure. 275227825Stheraven if (__n > 0) 276227825Stheraven *__s = char_type(); 277227825Stheraven if (!_M_gcount) 278227825Stheraven __err |= ios_base::failbit; 279227825Stheraven if (__err) 280227825Stheraven this->setstate(__err); 281227825Stheraven return *this; 282227825Stheraven } 283227825Stheraven 284227825Stheraven template<typename _CharT, typename _Traits> 285227825Stheraven basic_istream<_CharT, _Traits>& 286227825Stheraven basic_istream<_CharT, _Traits>:: 287227825Stheraven get(__streambuf_type& __sb, char_type __delim) 288227825Stheraven { 289227825Stheraven _M_gcount = 0; 290227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 291227825Stheraven sentry __cerb(*this, true); 292227825Stheraven if (__cerb) 293227825Stheraven { 294227825Stheraven try 295227825Stheraven { 296227825Stheraven const int_type __idelim = traits_type::to_int_type(__delim); 297227825Stheraven const int_type __eof = traits_type::eof(); 298227825Stheraven __streambuf_type* __this_sb = this->rdbuf(); 299227825Stheraven int_type __c = __this_sb->sgetc(); 300227825Stheraven char_type __c2 = traits_type::to_char_type(__c); 301227825Stheraven 302227825Stheraven while (!traits_type::eq_int_type(__c, __eof) 303227825Stheraven && !traits_type::eq_int_type(__c, __idelim) 304227825Stheraven && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) 305227825Stheraven { 306227825Stheraven ++_M_gcount; 307227825Stheraven __c = __this_sb->snextc(); 308227825Stheraven __c2 = traits_type::to_char_type(__c); 309227825Stheraven } 310227825Stheraven if (traits_type::eq_int_type(__c, __eof)) 311227825Stheraven __err |= ios_base::eofbit; 312227825Stheraven } 313227825Stheraven catch(...) 314227825Stheraven { this->_M_setstate(ios_base::badbit); } 315227825Stheraven } 316227825Stheraven if (!_M_gcount) 317227825Stheraven __err |= ios_base::failbit; 318227825Stheraven if (__err) 319227825Stheraven this->setstate(__err); 320227825Stheraven return *this; 321227825Stheraven } 322227825Stheraven 323227825Stheraven template<typename _CharT, typename _Traits> 324227825Stheraven basic_istream<_CharT, _Traits>& 325227825Stheraven basic_istream<_CharT, _Traits>:: 326227825Stheraven getline(char_type* __s, streamsize __n, char_type __delim) 327227825Stheraven { 328227825Stheraven _M_gcount = 0; 329227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 330227825Stheraven sentry __cerb(*this, true); 331227825Stheraven if (__cerb) 332227825Stheraven { 333227825Stheraven try 334227825Stheraven { 335227825Stheraven const int_type __idelim = traits_type::to_int_type(__delim); 336227825Stheraven const int_type __eof = traits_type::eof(); 337227825Stheraven __streambuf_type* __sb = this->rdbuf(); 338227825Stheraven int_type __c = __sb->sgetc(); 339227825Stheraven 340227825Stheraven while (_M_gcount + 1 < __n 341227825Stheraven && !traits_type::eq_int_type(__c, __eof) 342227825Stheraven && !traits_type::eq_int_type(__c, __idelim)) 343227825Stheraven { 344227825Stheraven *__s++ = traits_type::to_char_type(__c); 345227825Stheraven __c = __sb->snextc(); 346227825Stheraven ++_M_gcount; 347227825Stheraven } 348227825Stheraven if (traits_type::eq_int_type(__c, __eof)) 349227825Stheraven __err |= ios_base::eofbit; 350227825Stheraven else 351227825Stheraven { 352227825Stheraven if (traits_type::eq_int_type(__c, __idelim)) 353227825Stheraven { 354227825Stheraven __sb->sbumpc(); 355227825Stheraven ++_M_gcount; 356227825Stheraven } 357227825Stheraven else 358227825Stheraven __err |= ios_base::failbit; 359227825Stheraven } 360227825Stheraven } 361227825Stheraven catch(...) 362227825Stheraven { this->_M_setstate(ios_base::badbit); } 363227825Stheraven } 364227825Stheraven // _GLIBCXX_RESOLVE_LIB_DEFECTS 365227825Stheraven // 243. get and getline when sentry reports failure. 366227825Stheraven if (__n > 0) 367227825Stheraven *__s = char_type(); 368227825Stheraven if (!_M_gcount) 369227825Stheraven __err |= ios_base::failbit; 370227825Stheraven if (__err) 371227825Stheraven this->setstate(__err); 372227825Stheraven return *this; 373227825Stheraven } 374227825Stheraven 375227825Stheraven // We provide three overloads, since the first two are much simpler 376227825Stheraven // than the general case. Also, the latter two can thus adopt the 377227825Stheraven // same "batchy" strategy used by getline above. 378227825Stheraven template<typename _CharT, typename _Traits> 379227825Stheraven basic_istream<_CharT, _Traits>& 380227825Stheraven basic_istream<_CharT, _Traits>:: 381227825Stheraven ignore(void) 382227825Stheraven { 383227825Stheraven _M_gcount = 0; 384227825Stheraven sentry __cerb(*this, true); 385227825Stheraven if (__cerb) 386227825Stheraven { 387227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 388227825Stheraven try 389227825Stheraven { 390227825Stheraven const int_type __eof = traits_type::eof(); 391227825Stheraven __streambuf_type* __sb = this->rdbuf(); 392227825Stheraven 393227825Stheraven if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) 394227825Stheraven __err |= ios_base::eofbit; 395227825Stheraven else 396227825Stheraven _M_gcount = 1; 397227825Stheraven } 398227825Stheraven catch(...) 399227825Stheraven { this->_M_setstate(ios_base::badbit); } 400227825Stheraven if (__err) 401227825Stheraven this->setstate(__err); 402227825Stheraven } 403227825Stheraven return *this; 404227825Stheraven } 405227825Stheraven 406227825Stheraven template<typename _CharT, typename _Traits> 407227825Stheraven basic_istream<_CharT, _Traits>& 408227825Stheraven basic_istream<_CharT, _Traits>:: 409227825Stheraven ignore(streamsize __n) 410227825Stheraven { 411227825Stheraven _M_gcount = 0; 412227825Stheraven sentry __cerb(*this, true); 413227825Stheraven if (__cerb && __n > 0) 414227825Stheraven { 415227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 416227825Stheraven try 417227825Stheraven { 418227825Stheraven const int_type __eof = traits_type::eof(); 419227825Stheraven __streambuf_type* __sb = this->rdbuf(); 420227825Stheraven int_type __c = __sb->sgetc(); 421227825Stheraven 422227825Stheraven // N.B. On LFS-enabled platforms streamsize is still 32 bits 423227825Stheraven // wide: if we want to implement the standard mandated behavior 424227825Stheraven // for n == max() (see 27.6.1.3/24) we are at risk of signed 425227825Stheraven // integer overflow: thus these contortions. Also note that, 426227825Stheraven // by definition, when more than 2G chars are actually ignored, 427227825Stheraven // _M_gcount (the return value of gcount, that is) cannot be 428227825Stheraven // really correct, being unavoidably too small. 429227825Stheraven bool __large_ignore = false; 430227825Stheraven while (true) 431227825Stheraven { 432227825Stheraven while (_M_gcount < __n 433227825Stheraven && !traits_type::eq_int_type(__c, __eof)) 434227825Stheraven { 435227825Stheraven ++_M_gcount; 436227825Stheraven __c = __sb->snextc(); 437227825Stheraven } 438227825Stheraven if (__n == numeric_limits<streamsize>::max() 439227825Stheraven && !traits_type::eq_int_type(__c, __eof)) 440227825Stheraven { 441227825Stheraven _M_gcount = numeric_limits<streamsize>::min(); 442227825Stheraven __large_ignore = true; 443227825Stheraven } 444227825Stheraven else 445227825Stheraven break; 446227825Stheraven } 447227825Stheraven 448227825Stheraven if (__large_ignore) 449227825Stheraven _M_gcount = numeric_limits<streamsize>::max(); 450227825Stheraven 451227825Stheraven if (traits_type::eq_int_type(__c, __eof)) 452227825Stheraven __err |= ios_base::eofbit; 453227825Stheraven } 454227825Stheraven catch(...) 455227825Stheraven { this->_M_setstate(ios_base::badbit); } 456227825Stheraven if (__err) 457227825Stheraven this->setstate(__err); 458227825Stheraven } 459227825Stheraven return *this; 460227825Stheraven } 461227825Stheraven 462227825Stheraven template<typename _CharT, typename _Traits> 463227825Stheraven basic_istream<_CharT, _Traits>& 464227825Stheraven basic_istream<_CharT, _Traits>:: 465227825Stheraven ignore(streamsize __n, int_type __delim) 466227825Stheraven { 467227825Stheraven _M_gcount = 0; 468227825Stheraven sentry __cerb(*this, true); 469227825Stheraven if (__cerb && __n > 0) 470227825Stheraven { 471227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 472227825Stheraven try 473227825Stheraven { 474227825Stheraven const int_type __eof = traits_type::eof(); 475227825Stheraven __streambuf_type* __sb = this->rdbuf(); 476227825Stheraven int_type __c = __sb->sgetc(); 477227825Stheraven 478227825Stheraven // See comment above. 479227825Stheraven bool __large_ignore = false; 480227825Stheraven while (true) 481227825Stheraven { 482227825Stheraven while (_M_gcount < __n 483227825Stheraven && !traits_type::eq_int_type(__c, __eof) 484227825Stheraven && !traits_type::eq_int_type(__c, __delim)) 485227825Stheraven { 486227825Stheraven ++_M_gcount; 487227825Stheraven __c = __sb->snextc(); 488227825Stheraven } 489227825Stheraven if (__n == numeric_limits<streamsize>::max() 490227825Stheraven && !traits_type::eq_int_type(__c, __eof) 491227825Stheraven && !traits_type::eq_int_type(__c, __delim)) 492227825Stheraven { 493227825Stheraven _M_gcount = numeric_limits<streamsize>::min(); 494227825Stheraven __large_ignore = true; 495227825Stheraven } 496227825Stheraven else 497227825Stheraven break; 498227825Stheraven } 499227825Stheraven 500227825Stheraven if (__large_ignore) 501227825Stheraven _M_gcount = numeric_limits<streamsize>::max(); 502227825Stheraven 503227825Stheraven if (traits_type::eq_int_type(__c, __eof)) 504227825Stheraven __err |= ios_base::eofbit; 505227825Stheraven else if (traits_type::eq_int_type(__c, __delim)) 506227825Stheraven { 507227825Stheraven if (_M_gcount < numeric_limits<streamsize>::max()) 508227825Stheraven ++_M_gcount; 509227825Stheraven __sb->sbumpc(); 510227825Stheraven } 511227825Stheraven } 512227825Stheraven catch(...) 513227825Stheraven { this->_M_setstate(ios_base::badbit); } 514227825Stheraven if (__err) 515227825Stheraven this->setstate(__err); 516227825Stheraven } 517227825Stheraven return *this; 518227825Stheraven } 519227825Stheraven 520227825Stheraven template<typename _CharT, typename _Traits> 521227825Stheraven typename basic_istream<_CharT, _Traits>::int_type 522227825Stheraven basic_istream<_CharT, _Traits>:: 523227825Stheraven peek(void) 524227825Stheraven { 525227825Stheraven int_type __c = traits_type::eof(); 526227825Stheraven _M_gcount = 0; 527227825Stheraven sentry __cerb(*this, true); 528227825Stheraven if (__cerb) 529227825Stheraven { 530227825Stheraven ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 531227825Stheraven try 532227825Stheraven { 533227825Stheraven __c = this->rdbuf()->sgetc(); 534227825Stheraven if (traits_type::eq_int_type(__c, traits_type::eof())) 535227825Stheraven __err |= ios_base::eofbit; 536227825Stheraven } 537227825Stheraven catch(...) 538227825Stheraven { this->_M_setstate(ios_base::badbit); } 539227825Stheraven if (__err) 540227825Stheraven this->setstate(__err); 541227825Stheraven } 542227825Stheraven return __c; 543227825Stheraven } 544227825Stheraven 545227825Stheraven template<typename _CharT, typename _Traits> 546227825Stheraven basic_istream<_CharT, _Traits>& 547227825Stheraven basic_istream<_CharT, _Traits>:: 548 read(char_type* __s, streamsize __n) 549 { 550 _M_gcount = 0; 551 sentry __cerb(*this, true); 552 if (__cerb) 553 { 554 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 555 try 556 { 557 _M_gcount = this->rdbuf()->sgetn(__s, __n); 558 if (_M_gcount != __n) 559 __err |= (ios_base::eofbit | ios_base::failbit); 560 } 561 catch(...) 562 { this->_M_setstate(ios_base::badbit); } 563 if (__err) 564 this->setstate(__err); 565 } 566 return *this; 567 } 568 569 template<typename _CharT, typename _Traits> 570 streamsize 571 basic_istream<_CharT, _Traits>:: 572 readsome(char_type* __s, streamsize __n) 573 { 574 _M_gcount = 0; 575 sentry __cerb(*this, true); 576 if (__cerb) 577 { 578 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 579 try 580 { 581 // Cannot compare int_type with streamsize generically. 582 const streamsize __num = this->rdbuf()->in_avail(); 583 if (__num > 0) 584 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); 585 else if (__num == -1) 586 __err |= ios_base::eofbit; 587 } 588 catch(...) 589 { this->_M_setstate(ios_base::badbit); } 590 if (__err) 591 this->setstate(__err); 592 } 593 return _M_gcount; 594 } 595 596 template<typename _CharT, typename _Traits> 597 basic_istream<_CharT, _Traits>& 598 basic_istream<_CharT, _Traits>:: 599 putback(char_type __c) 600 { 601 // _GLIBCXX_RESOLVE_LIB_DEFECTS 602 // 60. What is a formatted input function? 603 _M_gcount = 0; 604 sentry __cerb(*this, true); 605 if (__cerb) 606 { 607 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 608 try 609 { 610 const int_type __eof = traits_type::eof(); 611 __streambuf_type* __sb = this->rdbuf(); 612 if (!__sb 613 || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) 614 __err |= ios_base::badbit; 615 } 616 catch(...) 617 { this->_M_setstate(ios_base::badbit); } 618 if (__err) 619 this->setstate(__err); 620 } 621 return *this; 622 } 623 624 template<typename _CharT, typename _Traits> 625 basic_istream<_CharT, _Traits>& 626 basic_istream<_CharT, _Traits>:: 627 unget(void) 628 { 629 // _GLIBCXX_RESOLVE_LIB_DEFECTS 630 // 60. What is a formatted input function? 631 _M_gcount = 0; 632 sentry __cerb(*this, true); 633 if (__cerb) 634 { 635 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 636 try 637 { 638 const int_type __eof = traits_type::eof(); 639 __streambuf_type* __sb = this->rdbuf(); 640 if (!__sb 641 || traits_type::eq_int_type(__sb->sungetc(), __eof)) 642 __err |= ios_base::badbit; 643 } 644 catch(...) 645 { this->_M_setstate(ios_base::badbit); } 646 if (__err) 647 this->setstate(__err); 648 } 649 return *this; 650 } 651 652 template<typename _CharT, typename _Traits> 653 int 654 basic_istream<_CharT, _Traits>:: 655 sync(void) 656 { 657 // _GLIBCXX_RESOLVE_LIB_DEFECTS 658 // DR60. Do not change _M_gcount. 659 int __ret = -1; 660 sentry __cerb(*this, true); 661 if (__cerb) 662 { 663 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 664 try 665 { 666 __streambuf_type* __sb = this->rdbuf(); 667 if (__sb) 668 { 669 if (__sb->pubsync() == -1) 670 __err |= ios_base::badbit; 671 else 672 __ret = 0; 673 } 674 } 675 catch(...) 676 { this->_M_setstate(ios_base::badbit); } 677 if (__err) 678 this->setstate(__err); 679 } 680 return __ret; 681 } 682 683 template<typename _CharT, typename _Traits> 684 typename basic_istream<_CharT, _Traits>::pos_type 685 basic_istream<_CharT, _Traits>:: 686 tellg(void) 687 { 688 // _GLIBCXX_RESOLVE_LIB_DEFECTS 689 // DR60. Do not change _M_gcount. 690 pos_type __ret = pos_type(-1); 691 try 692 { 693 if (!this->fail()) 694 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, 695 ios_base::in); 696 } 697 catch(...) 698 { this->_M_setstate(ios_base::badbit); } 699 return __ret; 700 } 701 702 template<typename _CharT, typename _Traits> 703 basic_istream<_CharT, _Traits>& 704 basic_istream<_CharT, _Traits>:: 705 seekg(pos_type __pos) 706 { 707 // _GLIBCXX_RESOLVE_LIB_DEFECTS 708 // DR60. Do not change _M_gcount. 709 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 710 try 711 { 712 if (!this->fail()) 713 { 714 // 136. seekp, seekg setting wrong streams? 715 const pos_type __p = this->rdbuf()->pubseekpos(__pos, 716 ios_base::in); 717 718 // 129. Need error indication from seekp() and seekg() 719 if (__p == pos_type(off_type(-1))) 720 __err |= ios_base::failbit; 721 } 722 } 723 catch(...) 724 { this->_M_setstate(ios_base::badbit); } 725 if (__err) 726 this->setstate(__err); 727 return *this; 728 } 729 730 template<typename _CharT, typename _Traits> 731 basic_istream<_CharT, _Traits>& 732 basic_istream<_CharT, _Traits>:: 733 seekg(off_type __off, ios_base::seekdir __dir) 734 { 735 // _GLIBCXX_RESOLVE_LIB_DEFECTS 736 // DR60. Do not change _M_gcount. 737 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 738 try 739 { 740 if (!this->fail()) 741 { 742 // 136. seekp, seekg setting wrong streams? 743 const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, 744 ios_base::in); 745 746 // 129. Need error indication from seekp() and seekg() 747 if (__p == pos_type(off_type(-1))) 748 __err |= ios_base::failbit; 749 } 750 } 751 catch(...) 752 { this->_M_setstate(ios_base::badbit); } 753 if (__err) 754 this->setstate(__err); 755 return *this; 756 } 757 758 // 27.6.1.2.3 Character extraction templates 759 template<typename _CharT, typename _Traits> 760 basic_istream<_CharT, _Traits>& 761 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) 762 { 763 typedef basic_istream<_CharT, _Traits> __istream_type; 764 typedef typename __istream_type::int_type __int_type; 765 766 typename __istream_type::sentry __cerb(__in, false); 767 if (__cerb) 768 { 769 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 770 try 771 { 772 const __int_type __cb = __in.rdbuf()->sbumpc(); 773 if (!_Traits::eq_int_type(__cb, _Traits::eof())) 774 __c = _Traits::to_char_type(__cb); 775 else 776 __err |= (ios_base::eofbit | ios_base::failbit); 777 } 778 catch(...) 779 { __in._M_setstate(ios_base::badbit); } 780 if (__err) 781 __in.setstate(__err); 782 } 783 return __in; 784 } 785 786 template<typename _CharT, typename _Traits> 787 basic_istream<_CharT, _Traits>& 788 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) 789 { 790 typedef basic_istream<_CharT, _Traits> __istream_type; 791 typedef typename __istream_type::__streambuf_type __streambuf_type; 792 typedef typename _Traits::int_type int_type; 793 typedef _CharT char_type; 794 typedef ctype<_CharT> __ctype_type; 795 796 streamsize __extracted = 0; 797 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 798 typename __istream_type::sentry __cerb(__in, false); 799 if (__cerb) 800 { 801 try 802 { 803 // Figure out how many characters to extract. 804 streamsize __num = __in.width(); 805 if (__num <= 0) 806 __num = numeric_limits<streamsize>::max(); 807 808 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 809 810 const int_type __eof = _Traits::eof(); 811 __streambuf_type* __sb = __in.rdbuf(); 812 int_type __c = __sb->sgetc(); 813 814 while (__extracted < __num - 1 815 && !_Traits::eq_int_type(__c, __eof) 816 && !__ct.is(ctype_base::space, 817 _Traits::to_char_type(__c))) 818 { 819 *__s++ = _Traits::to_char_type(__c); 820 ++__extracted; 821 __c = __sb->snextc(); 822 } 823 if (_Traits::eq_int_type(__c, __eof)) 824 __err |= ios_base::eofbit; 825 826 // _GLIBCXX_RESOLVE_LIB_DEFECTS 827 // 68. Extractors for char* should store null at end 828 *__s = char_type(); 829 __in.width(0); 830 } 831 catch(...) 832 { __in._M_setstate(ios_base::badbit); } 833 } 834 if (!__extracted) 835 __err |= ios_base::failbit; 836 if (__err) 837 __in.setstate(__err); 838 return __in; 839 } 840 841 // 27.6.1.4 Standard basic_istream manipulators 842 template<typename _CharT, typename _Traits> 843 basic_istream<_CharT,_Traits>& 844 ws(basic_istream<_CharT,_Traits>& __in) 845 { 846 typedef basic_istream<_CharT, _Traits> __istream_type; 847 typedef typename __istream_type::__streambuf_type __streambuf_type; 848 typedef typename __istream_type::__ctype_type __ctype_type; 849 typedef typename __istream_type::int_type __int_type; 850 851 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 852 const __int_type __eof = _Traits::eof(); 853 __streambuf_type* __sb = __in.rdbuf(); 854 __int_type __c = __sb->sgetc(); 855 856 while (!_Traits::eq_int_type(__c, __eof) 857 && __ct.is(ctype_base::space, _Traits::to_char_type(__c))) 858 __c = __sb->snextc(); 859 860 if (_Traits::eq_int_type(__c, __eof)) 861 __in.setstate(ios_base::eofbit); 862 return __in; 863 } 864 865 // 21.3.7.9 basic_string::getline and operators 866 template<typename _CharT, typename _Traits, typename _Alloc> 867 basic_istream<_CharT, _Traits>& 868 operator>>(basic_istream<_CharT, _Traits>& __in, 869 basic_string<_CharT, _Traits, _Alloc>& __str) 870 { 871 typedef basic_istream<_CharT, _Traits> __istream_type; 872 typedef typename __istream_type::int_type __int_type; 873 typedef typename __istream_type::__streambuf_type __streambuf_type; 874 typedef typename __istream_type::__ctype_type __ctype_type; 875 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 876 typedef typename __string_type::size_type __size_type; 877 878 __size_type __extracted = 0; 879 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 880 typename __istream_type::sentry __cerb(__in, false); 881 if (__cerb) 882 { 883 try 884 { 885 // Avoid reallocation for common case. 886 __str.erase(); 887 _CharT __buf[128]; 888 __size_type __len = 0; 889 const streamsize __w = __in.width(); 890 const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) 891 : __str.max_size(); 892 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 893 const __int_type __eof = _Traits::eof(); 894 __streambuf_type* __sb = __in.rdbuf(); 895 __int_type __c = __sb->sgetc(); 896 897 while (__extracted < __n 898 && !_Traits::eq_int_type(__c, __eof) 899 && !__ct.is(ctype_base::space, _Traits::to_char_type(__c))) 900 { 901 if (__len == sizeof(__buf) / sizeof(_CharT)) 902 { 903 __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); 904 __len = 0; 905 } 906 __buf[__len++] = _Traits::to_char_type(__c); 907 ++__extracted; 908 __c = __sb->snextc(); 909 } 910 __str.append(__buf, __len); 911 912 if (_Traits::eq_int_type(__c, __eof)) 913 __err |= ios_base::eofbit; 914 __in.width(0); 915 } 916 catch(...) 917 { 918 // _GLIBCXX_RESOLVE_LIB_DEFECTS 919 // 91. Description of operator>> and getline() for string<> 920 // might cause endless loop 921 __in._M_setstate(ios_base::badbit); 922 } 923 } 924 // 211. operator>>(istream&, string&) doesn't set failbit 925 if (!__extracted) 926 __err |= ios_base::failbit; 927 if (__err) 928 __in.setstate(__err); 929 return __in; 930 } 931 932 template<typename _CharT, typename _Traits, typename _Alloc> 933 basic_istream<_CharT, _Traits>& 934 getline(basic_istream<_CharT, _Traits>& __in, 935 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) 936 { 937 typedef basic_istream<_CharT, _Traits> __istream_type; 938 typedef typename __istream_type::int_type __int_type; 939 typedef typename __istream_type::__streambuf_type __streambuf_type; 940 typedef typename __istream_type::__ctype_type __ctype_type; 941 typedef basic_string<_CharT, _Traits, _Alloc> __string_type; 942 typedef typename __string_type::size_type __size_type; 943 944 __size_type __extracted = 0; 945 const __size_type __n = __str.max_size(); 946 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); 947 typename __istream_type::sentry __cerb(__in, true); 948 if (__cerb) 949 { 950 try 951 { 952 __str.erase(); 953 const __int_type __idelim = _Traits::to_int_type(__delim); 954 const __int_type __eof = _Traits::eof(); 955 __streambuf_type* __sb = __in.rdbuf(); 956 __int_type __c = __sb->sgetc(); 957 958 while (__extracted < __n 959 && !_Traits::eq_int_type(__c, __eof) 960 && !_Traits::eq_int_type(__c, __idelim)) 961 { 962 __str += _Traits::to_char_type(__c); 963 ++__extracted; 964 __c = __sb->snextc(); 965 } 966 967 if (_Traits::eq_int_type(__c, __eof)) 968 __err |= ios_base::eofbit; 969 else if (_Traits::eq_int_type(__c, __idelim)) 970 { 971 ++__extracted; 972 __sb->sbumpc(); 973 } 974 else 975 __err |= ios_base::failbit; 976 } 977 catch(...) 978 { 979 // _GLIBCXX_RESOLVE_LIB_DEFECTS 980 // 91. Description of operator>> and getline() for string<> 981 // might cause endless loop 982 __in._M_setstate(ios_base::badbit); 983 } 984 } 985 if (!__extracted) 986 __err |= ios_base::failbit; 987 if (__err) 988 __in.setstate(__err); 989 return __in; 990 } 991 992 // Inhibit implicit instantiations for required instantiations, 993 // which are defined via explicit instantiations elsewhere. 994 // NB: This syntax is a GNU extension. 995#if _GLIBCXX_EXTERN_TEMPLATE 996 extern template class basic_istream<char>; 997 extern template istream& ws(istream&); 998 extern template istream& operator>>(istream&, char&); 999 extern template istream& operator>>(istream&, char*); 1000 extern template istream& operator>>(istream&, unsigned char&); 1001 extern template istream& operator>>(istream&, signed char&); 1002 extern template istream& operator>>(istream&, unsigned char*); 1003 extern template istream& operator>>(istream&, signed char*); 1004 1005 extern template istream& istream::_M_extract(unsigned short&); 1006 extern template istream& istream::_M_extract(unsigned int&); 1007 extern template istream& istream::_M_extract(long&); 1008 extern template istream& istream::_M_extract(unsigned long&); 1009 extern template istream& istream::_M_extract(bool&); 1010#ifdef _GLIBCXX_USE_LONG_LONG 1011 extern template istream& istream::_M_extract(long long&); 1012 extern template istream& istream::_M_extract(unsigned long long&); 1013#endif 1014 extern template istream& istream::_M_extract(float&); 1015 extern template istream& istream::_M_extract(double&); 1016 extern template istream& istream::_M_extract(long double&); 1017 extern template istream& istream::_M_extract(void*&); 1018 1019 extern template class basic_iostream<char>; 1020 1021#ifdef _GLIBCXX_USE_WCHAR_T 1022 extern template class basic_istream<wchar_t>; 1023 extern template wistream& ws(wistream&); 1024 extern template wistream& operator>>(wistream&, wchar_t&); 1025 extern template wistream& operator>>(wistream&, wchar_t*); 1026 1027 extern template wistream& wistream::_M_extract(unsigned short&); 1028 extern template wistream& wistream::_M_extract(unsigned int&); 1029 extern template wistream& wistream::_M_extract(long&); 1030 extern template wistream& wistream::_M_extract(unsigned long&); 1031 extern template wistream& wistream::_M_extract(bool&); 1032#ifdef _GLIBCXX_USE_LONG_LONG 1033 extern template wistream& wistream::_M_extract(long long&); 1034 extern template wistream& wistream::_M_extract(unsigned long long&); 1035#endif 1036 extern template wistream& wistream::_M_extract(float&); 1037 extern template wistream& wistream::_M_extract(double&); 1038 extern template wistream& wistream::_M_extract(long double&); 1039 extern template wistream& wistream::_M_extract(void*&); 1040 1041 extern template class basic_iostream<wchar_t>; 1042#endif 1043#endif 1044 1045_GLIBCXX_END_NAMESPACE 1046 1047#endif 1048