1// Stream buffer classes -*- C++ -*- 
2 
3// Copyright (C) 1997-2021 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/** @file include/streambuf 
26 * This is a Standard C++ Library header. 
27 */ 
28 
29// 
30// ISO C++ 14882: 27.5 Stream buffers 
31// 
32 
33#ifndef _GLIBXX_STREAMBUF 
34#define _GLIBXX_STREAMBUF 1 
35 
36#pragma GCC system_header 
37 
38#include <bits/c++config.h> 
39#include <iosfwd> 
40#include <bits/localefwd.h> 
41#include <bits/ios_base.h> 
42#include <bits/cpp_type_traits.h> 
43#include <ext/type_traits.h> 
44 
45namespace std _GLIBCXX_VISIBILITY(default) 
46{ 
47_GLIBCXX_BEGIN_NAMESPACE_VERSION 
48 
49#define _IsUnused __attribute__ ((__unused__)) 
50 
51 template<typename _CharT, typename _Traits> 
52 streamsize 
53 __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, 
54 basic_streambuf<_CharT, _Traits>*, bool&); 
55 
56 /** 
57 * @brief The actual work of input and output (interface). 
58 * @ingroup io 
59 * 
60 * @tparam _CharT Type of character stream. 
61 * @tparam _Traits Traits for character type, defaults to 
62 * char_traits<_CharT>. 
63 * 
64 * This is a base class. Derived stream buffers each control a 
65 * pair of character sequences: one for input, and one for output. 
66 * 
67 * Section [27.5.1] of the standard describes the requirements and 
68 * behavior of stream buffer classes. That section (three paragraphs) 
69 * is reproduced here, for simplicity and accuracy. 
70 * 
71 * -# Stream buffers can impose various constraints on the sequences 
72 * they control. Some constraints are: 
73 * - The controlled input sequence can be not readable. 
74 * - The controlled output sequence can be not writable. 
75 * - The controlled sequences can be associated with the contents of 
76 * other representations for character sequences, such as external 
77 * files. 
78 * - The controlled sequences can support operations @e directly to or 
79 * from associated sequences. 
80 * - The controlled sequences can impose limitations on how the 
81 * program can read characters from a sequence, write characters to 
82 * a sequence, put characters back into an input sequence, or alter 
83 * the stream position. 
84 * . 
85 * -# Each sequence is characterized by three pointers which, if non-null, 
86 * all point into the same @c charT array object. The array object 
87 * represents, at any moment, a (sub)sequence of characters from the 
88 * sequence. Operations performed on a sequence alter the values 
89 * stored in these pointers, perform reads and writes directly to or 
90 * from associated sequences, and alter <em>the stream position</em> and 
91 * conversion state as needed to maintain this subsequence relationship. 
92 * The three pointers are: 
93 * - the <em>beginning pointer</em>, or lowest element address in the 
94 * array (called @e xbeg here); 
95 * - the <em>next pointer</em>, or next element address that is a 
96 * current candidate for reading or writing (called @e xnext here); 
97 * - the <em>end pointer</em>, or first element address beyond the 
98 * end of the array (called @e xend here). 
99 * . 
100 * -# The following semantic constraints shall always apply for any set 
101 * of three pointers for a sequence, using the pointer names given 
102 * immediately above: 
103 * - If @e xnext is not a null pointer, then @e xbeg and @e xend shall 
104 * also be non-null pointers into the same @c charT array, as 
105 * described above; otherwise, @e xbeg and @e xend shall also be null. 
106 * - If @e xnext is not a null pointer and @e xnext < @e xend for an 
107 * output sequence, then a <em>write position</em> is available. 
108 * In this case, @e *xnext shall be assignable as the next element 
109 * to write (to put, or to store a character value, into the sequence). 
110 * - If @e xnext is not a null pointer and @e xbeg < @e xnext for an 
111 * input sequence, then a <em>putback position</em> is available. 
112 * In this case, @e xnext[-1] shall have a defined value and is the 
113 * next (preceding) element to store a character that is put back 
114 * into the input sequence. 
115 * - If @e xnext is not a null pointer and @e xnext< @e xend for an 
116 * input sequence, then a <em>read position</em> is available. 
117 * In this case, @e *xnext shall have a defined value and is the 
118 * next element to read (to get, or to obtain a character value, 
119 * from the sequence). 
120 */ 
121 template<typename _CharT, typename _Traits> 
122 class basic_streambuf 
123 { 
124 public: 
125 ///@{ 
126 /** 
127 * These are standard types. They permit a standardized way of 
128 * referring to names of (or names dependent on) the template 
129 * parameters, which are specific to the implementation. 
130 */ 
131 typedef _CharT char_type; 
132 typedef _Traits traits_type; 
133 typedef typename traits_type::int_type int_type; 
134 typedef typename traits_type::pos_type pos_type; 
135 typedef typename traits_type::off_type off_type; 
136 ///@} 
137 
138 ///@{ 
139 /// This is a non-standard type. 
140 typedef basic_streambuf<char_type, traits_type> __streambuf_type; 
141 ///@} 
142 
143 friend class basic_ios<char_type, traits_type>; 
144 friend class basic_istream<char_type, traits_type>; 
145 friend class basic_ostream<char_type, traits_type>; 
146 friend class istreambuf_iterator<char_type, traits_type>; 
147 friend class ostreambuf_iterator<char_type, traits_type>; 
148 
149 friend streamsize 
150 __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&); 
151 
152 template<bool _IsMove, typename _CharT2> 
153 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, 
154 _CharT2*>::__type 
155 __copy_move_a2(istreambuf_iterator<_CharT2>, 
156 istreambuf_iterator<_CharT2>, _CharT2*); 
157 
158 template<typename _CharT2> 
159 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, 
160 istreambuf_iterator<_CharT2> >::__type 
161 find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, 
162 const _CharT2&); 
163 
164 template<typename _CharT2, typename _Distance> 
165 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, 
166 void>::__type 
167 advance(istreambuf_iterator<_CharT2>&, _Distance); 
168 
169 friend void __istream_extract(istream&, char*, streamsize); 
170 
171 template<typename _CharT2, typename _Traits2, typename _Alloc> 
172 friend basic_istream<_CharT2, _Traits2>& 
173 operator>>(basic_istream<_CharT2, _Traits2>&, 
174 basic_string<_CharT2, _Traits2, _Alloc>&); 
175 
176 template<typename _CharT2, typename _Traits2, typename _Alloc> 
177 friend basic_istream<_CharT2, _Traits2>& 
178 getline(basic_istream<_CharT2, _Traits2>&, 
179 basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); 
180 
181 protected: 
182 /* 
183 * This is based on _IO_FILE, just reordered to be more consistent, 
184 * and is intended to be the most minimal abstraction for an 
185 * internal buffer. 
186 * - get == input == read 
187 * - put == output == write 
188 */ 
189 char_type* _M_in_beg; ///< Start of get area. 
190 char_type* _M_in_cur; ///< Current read area. 
191 char_type* _M_in_end; ///< End of get area. 
192 char_type* _M_out_beg; ///< Start of put area. 
193 char_type* _M_out_cur; ///< Current put area. 
194 char_type* _M_out_end; ///< End of put area. 
195 
196 /// Current locale setting. 
197 locale _M_buf_locale; 
198 
199 public: 
200 /// Destructor deallocates no buffer space. 
201 virtual 
202 ~basic_streambuf() 
203 { } 
204 
205 // [27.5.2.2.1] locales 
206 /** 
207 * @brief Entry point for imbue(). 
208 * @param __loc The new locale. 
209 * @return The previous locale. 
210 * 
211 * Calls the derived imbue(__loc). 
212 */ 
213 locale 
214 pubimbue(const locale& __loc) 
215 { 
216 locale __tmp(this->getloc()); 
217 this->imbue(__loc); 
218 _M_buf_locale = __loc; 
219 return __tmp; 
220 } 
221 
222 /** 
223 * @brief Locale access. 
224 * @return The current locale in effect. 
225 * 
226 * If pubimbue(loc) has been called, then the most recent @c loc 
227 * is returned. Otherwise the global locale in effect at the time 
228 * of construction is returned. 
229 */ 
230 locale 
231 getloc() const 
232 { return _M_buf_locale; } 
233 
234 // [27.5.2.2.2] buffer management and positioning 
235 ///@{ 
236 /** 
237 * @brief Entry points for derived buffer functions. 
238 * 
239 * The public versions of @c pubfoo dispatch to the protected 
240 * derived @c foo member functions, passing the arguments (if any) 
241 * and returning the result unchanged. 
242 */ 
243 basic_streambuf* 
244 pubsetbuf(char_type* __s, streamsize __n) 
245 { return this->setbuf(__s, __n); } 
246 
247 /** 
248 * @brief Alters the stream position. 
249 * @param __off Offset. 
250 * @param __way Value for ios_base::seekdir. 
251 * @param __mode Value for ios_base::openmode. 
252 * 
253 * Calls virtual seekoff function. 
254 */ 
255 pos_type 
256 pubseekoff(off_type __off, ios_base::seekdir __way, 
257 ios_base::openmode __mode = ios_base::in | ios_base::out) 
258 { return this->seekoff(__off, __way, __mode); } 
259 
260 /** 
261 * @brief Alters the stream position. 
262 * @param __sp Position 
263 * @param __mode Value for ios_base::openmode. 
264 * 
265 * Calls virtual seekpos function. 
266 */ 
267 pos_type 
268 pubseekpos(pos_type __sp, 
269 ios_base::openmode __mode = ios_base::in | ios_base::out) 
270 { return this->seekpos(__sp, __mode); } 
271 
272 /** 
273 * @brief Calls virtual sync function. 
274 */ 
275 int 
276 pubsync() { return this->sync(); } 
277 ///@} 
278 
279 // [27.5.2.2.3] get area 
280 /** 
281 * @brief Looking ahead into the stream. 
282 * @return The number of characters available. 
283 * 
284 * If a read position is available, returns the number of characters 
285 * available for reading before the buffer must be refilled. 
286 * Otherwise returns the derived @c showmanyc(). 
287 */ 
288 streamsize 
289 in_avail() 
290 { 
291 const streamsize __ret = this->egptr() - this->gptr(); 
292 return __ret ? __ret : this->showmanyc(); 
293 } 
294 
295 /** 
296 * @brief Getting the next character. 
297 * @return The next character, or eof. 
298 * 
299 * Calls @c sbumpc(), and if that function returns 
300 * @c traits::eof(), so does this function. Otherwise, @c sgetc(). 
301 */ 
302 int_type 
303 snextc() 
304 { 
305 int_type __ret = traits_type::eof(); 
306 if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), 
307 __ret), true)) 
308 __ret = this->sgetc(); 
309 return __ret; 
310 } 
311 
312 /** 
313 * @brief Getting the next character. 
314 * @return The next character, or eof. 
315 * 
316 * If the input read position is available, returns that character 
317 * and increments the read pointer, otherwise calls and returns 
318 * @c uflow(). 
319 */ 
320 int_type 
321 sbumpc() 
322 { 
323 int_type __ret; 
324 if (__builtin_expect(this->gptr() < this->egptr(), true)) 
325 { 
326 __ret = traits_type::to_int_type(*this->gptr()); 
327 this->gbump(1); 
328 } 
329 else 
330 __ret = this->uflow(); 
331 return __ret; 
332 } 
333 
334 /** 
335 * @brief Getting the next character. 
336 * @return The next character, or eof. 
337 * 
338 * If the input read position is available, returns that character, 
339 * otherwise calls and returns @c underflow(). Does not move the 
340 * read position after fetching the character. 
341 */ 
342 int_type 
343 sgetc() 
344 { 
345 int_type __ret; 
346 if (__builtin_expect(this->gptr() < this->egptr(), true)) 
347 __ret = traits_type::to_int_type(*this->gptr()); 
348 else 
349 __ret = this->underflow(); 
350 return __ret; 
351 } 
352 
353 /** 
354 * @brief Entry point for xsgetn. 
355 * @param __s A buffer area. 
356 * @param __n A count. 
357 * 
358 * Returns xsgetn(__s,__n). The effect is to fill @a __s[0] through 
359 * @a __s[__n-1] with characters from the input sequence, if possible. 
360 */ 
361 streamsize 
362 sgetn(char_type* __s, streamsize __n) 
363 { return this->xsgetn(__s, __n); } 
364 
365 // [27.5.2.2.4] putback 
366 /** 
367 * @brief Pushing characters back into the input stream. 
368 * @param __c The character to push back. 
369 * @return The previous character, if possible. 
370 * 
371 * Similar to sungetc(), but @a __c is pushed onto the stream 
372 * instead of <em>the previous character.</em> If successful, 
373 * the next character fetched from the input stream will be @a 
374 * __c. 
375 */ 
376 int_type 
377 sputbackc(char_type __c) 
378 { 
379 int_type __ret; 
380 const bool __testpos = this->eback() < this->gptr(); 
381 if (__builtin_expect(!__testpos || 
382 !traits_type::eq(__c, this->gptr()[-1]), false)) 
383 __ret = this->pbackfail(traits_type::to_int_type(__c)); 
384 else 
385 { 
386 this->gbump(-1); 
387 __ret = traits_type::to_int_type(*this->gptr()); 
388 } 
389 return __ret; 
390 } 
391 
392 /** 
393 * @brief Moving backwards in the input stream. 
394 * @return The previous character, if possible. 
395 * 
396 * If a putback position is available, this function decrements 
397 * the input pointer and returns that character. Otherwise, 
398 * calls and returns pbackfail(). The effect is to @a unget 
399 * the last character @a gotten. 
400 */ 
401 int_type 
402 sungetc() 
403 { 
404 int_type __ret; 
405 if (__builtin_expect(this->eback() < this->gptr(), true)) 
406 { 
407 this->gbump(-1); 
408 __ret = traits_type::to_int_type(*this->gptr()); 
409 } 
410 else 
411 __ret = this->pbackfail(); 
412 return __ret; 
413 } 
414 
415 // [27.5.2.2.5] put area 
416 /** 
417 * @brief Entry point for all single-character output functions. 
418 * @param __c A character to output. 
419 * @return @a __c, if possible. 
420 * 
421 * One of two public output functions. 
422 * 
423 * If a write position is available for the output sequence (i.e., 
424 * the buffer is not full), stores @a __c in that position, increments 
425 * the position, and returns @c traits::to_int_type(__c). If a write 
426 * position is not available, returns @c overflow(__c). 
427 */ 
428 int_type 
429 sputc(char_type __c) 
430 { 
431 int_type __ret; 
432 if (__builtin_expect(this->pptr() < this->epptr(), true)) 
433 { 
434 *this->pptr() = __c; 
435 this->pbump(1); 
436 __ret = traits_type::to_int_type(__c); 
437 } 
438 else 
439 __ret = this->overflow(traits_type::to_int_type(__c)); 
440 return __ret; 
441 } 
442 
443 /** 
444 * @brief Entry point for all single-character output functions. 
445 * @param __s A buffer read area. 
446 * @param __n A count. 
447 * 
448 * One of two public output functions. 
449 * 
450 * 
451 * Returns xsputn(__s,__n). The effect is to write @a __s[0] through 
452 * @a __s[__n-1] to the output sequence, if possible. 
453 */ 
454 streamsize 
455 sputn(const char_type* __s, streamsize __n) 
456 { return this->xsputn(__s, __n); } 
457 
458 protected: 
459 /** 
460 * @brief Base constructor. 
461 * 
462 * Only called from derived constructors, and sets up all the 
463 * buffer data to zero, including the pointers described in the 
464 * basic_streambuf class description. Note that, as a result, 
465 * - the class starts with no read nor write positions available, 
466 * - this is not an error 
467 */ 
468 basic_streambuf() 
469 : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), 
470 _M_out_beg(0), _M_out_cur(0), _M_out_end(0), 
471 _M_buf_locale(locale()) 
472 { } 
473 
474 // [27.5.2.3.1] get area access 
475 ///@{ 
476 /** 
477 * @brief Access to the get area. 
478 * 
479 * These functions are only available to other protected functions, 
480 * including derived classes. 
481 * 
482 * - eback() returns the beginning pointer for the input sequence 
483 * - gptr() returns the next pointer for the input sequence 
484 * - egptr() returns the end pointer for the input sequence 
485 */ 
486 char_type* 
487 eback() const { return _M_in_beg; } 
488 
489 char_type* 
490 gptr() const { return _M_in_cur; } 
491 
492 char_type* 
493 egptr() const { return _M_in_end; } 
494 ///@} 
495 
496 /** 
497 * @brief Moving the read position. 
498 * @param __n The delta by which to move. 
499 * 
500 * This just advances the read position without returning any data. 
501 */ 
502 void 
503 gbump(int __n) { _M_in_cur += __n; } 
504 
505 /** 
506 * @brief Setting the three read area pointers. 
507 * @param __gbeg A pointer. 
508 * @param __gnext A pointer. 
509 * @param __gend A pointer. 
510 * @post @a __gbeg == @c eback(), @a __gnext == @c gptr(), and 
511 * @a __gend == @c egptr() 
512 */ 
513 void 
514 setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) 
515 { 
516 _M_in_beg = __gbeg; 
517 _M_in_cur = __gnext; 
518 _M_in_end = __gend; 
519 } 
520 
521 // [27.5.2.3.2] put area access 
522 ///@{ 
523 /** 
524 * @brief Access to the put area. 
525 * 
526 * These functions are only available to other protected functions, 
527 * including derived classes. 
528 * 
529 * - pbase() returns the beginning pointer for the output sequence 
530 * - pptr() returns the next pointer for the output sequence 
531 * - epptr() returns the end pointer for the output sequence 
532 */ 
533 char_type* 
534 pbase() const { return _M_out_beg; } 
535 
536 char_type* 
537 pptr() const { return _M_out_cur; } 
538 
539 char_type* 
540 epptr() const { return _M_out_end; } 
541 ///@} 
542 
543 /** 
544 * @brief Moving the write position. 
545 * @param __n The delta by which to move. 
546 * 
547 * This just advances the write position without returning any data. 
548 */ 
549 void 
550 pbump(int __n) { _M_out_cur += __n; } 
551 
552 /** 
553 * @brief Setting the three write area pointers. 
554 * @param __pbeg A pointer. 
555 * @param __pend A pointer. 
556 * @post @a __pbeg == @c pbase(), @a __pbeg == @c pptr(), and 
557 * @a __pend == @c epptr() 
558 */ 
559 void 
560 setp(char_type* __pbeg, char_type* __pend) 
561 { 
562 _M_out_beg = _M_out_cur = __pbeg; 
563 _M_out_end = __pend; 
564 } 
565 
566 // [27.5.2.4] virtual functions 
567 // [27.5.2.4.1] locales 
568 /** 
569 * @brief Changes translations. 
570 * @param __loc A new locale. 
571 * 
572 * Translations done during I/O which depend on the current 
573 * locale are changed by this call. The standard adds, 
574 * <em>Between invocations of this function a class derived 
575 * from streambuf can safely cache results of calls to locale 
576 * functions and to members of facets so obtained.</em> 
577 * 
578 * @note Base class version does nothing. 
579 */ 
580 virtual void 
581 imbue(const locale& __loc _IsUnused) 
582 { } 
583 
584 // [27.5.2.4.2] buffer management and positioning 
585 /** 
586 * @brief Manipulates the buffer. 
587 * 
588 * Each derived class provides its own appropriate behavior. See 
589 * the next-to-last paragraph of 
590 * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html#io.streambuf.buffering 
591 * for more on this function. 
592 * 
593 * @note Base class version does nothing, returns @c this. 
594 */ 
595 virtual basic_streambuf<char_type,_Traits>* 
596 setbuf(char_type*, streamsize) 
597 { return this; } 
598 
599 /** 
600 * @brief Alters the stream positions. 
601 * 
602 * Each derived class provides its own appropriate behavior. 
603 * @note Base class version does nothing, returns a @c pos_type 
604 * that represents an invalid stream position. 
605 */ 
606 virtual pos_type 
607 seekoff(off_type, ios_base::seekdir, 
608 ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) 
609 { return pos_type(off_type(-1)); } 
610 
611 /** 
612 * @brief Alters the stream positions. 
613 * 
614 * Each derived class provides its own appropriate behavior. 
615 * @note Base class version does nothing, returns a @c pos_type 
616 * that represents an invalid stream position. 
617 */ 
618 virtual pos_type 
619 seekpos(pos_type, 
620 ios_base::openmode /*__mode*/ = ios_base::in | ios_base::out) 
621 { return pos_type(off_type(-1)); } 
622 
623 /** 
624 * @brief Synchronizes the buffer arrays with the controlled sequences. 
625 * @return -1 on failure. 
626 * 
627 * Each derived class provides its own appropriate behavior, 
628 * including the definition of @a failure. 
629 * @note Base class version does nothing, returns zero. 
630 */ 
631 virtual int 
632 sync() { return 0; } 
633 
634 // [27.5.2.4.3] get area 
635 /** 
636 * @brief Investigating the data available. 
637 * @return An estimate of the number of characters available in the 
638 * input sequence, or -1. 
639 * 
640 * <em>If it returns a positive value, then successive calls to 
641 * @c underflow() will not return @c traits::eof() until at 
642 * least that number of characters have been supplied. If @c 
643 * showmanyc() returns -1, then calls to @c underflow() or @c 
644 * uflow() will fail.</em> [27.5.2.4.3]/1 
645 * 
646 * @note Base class version does nothing, returns zero. 
647 * @note The standard adds that <em>the intention is not only that the 
648 * calls [to underflow or uflow] will not return @c eof() but 
649 * that they will return immediately.</em> 
650 * @note The standard adds that <em>the morphemes of @c showmanyc are 
651 * @b es-how-many-see, not @b show-manic.</em> 
652 */ 
653 virtual streamsize 
654 showmanyc() { return 0; } 
655 
656 /** 
657 * @brief Multiple character extraction. 
658 * @param __s A buffer area. 
659 * @param __n Maximum number of characters to assign. 
660 * @return The number of characters assigned. 
661 * 
662 * Fills @a __s[0] through @a __s[__n-1] with characters from the input 
663 * sequence, as if by @c sbumpc(). Stops when either @a __n characters 
664 * have been copied, or when @c traits::eof() would be copied. 
665 * 
666 * It is expected that derived classes provide a more efficient 
667 * implementation by overriding this definition. 
668 */ 
669 virtual streamsize 
670 xsgetn(char_type* __s, streamsize __n); 
671 
672 /** 
673 * @brief Fetches more data from the controlled sequence. 
674 * @return The first character from the <em>pending sequence</em>. 
675 * 
676 * Informally, this function is called when the input buffer is 
677 * exhausted (or does not exist, as buffering need not actually be 
678 * done). If a buffer exists, it is @a refilled. In either case, the 
679 * next available character is returned, or @c traits::eof() to 
680 * indicate a null pending sequence. 
681 * 
682 * For a formal definition of the pending sequence, see a good text 
683 * such as Langer & Kreft, or [27.5.2.4.3]/7-14. 
684 * 
685 * A functioning input streambuf can be created by overriding only 
686 * this function (no buffer area will be used). For an example, see 
687 * https://gcc.gnu.org/onlinedocs/libstdc++/manual/streambufs.html 
688 * 
689 * @note Base class version does nothing, returns eof(). 
690 */ 
691 virtual int_type 
692 underflow() 
693 { return traits_type::eof(); } 
694 
695 /** 
696 * @brief Fetches more data from the controlled sequence. 
697 * @return The first character from the <em>pending sequence</em>. 
698 * 
699 * Informally, this function does the same thing as @c underflow(), 
700 * and in fact is required to call that function. It also returns 
701 * the new character, like @c underflow() does. However, this 
702 * function also moves the read position forward by one. 
703 */ 
704 virtual int_type 
705 uflow() 
706 { 
707 int_type __ret = traits_type::eof(); 
708 const bool __testeof = traits_type::eq_int_type(this->underflow(), 
709 __ret); 
710 if (!__testeof) 
711 { 
712 __ret = traits_type::to_int_type(*this->gptr()); 
713 this->gbump(1); 
714 } 
715 return __ret; 
716 } 
717 
718 // [27.5.2.4.4] putback 
719 /** 
720 * @brief Tries to back up the input sequence. 
721 * @param __c The character to be inserted back into the sequence. 
722 * @return eof() on failure, <em>some other value</em> on success 
723 * @post The constraints of @c gptr(), @c eback(), and @c pptr() 
724 * are the same as for @c underflow(). 
725 * 
726 * @note Base class version does nothing, returns eof(). 
727 */ 
728 virtual int_type 
729 pbackfail(int_type __c _IsUnused = traits_type::eof()) 
730 { return traits_type::eof(); } 
731 
732 // Put area: 
733 /** 
734 * @brief Multiple character insertion. 
735 * @param __s A buffer area. 
736 * @param __n Maximum number of characters to write. 
737 * @return The number of characters written. 
738 * 
739 * Writes @a __s[0] through @a __s[__n-1] to the output sequence, as if 
740 * by @c sputc(). Stops when either @a n characters have been 
741 * copied, or when @c sputc() would return @c traits::eof(). 
742 * 
743 * It is expected that derived classes provide a more efficient 
744 * implementation by overriding this definition. 
745 */ 
746 virtual streamsize 
747 xsputn(const char_type* __s, streamsize __n); 
748 
749 /** 
750 * @brief Consumes data from the buffer; writes to the 
751 * controlled sequence. 
752 * @param __c An additional character to consume. 
753 * @return eof() to indicate failure, something else (usually 
754 * @a __c, or not_eof()) 
755 * 
756 * Informally, this function is called when the output buffer 
757 * is full (or does not exist, as buffering need not actually 
758 * be done). If a buffer exists, it is @a consumed, with 
759 * <em>some effect</em> on the controlled sequence. 
760 * (Typically, the buffer is written out to the sequence 
761 * verbatim.) In either case, the character @a c is also 
762 * written out, if @a __c is not @c eof(). 
763 * 
764 * For a formal definition of this function, see a good text 
765 * such as Langer & Kreft, or [27.5.2.4.5]/3-7. 
766 * 
767 * A functioning output streambuf can be created by overriding only 
768 * this function (no buffer area will be used). 
769 * 
770 * @note Base class version does nothing, returns eof(). 
771 */ 
772 virtual int_type 
773 overflow(int_type __c _IsUnused = traits_type::eof()) 
774 { return traits_type::eof(); } 
775 
776#if _GLIBCXX_USE_DEPRECATED && __cplusplus <= 201402L 
777 // Annex D.6 (removed in C++17) 
778 public: 
779 /** 
780 * @brief Tosses a character. 
781 * 
782 * Advances the read pointer, ignoring the character that would have 
783 * been read. 
784 * 
785 * See http://gcc.gnu.org/ml/libstdc++/2002-05/msg00168.html 
786 */ 
787 _GLIBCXX_DEPRECATED_SUGGEST("std::basic_streambuf::sbumpc") 
788 void 
789 stossc() 
790 { 
791 if (this->gptr() < this->egptr()) 
792 this->gbump(1); 
793 else 
794 this->uflow(); 
795 } 
796#endif 
797 
798 // Also used by specializations for char and wchar_t in src. 
799 void 
800 __safe_gbump(streamsize __n) { _M_in_cur += __n; } 
801 
802 void 
803 __safe_pbump(streamsize __n) { _M_out_cur += __n; } 
804 
805#if __cplusplus < 201103L 
806 private: 
807#else 
808 protected: 
809#endif 
810 basic_streambuf(const basic_streambuf&); 
811 
812 basic_streambuf& 
813 operator=(const basic_streambuf&); 
814 
815#if __cplusplus >= 201103L 
816 void 
817 swap(basic_streambuf& __sb) 
818 { 
819 std::swap(_M_in_beg, __sb._M_in_beg); 
820 std::swap(_M_in_cur, __sb._M_in_cur); 
821 std::swap(_M_in_end, __sb._M_in_end); 
822 std::swap(_M_out_beg, __sb._M_out_beg); 
823 std::swap(_M_out_cur, __sb._M_out_cur); 
824 std::swap(_M_out_end, __sb._M_out_end); 
825 std::swap(_M_buf_locale, __sb._M_buf_locale); 
826 } 
827#endif 
828 }; 
829 
830#if __cplusplus >= 201103L 
831 template<typename _CharT, typename _Traits> 
832 std::basic_streambuf<_CharT, _Traits>:: 
833 basic_streambuf(const basic_streambuf&) = default; 
834 
835 template<typename _CharT, typename _Traits> 
836 std::basic_streambuf<_CharT, _Traits>& 
837 std::basic_streambuf<_CharT, _Traits>:: 
838 operator=(const basic_streambuf&) = default; 
839#endif 
840 
841 // Explicit specialization declarations, defined in src/streambuf.cc. 
842 template<> 
843 streamsize 
844 __copy_streambufs_eof(basic_streambuf<char>* __sbin, 
845 basic_streambuf<char>* __sbout, bool& __ineof); 
846#ifdef _GLIBCXX_USE_WCHAR_T 
847 template<> 
848 streamsize 
849 __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin, 
850 basic_streambuf<wchar_t>* __sbout, bool& __ineof); 
851#endif 
852 
853#undef _IsUnused 
854 
855_GLIBCXX_END_NAMESPACE_VERSION 
856} // namespace 
857 
858#include <bits/streambuf.tcc> 
859 
860#endif /* _GLIBCXX_STREAMBUF */ 
861