1 // Input streams -*- C++ -*- 2 3 // Copyright (C) 2004-2018 Free Software Foundation, Inc. 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 8 // Free Software Foundation; either version 3, or (at your option) 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 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/>. 24 25 // 26 // ISO C++ 14882: 27.6.1 Input streams 27 // 28 29 #include <istream> 30 31 namespace std _GLIBCXX_VISIBILITY(default) 32 { 33 _GLIBCXX_BEGIN_NAMESPACE_VERSION 34 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; 41 ios_base::iostate __err = ios_base::goodbit; 42 sentry __cerb(*this, true); 43 if (__cerb) 44 { 45 __try 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; 69 __sb->__safe_gbump(__size); 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 } 91 __catch(__cxxabiv1::__forced_unwind&) 92 { 93 this->_M_setstate(ios_base::badbit); 94 __throw_exception_again; 95 } 96 __catch(...) 97 { this->_M_setstate(ios_base::badbit); } 98 } 99 // _GLIBCXX_RESOLVE_LIB_DEFECTS 100 // 243. get and getline when sentry reports failure. 101 if (__n > 0) 102 *__s = char_type(); 103 if (!_M_gcount) 104 __err |= ios_base::failbit; 105 if (__err) 106 this->setstate(__err); 107 return *this; 108 } 109 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); 120 if (__n > 0 && __cerb) 121 { 122 ios_base::iostate __err = ios_base::goodbit; 123 __try 124 { 125 const char_type __cdelim = traits_type::to_char_type(__delim); 126 const int_type __eof = traits_type::eof(); 127 __streambuf_type* __sb = this->rdbuf(); 128 int_type __c = __sb->sgetc(); 129 130 bool __large_ignore = false; 131 while (true) 132 { 133 while (_M_gcount < __n 134 && !traits_type::eq_int_type(__c, __eof) 135 && !traits_type::eq_int_type(__c, __delim)) 136 { 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(); 147 __sb->__safe_gbump(__size); 148 _M_gcount += __size; 149 __c = __sb->sgetc(); 150 } 151 else 152 { 153 ++_M_gcount; 154 __c = __sb->snextc(); 155 } 156 } 157 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max 158 && !traits_type::eq_int_type(__c, __eof) 159 && !traits_type::eq_int_type(__c, __delim)) 160 { 161 _M_gcount = 162 __gnu_cxx::__numeric_traits<streamsize>::__min; 163 __large_ignore = true; 164 } 165 else 166 break; 167 } 168 169 if (__large_ignore) 170 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; 171 172 if (traits_type::eq_int_type(__c, __eof)) 173 __err |= ios_base::eofbit; 174 else if (traits_type::eq_int_type(__c, __delim)) 175 { 176 if (_M_gcount 177 < __gnu_cxx::__numeric_traits<streamsize>::__max) 178 ++_M_gcount; 179 __sb->sbumpc(); 180 } 181 } 182 __catch(__cxxabiv1::__forced_unwind&) 183 { 184 this->_M_setstate(ios_base::badbit); 185 __throw_exception_again; 186 } 187 __catch(...) 188 { this->_M_setstate(ios_base::badbit); } 189 if (__err) 190 this->setstate(__err); 191 } 192 return *this; 193 } 194 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; 207 ios_base::iostate __err = ios_base::goodbit; 208 __istream_type::sentry __cerb(__in, false); 209 if (__cerb) 210 { 211 __try 212 { 213 // Figure out how many characters to extract. 214 streamsize __num = __in.width(); 215 if (__num <= 0) 216 __num = __gnu_cxx::__numeric_traits<streamsize>::__max; 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; 241 __sb->__safe_gbump(__size); 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 } 261 __catch(__cxxabiv1::__forced_unwind&) 262 { 263 __in._M_setstate(ios_base::badbit); 264 __throw_exception_again; 265 } 266 __catch(...) 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 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; 283 ios_base::iostate __err = ios_base::goodbit; 284 sentry __cerb(*this, true); 285 if (__cerb) 286 { 287 __try 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; 311 __sb->__safe_gbump(__size); 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 } 333 __catch(__cxxabiv1::__forced_unwind&) 334 { 335 this->_M_setstate(ios_base::badbit); 336 __throw_exception_again; 337 } 338 __catch(...) 339 { this->_M_setstate(ios_base::badbit); } 340 } 341 // _GLIBCXX_RESOLVE_LIB_DEFECTS 342 // 243. get and getline when sentry reports failure. 343 if (__n > 0) 344 *__s = char_type(); 345 if (!_M_gcount) 346 __err |= ios_base::failbit; 347 if (__err) 348 this->setstate(__err); 349 return *this; 350 } 351 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); 362 if (__n > 0 && __cerb) 363 { 364 ios_base::iostate __err = ios_base::goodbit; 365 __try 366 { 367 const char_type __cdelim = traits_type::to_char_type(__delim); 368 const int_type __eof = traits_type::eof(); 369 __streambuf_type* __sb = this->rdbuf(); 370 int_type __c = __sb->sgetc(); 371 372 bool __large_ignore = false; 373 while (true) 374 { 375 while (_M_gcount < __n 376 && !traits_type::eq_int_type(__c, __eof) 377 && !traits_type::eq_int_type(__c, __delim)) 378 { 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(); 389 __sb->__safe_gbump(__size); 390 _M_gcount += __size; 391 __c = __sb->sgetc(); 392 } 393 else 394 { 395 ++_M_gcount; 396 __c = __sb->snextc(); 397 } 398 } 399 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max 400 && !traits_type::eq_int_type(__c, __eof) 401 && !traits_type::eq_int_type(__c, __delim)) 402 { 403 _M_gcount = 404 __gnu_cxx::__numeric_traits<streamsize>::__min; 405 __large_ignore = true; 406 } 407 else 408 break; 409 } 410 411 if (__large_ignore) 412 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; 413 414 if (traits_type::eq_int_type(__c, __eof)) 415 __err |= ios_base::eofbit; 416 else if (traits_type::eq_int_type(__c, __delim)) 417 { 418 if (_M_gcount 419 < __gnu_cxx::__numeric_traits<streamsize>::__max) 420 ++_M_gcount; 421 __sb->sbumpc(); 422 } 423 } 424 __catch(__cxxabiv1::__forced_unwind&) 425 { 426 this->_M_setstate(ios_base::badbit); 427 __throw_exception_again; 428 } 429 __catch(...) 430 { this->_M_setstate(ios_base::badbit); } 431 if (__err) 432 this->setstate(__err); 433 } 434 return *this; 435 } 436 #endif 437 438 439 _GLIBCXX_END_NAMESPACE_VERSION 440 } // namespace 441