[thirdparty/gcc.git] / libstdc++-v3 / src / c++98 / istream.cc

// Input streams -*- C++ -*-

// Copyright (C) 2004-2016 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

//
// ISO C++ 14882: 27.6.1  Input streams
//

#include <istream>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  template<>
    basic_istream<char>&
    basic_istream<char>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
	{
          __try
	    {
	      const int_type __idelim = traits_type::to_int_type(__delim);
	      const int_type __eof = traits_type::eof();
	      __streambuf_type* __sb = this->rdbuf();
	      int_type __c = __sb->sgetc();
	      
	      while (_M_gcount + 1 < __n
		     && !traits_type::eq_int_type(__c, __eof)
		     && !traits_type::eq_int_type(__c, __idelim))
		{
		  streamsize __size = std::min(streamsize(__sb->egptr()
							  - __sb->gptr()),
					       streamsize(__n - _M_gcount
							  - 1));
		  if (__size > 1)
		    {
		      const char_type* __p = traits_type::find(__sb->gptr(),
							       __size,
							       __delim);
		      if (__p)
			__size = __p - __sb->gptr();
		      traits_type::copy(__s, __sb->gptr(), __size);
		      __s += __size;
		      __sb->__safe_gbump(__size);
		      _M_gcount += __size;
		      __c = __sb->sgetc();
		    }
		  else
		    {
		      *__s++ = traits_type::to_char_type(__c);
		      ++_M_gcount;
		      __c = __sb->snextc();
		    }
		}

	      if (traits_type::eq_int_type(__c, __eof))
		__err |= ios_base::eofbit;
	      else if (traits_type::eq_int_type(__c, __idelim))
		{
		  ++_M_gcount;		  
		  __sb->sbumpc();
		}
	      else
		__err |= ios_base::failbit;
	    }
	  __catch(__cxxabiv1::__forced_unwind&)
	    {
	      this->_M_setstate(ios_base::badbit);
	      __throw_exception_again;
	    }
	  __catch(...)
	    { this->_M_setstate(ios_base::badbit); }
	}
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 243. get and getline when sentry reports failure.
      if (__n > 0)
	*__s = char_type();
      if (!_M_gcount)
	__err |= ios_base::failbit;
      if (__err)
	this->setstate(__err);
      return *this;
    }

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n, int_type __delim)
    {
      if (traits_type::eq_int_type(__delim, traits_type::eof()))
	return ignore(__n);

      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__n > 0 && __cerb)
	{
	  ios_base::iostate __err = ios_base::goodbit;
	  __try
	    {
	      const char_type __cdelim = traits_type::to_char_type(__delim);
	      const int_type __eof = traits_type::eof();
	      __streambuf_type* __sb = this->rdbuf();
	      int_type __c = __sb->sgetc();

	      bool __large_ignore = false;
	      while (true)
		{
		  while (_M_gcount < __n
			 && !traits_type::eq_int_type(__c, __eof)
			 && !traits_type::eq_int_type(__c, __delim))
		    {
		      streamsize __size = std::min(streamsize(__sb->egptr()
							      - __sb->gptr()),
						   streamsize(__n - _M_gcount));
		      if (__size > 1)
			{
			  const char_type* __p = traits_type::find(__sb->gptr(),
								   __size,
								   __cdelim);
			  if (__p)
			    __size = __p - __sb->gptr();
			  __sb->__safe_gbump(__size);
			  _M_gcount += __size;
			  __c = __sb->sgetc();
			}
		      else
			{
			  ++_M_gcount;
			  __c = __sb->snextc();
			}
		    }
		  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
		      && !traits_type::eq_int_type(__c, __eof)
		      && !traits_type::eq_int_type(__c, __delim))
		    {
		      _M_gcount =
			__gnu_cxx::__numeric_traits<streamsize>::__min;
		      __large_ignore = true;
		    }
		  else
		    break;
		}

	      if (__large_ignore)
		_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

	      if (traits_type::eq_int_type(__c, __eof))
		__err |= ios_base::eofbit;
	      else if (traits_type::eq_int_type(__c, __delim))
		{
		  if (_M_gcount
		      < __gnu_cxx::__numeric_traits<streamsize>::__max)
		    ++_M_gcount;
		  __sb->sbumpc();
		}
	    }
	  __catch(__cxxabiv1::__forced_unwind&)
	    {
	      this->_M_setstate(ios_base::badbit);
	      __throw_exception_again;
	    }
	  __catch(...)
	    { this->_M_setstate(ios_base::badbit); }
	  if (__err)
	    this->setstate(__err);
	}
      return *this;
    }

  template<>
    basic_istream<char>&
    operator>>(basic_istream<char>& __in, char* __s)
    {
      typedef basic_istream<char>       	__istream_type;
      typedef __istream_type::int_type		__int_type;
      typedef __istream_type::char_type		__char_type;
      typedef __istream_type::traits_type	__traits_type;
      typedef __istream_type::__streambuf_type  __streambuf_type;
      typedef __istream_type::__ctype_type	__ctype_type;

      streamsize __extracted = 0;
      ios_base::iostate __err = ios_base::goodbit;
      __istream_type::sentry __cerb(__in, false);
      if (__cerb)
	{
	  __try
	    {
	      // Figure out how many characters to extract.
	      streamsize __num = __in.width();
	      if (__num <= 0)
		__num = __gnu_cxx::__numeric_traits<streamsize>::__max;

	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

	      const __int_type __eof = __traits_type::eof();
	      __streambuf_type* __sb = __in.rdbuf();
	      __int_type __c = __sb->sgetc();

	      while (__extracted < __num - 1
		     && !__traits_type::eq_int_type(__c, __eof)
		     && !__ct.is(ctype_base::space,
				 __traits_type::to_char_type(__c)))
		{
		  streamsize __size = std::min(streamsize(__sb->egptr()
							  - __sb->gptr()),
					       streamsize(__num - __extracted
							  - 1));
		  if (__size > 1)
		    {
		      __size = (__ct.scan_is(ctype_base::space,
					     __sb->gptr() + 1,
					     __sb->gptr() + __size)
				- __sb->gptr());
		      __traits_type::copy(__s, __sb->gptr(), __size);
		      __s += __size;
		      __sb->__safe_gbump(__size);
		      __extracted += __size;
		      __c = __sb->sgetc();
		    }
		  else
		    {
		      *__s++ = __traits_type::to_char_type(__c);
		      ++__extracted;
		      __c = __sb->snextc();
		    }
		}

	      if (__traits_type::eq_int_type(__c, __eof))
		__err |= ios_base::eofbit;

	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
	      // 68.  Extractors for char* should store null at end
	      *__s = __char_type();
	      __in.width(0);
	    }
	  __catch(__cxxabiv1::__forced_unwind&)
	    {
	      __in._M_setstate(ios_base::badbit);
	      __throw_exception_again;
	    }
	  __catch(...)
	    { __in._M_setstate(ios_base::badbit); }
	}
      if (!__extracted)
	__err |= ios_base::failbit;
      if (__err)
	__in.setstate(__err);
      return __in;
    }

