ostream revision 287679 
1// -*- C++ -*-
2//===-------------------------- ostream -----------------------------------===//
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_OSTREAM
12#define _LIBCPP_OSTREAM
13
14/*
15    ostream synopsis
16
17template <class charT, class traits = char_traits<charT> >
18class basic_ostream
19    : virtual public basic_ios<charT,traits>
20{
21public:
22    // types (inherited from basic_ios (27.5.4)):
23    typedef charT                          char_type;
24    typedef traits                         traits_type;
25    typedef typename traits_type::int_type int_type;
26    typedef typename traits_type::pos_type pos_type;
27    typedef typename traits_type::off_type off_type;
28
29    // 27.7.2.2 Constructor/destructor:
30    explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
31    basic_ostream(basic_ostream&& rhs);
32    virtual ~basic_ostream();
33
34    // 27.7.2.3 Assign/swap
35    basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14
36    basic_ostream& operator=(basic_ostream&& rhs);
37    void swap(basic_ostream& rhs);
38
39    // 27.7.2.4 Prefix/suffix:
40    class sentry;
41
42    // 27.7.2.6 Formatted output:
43    basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
44    basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&));
45    basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
46    basic_ostream& operator<<(bool n);
47    basic_ostream& operator<<(short n);
48    basic_ostream& operator<<(unsigned short n);
49    basic_ostream& operator<<(int n);
50    basic_ostream& operator<<(unsigned int n);
51    basic_ostream& operator<<(long n);
52    basic_ostream& operator<<(unsigned long n);
53    basic_ostream& operator<<(long long n);
54    basic_ostream& operator<<(unsigned long long n);
55    basic_ostream& operator<<(float f);
56    basic_ostream& operator<<(double f);
57    basic_ostream& operator<<(long double f);
58    basic_ostream& operator<<(const void* p);
59    basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
60
61    // 27.7.2.7 Unformatted output:
62    basic_ostream& put(char_type c);
63    basic_ostream& write(const char_type* s, streamsize n);
64    basic_ostream& flush();
65
66    // 27.7.2.5 seeks:
67    pos_type tellp();
68    basic_ostream& seekp(pos_type);
69    basic_ostream& seekp(off_type, ios_base::seekdir);
70protected:
71    basic_ostream(const basic_ostream& rhs) = delete;
72    basic_ostream(basic_ostream&& rhs);
73    // 27.7.3.3 Assign/swap
74    basic_ostream& operator=(basic_ostream& rhs) = delete;
75    basic_ostream& operator=(const basic_ostream&& rhs);
76    void swap(basic_ostream& rhs);
77};
78
79// 27.7.2.6.4 character inserters
80
81template<class charT, class traits>
82  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT);
83
84template<class charT, class traits>
85  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char);
86
87template<class traits>
88  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char);
89
90// signed and unsigned
91
92template<class traits>
93  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char);
94
95template<class traits>
96  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char);
97
98// NTBS
99template<class charT, class traits>
100  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*);
101
102template<class charT, class traits>
103  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*);
104
105template<class traits>
106  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*);
107
108// signed and unsigned
109template<class traits>
110basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*);
111
112template<class traits>
113  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*);
114
115// swap:
116template <class charT, class traits>
117  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
118
119template <class charT, class traits>
120  basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
121
122template <class charT, class traits>
123  basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
124
125template <class charT, class traits>
126  basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
127
128// rvalue stream insertion
129template <class charT, class traits, class T>
130  basic_ostream<charT, traits>&
131  operator<<(basic_ostream<charT, traits>&& os, const T& x);
132
133}  // std
134
135*/
136
137#include <__config>
138#include <ios>
139#include <streambuf>
140#include <locale>
141#include <iterator>
142#include <bitset>
143
144#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
145#pragma GCC system_header
146#endif
147
148_LIBCPP_BEGIN_NAMESPACE_STD
149
150template <class _CharT, class _Traits>
151class _LIBCPP_TYPE_VIS_ONLY basic_ostream
152    : virtual public basic_ios<_CharT, _Traits>
153{
154public:
155    // types (inherited from basic_ios (27.5.4)):
156    typedef _CharT                         char_type;
157    typedef _Traits                        traits_type;
158    typedef typename traits_type::int_type int_type;
159    typedef typename traits_type::pos_type pos_type;
160    typedef typename traits_type::off_type off_type;
161
162    // 27.7.2.2 Constructor/destructor:
163    explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb);
164    virtual ~basic_ostream();
165protected:
166#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
167    _LIBCPP_INLINE_VISIBILITY
168    basic_ostream(basic_ostream&& __rhs);
169#endif
170
171    // 27.7.2.3 Assign/swap
172#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
173    _LIBCPP_INLINE_VISIBILITY
174    basic_ostream& operator=(basic_ostream&& __rhs);
175#endif
176    void swap(basic_ostream& __rhs);
177
178#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
179    basic_ostream           (const basic_ostream& __rhs) = delete;
180    basic_ostream& operator=(const basic_ostream& __rhs) = delete;
181#else
182    basic_ostream           (const basic_ostream& __rhs); // not defined
183    basic_ostream& operator=(const basic_ostream& __rhs); // not defined
184#endif
185public:
186
187    // 27.7.2.4 Prefix/suffix:
188    class _LIBCPP_TYPE_VIS_ONLY sentry;
189
190    // 27.7.2.6 Formatted output:
191    basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&));
192    basic_ostream& operator<<(basic_ios<char_type, traits_type>&
193                              (*__pf)(basic_ios<char_type,traits_type>&));
194    basic_ostream& operator<<(ios_base& (*__pf)(ios_base&));
195    basic_ostream& operator<<(bool __n);
196    basic_ostream& operator<<(short __n);
197    basic_ostream& operator<<(unsigned short __n);
198    basic_ostream& operator<<(int __n);
199    basic_ostream& operator<<(unsigned int __n);
200    basic_ostream& operator<<(long __n);
201    basic_ostream& operator<<(unsigned long __n);
202    basic_ostream& operator<<(long long __n);
203    basic_ostream& operator<<(unsigned long long __n);
204    basic_ostream& operator<<(float __f);
205    basic_ostream& operator<<(double __f);
206    basic_ostream& operator<<(long double __f);
207    basic_ostream& operator<<(const void* __p);
208    basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
209
210    // 27.7.2.7 Unformatted output:
211    basic_ostream& put(char_type __c);
212    basic_ostream& write(const char_type* __s, streamsize __n);
213    basic_ostream& flush();
214
215    // 27.7.2.5 seeks:
216    pos_type tellp();
217    basic_ostream& seekp(pos_type __pos);
218    basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
219
220protected:
221    _LIBCPP_ALWAYS_INLINE
222    basic_ostream() {}  // extension, intentially does not initialize
223};
224
225template <class _CharT, class _Traits>
226class _LIBCPP_TYPE_VIS_ONLY basic_ostream<_CharT, _Traits>::sentry
227{
228    bool __ok_;
229    basic_ostream<_CharT, _Traits>& __os_;
230
231    sentry(const sentry&); // = delete;
232    sentry& operator=(const sentry&); // = delete;
233
234public:
235    explicit sentry(basic_ostream<_CharT, _Traits>& __os);
236    ~sentry();
237
238    _LIBCPP_ALWAYS_INLINE
239        _LIBCPP_EXPLICIT
240        operator bool() const {return __ok_;}
241};
242
243template <class _CharT, class _Traits>
244basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os)
245    : __ok_(false),
246      __os_(__os)
247{
248    if (__os.good())
249    {
250        if (__os.tie())
251            __os.tie()->flush();
252        __ok_ = true;
253    }
254}
255
256template <class _CharT, class _Traits>
257basic_ostream<_CharT, _Traits>::sentry::~sentry()
258{
259    if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)
260                      && !uncaught_exception())
261    {
262#ifndef _LIBCPP_NO_EXCEPTIONS
263        try
264        {
265#endif  // _LIBCPP_NO_EXCEPTIONS
266            if (__os_.rdbuf()->pubsync() == -1)
267                __os_.setstate(ios_base::badbit);
268#ifndef _LIBCPP_NO_EXCEPTIONS
269        }
270        catch (...)
271        {
272        }
273#endif  // _LIBCPP_NO_EXCEPTIONS
274    }
275}
276
277template <class _CharT, class _Traits>
278inline _LIBCPP_INLINE_VISIBILITY
279basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
280{
281    this->init(__sb);
282}
283
284#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
285
286template <class _CharT, class _Traits>
287inline _LIBCPP_INLINE_VISIBILITY
288basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
289{
290    this->move(__rhs);
291}
292
293template <class _CharT, class _Traits>
294inline _LIBCPP_INLINE_VISIBILITY
295basic_ostream<_CharT, _Traits>&
296basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
297{
298    swap(__rhs);
299    return *this;
300}
301
302#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
303
304template <class _CharT, class _Traits>
305basic_ostream<_CharT, _Traits>::~basic_ostream()
306{
307}
308
309template <class _CharT, class _Traits>
310inline _LIBCPP_INLINE_VISIBILITY
311void
312basic_ostream<_CharT, _Traits>::swap(basic_ostream& __rhs)
313{
314    basic_ios<char_type, traits_type>::swap(__rhs);
315}
316
317template <class _CharT, class _Traits>
318inline _LIBCPP_INLINE_VISIBILITY
319basic_ostream<_CharT, _Traits>&
320basic_ostream<_CharT, _Traits>::operator<<(basic_ostream& (*__pf)(basic_ostream&))
321{
322    return __pf(*this);
323}
324
325template <class _CharT, class _Traits>
326inline _LIBCPP_INLINE_VISIBILITY
327basic_ostream<_CharT, _Traits>&
328basic_ostream<_CharT, _Traits>::operator<<(basic_ios<char_type, traits_type>&
329                                           (*__pf)(basic_ios<char_type,traits_type>&))
330{
331    __pf(*this);
332    return *this;
333}
334
335template <class _CharT, class _Traits>
336inline _LIBCPP_INLINE_VISIBILITY
337basic_ostream<_CharT, _Traits>&
338basic_ostream<_CharT, _Traits>::operator<<(ios_base& (*__pf)(ios_base&))
339{
340    __pf(*this);
341    return *this;
342}
343
344template <class _CharT, class _Traits>
345basic_ostream<_CharT, _Traits>&
346basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
347{
348#ifndef _LIBCPP_NO_EXCEPTIONS
349    try
350    {
351#endif  // _LIBCPP_NO_EXCEPTIONS
352        sentry __s(*this);
353        if (__s)
354        {
355            if (__sb)
356            {
357#ifndef _LIBCPP_NO_EXCEPTIONS
358                try
359                {
360#endif  // _LIBCPP_NO_EXCEPTIONS
361                    typedef istreambuf_iterator<_CharT, _Traits> _Ip;
362                    typedef ostreambuf_iterator<_CharT, _Traits> _Op;
363                    _Ip __i(__sb);
364                    _Ip __eof;
365                    _Op __o(*this);
366                    size_t __c = 0;
367                    for (; __i != __eof; ++__i, ++__o, ++__c)
368                    {
369                        *__o = *__i;
370                        if (__o.failed())
371                            break;
372                    }
373                    if (__c == 0)
374                        this->setstate(ios_base::failbit);
375#ifndef _LIBCPP_NO_EXCEPTIONS
376                }
377                catch (...)
378                {
379                    this->__set_failbit_and_consider_rethrow();
380                }
381#endif  // _LIBCPP_NO_EXCEPTIONS
382            }
383            else
384                this->setstate(ios_base::badbit);
385        }
386#ifndef _LIBCPP_NO_EXCEPTIONS
387    }
388    catch (...)
389    {
390        this->__set_badbit_and_consider_rethrow();
391    }
392#endif  // _LIBCPP_NO_EXCEPTIONS
393    return *this;
394}
395
396template <class _CharT, class _Traits>
397basic_ostream<_CharT, _Traits>&
398basic_ostream<_CharT, _Traits>::operator<<(bool __n)
399{
400#ifndef _LIBCPP_NO_EXCEPTIONS
401    try
402    {
403#endif  // _LIBCPP_NO_EXCEPTIONS
404        sentry __s(*this);
405        if (__s)
406        {
407            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
408            const _Fp& __f = use_facet<_Fp>(this->getloc());
409            if (__f.put(*this, *this, this->fill(), __n).failed())
410                this->setstate(ios_base::badbit | ios_base::failbit);
411        }
412#ifndef _LIBCPP_NO_EXCEPTIONS
413    }
414    catch (...)
415    {
416        this->__set_badbit_and_consider_rethrow();
417    }
418#endif  // _LIBCPP_NO_EXCEPTIONS
419    return *this;
420}
421
422template <class _CharT, class _Traits>
423basic_ostream<_CharT, _Traits>&
424basic_ostream<_CharT, _Traits>::operator<<(short __n)
425{
426#ifndef _LIBCPP_NO_EXCEPTIONS
427    try
428    {
429#endif  // _LIBCPP_NO_EXCEPTIONS
430        sentry __s(*this);
431        if (__s)
432        {
433            ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
434            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
435            const _Fp& __f = use_facet<_Fp>(this->getloc());
436            if (__f.put(*this, *this, this->fill(),
437                        __flags == ios_base::oct || __flags == ios_base::hex ?
438                        static_cast<long>(static_cast<unsigned short>(__n))  :
439                        static_cast<long>(__n)).failed())
440                this->setstate(ios_base::badbit | ios_base::failbit);
441        }
442#ifndef _LIBCPP_NO_EXCEPTIONS
443    }
444    catch (...)
445    {
446        this->__set_badbit_and_consider_rethrow();
447    }
448#endif  // _LIBCPP_NO_EXCEPTIONS
449    return *this;
450}
451
452template <class _CharT, class _Traits>
453basic_ostream<_CharT, _Traits>&
454basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
455{
456#ifndef _LIBCPP_NO_EXCEPTIONS
457    try
458    {
459#endif  // _LIBCPP_NO_EXCEPTIONS
460        sentry __s(*this);
461        if (__s)
462        {
463            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
464            const _Fp& __f = use_facet<_Fp>(this->getloc());
465            if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
466                this->setstate(ios_base::badbit | ios_base::failbit);
467        }
468#ifndef _LIBCPP_NO_EXCEPTIONS
469    }
470    catch (...)
471    {
472        this->__set_badbit_and_consider_rethrow();
473    }
474#endif  // _LIBCPP_NO_EXCEPTIONS
475    return *this;
476}
477
478template <class _CharT, class _Traits>
479basic_ostream<_CharT, _Traits>&
480basic_ostream<_CharT, _Traits>::operator<<(int __n)
481{
482#ifndef _LIBCPP_NO_EXCEPTIONS
483    try
484    {
485#endif  // _LIBCPP_NO_EXCEPTIONS
486        sentry __s(*this);
487        if (__s)
488        {
489            ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
490            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
491            const _Fp& __f = use_facet<_Fp>(this->getloc());
492            if (__f.put(*this, *this, this->fill(),
493                        __flags == ios_base::oct || __flags == ios_base::hex ?
494                        static_cast<long>(static_cast<unsigned int>(__n))  :
495                        static_cast<long>(__n)).failed())
496                this->setstate(ios_base::badbit | ios_base::failbit);
497        }
498#ifndef _LIBCPP_NO_EXCEPTIONS
499    }
500    catch (...)
501    {
502        this->__set_badbit_and_consider_rethrow();
503    }
504#endif  // _LIBCPP_NO_EXCEPTIONS
505    return *this;
506}
507
508template <class _CharT, class _Traits>
509basic_ostream<_CharT, _Traits>&
510basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
511{
512#ifndef _LIBCPP_NO_EXCEPTIONS
513    try
514    {
515#endif  // _LIBCPP_NO_EXCEPTIONS
516        sentry __s(*this);
517        if (__s)
518        {
519            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
520            const _Fp& __f = use_facet<_Fp>(this->getloc());
521            if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
522                this->setstate(ios_base::badbit | ios_base::failbit);
523        }
524#ifndef _LIBCPP_NO_EXCEPTIONS
525    }
526    catch (...)
527    {
528        this->__set_badbit_and_consider_rethrow();
529    }
530#endif  // _LIBCPP_NO_EXCEPTIONS
531    return *this;
532}
533
534template <class _CharT, class _Traits>
535basic_ostream<_CharT, _Traits>&
536basic_ostream<_CharT, _Traits>::operator<<(long __n)
537{
538#ifndef _LIBCPP_NO_EXCEPTIONS
539    try
540    {
541#endif  // _LIBCPP_NO_EXCEPTIONS
542        sentry __s(*this);
543        if (__s)
544        {
545            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
546            const _Fp& __f = use_facet<_Fp>(this->getloc());
547            if (__f.put(*this, *this, this->fill(), __n).failed())
548                this->setstate(ios_base::badbit | ios_base::failbit);
549        }
550#ifndef _LIBCPP_NO_EXCEPTIONS
551    }
552    catch (...)
553    {
554        this->__set_badbit_and_consider_rethrow();
555    }
556#endif  // _LIBCPP_NO_EXCEPTIONS
557    return *this;
558}
559
560template <class _CharT, class _Traits>
561basic_ostream<_CharT, _Traits>&
562basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
563{
564#ifndef _LIBCPP_NO_EXCEPTIONS
565    try
566    {
567#endif  // _LIBCPP_NO_EXCEPTIONS
568        sentry __s(*this);
569        if (__s)
570        {
571            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
572            const _Fp& __f = use_facet<_Fp>(this->getloc());
573            if (__f.put(*this, *this, this->fill(), __n).failed())
574                this->setstate(ios_base::badbit | ios_base::failbit);
575        }
576#ifndef _LIBCPP_NO_EXCEPTIONS
577    }
578    catch (...)
579    {
580        this->__set_badbit_and_consider_rethrow();
581    }
582#endif  // _LIBCPP_NO_EXCEPTIONS
583    return *this;
584}
585
586template <class _CharT, class _Traits>
587basic_ostream<_CharT, _Traits>&
588basic_ostream<_CharT, _Traits>::operator<<(long long __n)
589{
590#ifndef _LIBCPP_NO_EXCEPTIONS
591    try
592    {
593#endif  // _LIBCPP_NO_EXCEPTIONS
594        sentry __s(*this);
595        if (__s)
596        {
597            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
598            const _Fp& __f = use_facet<_Fp>(this->getloc());
599            if (__f.put(*this, *this, this->fill(), __n).failed())
600                this->setstate(ios_base::badbit | ios_base::failbit);
601        }
602#ifndef _LIBCPP_NO_EXCEPTIONS
603    }
604    catch (...)
605    {
606        this->__set_badbit_and_consider_rethrow();
607    }
608#endif  // _LIBCPP_NO_EXCEPTIONS
609    return *this;
610}
611
612template <class _CharT, class _Traits>
613basic_ostream<_CharT, _Traits>&
614basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
615{
616#ifndef _LIBCPP_NO_EXCEPTIONS
617    try
618    {
619#endif  // _LIBCPP_NO_EXCEPTIONS
620        sentry __s(*this);
621        if (__s)
622        {
623            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
624            const _Fp& __f = use_facet<_Fp>(this->getloc());
625            if (__f.put(*this, *this, this->fill(), __n).failed())
626                this->setstate(ios_base::badbit | ios_base::failbit);
627        }
628#ifndef _LIBCPP_NO_EXCEPTIONS
629    }
630    catch (...)
631    {
632        this->__set_badbit_and_consider_rethrow();
633    }
634#endif  // _LIBCPP_NO_EXCEPTIONS
635    return *this;
636}
637
638template <class _CharT, class _Traits>
639basic_ostream<_CharT, _Traits>&
640basic_ostream<_CharT, _Traits>::operator<<(float __n)
641{
642#ifndef _LIBCPP_NO_EXCEPTIONS
643    try
644    {
645#endif  // _LIBCPP_NO_EXCEPTIONS
646        sentry __s(*this);
647        if (__s)
648        {
649            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
650            const _Fp& __f = use_facet<_Fp>(this->getloc());
651            if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
652                this->setstate(ios_base::badbit | ios_base::failbit);
653        }
654#ifndef _LIBCPP_NO_EXCEPTIONS
655    }
656    catch (...)
657    {
658        this->__set_badbit_and_consider_rethrow();
659    }
660#endif  // _LIBCPP_NO_EXCEPTIONS
661    return *this;
662}
663
664template <class _CharT, class _Traits>
665basic_ostream<_CharT, _Traits>&
666basic_ostream<_CharT, _Traits>::operator<<(double __n)
667{
668#ifndef _LIBCPP_NO_EXCEPTIONS
669    try
670    {
671#endif  // _LIBCPP_NO_EXCEPTIONS
672        sentry __s(*this);
673        if (__s)
674        {
675            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
676            const _Fp& __f = use_facet<_Fp>(this->getloc());
677            if (__f.put(*this, *this, this->fill(), __n).failed())
678                this->setstate(ios_base::badbit | ios_base::failbit);
679        }
680#ifndef _LIBCPP_NO_EXCEPTIONS
681    }
682    catch (...)
683    {
684        this->__set_badbit_and_consider_rethrow();
685    }
686#endif  // _LIBCPP_NO_EXCEPTIONS
687    return *this;
688}
689
690template <class _CharT, class _Traits>
691basic_ostream<_CharT, _Traits>&
692basic_ostream<_CharT, _Traits>::operator<<(long double __n)
693{
694#ifndef _LIBCPP_NO_EXCEPTIONS
695    try
696    {
697#endif  // _LIBCPP_NO_EXCEPTIONS
698        sentry __s(*this);
699        if (__s)
700        {
701            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
702            const _Fp& __f = use_facet<_Fp>(this->getloc());
703            if (__f.put(*this, *this, this->fill(), __n).failed())
704                this->setstate(ios_base::badbit | ios_base::failbit);
705        }
706#ifndef _LIBCPP_NO_EXCEPTIONS
707    }
708    catch (...)
709    {
710        this->__set_badbit_and_consider_rethrow();
711    }
712#endif  // _LIBCPP_NO_EXCEPTIONS
713    return *this;
714}
715
716template <class _CharT, class _Traits>
717basic_ostream<_CharT, _Traits>&
718basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
719{
720#ifndef _LIBCPP_NO_EXCEPTIONS
721    try
722    {
723#endif  // _LIBCPP_NO_EXCEPTIONS
724        sentry __s(*this);
725        if (__s)
726        {
727            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
728            const _Fp& __f = use_facet<_Fp>(this->getloc());
729            if (__f.put(*this, *this, this->fill(), __n).failed())
730                this->setstate(ios_base::badbit | ios_base::failbit);
731        }
732#ifndef _LIBCPP_NO_EXCEPTIONS
733    }
734    catch (...)
735    {
736        this->__set_badbit_and_consider_rethrow();
737    }
738#endif  // _LIBCPP_NO_EXCEPTIONS
739    return *this;
740}
741
742template<class _CharT, class _Traits>
743basic_ostream<_CharT, _Traits>&
744__put_character_sequence(basic_ostream<_CharT, _Traits>& __os,
745                          const _CharT* __str, size_t __len)
746{
747#ifndef _LIBCPP_NO_EXCEPTIONS
748    try
749    {
750#endif  // _LIBCPP_NO_EXCEPTIONS
751        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
752        if (__s)
753        {
754            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
755            if (__pad_and_output(_Ip(__os),
756                                 __str,
757                                 (__os.flags() & ios_base::adjustfield) == ios_base::left ?
758                                     __str + __len :
759                                     __str,
760                                 __str + __len,
761                                 __os,
762                                 __os.fill()).failed())
763                __os.setstate(ios_base::badbit | ios_base::failbit);
764        }
765#ifndef _LIBCPP_NO_EXCEPTIONS
766    }
767    catch (...)
768    {
769        __os.__set_badbit_and_consider_rethrow();
770    }
771#endif  // _LIBCPP_NO_EXCEPTIONS
772    return __os;
773}
774
775
776template<class _CharT, class _Traits>
777basic_ostream<_CharT, _Traits>&
778operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
779{
780    return _VSTD::__put_character_sequence(__os, &__c, 1);
781}
782
783template<class _CharT, class _Traits>
784basic_ostream<_CharT, _Traits>&
785operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
786{
787#ifndef _LIBCPP_NO_EXCEPTIONS
788    try
789    {
790#endif  // _LIBCPP_NO_EXCEPTIONS
791        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
792        if (__s)
793        {
794            _CharT __c = __os.widen(__cn);
795            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
796            if (__pad_and_output(_Ip(__os),
797                                 &__c,
798                                 (__os.flags() & ios_base::adjustfield) == ios_base::left ?
799                                     &__c + 1 :
800                                     &__c,
801                                 &__c + 1,
802                                 __os,
803                                 __os.fill()).failed())
804                __os.setstate(ios_base::badbit | ios_base::failbit);
805        }
806#ifndef _LIBCPP_NO_EXCEPTIONS
807    }
808    catch (...)
809    {
810        __os.__set_badbit_and_consider_rethrow();
811    }
812#endif  // _LIBCPP_NO_EXCEPTIONS
813    return __os;
814}
815
816template<class _Traits>
817basic_ostream<char, _Traits>&
818operator<<(basic_ostream<char, _Traits>& __os, char __c)
819{
820    return _VSTD::__put_character_sequence(__os, &__c, 1);
821}
822
823template<class _Traits>
824basic_ostream<char, _Traits>&
825operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
826{
827    return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
828}
829
830template<class _Traits>
831basic_ostream<char, _Traits>&
832operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
833{
834    return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
835}
836
837template<class _CharT, class _Traits>
838basic_ostream<_CharT, _Traits>&
839operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
840{
841    return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
842}
843
844template<class _CharT, class _Traits>
845basic_ostream<_CharT, _Traits>&
846operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
847{
848#ifndef _LIBCPP_NO_EXCEPTIONS
849    try
850    {
851#endif  // _LIBCPP_NO_EXCEPTIONS
852        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
853        if (__s)
854        {
855            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
856            size_t __len = char_traits<char>::length(__strn);
857            const int __bs = 100;
858            _CharT __wbb[__bs];
859            _CharT* __wb = __wbb;
860            unique_ptr<_CharT, void(*)(void*)> __h(0, free);
861            if (__len > __bs)
862            {
863                __wb = (_CharT*)malloc(__len*sizeof(_CharT));
864                if (__wb == 0)
865                    __throw_bad_alloc();
866                __h.reset(__wb);
867            }
868            for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
869                *__p = __os.widen(*__strn);
870            if (__pad_and_output(_Ip(__os),
871                                 __wb,
872                                 (__os.flags() & ios_base::adjustfield) == ios_base::left ?
873                                     __wb + __len :
874                                     __wb,
875                                 __wb + __len,
876                                 __os,
877                                 __os.fill()).failed())
878                __os.setstate(ios_base::badbit | ios_base::failbit);
879        }
880#ifndef _LIBCPP_NO_EXCEPTIONS
881    }
882    catch (...)
883    {
884        __os.__set_badbit_and_consider_rethrow();
885    }
886#endif  // _LIBCPP_NO_EXCEPTIONS
887    return __os;
888}
889
890template<class _Traits>
891basic_ostream<char, _Traits>&
892operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
893{
894    return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
895}
896
897template<class _Traits>
898basic_ostream<char, _Traits>&
899operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
900{
901    const char *__s = (const char *) __str;
902    return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
903}
904
905template<class _Traits>
906basic_ostream<char, _Traits>&
907operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
908{
909    const char *__s = (const char *) __str;
910    return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
911}
912
913template <class _CharT, class _Traits>
914basic_ostream<_CharT, _Traits>&
915basic_ostream<_CharT, _Traits>::put(char_type __c)
916{
917#ifndef _LIBCPP_NO_EXCEPTIONS
918    try
919    {
920#endif  // _LIBCPP_NO_EXCEPTIONS
921        sentry __s(*this);
922        if (__s)
923        {
924            typedef ostreambuf_iterator<_CharT, _Traits> _Op;
925            _Op __o(*this);
926            *__o = __c;
927            if (__o.failed())
928                this->setstate(ios_base::badbit);
929        }
930#ifndef _LIBCPP_NO_EXCEPTIONS
931    }
932    catch (...)
933    {
934        this->__set_badbit_and_consider_rethrow();
935    }
936#endif  // _LIBCPP_NO_EXCEPTIONS
937    return *this;
938}
939
940template <class _CharT, class _Traits>
941basic_ostream<_CharT, _Traits>&
942basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
943{
944#ifndef _LIBCPP_NO_EXCEPTIONS
945    try
946    {
947#endif  // _LIBCPP_NO_EXCEPTIONS
948        sentry __sen(*this);
949        if (__sen && __n)
950        {
951            if (this->rdbuf()->sputn(__s, __n) != __n)
952                this->setstate(ios_base::badbit);
953        }
954#ifndef _LIBCPP_NO_EXCEPTIONS
955    }
956    catch (...)
957    {
958        this->__set_badbit_and_consider_rethrow();
959    }
960#endif  // _LIBCPP_NO_EXCEPTIONS
961    return *this;
962}
963
964template <class _CharT, class _Traits>
965basic_ostream<_CharT, _Traits>&
966basic_ostream<_CharT, _Traits>::flush()
967{
968#ifndef _LIBCPP_NO_EXCEPTIONS
969    try
970    {
971#endif  // _LIBCPP_NO_EXCEPTIONS
972        if (this->rdbuf())
973        {
974            sentry __s(*this);
975            if (__s)
976            {
977                if (this->rdbuf()->pubsync() == -1)
978                    this->setstate(ios_base::badbit);
979            }
980        }
981#ifndef _LIBCPP_NO_EXCEPTIONS
982    }
983    catch (...)
984    {
985        this->__set_badbit_and_consider_rethrow();
986    }
987#endif  // _LIBCPP_NO_EXCEPTIONS
988    return *this;
989}
990
991template <class _CharT, class _Traits>
992inline _LIBCPP_INLINE_VISIBILITY
993typename basic_ostream<_CharT, _Traits>::pos_type
994basic_ostream<_CharT, _Traits>::tellp()
995{
996    if (this->fail())
997        return pos_type(-1);
998    return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
999}
1000
1001template <class _CharT, class _Traits>
1002inline _LIBCPP_INLINE_VISIBILITY
1003basic_ostream<_CharT, _Traits>&
1004basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
1005{
1006    sentry __s(*this);
1007    if (__s)
1008    {
1009        if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
1010            this->setstate(ios_base::failbit);
1011    }
1012    return *this;
1013}
1014
1015template <class _CharT, class _Traits>
1016inline _LIBCPP_INLINE_VISIBILITY
1017basic_ostream<_CharT, _Traits>&
1018basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
1019{
1020    sentry __s(*this);
1021    if (__s)
1022    {
1023        if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
1024            this->setstate(ios_base::failbit);
1025    }
1026    return *this;
1027}
1028
1029template <class _CharT, class _Traits>
1030inline _LIBCPP_INLINE_VISIBILITY
1031basic_ostream<_CharT, _Traits>&
1032endl(basic_ostream<_CharT, _Traits>& __os)
1033{
1034    __os.put(__os.widen('\n'));
1035    __os.flush();
1036    return __os;
1037}
1038
1039template <class _CharT, class _Traits>
1040inline _LIBCPP_INLINE_VISIBILITY
1041basic_ostream<_CharT, _Traits>&
1042ends(basic_ostream<_CharT, _Traits>& __os)
1043{
1044    __os.put(_CharT());
1045    return __os;
1046}
1047
1048template <class _CharT, class _Traits>
1049inline _LIBCPP_INLINE_VISIBILITY
1050basic_ostream<_CharT, _Traits>&
1051flush(basic_ostream<_CharT, _Traits>& __os)
1052{
1053    __os.flush();
1054    return __os;
1055}
1056
1057#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1058
1059template <class _Stream, class _Tp>
1060inline _LIBCPP_INLINE_VISIBILITY
1061typename enable_if
1062<
1063    !is_lvalue_reference<_Stream>::value &&
1064    is_base_of<ios_base, _Stream>::value,
1065    _Stream&&
1066>::type
1067operator<<(_Stream&& __os, const _Tp& __x)
1068{
1069    __os << __x;
1070    return _VSTD::move(__os);
1071}
1072
1073#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1074
1075template<class _CharT, class _Traits, class _Allocator>
1076basic_ostream<_CharT, _Traits>&
1077operator<<(basic_ostream<_CharT, _Traits>& __os,
1078           const basic_string<_CharT, _Traits, _Allocator>& __str)
1079{
1080    return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
1081}
1082
1083template <class _CharT, class _Traits>
1084inline _LIBCPP_INLINE_VISIBILITY
1085basic_ostream<_CharT, _Traits>&
1086operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
1087{
1088    return __os << __ec.category().name() << ':' << __ec.value();
1089}
1090
1091template<class _CharT, class _Traits, class _Yp>
1092inline _LIBCPP_INLINE_VISIBILITY
1093basic_ostream<_CharT, _Traits>&
1094operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
1095{
1096    return __os << __p.get();
1097}
1098
1099template <class _CharT, class _Traits, size_t _Size>
1100basic_ostream<_CharT, _Traits>&
1101operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
1102{
1103    return __os << __x.template to_string<_CharT, _Traits>
1104                        (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
1105                         use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
1106}
1107
1108_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ostream<char>)
1109_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_ostream<wchar_t>)
1110
1111_LIBCPP_END_NAMESPACE_STD
1112
1113#endif  // _LIBCPP_OSTREAM
1114