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