#ifdef _GLIBCXX_USE_WCHAR_T
  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
	{
          __try
	    {
	      const int_type __idelim = traits_type::to_int_type(__delim);
	      const int_type __eof = traits_type::eof();
	      __streambuf_type* __sb = this->rdbuf();
	      int_type __c = __sb->sgetc();
	      
	      while (_M_gcount + 1 < __n
		     && !traits_type::eq_int_type(__c, __eof)
		     && !traits_type::eq_int_type(__c, __idelim))
		{
		  streamsize __size = std::min(streamsize(__sb->egptr()
							  - __sb->gptr()),
					       streamsize(__n - _M_gcount
							  - 1));
		  if (__size > 1)
		    {
		      const char_type* __p = traits_type::find(__sb->gptr(),
							       __size,
							       __delim);
		      if (__p)
			__size = __p - __sb->gptr();
		      traits_type::copy(__s, __sb->gptr(), __size);
		      __s += __size;
		      __sb->__safe_gbump(__size);
		      _M_gcount += __size;
		      __c = __sb->sgetc();
		    }
		  else
		    {
		      *__s++ = traits_type::to_char_type(__c);
		      ++_M_gcount;
		      __c = __sb->snextc();
		    }
		}

	      if (traits_type::eq_int_type(__c, __eof))
		__err |= ios_base::eofbit;
	      else if (traits_type::eq_int_type(__c, __idelim))
		{
		  ++_M_gcount;		  
		  __sb->sbumpc();
		}
	      else
		__err |= ios_base::failbit;
	    }
	  __catch(__cxxabiv1::__forced_unwind&)
	    {
	      this->_M_setstate(ios_base::badbit);
	      __throw_exception_again;
	    }
	  __catch(...)
	    { this->_M_setstate(ios_base::badbit); }
	}
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 243. get and getline when sentry reports failure.
      if (__n > 0)
	*__s = char_type();
      if (!_M_gcount)
	__err |= ios_base::failbit;
      if (__err)
	this->setstate(__err);
      return *this;
    }

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n, int_type __delim)
    {
      if (traits_type::eq_int_type(__delim, traits_type::eof()))
	return ignore(__n);

      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__n > 0 && __cerb)
	{
	  ios_base::iostate __err = ios_base::goodbit;
	  __try
	    {
	      const char_type __cdelim = traits_type::to_char_type(__delim);
	      const int_type __eof = traits_type::eof();
	      __streambuf_type* __sb = this->rdbuf();
	      int_type __c = __sb->sgetc();

	      bool __large_ignore = false;
	      while (true)
		{
		  while (_M_gcount < __n
			 && !traits_type::eq_int_type(__c, __eof)
			 && !traits_type::eq_int_type(__c, __delim))
		    {
		      streamsize __size = std::min(streamsize(__sb->egptr()
							      - __sb->gptr()),
						   streamsize(__n - _M_gcount));
		      if (__size > 1)
			{
			  const char_type* __p = traits_type::find(__sb->gptr(),
								   __size,
								   __cdelim);
			  if (__p)
			    __size = __p - __sb->gptr();
			  __sb->__safe_gbump(__size);
			  _M_gcount += __size;
			  __c = __sb->sgetc();
			}
		      else
			{
			  ++_M_gcount;
			  __c = __sb->snextc();
			}
		    }
		  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
		      && !traits_type::eq_int_type(__c, __eof)
		      && !traits_type::eq_int_type(__c, __delim))
		    {
		      _M_gcount =
			__gnu_cxx::__numeric_traits<streamsize>::__min;
		      __large_ignore = true;
		    }
		  else
		    break;
		}

	      if (__large_ignore)
		_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

	      if (traits_type::eq_int_type(__c, __eof))
		__err |= ios_base::eofbit;
	      else if (traits_type::eq_int_type(__c, __delim))
		{
		  if (_M_gcount
		      < __gnu_cxx::__numeric_traits<streamsize>::__max)
		    ++_M_gcount;
		  __sb->sbumpc();
		}
	    }
	  __catch(__cxxabiv1::__forced_unwind&)
	    {
	      this->_M_setstate(ios_base::badbit);
	      __throw_exception_again;
	    }
	  __catch(...)
	    { this->_M_setstate(ios_base::badbit); }
	  if (__err)
	    this->setstate(__err);
	}
      return *this;
    }
