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