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