xref: /freebsd/contrib/llvm-project/libcxx/include/ostream (revision 5def4c47d4bd90b209b9b4a4ba9faec15846d8fd) 
1// -*- C++ -*-
2//===-------------------------- ostream -----------------------------------===//
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_OSTREAM
11#define _LIBCPP_OSTREAM
12
13/*
14    ostream synopsis
15
16template <class charT, class traits = char_traits<charT> >
17class basic_ostream
18    : virtual public basic_ios<charT,traits>
19{
20public:
21    // types (inherited from basic_ios (27.5.4)):
22    typedef charT                          char_type;
23    typedef traits                         traits_type;
24    typedef typename traits_type::int_type int_type;
25    typedef typename traits_type::pos_type pos_type;
26    typedef typename traits_type::off_type off_type;
27
28    // 27.7.2.2 Constructor/destructor:
29    explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
30    basic_ostream(basic_ostream&& rhs);
31    virtual ~basic_ostream();
32
33    // 27.7.2.3 Assign/swap
34    basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14
35    basic_ostream& operator=(basic_ostream&& rhs);
36    void swap(basic_ostream& rhs);
37
38    // 27.7.2.4 Prefix/suffix:
39    class sentry;
40
41    // 27.7.2.6 Formatted output:
42    basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
43    basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&));
44    basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
45    basic_ostream& operator<<(bool n);
46    basic_ostream& operator<<(short n);
47    basic_ostream& operator<<(unsigned short n);
48    basic_ostream& operator<<(int n);
49    basic_ostream& operator<<(unsigned int n);
50    basic_ostream& operator<<(long n);
51    basic_ostream& operator<<(unsigned long n);
52    basic_ostream& operator<<(long long n);
53    basic_ostream& operator<<(unsigned long long n);
54    basic_ostream& operator<<(float f);
55    basic_ostream& operator<<(double f);
56    basic_ostream& operator<<(long double f);
57    basic_ostream& operator<<(const void* p);
58    basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
59    basic_ostream& operator<<(nullptr_t);
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 Stream, class T>
130  Stream&& operator<<(Stream&& os, const T& x);
131
132}  // std
133
134*/
135
136#include <__config>
137#include <ios>
138#include <streambuf>
139#include <locale>
140#include <iterator>
141#include <bitset>
142#include <version>
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_TEMPLATE_VIS 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    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
164    explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
165    { this->init(__sb); }
166    virtual ~basic_ostream();
167protected:
168#ifndef _LIBCPP_CXX03_LANG
169    inline _LIBCPP_INLINE_VISIBILITY
170    basic_ostream(basic_ostream&& __rhs);
171
172    // 27.7.2.3 Assign/swap
173    inline _LIBCPP_INLINE_VISIBILITY
174    basic_ostream& operator=(basic_ostream&& __rhs);
175#endif
176    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
177    void swap(basic_ostream& __rhs)
178    { basic_ios<char_type, traits_type>::swap(__rhs); }
179
180#ifndef _LIBCPP_CXX03_LANG
181    basic_ostream           (const basic_ostream& __rhs) = delete;
182    basic_ostream& operator=(const basic_ostream& __rhs) = delete;
183#else
184    basic_ostream           (const basic_ostream& __rhs); // not defined
185    basic_ostream& operator=(const basic_ostream& __rhs); // not defined
186#endif
187public:
188
189    // 27.7.2.4 Prefix/suffix:
190    class _LIBCPP_TEMPLATE_VIS sentry;
191
192    // 27.7.2.6 Formatted output:
193    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
194    basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
195    { return __pf(*this); }
196
197    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
198    basic_ostream& operator<<(basic_ios<char_type, traits_type>&
199                              (*__pf)(basic_ios<char_type,traits_type>&))
200    { __pf(*this); return *this; }
201
202    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
203    basic_ostream& operator<<(ios_base& (*__pf)(ios_base&))
204    { __pf(*this); return *this; }
205
206    basic_ostream& operator<<(bool __n);
207    basic_ostream& operator<<(short __n);
208    basic_ostream& operator<<(unsigned short __n);
209    basic_ostream& operator<<(int __n);
210    basic_ostream& operator<<(unsigned int __n);
211    basic_ostream& operator<<(long __n);
212    basic_ostream& operator<<(unsigned long __n);
213    basic_ostream& operator<<(long long __n);
214    basic_ostream& operator<<(unsigned long long __n);
215    basic_ostream& operator<<(float __f);
216    basic_ostream& operator<<(double __f);
217    basic_ostream& operator<<(long double __f);
218    basic_ostream& operator<<(const void* __p);
219    basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
220
221    _LIBCPP_INLINE_VISIBILITY
222    basic_ostream& operator<<(nullptr_t)
223    { return *this << "nullptr"; }
224
225    // 27.7.2.7 Unformatted output:
226    basic_ostream& put(char_type __c);
227    basic_ostream& write(const char_type* __s, streamsize __n);
228    basic_ostream& flush();
229
230    // 27.7.2.5 seeks:
231    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
232    pos_type tellp();
233    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
234    basic_ostream& seekp(pos_type __pos);
235    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
236    basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
237
238protected:
239    _LIBCPP_INLINE_VISIBILITY
240    basic_ostream() {}  // extension, intentially does not initialize
241};
242
243template <class _CharT, class _Traits>
244class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry
245{
246    bool __ok_;
247    basic_ostream<_CharT, _Traits>& __os_;
248
249    sentry(const sentry&); // = delete;
250    sentry& operator=(const sentry&); // = delete;
251
252public:
253    explicit sentry(basic_ostream<_CharT, _Traits>& __os);
254    ~sentry();
255
256    _LIBCPP_INLINE_VISIBILITY
257        _LIBCPP_EXPLICIT
258        operator bool() const {return __ok_;}
259};
260
261template <class _CharT, class _Traits>
262basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os)
263    : __ok_(false),
264      __os_(__os)
265{
266    if (__os.good())
267    {
268        if (__os.tie())
269            __os.tie()->flush();
270        __ok_ = true;
271    }
272}
273
274template <class _CharT, class _Traits>
275basic_ostream<_CharT, _Traits>::sentry::~sentry()
276{
277    if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)
278                      && !uncaught_exception())
279    {
280#ifndef _LIBCPP_NO_EXCEPTIONS
281        try
282        {
283#endif  // _LIBCPP_NO_EXCEPTIONS
284            if (__os_.rdbuf()->pubsync() == -1)
285                __os_.setstate(ios_base::badbit);
286#ifndef _LIBCPP_NO_EXCEPTIONS
287        }
288        catch (...)
289        {
290        }
291#endif  // _LIBCPP_NO_EXCEPTIONS
292    }
293}
294
295#ifndef _LIBCPP_CXX03_LANG
296
297template <class _CharT, class _Traits>
298basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
299{
300    this->move(__rhs);
301}
302
303template <class _CharT, class _Traits>
304basic_ostream<_CharT, _Traits>&
305basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
306{
307    swap(__rhs);
308    return *this;
309}
310
311#endif  // _LIBCPP_CXX03_LANG
312
313template <class _CharT, class _Traits>
314basic_ostream<_CharT, _Traits>::~basic_ostream()
315{
316}
317
318template <class _CharT, class _Traits>
319basic_ostream<_CharT, _Traits>&
320basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
321{
322#ifndef _LIBCPP_NO_EXCEPTIONS
323    try
324    {
325#endif  // _LIBCPP_NO_EXCEPTIONS
326        sentry __s(*this);
327        if (__s)
328        {
329            if (__sb)
330            {
331#ifndef _LIBCPP_NO_EXCEPTIONS
332                try
333                {
334#endif  // _LIBCPP_NO_EXCEPTIONS
335                    typedef istreambuf_iterator<_CharT, _Traits> _Ip;
336                    typedef ostreambuf_iterator<_CharT, _Traits> _Op;
337                    _Ip __i(__sb);
338                    _Ip __eof;
339                    _Op __o(*this);
340                    size_t __c = 0;
341                    for (; __i != __eof; ++__i, ++__o, ++__c)
342                    {
343                        *__o = *__i;
344                        if (__o.failed())
345                            break;
346                    }
347                    if (__c == 0)
348                        this->setstate(ios_base::failbit);
349#ifndef _LIBCPP_NO_EXCEPTIONS
350                }
351                catch (...)
352                {
353                    this->__set_failbit_and_consider_rethrow();
354                }
355#endif  // _LIBCPP_NO_EXCEPTIONS
356            }
357            else
358                this->setstate(ios_base::badbit);
359        }
360#ifndef _LIBCPP_NO_EXCEPTIONS
361    }
362    catch (...)
363    {
364        this->__set_badbit_and_consider_rethrow();
365    }
366#endif  // _LIBCPP_NO_EXCEPTIONS
367    return *this;
368}
369
370template <class _CharT, class _Traits>
371basic_ostream<_CharT, _Traits>&
372basic_ostream<_CharT, _Traits>::operator<<(bool __n)
373{
374#ifndef _LIBCPP_NO_EXCEPTIONS
375    try
376    {
377#endif  // _LIBCPP_NO_EXCEPTIONS
378        sentry __s(*this);
379        if (__s)
380        {
381            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
382            const _Fp& __f = use_facet<_Fp>(this->getloc());
383            if (__f.put(*this, *this, this->fill(), __n).failed())
384                this->setstate(ios_base::badbit | ios_base::failbit);
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<<(short __n)
399{
400#ifndef _LIBCPP_NO_EXCEPTIONS
401    try
402    {
403#endif  // _LIBCPP_NO_EXCEPTIONS
404        sentry __s(*this);
405        if (__s)
406        {
407            ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
408            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
409            const _Fp& __f = use_facet<_Fp>(this->getloc());
410            if (__f.put(*this, *this, this->fill(),
411                        __flags == ios_base::oct || __flags == ios_base::hex ?
412                        static_cast<long>(static_cast<unsigned short>(__n))  :
413                        static_cast<long>(__n)).failed())
414                this->setstate(ios_base::badbit | ios_base::failbit);
415        }
416#ifndef _LIBCPP_NO_EXCEPTIONS
417    }
418    catch (...)
419    {
420        this->__set_badbit_and_consider_rethrow();
421    }
422#endif  // _LIBCPP_NO_EXCEPTIONS
423    return *this;
424}
425
426template <class _CharT, class _Traits>
427basic_ostream<_CharT, _Traits>&
428basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
429{
430#ifndef _LIBCPP_NO_EXCEPTIONS
431    try
432    {
433#endif  // _LIBCPP_NO_EXCEPTIONS
434        sentry __s(*this);
435        if (__s)
436        {
437            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
438            const _Fp& __f = use_facet<_Fp>(this->getloc());
439            if (__f.put(*this, *this, this->fill(), static_cast<unsigned 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<<(int __n)
455{
456#ifndef _LIBCPP_NO_EXCEPTIONS
457    try
458    {
459#endif  // _LIBCPP_NO_EXCEPTIONS
460        sentry __s(*this);
461        if (__s)
462        {
463            ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
464            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
465            const _Fp& __f = use_facet<_Fp>(this->getloc());
466            if (__f.put(*this, *this, this->fill(),
467                        __flags == ios_base::oct || __flags == ios_base::hex ?
468                        static_cast<long>(static_cast<unsigned int>(__n))  :
469                        static_cast<long>(__n)).failed())
470                this->setstate(ios_base::badbit | ios_base::failbit);
471        }
472#ifndef _LIBCPP_NO_EXCEPTIONS
473    }
474    catch (...)
475    {
476        this->__set_badbit_and_consider_rethrow();
477    }
478#endif  // _LIBCPP_NO_EXCEPTIONS
479    return *this;
480}
481
482template <class _CharT, class _Traits>
483basic_ostream<_CharT, _Traits>&
484basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
485{
486#ifndef _LIBCPP_NO_EXCEPTIONS
487    try
488    {
489#endif  // _LIBCPP_NO_EXCEPTIONS
490        sentry __s(*this);
491        if (__s)
492        {
493            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
494            const _Fp& __f = use_facet<_Fp>(this->getloc());
495            if (__f.put(*this, *this, this->fill(), static_cast<unsigned 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<<(long __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(), __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<<(unsigned 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<<(long 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<<(unsigned 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<<(float __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(), static_cast<double>(__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<<(double __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(), __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<<(long 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<<(const void* __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>&
718__put_character_sequence(basic_ostream<_CharT, _Traits>& __os,
719                          const _CharT* __str, size_t __len)
720{
721#ifndef _LIBCPP_NO_EXCEPTIONS
722    try
723    {
724#endif  // _LIBCPP_NO_EXCEPTIONS
725        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
726        if (__s)
727        {
728            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
729            if (__pad_and_output(_Ip(__os),
730                                 __str,
731                                 (__os.flags() & ios_base::adjustfield) == ios_base::left ?
732                                     __str + __len :
733                                     __str,
734                                 __str + __len,
735                                 __os,
736                                 __os.fill()).failed())
737                __os.setstate(ios_base::badbit | ios_base::failbit);
738        }
739#ifndef _LIBCPP_NO_EXCEPTIONS
740    }
741    catch (...)
742    {
743        __os.__set_badbit_and_consider_rethrow();
744    }
745#endif  // _LIBCPP_NO_EXCEPTIONS
746    return __os;
747}
748
749
750template<class _CharT, class _Traits>
751basic_ostream<_CharT, _Traits>&
752operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
753{
754    return _VSTD::__put_character_sequence(__os, &__c, 1);
755}
756
757template<class _CharT, class _Traits>
758basic_ostream<_CharT, _Traits>&
759operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
760{
761#ifndef _LIBCPP_NO_EXCEPTIONS
762    try
763    {
764#endif  // _LIBCPP_NO_EXCEPTIONS
765        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
766        if (__s)
767        {
768            _CharT __c = __os.widen(__cn);
769            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
770            if (__pad_and_output(_Ip(__os),
771                                 &__c,
772                                 (__os.flags() & ios_base::adjustfield) == ios_base::left ?
773                                     &__c + 1 :
774                                     &__c,
775                                 &__c + 1,
776                                 __os,
777                                 __os.fill()).failed())
778                __os.setstate(ios_base::badbit | ios_base::failbit);
779        }
780#ifndef _LIBCPP_NO_EXCEPTIONS
781    }
782    catch (...)
783    {
784        __os.__set_badbit_and_consider_rethrow();
785    }
786#endif  // _LIBCPP_NO_EXCEPTIONS
787    return __os;
788}
789
790template<class _Traits>
791basic_ostream<char, _Traits>&
792operator<<(basic_ostream<char, _Traits>& __os, char __c)
793{
794    return _VSTD::__put_character_sequence(__os, &__c, 1);
795}
796
797template<class _Traits>
798basic_ostream<char, _Traits>&
799operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
800{
801    return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
802}
803
804template<class _Traits>
805basic_ostream<char, _Traits>&
806operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
807{
808    return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
809}
810
811template<class _CharT, class _Traits>
812basic_ostream<_CharT, _Traits>&
813operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
814{
815    return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
816}
817
818template<class _CharT, class _Traits>
819basic_ostream<_CharT, _Traits>&
820operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
821{
822#ifndef _LIBCPP_NO_EXCEPTIONS
823    try
824    {
825#endif  // _LIBCPP_NO_EXCEPTIONS
826        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
827        if (__s)
828        {
829            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
830            size_t __len = char_traits<char>::length(__strn);
831            const int __bs = 100;
832            _CharT __wbb[__bs];
833            _CharT* __wb = __wbb;
834            unique_ptr<_CharT, void(*)(void*)> __h(0, free);
835            if (__len > __bs)
836            {
837                __wb = (_CharT*)malloc(__len*sizeof(_CharT));
838                if (__wb == 0)
839                    __throw_bad_alloc();
840                __h.reset(__wb);
841            }
842            for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
843                *__p = __os.widen(*__strn);
844            if (__pad_and_output(_Ip(__os),
845                                 __wb,
846                                 (__os.flags() & ios_base::adjustfield) == ios_base::left ?
847                                     __wb + __len :
848                                     __wb,
849                                 __wb + __len,
850                                 __os,
851                                 __os.fill()).failed())
852                __os.setstate(ios_base::badbit | ios_base::failbit);
853        }
854#ifndef _LIBCPP_NO_EXCEPTIONS
855    }
856    catch (...)
857    {
858        __os.__set_badbit_and_consider_rethrow();
859    }
860#endif  // _LIBCPP_NO_EXCEPTIONS
861    return __os;
862}
863
864template<class _Traits>
865basic_ostream<char, _Traits>&
866operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
867{
868    return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
869}
870
871template<class _Traits>
872basic_ostream<char, _Traits>&
873operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
874{
875    const char *__s = (const char *) __str;
876    return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
877}
878
879template<class _Traits>
880basic_ostream<char, _Traits>&
881operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
882{
883    const char *__s = (const char *) __str;
884    return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
885}
886
887template <class _CharT, class _Traits>
888basic_ostream<_CharT, _Traits>&
889basic_ostream<_CharT, _Traits>::put(char_type __c)
890{
891#ifndef _LIBCPP_NO_EXCEPTIONS
892    try
893    {
894#endif  // _LIBCPP_NO_EXCEPTIONS
895        sentry __s(*this);
896        if (__s)
897        {
898            typedef ostreambuf_iterator<_CharT, _Traits> _Op;
899            _Op __o(*this);
900            *__o = __c;
901            if (__o.failed())
902                this->setstate(ios_base::badbit);
903        }
904#ifndef _LIBCPP_NO_EXCEPTIONS
905    }
906    catch (...)
907    {
908        this->__set_badbit_and_consider_rethrow();
909    }
910#endif  // _LIBCPP_NO_EXCEPTIONS
911    return *this;
912}
913
914template <class _CharT, class _Traits>
915basic_ostream<_CharT, _Traits>&
916basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
917{
918#ifndef _LIBCPP_NO_EXCEPTIONS
919    try
920    {
921#endif  // _LIBCPP_NO_EXCEPTIONS
922        sentry __sen(*this);
923        if (__sen && __n)
924        {
925            if (this->rdbuf()->sputn(__s, __n) != __n)
926                this->setstate(ios_base::badbit);
927        }
928#ifndef _LIBCPP_NO_EXCEPTIONS
929    }
930    catch (...)
931    {
932        this->__set_badbit_and_consider_rethrow();
933    }
934#endif  // _LIBCPP_NO_EXCEPTIONS
935    return *this;
936}
937
938template <class _CharT, class _Traits>
939basic_ostream<_CharT, _Traits>&
940basic_ostream<_CharT, _Traits>::flush()
941{
942#ifndef _LIBCPP_NO_EXCEPTIONS
943    try
944    {
945#endif  // _LIBCPP_NO_EXCEPTIONS
946        if (this->rdbuf())
947        {
948            sentry __s(*this);
949            if (__s)
950            {
951                if (this->rdbuf()->pubsync() == -1)
952                    this->setstate(ios_base::badbit);
953            }
954        }
955#ifndef _LIBCPP_NO_EXCEPTIONS
956    }
957    catch (...)
958    {
959        this->__set_badbit_and_consider_rethrow();
960    }
961#endif  // _LIBCPP_NO_EXCEPTIONS
962    return *this;
963}
964
965template <class _CharT, class _Traits>
966typename basic_ostream<_CharT, _Traits>::pos_type
967basic_ostream<_CharT, _Traits>::tellp()
968{
969    if (this->fail())
970        return pos_type(-1);
971    return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
972}
973
974template <class _CharT, class _Traits>
975basic_ostream<_CharT, _Traits>&
976basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
977{
978    sentry __s(*this);
979    if (!this->fail())
980    {
981        if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
982            this->setstate(ios_base::failbit);
983    }
984    return *this;
985}
986
987template <class _CharT, class _Traits>
988basic_ostream<_CharT, _Traits>&
989basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
990{
991    sentry __s(*this);
992    if (!this->fail())
993    {
994        if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
995            this->setstate(ios_base::failbit);
996    }
997    return *this;
998}
999
1000template <class _CharT, class _Traits>
1001inline
1002basic_ostream<_CharT, _Traits>&
1003endl(basic_ostream<_CharT, _Traits>& __os)
1004{
1005    __os.put(__os.widen('\n'));
1006    __os.flush();
1007    return __os;
1008}
1009
1010template <class _CharT, class _Traits>
1011inline
1012basic_ostream<_CharT, _Traits>&
1013ends(basic_ostream<_CharT, _Traits>& __os)
1014{
1015    __os.put(_CharT());
1016    return __os;
1017}
1018
1019template <class _CharT, class _Traits>
1020inline
1021basic_ostream<_CharT, _Traits>&
1022flush(basic_ostream<_CharT, _Traits>& __os)
1023{
1024    __os.flush();
1025    return __os;
1026}
1027
1028#ifndef _LIBCPP_CXX03_LANG
1029
1030template <class _Stream, class _Tp, class = void>
1031struct __is_ostreamable : false_type { };
1032
1033template <class _Stream, class _Tp>
1034struct __is_ostreamable<_Stream, _Tp, decltype(
1035    _VSTD::declval<_Stream>() << _VSTD::declval<_Tp>(), void()
1036)> : true_type { };
1037
1038template <class _Stream, class _Tp, class = typename enable_if<
1039    _And<is_base_of<ios_base, _Stream>,
1040         __is_ostreamable<_Stream&, const _Tp&>>::value
1041>::type>
1042_LIBCPP_INLINE_VISIBILITY
1043_Stream&& operator<<(_Stream&& __os, const _Tp& __x)
1044{
1045    __os << __x;
1046    return _VSTD::move(__os);
1047}
1048
1049#endif  // _LIBCPP_CXX03_LANG
1050
1051template<class _CharT, class _Traits, class _Allocator>
1052basic_ostream<_CharT, _Traits>&
1053operator<<(basic_ostream<_CharT, _Traits>& __os,
1054           const basic_string<_CharT, _Traits, _Allocator>& __str)
1055{
1056    return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
1057}
1058
1059template<class _CharT, class _Traits>
1060basic_ostream<_CharT, _Traits>&
1061operator<<(basic_ostream<_CharT, _Traits>& __os,
1062           basic_string_view<_CharT, _Traits> __sv)
1063{
1064    return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size());
1065}
1066
1067template <class _CharT, class _Traits>
1068inline _LIBCPP_INLINE_VISIBILITY
1069basic_ostream<_CharT, _Traits>&
1070operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
1071{
1072    return __os << __ec.category().name() << ':' << __ec.value();
1073}
1074
1075template<class _CharT, class _Traits, class _Yp>
1076inline _LIBCPP_INLINE_VISIBILITY
1077basic_ostream<_CharT, _Traits>&
1078operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
1079{
1080    return __os << __p.get();
1081}
1082
1083template<class _CharT, class _Traits, class _Yp, class _Dp>
1084inline _LIBCPP_INLINE_VISIBILITY
1085typename enable_if
1086<
1087    is_same<void, typename __void_t<decltype((declval<basic_ostream<_CharT, _Traits>&>() << declval<typename unique_ptr<_Yp, _Dp>::pointer>()))>::type>::value,
1088    basic_ostream<_CharT, _Traits>&
1089>::type
1090operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p)
1091{
1092    return __os << __p.get();
1093}
1094
1095template <class _CharT, class _Traits, size_t _Size>
1096basic_ostream<_CharT, _Traits>&
1097operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
1098{
1099    return __os << __x.template to_string<_CharT, _Traits>
1100                        (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
1101                         use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
1102}
1103
1104_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>)
1105_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>)
1106
1107_LIBCPP_END_NAMESPACE_STD
1108
1109#endif  // _LIBCPP_OSTREAM
1110