#endif


_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
Commit	Line	Data
adb31ad6 PC	1	// Input streams -- C++ --
adb31ad6 PC	2
818ab71a	3	// Copyright (C) 2004-2016 Free Software Foundation, Inc.
adb31ad6 PC	4	//
	5	// This file is part of the GNU ISO C++ Library. This library is free
	6	// software; you can redistribute it and/or modify it under the
	7	// terms of the GNU General Public License as published by the
748086b7	8	// Free Software Foundation; either version 3, or (at your option)
adb31ad6 PC	9	// any later version.
	10
	11	// This library is distributed in the hope that it will be useful,
	12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	// GNU General Public License for more details.
	15
748086b7 JJ	16	// Under Section 7 of GPL version 3, you are granted additional
	17	// permissions described in the GCC Runtime Library Exception, version
	18	// 3.1, as published by the Free Software Foundation.
	19
	20	// You should have received a copy of the GNU General Public License and
	21	// a copy of the GCC Runtime Library Exception along with this program;
	22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
	23	// <http://www.gnu.org/licenses/>.
adb31ad6 PC	24
	25	//
	26	// ISO C++ 14882: 27.6.1 Input streams
	27	//
	28
	29	#include <istream>
	30
12ffa228 BK	31	namespace std _GLIBCXX_VISIBILITY(default)
	32	{
	33	_GLIBCXX_BEGIN_NAMESPACE_VERSION
3cbc7af0	34
adb31ad6 PC	35	template<>
	36	basic_istream<char>&
	37	basic_istream<char>::
	38	getline(char_type* __s, streamsize __n, char_type __delim)
	39	{
	40	_M_gcount = 0;
6f0398bb	41	ios_base::iostate __err = ios_base::goodbit;
adb31ad6	42	sentry __cerb(*this, true);
880b527f	43	if (__cerb)
adb31ad6	44	{
bc2631e0	45	__try
adb31ad6 PC	46	{
	47	const int_type __idelim = traits_type::to_int_type(__delim);
	48	const int_type __eof = traits_type::eof();
	49	__streambuf_type* __sb = this->rdbuf();
	50	int_type __c = __sb->sgetc();
	51
	52	while (_M_gcount + 1 < __n
	53	&& !traits_type::eq_int_type(__c, __eof)
	54	&& !traits_type::eq_int_type(__c, __idelim))
	55	{
	56	streamsize __size = std::min(streamsize(__sb->egptr()
	57	- __sb->gptr()),
	58	streamsize(__n - _M_gcount
	59	- 1));
	60	if (__size > 1)
	61	{
	62	const char_type* __p = traits_type::find(__sb->gptr(),
	63	__size,
	64	__delim);
	65	if (__p)
	66	__size = __p - __sb->gptr();
	67	traits_type::copy(__s, __sb->gptr(), __size);
	68	__s += __size;
1139a735	69	__sb->__safe_gbump(__size);
adb31ad6 PC	70	_M_gcount += __size;
	71	__c = __sb->sgetc();
	72	}
	73	else
	74	{
	75	*__s++ = traits_type::to_char_type(__c);
	76	++_M_gcount;
	77	__c = __sb->snextc();
	78	}
	79	}
	80
	81	if (traits_type::eq_int_type(__c, __eof))
	82	__err \|= ios_base::eofbit;
	83	else if (traits_type::eq_int_type(__c, __idelim))
	84	{
	85	++_M_gcount;
	86	__sb->sbumpc();
	87	}
	88	else
	89	__err \|= ios_base::failbit;
	90	}
bc2631e0	91	__catch(__cxxabiv1::__forced_unwind&)
d05f74f1 JM	92	{
	93	this->_M_setstate(ios_base::badbit);
	94	__throw_exception_again;
	95	}
bc2631e0	96	__catch(...)
adb31ad6 PC	97	{ this->_M_setstate(ios_base::badbit); }
adb31ad6 PC	98	}
75a25e3f PC	99	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	100	// 243. get and getline when sentry reports failure.
	101	if (__n > 0)
	102	*__s = char_type();
adb31ad6 PC	103	if (!_M_gcount)
	104	__err \|= ios_base::failbit;
	105	if (__err)
	106	this->setstate(__err);
	107	return *this;
	108	}
	109
adb31ad6 PC	110	template<>
	111	basic_istream<char>&
	112	basic_istream<char>::
	113	ignore(streamsize __n, int_type __delim)
	114	{
	115	if (traits_type::eq_int_type(__delim, traits_type::eof()))
	116	return ignore(__n);
	117
	118	_M_gcount = 0;
	119	sentry __cerb(*this, true);
880b527f	120	if (__n > 0 && __cerb)
adb31ad6	121	{
6f0398bb	122	ios_base::iostate __err = ios_base::goodbit;
bc2631e0	123	__try
adb31ad6	124	{
21da6d0f	125	const char_type __cdelim = traits_type::to_char_type(__delim);
adb31ad6 PC	126	const int_type __eof = traits_type::eof();
	127	__streambuf_type* __sb = this->rdbuf();
	128	int_type __c = __sb->sgetc();
	129
78593d78	130	bool __large_ignore = false;
bea53dbf	131	while (true)
adb31ad6	132	{
bea53dbf PC	133	while (_M_gcount < __n
	134	&& !traits_type::eq_int_type(__c, __eof)
	135	&& !traits_type::eq_int_type(__c, __delim))
adb31ad6	136	{
bea53dbf PC	137	streamsize __size = std::min(streamsize(__sb->egptr()
	138	- __sb->gptr()),
	139	streamsize(__n - _M_gcount));
	140	if (__size > 1)
	141	{
	142	const char_type* __p = traits_type::find(__sb->gptr(),
	143	__size,
	144	__cdelim);
	145	if (__p)
	146	__size = __p - __sb->gptr();
1139a735	147	__sb->__safe_gbump(__size);
bea53dbf PC	148	_M_gcount += __size;
	149	__c = __sb->sgetc();
	150	}
	151	else
	152	{
	153	++_M_gcount;
	154	__c = __sb->snextc();
	155	}
adb31ad6	156	}
6725add5	157	if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
bea53dbf PC	158	&& !traits_type::eq_int_type(__c, __eof)
bea53dbf PC	159	&& !traits_type::eq_int_type(__c, __delim))
78593d78	160	{
6725add5 PC	161	_M_gcount =
6725add5 PC	162	__gnu_cxx::__numeric_traits<streamsize>::__min;
78593d78 PC	163	__large_ignore = true;
78593d78 PC	164	}
adb31ad6	165	else
bea53dbf	166	break;
adb31ad6	167	}
bea53dbf	168
78593d78	169	if (__large_ignore)
6725add5	170	_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
78593d78	171
a141a5af	172	if (traits_type::eq_int_type(__c, __eof))
adb31ad6	173	__err \|= ios_base::eofbit;
a141a5af	174	else if (traits_type::eq_int_type(__c, __delim))
adb31ad6	175	{
6725add5 PC	176	if (_M_gcount
6725add5 PC	177	< __gnu_cxx::__numeric_traits<streamsize>::__max)
78593d78	178	++_M_gcount;
adb31ad6 PC	179	__sb->sbumpc();
	180	}
	181	}
bc2631e0	182	__catch(__cxxabiv1::__forced_unwind&)
d05f74f1 JM	183	{
	184	this->_M_setstate(ios_base::badbit);
	185	__throw_exception_again;
	186	}
bc2631e0	187	__catch(...)
adb31ad6 PC	188	{ this->_M_setstate(ios_base::badbit); }
	189	if (__err)
	190	this->setstate(__err);
	191	}
	192	return *this;
	193	}
	194
