← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/include/libcxx/streambuf

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/libcxx/streambuf
 
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_TYPE_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
    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
 
 
162
protected:
 
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
 
 
207
private:
 
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
 
 
217
template <class _CharT, class _Traits>
 
218
basic_streambuf<_CharT, _Traits>::~basic_streambuf()
 
219
{
 
220
}
 
221
 
 
222
template <class _CharT, class _Traits>
 
223
inline _LIBCPP_INLINE_VISIBILITY
 
224
locale
 
225
basic_streambuf<_CharT, _Traits>::pubimbue(const locale& __loc)
 
226
{
 
227
    imbue(__loc);
 
228
    locale __r = __loc_;
 
229
    __loc_ = __loc;
 
230
    return __r;
 
231
}
 
232
 
 
233
template <class _CharT, class _Traits>
 
234
inline _LIBCPP_INLINE_VISIBILITY
 
235
locale
 
236
basic_streambuf<_CharT, _Traits>::getloc() const
 
237
{
 
238
    return __loc_;
 
239
}
 
240
 
 
241
template <class _CharT, class _Traits>
 
242
inline _LIBCPP_INLINE_VISIBILITY
 
243
basic_streambuf<_CharT, _Traits>*
 
244
basic_streambuf<_CharT, _Traits>::pubsetbuf(char_type* __s, streamsize __n)
 
245
{
 
246
    return setbuf(__s, __n);
 
247
}
 
248
 
 
249
template <class _CharT, class _Traits>
 
250
inline _LIBCPP_INLINE_VISIBILITY
 
251
typename basic_streambuf<_CharT, _Traits>::pos_type
 
252
basic_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
 
 
259
template <class _CharT, class _Traits>
 
260
inline _LIBCPP_INLINE_VISIBILITY
 
261
typename basic_streambuf<_CharT, _Traits>::pos_type
 
262
basic_streambuf<_CharT, _Traits>::pubseekpos(pos_type __sp,
 
263
                                             ios_base::openmode __which)
 
264
{
 
265
    return seekpos(__sp, __which);
 
266
}
 
267
 
 
268
template <class _CharT, class _Traits>
 
269
inline _LIBCPP_INLINE_VISIBILITY
 
270
int
 
271
basic_streambuf<_CharT, _Traits>::pubsync()
 
272
{
 
273
    return sync();
 
274
}
 
275
 
 
276
template <class _CharT, class _Traits>
 
277
inline _LIBCPP_INLINE_VISIBILITY
 
278
streamsize
 
279
basic_streambuf<_CharT, _Traits>::in_avail()
 
280
{
 
281
    if (__ninp_ < __einp_)
 
282
        return static_cast<streamsize>(__einp_ - __ninp_);
 
283
    return showmanyc();
 
284
}
 
285
 
 
286
template <class _CharT, class _Traits>
 
287
inline _LIBCPP_INLINE_VISIBILITY
 
288
typename basic_streambuf<_CharT, _Traits>::int_type
 
289
basic_streambuf<_CharT, _Traits>::snextc()
 
290
{
 
291
    if (sbumpc() == traits_type::eof())
 
292
        return traits_type::eof();
 
293
    return sgetc();
 
294
}
 
295
 
 
296
template <class _CharT, class _Traits>
 
297
inline _LIBCPP_INLINE_VISIBILITY
 
298
typename basic_streambuf<_CharT, _Traits>::int_type
 
299
basic_streambuf<_CharT, _Traits>::sbumpc()
 
300
{
 
301
    if (__ninp_ == __einp_)
 
302
        return uflow();
 
303
    return traits_type::to_int_type(*__ninp_++);
 
304
}
 
305
 
 
306
template <class _CharT, class _Traits>
 
307
inline _LIBCPP_INLINE_VISIBILITY
 
308
typename basic_streambuf<_CharT, _Traits>::int_type
 
309
basic_streambuf<_CharT, _Traits>::sgetc()
 
310
{
 
311
    if (__ninp_ == __einp_)
 
312
        return underflow();
 
313
    return traits_type::to_int_type(*__ninp_);
 
314
}
 
315
 
 
316
template <class _CharT, class _Traits>
 
317
inline _LIBCPP_INLINE_VISIBILITY
 
318
streamsize
 
319
basic_streambuf<_CharT, _Traits>::sgetn(char_type* __s, streamsize __n)
 
320
{
 
321
    return xsgetn(__s, __n);
 
322
}
 
323
 
 
324
template <class _CharT, class _Traits>
 
325
inline _LIBCPP_INLINE_VISIBILITY
 
326
typename basic_streambuf<_CharT, _Traits>::int_type
 
327
basic_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
 
 
334
template <class _CharT, class _Traits>
 
335
inline _LIBCPP_INLINE_VISIBILITY
 
336
typename basic_streambuf<_CharT, _Traits>::int_type
 
337
basic_streambuf<_CharT, _Traits>::sungetc()
 
338
{
 
339
    if (__binp_ == __ninp_)
 
340
        return pbackfail();
 
341
    return traits_type::to_int_type(*--__ninp_);
 
342
}
 
343
 
 
344
template <class _CharT, class _Traits>
 
345
inline _LIBCPP_INLINE_VISIBILITY
 
346
typename basic_streambuf<_CharT, _Traits>::int_type
 
347
basic_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
 
 
355
template <class _CharT, class _Traits>
 
