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