Home | History | Annotate | Download | only in v1 
      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 
     17 namespace std
     18 {
     19 
     20 template <class charT, class traits = char_traits<charT> >
     21 class basic_streambuf
     22 {
     23 public:
     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 
     61 protected:
     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 
    121 template <class _CharT, class _Traits>
    122 class _LIBCPP_TEMPLATE_VIS basic_streambuf
    123 {
    124 public:
    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     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    136     locale pubimbue(const locale& __loc) {
    137         imbue(__loc);
    138         locale __r = __loc_;
    139         __loc_ = __loc;
    140         return __r;
    141     }
    142 
    143     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    144     locale getloc() const { return __loc_; }
    145 
    146     // 27.6.2.2.2 buffer and positioning:
    147     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    148     basic_streambuf* pubsetbuf(char_type* __s, streamsize __n)
    149     { return setbuf(__s, __n); }
    150 
    151     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    152     pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
    153                         ios_base::openmode __which = ios_base::in | ios_base::out)
    154     { return seekoff(__off, __way, __which); }
    155 
    156     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    157     pos_type pubseekpos(pos_type __sp,
    158                         ios_base::openmode __which = ios_base::in | ios_base::out)
    159     { return seekpos(__sp, __which); }
    160 
    161     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    162     int pubsync() { return sync(); }
    163 
    164     // Get and put areas:
    165     // 27.6.2.2.3 Get area:
    166     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    167     streamsize in_avail() {
    168         if (__ninp_ < __einp_)
    169             return static_cast<streamsize>(__einp_ - __ninp_);
    170         return showmanyc();
    171     }
    172 
    173     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    174     int_type snextc() {
    175         if (sbumpc() == traits_type::eof())
    176             return traits_type::eof();
    177         return sgetc();
    178     }
    179 
    180     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    181     int_type sbumpc() {
    182         if (__ninp_ == __einp_)
    183             return uflow();
    184         return traits_type::to_int_type(*__ninp_++);
    185     }
    186 
    187     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    188     int_type sgetc() {
    189         if (__ninp_ == __einp_)
    190             return underflow();
    191         return traits_type::to_int_type(*__ninp_);
    192     }
    193 
    194     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    195     streamsize sgetn(char_type* __s, streamsize __n)
    196     { return xsgetn(__s, __n); }
    197 
    198     // 27.6.2.2.4 Putback:
    199     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    200     int_type sputbackc(char_type __c) {
    201         if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
    202             return pbackfail(traits_type::to_int_type(__c));
    203         return traits_type::to_int_type(*--__ninp_);
    204     }
    205 
    206     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    207     int_type sungetc() {
    208         if (__binp_ == __ninp_)
    209           return pbackfail();
    210         return traits_type::to_int_type(*--__ninp_);
    211     }
    212 
    213     // 27.6.2.2.5 Put area:
    214     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    215     int_type sputc(char_type __c) {
    216         if (__nout_ == __eout_)
    217             return overflow(traits_type::to_int_type(__c));
    218         *__nout_++ = __c;
    219         return traits_type::to_int_type(__c);
    220     }
    221 
    222     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    223     streamsize sputn(const char_type* __s, streamsize __n)
    224     { return xsputn(__s, __n); }
    225 
    226 protected:
    227     basic_streambuf();
    228     basic_streambuf(const basic_streambuf& __rhs);
    229     basic_streambuf& operator=(const basic_streambuf& __rhs);
    230     void swap(basic_streambuf& __rhs);
    231 
    232     // 27.6.2.3.2 Get area:
    233     _LIBCPP_ALWAYS_INLINE char_type* eback() const {return __binp_;}
    234     _LIBCPP_ALWAYS_INLINE char_type* gptr()  const {return __ninp_;}
    235     _LIBCPP_ALWAYS_INLINE char_type* egptr() const {return __einp_;}
    236 
    237     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    238     void gbump(int __n) { __ninp_ += __n; }
    239 
    240     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    241     void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
    242         __binp_ = __gbeg;
    243         __ninp_ = __gnext;
    244         __einp_ = __gend;
    245     }
    246 
    247     // 27.6.2.3.3 Put area:
    248     _LIBCPP_ALWAYS_INLINE char_type* pbase() const {return __bout_;}
    249     _LIBCPP_ALWAYS_INLINE char_type* pptr()  const {return __nout_;}
    250     _LIBCPP_ALWAYS_INLINE char_type* epptr() const {return __eout_;}
    251 
    252     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    253     void pbump(int __n) { __nout_ += __n; }
    254 
    255     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    256     void setp(char_type* __pbeg, char_type* __pend) {
    257         __bout_ = __nout_ = __pbeg;
    258         __eout_ = __pend;
    259     }
    260 
    261     // 27.6.2.4 virtual functions:
    262     // 27.6.2.4.1 Locales:
    263     virtual void imbue(const locale& __loc);
    264 
    265     // 27.6.2.4.2 Buffer management and positioning:
    266     virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
    267     virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
    268                              ios_base::openmode __which = ios_base::in | ios_base::out);
    269     virtual pos_type seekpos(pos_type __sp,
    270                              ios_base::openmode __which = ios_base::in | ios_base::out);
    271     virtual int sync();
    272 
    273     // 27.6.2.4.3 Get area:
    274     virtual streamsize showmanyc();
    275     virtual streamsize xsgetn(char_type* __s, streamsize __n);
    276     virtual int_type underflow();
    277     virtual int_type uflow();
    278 
    279     // 27.6.2.4.4 Putback:
    280     virtual int_type pbackfail(int_type __c = traits_type::eof());
    281 
    282     // 27.6.2.4.5 Put area:
    283     virtual streamsize xsputn(const char_type* __s, streamsize __n);
    284     virtual int_type overflow(int_type __c = traits_type::eof());
    285 
    286 private:
    287     locale __loc_;
    288     char_type* __binp_;
    289     char_type* __ninp_;
    290     char_type* __einp_;
    291     char_type* __bout_;
    292     char_type* __nout_;
    293     char_type* __eout_;
    294 };
    295 
    296 template <class _CharT, class _Traits>
    297 basic_streambuf<_CharT, _Traits>::~basic_streambuf()
    298 {
    299 }
    300 
    301 template <class _CharT, class _Traits>
    302 basic_streambuf<_CharT, _Traits>::basic_streambuf()
    303     : __binp_(0),
    304       __ninp_(0),
    305       __einp_(0),
    306       __bout_(0),
    307       __nout_(0),
    308       __eout_(0)
    309 {
    310 }
    311 
    312 template <class _CharT, class _Traits>
    313 basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
    314     : __loc_(__sb.__loc_),
    315       __binp_(__sb.__binp_),
    316       __ninp_(__sb.__ninp_),
    317       __einp_(__sb.__einp_),
    318       __bout_(__sb.__bout_),
    319       __nout_(__sb.__nout_),
    320       __eout_(__sb.__eout_)
    321 {
    322 }
    323 
    324 template <class _CharT, class _Traits>
    325 basic_streambuf<_CharT, _Traits>&
    326 basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb)
    327 {
    328     __loc_ = __sb.__loc_;
    329     __binp_ = __sb.__binp_;
    330     __ninp_ = __sb.__ninp_;
    331     __einp_ = __sb.__einp_;
    332     __bout_ = __sb.__bout_;
    333     __nout_ = __sb.__nout_;
    334     __eout_ = __sb.__eout_;
    335     return *this;
    336 }
    337 
    338 template <class _CharT, class _Traits>
    339 void
    340 basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
    341 {
    342     _VSTD::swap(__loc_, __sb.__loc_);
    343     _VSTD::swap(__binp_, __sb.__binp_);
    344     _VSTD::swap(__ninp_, __sb.__ninp_);
    345     _VSTD::swap(__einp_, __sb.__einp_);
    346     _VSTD::swap(__bout_, __sb.__bout_);
    347     _VSTD::swap(__nout_, __sb.__nout_);
    348     _VSTD::swap(__eout_, __sb.__eout_);
    349 }
    350 
    351 template <class _CharT, class _Traits>
    352 void
    353 basic_streambuf<_CharT, _Traits>::imbue(const locale&)
    354 {
    355 }
    356 
    357 template <class _CharT, class _Traits>
    358 basic_streambuf<_CharT, _Traits>*
    359 basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
    360 {
    361     return this;
    362 }
    363 
    364 template <class _CharT, class _Traits>
    365 typename basic_streambuf<_CharT, _Traits>::pos_type
    366 basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
    367                                           ios_base::openmode)
    368 {
    369     return pos_type(off_type(-1));
    370 }
    371 
    372 template <class _CharT, class _Traits>
    373 typename basic_streambuf<_CharT, _Traits>::pos_type
    374 basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
    375 {
    376     return pos_type(off_type(-1));
    377 }
    378 
    379 template <class _CharT, class _Traits>
    380 int
    381 basic_streambuf<_CharT, _Traits>::sync()
    382 {
    383     return 0;
    384 }
    385 
    386 template <class _CharT, class _Traits>
    387 streamsize
    388 basic_streambuf<_CharT, _Traits>::showmanyc()
    389 {
    390     return 0;
    391 }
    392 
    393 template <class _CharT, class _Traits>
    394 streamsize
    395 basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
    396 {
    397     const int_type __eof = traits_type::eof();
    398     int_type __c;
    399     streamsize __i = 0;
    400     while(__i < __n)
    401     {
    402         if (__ninp_ < __einp_)
    403         {
    404             const streamsize __len = _VSTD::min(__einp_ - __ninp_, __n - __i);
    405             traits_type::copy(__s, __ninp_, __len);
    406             __s +=  __len;
    407             __i +=  __len;
    408             this->gbump(__len);
    409         }
    410         else if ((__c = uflow()) != __eof)
    411         {
    412             *__s = traits_type::to_char_type(__c);
    413             ++__s;
    414             ++__i;
    415         }
    416         else
    417             break;
    418     }
    419     return __i;
    420 }
    421 
    422 template <class _CharT, class _Traits>
    423 typename basic_streambuf<_CharT, _Traits>::int_type
    424 basic_streambuf<_CharT, _Traits>::underflow()
    425 {
    426     return traits_type::eof();
    427 }
    428 
    429 template <class _CharT, class _Traits>
    430 typename basic_streambuf<_CharT, _Traits>::int_type
    431 basic_streambuf<_CharT, _Traits>::uflow()
    432 {
    433     if (underflow() == traits_type::eof())
    434         return traits_type::eof();
    435     return traits_type::to_int_type(*__ninp_++);
    436 }
    437 
    438 template <class _CharT, class _Traits>
    439 typename basic_streambuf<_CharT, _Traits>::int_type
    440 basic_streambuf<_CharT, _Traits>::pbackfail(int_type)
    441 {
    442     return traits_type::eof();
    443 }
    444 
    445 template <class _CharT, class _Traits>
    446 streamsize
    447 basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
    448 {
    449     streamsize __i = 0;
    450     int_type __eof = traits_type::eof();
    451     while( __i < __n)
    452     {
    453         if (__nout_ >= __eout_)
    454         {
    455             if (overflow(traits_type::to_int_type(*__s)) == __eof)
    456                 break;
    457             ++__s;
    458             ++__i;
    459         }
    460         else
    461         {
    462             streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i);
    463             traits_type::copy(__nout_, __s, __chunk_size);
    464             __nout_ += __chunk_size;
    465             __s     += __chunk_size;
    466             __i     += __chunk_size;
    467         }
    468     }
    469     return __i;
    470 }
    471 
    472 template <class _CharT, class _Traits>
    473 typename basic_streambuf<_CharT, _Traits>::int_type
    474 basic_streambuf<_CharT, _Traits>::overflow(int_type)
    475 {
    476     return traits_type::eof();
    477 }
    478 
    479 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<char>)
    480 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<wchar_t>)
    481 
    482 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<char>)
    483 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t>)
    484 
    485 _LIBCPP_END_NAMESPACE_STD
    486 
    487 #endif  // _LIBCPP_STEAMBUF
    488