356
inline _LIBCPP_INLINE_VISIBILITY
 
357
streamsize
 
358
basic_streambuf<_CharT, _Traits>::sputn(const char_type* __s, streamsize __n)
 
359
{
 
360
    return xsputn(__s, __n);
 
361
}
 
362
 
 
363
template <class _CharT, class _Traits>
 
364
basic_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
 
 
374
template <class _CharT, class _Traits>
 
375
basic_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
 
 
386
template <class _CharT, class _Traits>
 
387
basic_streambuf<_CharT, _Traits>&
 
388
basic_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
 
 
400
template <class _CharT, class _Traits>
 
401
void
 
402
basic_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
 
 
413
template <class _CharT, class _Traits>
 
414
inline _LIBCPP_INLINE_VISIBILITY
 
415
void
 
416
basic_streambuf<_CharT, _Traits>::gbump(int __n)
 
417
{
 
418
    __ninp_ += __n;
 
419
}
 
420
 
 
421
template <class _CharT, class _Traits>
 
422
inline _LIBCPP_INLINE_VISIBILITY
 
423
void
 
424
basic_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
 
 
432
template <class _CharT, class _Traits>
 
433
inline _LIBCPP_INLINE_VISIBILITY
 
434
void
 
435
basic_streambuf<_CharT, _Traits>::pbump(int __n)
 
436
{
 
437
    __nout_ += __n;
 
438
}
 
439
 
 
440
template <class _CharT, class _Traits>
 
441
inline _LIBCPP_INLINE_VISIBILITY
 
442
void
 
443
basic_streambuf<_CharT, _Traits>::setp(char_type* __pbeg, char_type* __pend)
 
444
{
 
445
    __bout_ = __nout_ = __pbeg;
 
446
    __eout_ = __pend;
 
447
}
 
448
 
 
449
template <class _CharT, class _Traits>
 
450
void
 
451
basic_streambuf<_CharT, _Traits>::imbue(const locale&)
 
452
{
 
453
}
 
454
 
 
455
template <class _CharT, class _Traits>
 
456
basic_streambuf<_CharT, _Traits>*
 
457
basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
 
458
{
 
459
    return this;
 
460
}
 
461
 
 
462
template <class _CharT, class _Traits>
 
463
typename basic_streambuf<_CharT, _Traits>::pos_type
 
464
basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
 
465
                                          ios_base::openmode)
 
466
{
 
467
    return pos_type(off_type(-1));
 
468
}
 
469
 
 
470
template <class _CharT, class _Traits>
 
471
typename basic_streambuf<_CharT, _Traits>::pos_type
 
472
basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
 
473
{
 
474
    return pos_type(off_type(-1));
 
475
}
 
476
 
 
477
template <class _CharT, class _Traits>
 
478
int
 
479
basic_streambuf<_CharT, _Traits>::sync()
 
480
{
 
481
    return 0;
 
482
}
 
483
 
 
484
template <class _CharT, class _Traits>
 
485
streamsize
 
486
basic_streambuf<_CharT, _Traits>::showmanyc()
 
487
{
 
488
    return 0;
 
489
}
 
490
 
 
491
template <class _CharT, class _Traits>
 
492
streamsize
 
493
basic_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
 
 
510
template <class _CharT, class _Traits>
 
511
typename basic_streambuf<_CharT, _Traits>::int_type
 
512
basic_streambuf<_CharT, _Traits>::underflow()
 
513
{
 
514
    return traits_type::eof();
 
515
}
 
516
 
 
517
template <class _CharT, class _Traits>
 
518
typename basic_streambuf<_CharT, _Traits>::int_type
 
519
basic_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
 
 
526
template <class _CharT, class _Traits>
 
527
typename basic_streambuf<_CharT, _Traits>::int_type
 
528
basic_streambuf<_CharT, _Traits>::pbackfail(int_type)
 
529
{
 
530
    return traits_type::eof();
 
531
}
 
532
 
 
533
template <class _CharT, class _Traits>
 
534
streamsize
 
535
basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
 
536
{
 
537
    streamsize __i = 0;
 
538
    int_type __eof = traits_type::eof();
 
539
    for (; __i < __n; ++__s, ++__i)
 
540
    {
 
541
        if (__nout_ < __eout_)
 
542
            *__nout_++ = *__s;
 
543
        else if (overflow(traits_type::to_int_type(*__s)) == __eof)
 
544
            break;
 
545
    }
 
546
    return __i;
 
547
}
 
548
 
 
549
template <class _CharT, class _Traits>
 
550
typename basic_streambuf<_CharT, _Traits>::int_type
 
551
basic_streambuf<_CharT, _Traits>::overflow(int_type)
 
552
{
 
553
    return traits_type::eof();
 
554
}
 
555
 
 
556
_LIBCPP_EXTERN_TEMPLATE(class basic_streambuf<char>)
 
557
_LIBCPP_EXTERN_TEMPLATE(class basic_streambuf<wchar_t>)
 
558
 
 
559
_LIBCPP_EXTERN_TEMPLATE(class basic_ios<char>)
 
560
_LIBCPP_EXTERN_TEMPLATE(class basic_ios<wchar_t>)
 
561
 
 
562
_LIBCPP_END_NAMESPACE_STD
 
563
 
 
564
#endif  // _LIBCPP_STEAMBUF