ceed88b1 PC	195	template<>
	196	basic_istream<char>&
	197	operator>>(basic_istream<char>& __in, char* __s)
	198	{
	199	typedef basic_istream<char> __istream_type;
	200	typedef __istream_type::int_type __int_type;
	201	typedef __istream_type::char_type __char_type;
	202	typedef __istream_type::traits_type __traits_type;
	203	typedef __istream_type::__streambuf_type __streambuf_type;
	204	typedef __istream_type::__ctype_type __ctype_type;
	205
	206	streamsize __extracted = 0;
6f0398bb	207	ios_base::iostate __err = ios_base::goodbit;
ceed88b1	208	__istream_type::sentry __cerb(__in, false);
880b527f	209	if (__cerb)
ceed88b1	210	{
bc2631e0	211	__try
ceed88b1 PC	212	{
	213	// Figure out how many characters to extract.
	214	streamsize __num = __in.width();
	215	if (__num <= 0)
6725add5	216	__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
ceed88b1 PC	217
	218	const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
	219
	220	const __int_type __eof = __traits_type::eof();
	221	__streambuf_type* __sb = __in.rdbuf();
	222	__int_type __c = __sb->sgetc();
	223
	224	while (__extracted < __num - 1
	225	&& !__traits_type::eq_int_type(__c, __eof)
	226	&& !__ct.is(ctype_base::space,
	227	__traits_type::to_char_type(__c)))
	228	{
	229	streamsize __size = std::min(streamsize(__sb->egptr()
	230	- __sb->gptr()),
	231	streamsize(__num - __extracted
	232	- 1));
	233	if (__size > 1)
	234	{
	235	__size = (__ct.scan_is(ctype_base::space,
	236	__sb->gptr() + 1,
	237	__sb->gptr() + __size)
	238	- __sb->gptr());
	239	__traits_type::copy(__s, __sb->gptr(), __size);
	240	__s += __size;
1139a735	241	__sb->__safe_gbump(__size);
ceed88b1 PC	242	__extracted += __size;
	243	__c = __sb->sgetc();
	244	}
	245	else
	246	{
	247	*__s++ = __traits_type::to_char_type(__c);
	248	++__extracted;
	249	__c = __sb->snextc();
	250	}
	251	}
	252
	253	if (__traits_type::eq_int_type(__c, __eof))
	254	__err \|= ios_base::eofbit;
	255
	256	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	257	// 68. Extractors for char* should store null at end
	258	*__s = __char_type();
	259	__in.width(0);
	260	}
bc2631e0	261	__catch(__cxxabiv1::__forced_unwind&)
d05f74f1 JM	262	{
	263	__in._M_setstate(ios_base::badbit);
	264	__throw_exception_again;
	265	}
bc2631e0	266	__catch(...)
ceed88b1 PC	267	{ __in._M_setstate(ios_base::badbit); }
	268	}
	269	if (!__extracted)
	270	__err \|= ios_base::failbit;
	271	if (__err)
	272	__in.setstate(__err);
	273	return __in;
	274	}
	275
