?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* gimple-ssa-store-merging.c (struct store_immediate_info): Add
[official-gcc.git] / libstdc++-v3 / src / c++98 / istream.cc
bloba4bf80535cee05a08981082532b05a540dcbc6dc
1 // Input streams -*- C++ -*-
2
3 // Copyright (C) 2004-2017 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
Mirror of the offical gcc git repository hosted at gcc.gnu.org