1// -*- C++ -*-
2//===------------------------- streambuf ----------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_STEAMBUF
12#define _LIBCPP_STEAMBUF
13
14/*
15    streambuf synopsis
16
17namespace std
18{
19
20template <class charT, class traits = char_traits<charT> >
21class basic_streambuf
22{
23public:
24    // types:
25    typedef charT char_type;
26    typedef traits traits_type;
27    typedef typename traits_type::int_type int_type;
28    typedef typename traits_type::pos_type pos_type;
29    typedef typename traits_type::off_type off_type;
30
31    virtual ~basic_streambuf();
32
33    // 27.6.2.2.1 locales:
34    locale pubimbue(const locale& loc);
35    locale getloc() const;
36
37    // 27.6.2.2.2 buffer and positioning:
38    basic_streambuf* pubsetbuf(char_type* s, streamsize n);
39    pos_type pubseekoff(off_type off, ios_base::seekdir way,
40                        ios_base::openmode which = ios_base::in | ios_base::out);
41    pos_type pubseekpos(pos_type sp,
42                        ios_base::openmode which = ios_base::in | ios_base::out);
43    int pubsync();
44
45    // Get and put areas:
46    // 27.6.2.2.3 Get area:
47    streamsize in_avail();
48    int_type snextc();
49    int_type sbumpc();
50    int_type sgetc();
51    streamsize sgetn(char_type* s, streamsize n);
52
53    // 27.6.2.2.4 Putback:
54    int_type sputbackc(char_type c);
55    int_type sungetc();
56
57    // 27.6.2.2.5 Put area:
58    int_type sputc(char_type c);
59    streamsize sputn(const char_type* s, streamsize n);
60
61protected:
62    basic_streambuf();
63    basic_streambuf(const basic_streambuf& rhs);
64    basic_streambuf& operator=(const basic_streambuf& rhs);
65    void swap(basic_streambuf& rhs);
66
67    // 27.6.2.3.2 Get area:
68    char_type* eback() const;
69    char_type* gptr() const;
70    char_type* egptr() const;
71    void gbump(int n);
72    void setg(char_type* gbeg, char_type* gnext, char_type* gend);
73
74    // 27.6.2.3.3 Put area:
75    char_type* pbase() const;
76    char_type* pptr() const;
77    char_type* epptr() const;
78    void pbump(int n);
79    void setp(char_type* pbeg, char_type* pend);
80
81    // 27.6.2.4 virtual functions:
82    // 27.6.2.4.1 Locales:
83    virtual void imbue(const locale& loc);
84
85    // 27.6.2.4.2 Buffer management and positioning:
86    virtual basic_streambuf* setbuf(char_type* s, streamsize n);
87    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
88                             ios_base::openmode which = ios_base::in | ios_base::out);
89    virtual pos_type seekpos(pos_type sp,
90                             ios_base::openmode which = ios_base::in | ios_base::out);
91    virtual int sync();
92
93    // 27.6.2.4.3 Get area:
94    virtual streamsize showmanyc();
95    virtual streamsize xsgetn(char_type* s, streamsize n);
96    virtual int_type underflow();
97    virtual int_type uflow();
98
99    // 27.6.2.4.4 Putback:
100    virtual int_type pbackfail(int_type c = traits_type::eof());
101
102    // 27.6.2.4.5 Put area:
103    virtual streamsize xsputn(const char_type* s, streamsize n);
104    virtual int_type overflow (int_type c = traits_type::eof());
105};
106
107}  // std
108
109*/
110
111#include <__config>
112#include <iosfwd>
113#include <ios>
114
115#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
116#pragma GCC system_header
117#endif
118
119_LIBCPP_BEGIN_NAMESPACE_STD
120
121template <class _CharT, class _Traits>
122class _LIBCPP_TYPE_VIS_ONLY basic_streambuf
123{
124public:
125    // types:
126    typedef _CharT                         char_type;
127    typedef _Traits                        traits_type;
128    typedef typename traits_type::int_type int_type;
129    typedef typename traits_type::pos_type pos_type;
130    typedef typename traits_type::off_type off_type;
131
132    virtual ~basic_streambuf();
133
134    // 27.6.2.2.1 locales:
135    locale pubimbue(const locale& __loc);
136    locale getloc() const;
137
138    // 27.6.2.2.2 buffer and positioning:
139    basic_streambuf* pubsetbuf(char_type* __s, streamsize __n);
140    pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
141                        ios_base::openmode __which = ios_base::in | ios_base::out);
142    pos_type pubseekpos(pos_type __sp,
143                        ios_base::openmode __which = ios_base::in | ios_base::out);
144    int pubsync();
145
146    // Get and put areas:
147    // 27.6.2.2.3 Get area:
148    streamsize in_avail();
149    int_type snextc();
150    int_type sbumpc();
151    int_type sgetc();
152    streamsize sgetn(char_type* __s, streamsize __n);
153
154    // 27.6.2.2.4 Putback:
155    int_type sputbackc(char_type __c);
156    int_type sungetc();
157
158    // 27.6.2.2.5 Put area:
159    int_type sputc(char_type __c);
160    streamsize sputn(const char_type* __s, streamsize __n);
161
162protected:
163    basic_streambuf();
164    basic_streambuf(const basic_streambuf& __rhs);
165    basic_streambuf& operator=(const basic_streambuf& __rhs);
166    void swap(basic_streambuf& __rhs);
167
168    // 27.6.2.3.2 Get area:
169    _LIBCPP_ALWAYS_INLINE char_type* eback() const {return __binp_;}
170    _LIBCPP_ALWAYS_INLINE char_type* gptr()  const {return __ninp_;}
171    _LIBCPP_ALWAYS_INLINE char_type* egptr() const {return __einp_;}
172    void gbump(int __n);
173    void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend);
174
175    // 27.6.2.3.3 Put area:
176    _LIBCPP_ALWAYS_INLINE char_type* pbase() const {return __bout_;}
177    _LIBCPP_ALWAYS_INLINE char_type* pptr()  const {return __nout_;}
178    _LIBCPP_ALWAYS_INLINE char_type* epptr() const {return __eout_;}
179    void pbump(int __n);
180    void setp(char_type* __pbeg, char_type* __pend);
181
182    // 27.6.2.4 virtual functions:
183    // 27.6.2.4.1 Locales:
184    virtual void imbue(const locale& __loc);
185
186    // 27.6.2.4.2 Buffer management and positioning:
187    virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
188    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
189                             ios_base::openmode __which = ios_base::in | ios_base::out);
190    virtual pos_type seekpos(pos_type __sp,
191                             ios_base::openmode __which = ios_base::in | ios_base::out);
192    virtual int sync();
193
194    // 27.6.2.4.3 Get area:
195    virtual streamsize showmanyc();
196    virtual streamsize xsgetn(char_type* __s, streamsize __n);
197    virtual int_type underflow();
198    virtual int_type uflow();
199
200    // 27.6.2.4.4 Putback:
201    virtual int_type pbackfail(int_type __c = traits_type::eof());
202
203    // 27.6.2.4.5 Put area:
204    virtual streamsize xsputn(const char_type* __s, streamsize __n);
205    virtual int_type overflow(int_type __c = traits_type::eof());
206
207private:
208    locale __loc_;
209    char_type* __binp_;
210    char_type* __ninp_;
211    char_type* __einp_;
212    char_type* __bout_;
213    char_type* __nout_;
214    char_type* __eout_;
215};
216
217template <class _CharT, class _Traits>
218basic_streambuf<_CharT, _Traits>::~basic_streambuf()
219{
220}
221
222template <class _CharT, class _Traits>
223inline _LIBCPP_INLINE_VISIBILITY
224locale
225basic_streambuf<_CharT, _Traits>::pubimbue(const locale& __loc)
226{
227    imbue(__loc);
228    locale __r = __loc_;
229    __loc_ = __loc;
230    return __r;
231}
232
233template <class _CharT, class _Traits>
234inline _LIBCPP_INLINE_VISIBILITY
235locale
236basic_streambuf<_CharT, _Traits>::getloc() const
237{
238    return __loc_;
239}
240
241template <class _CharT, class _Traits>
242inline _LIBCPP_INLINE_VISIBILITY
243basic_streambuf<_CharT, _Traits>*
244basic_streambuf<_CharT, _Traits>::pubsetbuf(char_type* __s, streamsize __n)
245{
246    return setbuf(__s, __n);
247}
248
249template <class _CharT, class _Traits>
250inline _LIBCPP_INLINE_VISIBILITY
251typename basic_streambuf<_CharT, _Traits>::pos_type
252basic_streambuf<_CharT, _Traits>::pubseekoff(off_type __off,
253                                             ios_base::seekdir __way,
254                                             ios_base::openmode __which)
255{
256    return seekoff(__off, __way, __which);
257}
258
259template <class _CharT, class _Traits>
260inline _LIBCPP_INLINE_VISIBILITY
261typename basic_streambuf<_CharT, _Traits>::pos_type
262basic_streambuf<_CharT, _Traits>::pubseekpos(pos_type __sp,
263                                             ios_base::openmode __which)
264{
265    return seekpos(__sp, __which);
266}
267
268template <class _CharT, class _Traits>
269inline _LIBCPP_INLINE_VISIBILITY
270int
271basic_streambuf<_CharT, _Traits>::pubsync()
272{
273    return sync();
274}
275
276template <class _CharT, class _Traits>
277inline _LIBCPP_INLINE_VISIBILITY
278streamsize
279basic_streambuf<_CharT, _Traits>::in_avail()
280{
281    if (__ninp_ < __einp_)
282        return static_cast<streamsize>(__einp_ - __ninp_);
283    return showmanyc();
284}
285
286template <class _CharT, class _Traits>
287inline _LIBCPP_INLINE_VISIBILITY
288typename basic_streambuf<_CharT, _Traits>::int_type
289basic_streambuf<_CharT, _Traits>::snextc()
290{
291    if (sbumpc() == traits_type::eof())
292        return traits_type::eof();
293    return sgetc();
294}
295
296template <class _CharT, class _Traits>
297inline _LIBCPP_INLINE_VISIBILITY
298typename basic_streambuf<_CharT, _Traits>::int_type
299basic_streambuf<_CharT, _Traits>::sbumpc()
300{
301    if (__ninp_ == __einp_)
302        return uflow();
303    return traits_type::to_int_type(*__ninp_++);
304}
305
306template <class _CharT, class _Traits>
307inline _LIBCPP_INLINE_VISIBILITY
308typename basic_streambuf<_CharT, _Traits>::int_type
309basic_streambuf<_CharT, _Traits>::sgetc()
310{
311    if (__ninp_ == __einp_)
312        return underflow();
313    return traits_type::to_int_type(*__ninp_);
314}
315
316template <class _CharT, class _Traits>
317inline _LIBCPP_INLINE_VISIBILITY
318streamsize
319basic_streambuf<_CharT, _Traits>::sgetn(char_type* __s, streamsize __n)
320{
321    return xsgetn(__s, __n);
322}
323
324template <class _CharT, class _Traits>
325inline _LIBCPP_INLINE_VISIBILITY
326typename basic_streambuf<_CharT, _Traits>::int_type
327basic_streambuf<_CharT, _Traits>::sputbackc(char_type __c)
328{
329    if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
330        return pbackfail(traits_type::to_int_type(__c));
331    return traits_type::to_int_type(*--__ninp_);
332}
333
334template <class _CharT, class _Traits>
335inline _LIBCPP_INLINE_VISIBILITY
336typename basic_streambuf<_CharT, _Traits>::int_type
337basic_streambuf<_CharT, _Traits>::sungetc()
338{
339    if (__binp_ == __ninp_)
340        return pbackfail();
341    return traits_type::to_int_type(*--__ninp_);
342}
343
344template <class _CharT, class _Traits>
345inline _LIBCPP_INLINE_VISIBILITY
346typename basic_streambuf<_CharT, _Traits>::int_type
347basic_streambuf<_CharT, _Traits>::sputc(char_type __c)
348{
349    if (__nout_ == __eout_)
350        return overflow(traits_type::to_int_type(__c));
351    *__nout_++ = __c;
352    return traits_type::to_int_type(__c);
353}
354
355template <class _CharT, class _Traits>
356inline _LIBCPP_INLINE_VISIBILITY
357streamsize
358basic_streambuf<_CharT, _Traits>::sputn(const char_type* __s, streamsize __n)
359{
360    return xsputn(__s, __n);
361}
362
363template <class _CharT, class _Traits>
364basic_streambuf<_CharT, _Traits>::basic_streambuf()
365    : __binp_(0),
366      __ninp_(0),
367      __einp_(0),
368      __bout_(0),
369      __nout_(0),
370      __eout_(0)
371{
372}
373
374template <class _CharT, class _Traits>
375basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
376    : __loc_(__sb.__loc_),
377      __binp_(__sb.__binp_),
378      __ninp_(__sb.__ninp_),
379      __einp_(__sb.__einp_),
380      __bout_(__sb.__bout_),
381      __nout_(__sb.__nout_),
382      __eout_(__sb.__eout_)
383{
384}
385
386template <class _CharT, class _Traits>
387basic_streambuf<_CharT, _Traits>&
388basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb)
389{
390    __loc_ = __sb.__loc_;
391    __binp_ = __sb.__binp_;
392    __ninp_ = __sb.__ninp_;
393    __einp_ = __sb.__einp_;
394    __bout_ = __sb.__bout_;
395    __nout_ = __sb.__nout_;
396    __eout_ = __sb.__eout_;
397    return *this;
398}
399
400template <class _CharT, class _Traits>
401void
402basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
403{
404    _VSTD::swap(__loc_, __sb.__loc_);
405    _VSTD::swap(__binp_, __sb.__binp_);
406    _VSTD::swap(__ninp_, __sb.__ninp_);
407    _VSTD::swap(__einp_, __sb.__einp_);
408    _VSTD::swap(__bout_, __sb.__bout_);
409    _VSTD::swap(__nout_, __sb.__nout_);
410    _VSTD::swap(__eout_, __sb.__eout_);
411}
412
413template <class _CharT, class _Traits>
414inline _LIBCPP_INLINE_VISIBILITY
415void
416basic_streambuf<_CharT, _Traits>::gbump(int __n)
417{
418    __ninp_ += __n;
419}
420
421template <class _CharT, class _Traits>
422inline _LIBCPP_INLINE_VISIBILITY
423void
424basic_streambuf<_CharT, _Traits>::setg(char_type* __gbeg, char_type* __gnext,
425                                                          char_type* __gend)
426{
427    __binp_ = __gbeg;
428    __ninp_ = __gnext;
429    __einp_ = __gend;
430}
431
432template <class _CharT, class _Traits>
433inline _LIBCPP_INLINE_VISIBILITY
434void
435basic_streambuf<_CharT, _Traits>::pbump(int __n)
436{
437    __nout_ += __n;
438}
439
440template <class _CharT, class _Traits>
441inline _LIBCPP_INLINE_VISIBILITY
442void
443basic_streambuf<_CharT, _Traits>::setp(char_type* __pbeg, char_type* __pend)
444{
445    __bout_ = __nout_ = __pbeg;
446    __eout_ = __pend;
447}
448
449template <class _CharT, class _Traits>
450void
451basic_streambuf<_CharT, _Traits>::imbue(const locale&)
452{
453}
454
455template <class _CharT, class _Traits>
456basic_streambuf<_CharT, _Traits>*
457basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
458{
459    return this;
460}
461
462template <class _CharT, class _Traits>
463typename basic_streambuf<_CharT, _Traits>::pos_type
464basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
465                                          ios_base::openmode)
466{
467    return pos_type(off_type(-1));
468}
469
470template <class _CharT, class _Traits>
471typename basic_streambuf<_CharT, _Traits>::pos_type
472basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
473{
474    return pos_type(off_type(-1));
475}
476
477template <class _CharT, class _Traits>
478int
479basic_streambuf<_CharT, _Traits>::sync()
480{
481    return 0;
482}
483
484template <class _CharT, class _Traits>
485streamsize
486basic_streambuf<_CharT, _Traits>::showmanyc()
487{
488    return 0;
489}
490
491template <class _CharT, class _Traits>
492streamsize
493basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
494{
495    const int_type __eof = traits_type::eof();
496    int_type __c;
497    streamsize __i = 0;
498    for (;__i < __n; ++__i, ++__s)
499    {
500        if (__ninp_ < __einp_)
501            *__s = *__ninp_++;
502        else if ((__c = uflow()) != __eof)
503            *__s = traits_type::to_char_type(__c);
504        else
505            break;
506    }
507    return __i;
508}
509
510template <class _CharT, class _Traits>
511typename basic_streambuf<_CharT, _Traits>::int_type
512basic_streambuf<_CharT, _Traits>::underflow()
513{
514    return traits_type::eof();
515}
516
517template <class _CharT, class _Traits>
518typename basic_streambuf<_CharT, _Traits>::int_type
519basic_streambuf<_CharT, _Traits>::uflow()
520{
521    if (underflow() == traits_type::eof())
522        return traits_type::eof();
523    return traits_type::to_int_type(*__ninp_++);
524}
525
526template <class _CharT, class _Traits>
527typename basic_streambuf<_CharT, _Traits>::int_type
528basic_streambuf<_CharT, _Traits>::pbackfail(int_type)
529{
530    return traits_type::eof();
531}
532
533template <class _CharT, class _Traits>
534streamsize
535basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
536{
537    streamsize __i = 0;
538    int_type __eof = traits_type::eof();
539    while( __i < __n)
540    {
541        if (__nout_ >= __eout_)
542        {
543            if (overflow(traits_type::to_int_type(*__s)) == __eof)
544                break;
545            ++__s;
546            ++__i;
547        }
548        else
549        {
550            streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i);
551            traits_type::copy(__nout_, __s, __chunk_size);
552            __nout_ += __chunk_size;
553            __s     += __chunk_size;
554            __i     += __chunk_size;
555        }
556    }
557    return __i;
558}
559
560template <class _CharT, class _Traits>
561typename basic_streambuf<_CharT, _Traits>::int_type
562basic_streambuf<_CharT, _Traits>::overflow(int_type)
563{
564    return traits_type::eof();
565}
566
567_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_streambuf<char>)
568_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_streambuf<wchar_t>)
569
570_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ios<char>)
571_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ios<wchar_t>)
572
573_LIBCPP_END_NAMESPACE_STD
574
575#endif  // _LIBCPP_STEAMBUF
576