adb31ad6 PC	276	#ifdef _GLIBCXX_USE_WCHAR_T
	277	template<>
	278	basic_istream<wchar_t>&
	279	basic_istream<wchar_t>::
	280	getline(char_type* __s, streamsize __n, char_type __delim)
	281	{
	282	_M_gcount = 0;
6f0398bb	283	ios_base::iostate __err = ios_base::goodbit;
adb31ad6	284	sentry __cerb(*this, true);
880b527f	285	if (__cerb)
adb31ad6	286	{
bc2631e0	287	__try
adb31ad6 PC	288	{
	289	const int_type __idelim = traits_type::to_int_type(__delim);
	290	const int_type __eof = traits_type::eof();
	291	__streambuf_type* __sb = this->rdbuf();
	292	int_type __c = __sb->sgetc();
	293
	294	while (_M_gcount + 1 < __n
	295	&& !traits_type::eq_int_type(__c, __eof)
	296	&& !traits_type::eq_int_type(__c, __idelim))
	297	{
	298	streamsize __size = std::min(streamsize(__sb->egptr()
	299	- __sb->gptr()),
	300	streamsize(__n - _M_gcount
	301	- 1));
	302	if (__size > 1)
	303	{
	304	const char_type* __p = traits_type::find(__sb->gptr(),
	305	__size,
	306	__delim);
	307	if (__p)
	308	__size = __p - __sb->gptr();
	309	traits_type::copy(__s, __sb->gptr(), __size);
	310	__s += __size;
1139a735	311	__sb->__safe_gbump(__size);
adb31ad6 PC	312	_M_gcount += __size;
	313	__c = __sb->sgetc();
	314	}
	315	else
	316	{
	317	*__s++ = traits_type::to_char_type(__c);
	318	++_M_gcount;
	319	__c = __sb->snextc();
	320	}
	321	}
	322
	323	if (traits_type::eq_int_type(__c, __eof))
	324	__err \|= ios_base::eofbit;
	325	else if (traits_type::eq_int_type(__c, __idelim))
	326	{
	327	++_M_gcount;
	328	__sb->sbumpc();
	329	}
	330	else
	331	__err \|= ios_base::failbit;
	332	}
bc2631e0	333	__catch(__cxxabiv1::__forced_unwind&)
d05f74f1 JM	334	{
	335	this->_M_setstate(ios_base::badbit);
	336	__throw_exception_again;
	337	}
bc2631e0	338	__catch(...)
adb31ad6 PC	339	{ this->_M_setstate(ios_base::badbit); }
adb31ad6 PC	340	}
75a25e3f PC	341	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	342	// 243. get and getline when sentry reports failure.
	343	if (__n > 0)
	344	*__s = char_type();
adb31ad6 PC	345	if (!_M_gcount)
	346	__err \|= ios_base::failbit;
	347	if (__err)
	348	this->setstate(__err);
	349	return *this;
	350	}
	351
