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