adb31ad6 PC	352	template<>
	353	basic_istream<wchar_t>&
	354	basic_istream<wchar_t>::
	355	ignore(streamsize __n, int_type __delim)
	356	{
	357	if (traits_type::eq_int_type(__delim, traits_type::eof()))
	358	return ignore(__n);
	359
	360	_M_gcount = 0;
	361	sentry __cerb(*this, true);
880b527f	362	if (__n > 0 && __cerb)
adb31ad6	363	{
6f0398bb	364	ios_base::iostate __err = ios_base::goodbit;
bc2631e0	365	__try
adb31ad6	366	{
880b527f	367	const char_type __cdelim = traits_type::to_char_type(__delim);
adb31ad6 PC	368	const int_type __eof = traits_type::eof();
	369	__streambuf_type* __sb = this->rdbuf();
	370	int_type __c = __sb->sgetc();
	371
78593d78	372	bool __large_ignore = false;
bea53dbf	373	while (true)
adb31ad6	374	{
bea53dbf PC	375	while (_M_gcount < __n
	376	&& !traits_type::eq_int_type(__c, __eof)
	377	&& !traits_type::eq_int_type(__c, __delim))
adb31ad6	378	{
bea53dbf PC	379	streamsize __size = std::min(streamsize(__sb->egptr()
	380	- __sb->gptr()),
	381	streamsize(__n - _M_gcount));
	382	if (__size > 1)
	383	{
	384	const char_type* __p = traits_type::find(__sb->gptr(),
	385	__size,
	386	__cdelim);
	387	if (__p)
	388	__size = __p - __sb->gptr();
1139a735	389	__sb->__safe_gbump(__size);
bea53dbf PC	390	_M_gcount += __size;
	391	__c = __sb->sgetc();
	392	}
	393	else
	394	{
	395	++_M_gcount;
	396	__c = __sb->snextc();
	397	}
adb31ad6	398	}
6725add5	399	if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
bea53dbf PC	400	&& !traits_type::eq_int_type(__c, __eof)
bea53dbf PC	401	&& !traits_type::eq_int_type(__c, __delim))
78593d78	402	{
6725add5 PC	403	_M_gcount =
6725add5 PC	404	__gnu_cxx::__numeric_traits<streamsize>::__min;
78593d78 PC	405	__large_ignore = true;
78593d78 PC	406	}
adb31ad6	407	else
bea53dbf	408	break;
adb31ad6	409	}
bea53dbf	410
78593d78	411	if (__large_ignore)
6725add5	412	_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
78593d78	413
a141a5af	414	if (traits_type::eq_int_type(__c, __eof))
adb31ad6	415	__err \|= ios_base::eofbit;
a141a5af	416	else if (traits_type::eq_int_type(__c, __delim))
adb31ad6	417	{
6725add5 PC	418	if (_M_gcount
6725add5 PC	419	< __gnu_cxx::__numeric_traits<streamsize>::__max)
78593d78	420	++_M_gcount;
adb31ad6 PC	421	__sb->sbumpc();
	422	}
	423	}
bc2631e0	424	__catch(__cxxabiv1::__forced_unwind&)
d05f74f1 JM	425	{
	426	this->_M_setstate(ios_base::badbit);
	427	__throw_exception_again;
	428	}
bc2631e0	429	__catch(...)
adb31ad6 PC	430	{ this->_M_setstate(ios_base::badbit); }
	431	if (__err)
	432	this->setstate(__err);
	433	}
	434	return *this;
	435	}
	436	#endif
3cbc7af0	437
34a2b755	438
12ffa228 BK	439	_GLIBCXX_END_NAMESPACE_VERSION
12ffa228 BK	440	} // namespace