xref: /freebsd/contrib/llvm-project/libcxx/include/__ostream/basic_ostream.h (revision 0fca6ea1d4eea4c934cfff25ac9ee8ad6fe95583) 
1 //===---------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===---------------------------------------------------------------------===//
8 
9 #ifndef _LIBCPP___OSTREAM_BASIC_OSTREAM_H
10 #define _LIBCPP___OSTREAM_BASIC_OSTREAM_H
11 
12 #include <__config>
13 #include <__exception/operations.h>
14 #include <__memory/shared_ptr.h>
15 #include <__memory/unique_ptr.h>
16 #include <__system_error/error_code.h>
17 #include <__type_traits/conjunction.h>
18 #include <__type_traits/enable_if.h>
19 #include <__type_traits/is_base_of.h>
20 #include <__type_traits/void_t.h>
21 #include <__utility/declval.h>
22 #include <bitset>
23 #include <cstddef>
24 #include <ios>
25 #include <locale>
26 #include <new> // for __throw_bad_alloc
27 #include <streambuf>
28 #include <string_view>
29 
30 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
31 #  pragma GCC system_header
32 #endif
33 
34 _LIBCPP_PUSH_MACROS
35 #include <__undef_macros>
36 
37 _LIBCPP_BEGIN_NAMESPACE_STD
38 
39 template <class _CharT, class _Traits>
40 class _LIBCPP_TEMPLATE_VIS basic_ostream : virtual public basic_ios<_CharT, _Traits> {
41 public:
42   // types (inherited from basic_ios (27.5.4)):
43   typedef _CharT char_type;
44   typedef _Traits traits_type;
45   typedef typename traits_type::int_type int_type;
46   typedef typename traits_type::pos_type pos_type;
47   typedef typename traits_type::off_type off_type;
48 
49   // 27.7.2.2 Constructor/destructor:
basic_ostream(basic_streambuf<char_type,traits_type> * __sb)50   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) {
51     this->init(__sb);
52   }
53   ~basic_ostream() override;
54 
55   basic_ostream(const basic_ostream& __rhs)            = delete;
56   basic_ostream& operator=(const basic_ostream& __rhs) = delete;
57 
58 protected:
59   inline _LIBCPP_HIDE_FROM_ABI basic_ostream(basic_ostream&& __rhs);
60 
61   // 27.7.2.3 Assign/swap
62   inline _LIBCPP_HIDE_FROM_ABI basic_ostream& operator=(basic_ostream&& __rhs);
63 
swap(basic_ostream & __rhs)64   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_ostream& __rhs) {
65     basic_ios<char_type, traits_type>::swap(__rhs);
66   }
67 
68 public:
69   // 27.7.2.4 Prefix/suffix:
70   class _LIBCPP_TEMPLATE_VIS sentry;
71 
72   // 27.7.2.6 Formatted output:
73   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) {
74     return __pf(*this);
75   }
76 
77   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream&
78   operator<<(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {
79     __pf(*this);
80     return *this;
81   }
82 
83   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) {
84     __pf(*this);
85     return *this;
86   }
87 
88   basic_ostream& operator<<(bool __n);
89   basic_ostream& operator<<(short __n);
90   basic_ostream& operator<<(unsigned short __n);
91   basic_ostream& operator<<(int __n);
92   basic_ostream& operator<<(unsigned int __n);
93   basic_ostream& operator<<(long __n);
94   basic_ostream& operator<<(unsigned long __n);
95   basic_ostream& operator<<(long long __n);
96   basic_ostream& operator<<(unsigned long long __n);
97   basic_ostream& operator<<(float __f);
98   basic_ostream& operator<<(double __f);
99   basic_ostream& operator<<(long double __f);
100   basic_ostream& operator<<(const void* __p);
101 
102 #if _LIBCPP_STD_VER >= 23
103   _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(const volatile void* __p) {
104     return operator<<(const_cast<const void*>(__p));
105   }
106 #endif
107 
108   basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
109 
110 #if _LIBCPP_STD_VER >= 17
111   // LWG 2221 - nullptr. This is not backported to older standards modes.
112   // See https://reviews.llvm.org/D127033 for more info on the rationale.
113   _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(nullptr_t) { return *this << "nullptr"; }
114 #endif
115 
116   // 27.7.2.7 Unformatted output:
117   basic_ostream& put(char_type __c);
118   basic_ostream& write(const char_type* __s, streamsize __n);
119   basic_ostream& flush();
120 
121   // 27.7.2.5 seeks:
122   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type tellp();
123   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(pos_type __pos);
124   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
125 
126 protected:
basic_ostream()127   _LIBCPP_HIDE_FROM_ABI basic_ostream() {} // extension, intentially does not initialize
128 };
129 
130 template <class _CharT, class _Traits>
131 class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry {
132   bool __ok_;
133   basic_ostream<_CharT, _Traits>& __os_;
134 
135 public:
136   explicit sentry(basic_ostream<_CharT, _Traits>& __os);
137   ~sentry();
138   sentry(const sentry&)            = delete;
139   sentry& operator=(const sentry&) = delete;
140 
141   _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ok_; }
142 };
143 
144 template <class _CharT, class _Traits>
sentry(basic_ostream<_CharT,_Traits> & __os)145 basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os) : __ok_(false), __os_(__os) {
146   if (__os.good()) {
147     if (__os.tie())
148       __os.tie()->flush();
149     __ok_ = true;
150   }
151 }
152 
153 template <class _CharT, class _Traits>
~sentry()154 basic_ostream<_CharT, _Traits>::sentry::~sentry() {
155   if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) && !uncaught_exception()) {
156 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
157     try {
158 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
159       if (__os_.rdbuf()->pubsync() == -1)
160         __os_.setstate(ios_base::badbit);
161 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
162     } catch (...) {
163     }
164 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
165   }
166 }
167 
168 template <class _CharT, class _Traits>
basic_ostream(basic_ostream && __rhs)169 basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) {
170   this->move(__rhs);
171 }
172 
173 template <class _CharT, class _Traits>
174 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) {
175   swap(__rhs);
176   return *this;
177 }
178 
179 template <class _CharT, class _Traits>
~basic_ostream()180 basic_ostream<_CharT, _Traits>::~basic_ostream() {}
181 
182 template <class _CharT, class _Traits>
183 basic_ostream<_CharT, _Traits>&
184 basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) {
185 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
186   try {
187 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
188     sentry __s(*this);
189     if (__s) {
190       if (__sb) {
191 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
192         try {
193 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
194           typedef istreambuf_iterator<_CharT, _Traits> _Ip;
195           typedef ostreambuf_iterator<_CharT, _Traits> _Op;
196           _Ip __i(__sb);
197           _Ip __eof;
198           _Op __o(*this);
199           size_t __c = 0;
200           for (; __i != __eof; ++__i, ++__o, ++__c) {
201             *__o = *__i;
202             if (__o.failed())
203               break;
204           }
205           if (__c == 0)
206             this->setstate(ios_base::failbit);
207 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)208         } catch (...) {
209           this->__set_failbit_and_consider_rethrow();
210         }
211 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
212       } else
213         this->setstate(ios_base::badbit);
214     }
215 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)216   } catch (...) {
217     this->__set_badbit_and_consider_rethrow();
218   }
219 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
220   return *this;
221 }
222 
223 template <class _CharT, class _Traits>
224 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(bool __n) {
225 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
226   try {
227 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
228     sentry __s(*this);
229     if (__s) {
230       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
231       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
232       if (__f.put(*this, *this, this->fill(), __n).failed())
233         this->setstate(ios_base::badbit | ios_base::failbit);
234     }
235 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)236   } catch (...) {
237     this->__set_badbit_and_consider_rethrow();
238   }
239 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
240   return *this;
241 }
242 
243 template <class _CharT, class _Traits>
244 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(short __n) {
245 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
246   try {
247 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
248     sentry __s(*this);
249     if (__s) {
250       ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
251       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
252       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
253       if (__f.put(*this,
254                   *this,
255                   this->fill(),
256                   __flags == ios_base::oct || __flags == ios_base::hex
257                       ? static_cast<long>(static_cast<unsigned short>(__n))
258                       : static_cast<long>(__n))
259               .failed())
260         this->setstate(ios_base::badbit | ios_base::failbit);
261     }
262 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)263   } catch (...) {
264     this->__set_badbit_and_consider_rethrow();
265   }
266 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
267   return *this;
268 }
269 
270 template <class _CharT, class _Traits>
271 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) {
272 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
273   try {
274 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
275     sentry __s(*this);
276     if (__s) {
277       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
278       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
279       if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
280         this->setstate(ios_base::badbit | ios_base::failbit);
281     }
282 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)283   } catch (...) {
284     this->__set_badbit_and_consider_rethrow();
285   }
286 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
287   return *this;
288 }
289 
290 template <class _CharT, class _Traits>
291 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(int __n) {
292 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
293   try {
294 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
295     sentry __s(*this);
296     if (__s) {
297       ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
298       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
299       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
300       if (__f.put(*this,
301                   *this,
302                   this->fill(),
303                   __flags == ios_base::oct || __flags == ios_base::hex
304                       ? static_cast<long>(static_cast<unsigned int>(__n))
305                       : static_cast<long>(__n))
306               .failed())
307         this->setstate(ios_base::badbit | ios_base::failbit);
308     }
309 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)310   } catch (...) {
311     this->__set_badbit_and_consider_rethrow();
312   }
313 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
314   return *this;
315 }
316 
317 template <class _CharT, class _Traits>
318 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) {
319 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
320   try {
321 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
322     sentry __s(*this);
323     if (__s) {
324       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
325       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
326       if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
327         this->setstate(ios_base::badbit | ios_base::failbit);
328     }
329 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)330   } catch (...) {
331     this->__set_badbit_and_consider_rethrow();
332   }
333 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
334   return *this;
335 }
336 
337 template <class _CharT, class _Traits>
338 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long __n) {
339 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
340   try {
341 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
342     sentry __s(*this);
343     if (__s) {
344       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
345       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
346       if (__f.put(*this, *this, this->fill(), __n).failed())
347         this->setstate(ios_base::badbit | ios_base::failbit);
348     }
349 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)350   } catch (...) {
351     this->__set_badbit_and_consider_rethrow();
352   }
353 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
354   return *this;
355 }
356 
357 template <class _CharT, class _Traits>
358 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) {
359 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
360   try {
361 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
362     sentry __s(*this);
363     if (__s) {
364       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
365       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
366       if (__f.put(*this, *this, this->fill(), __n).failed())
367         this->setstate(ios_base::badbit | ios_base::failbit);
368     }
369 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)370   } catch (...) {
371     this->__set_badbit_and_consider_rethrow();
372   }
373 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
374   return *this;
375 }
376 
377 template <class _CharT, class _Traits>
378 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long long __n) {
379 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
380   try {
381 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
382     sentry __s(*this);
383     if (__s) {
384       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
385       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
386       if (__f.put(*this, *this, this->fill(), __n).failed())
387         this->setstate(ios_base::badbit | ios_base::failbit);
388     }
389 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)390   } catch (...) {
391     this->__set_badbit_and_consider_rethrow();
392   }
393 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
394   return *this;
395 }
396 
397 template <class _CharT, class _Traits>
398 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) {
399 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
400   try {
401 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
402     sentry __s(*this);
403     if (__s) {
404       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
405       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
406       if (__f.put(*this, *this, this->fill(), __n).failed())
407         this->setstate(ios_base::badbit | ios_base::failbit);
408     }
409 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)410   } catch (...) {
411     this->__set_badbit_and_consider_rethrow();
412   }
413 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
414   return *this;
415 }
416 
417 template <class _CharT, class _Traits>
418 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(float __n) {
419 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
420   try {
421 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
422     sentry __s(*this);
423     if (__s) {
424       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
425       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
426       if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
427         this->setstate(ios_base::badbit | ios_base::failbit);
428     }
429 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)430   } catch (...) {
431     this->__set_badbit_and_consider_rethrow();
432   }
433 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
434   return *this;
435 }
436 
437 template <class _CharT, class _Traits>
438 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(double __n) {
439 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
440   try {
441 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
442     sentry __s(*this);
443     if (__s) {
444       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
445       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
446       if (__f.put(*this, *this, this->fill(), __n).failed())
447         this->setstate(ios_base::badbit | ios_base::failbit);
448     }
449 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)450   } catch (...) {
451     this->__set_badbit_and_consider_rethrow();
452   }
453 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
454   return *this;
455 }
456 
457 template <class _CharT, class _Traits>
458 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long double __n) {
459 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
460   try {
461 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
462     sentry __s(*this);
463     if (__s) {
464       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
465       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
466       if (__f.put(*this, *this, this->fill(), __n).failed())
467         this->setstate(ios_base::badbit | ios_base::failbit);
468     }
469 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)470   } catch (...) {
471     this->__set_badbit_and_consider_rethrow();
472   }
473 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
474   return *this;
475 }
476 
477 template <class _CharT, class _Traits>
478 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(const void* __n) {
479 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
480   try {
481 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
482     sentry __s(*this);
483     if (__s) {
484       typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
485       const _Fp& __f = std::use_facet<_Fp>(this->getloc());
486       if (__f.put(*this, *this, this->fill(), __n).failed())
487         this->setstate(ios_base::badbit | ios_base::failbit);
488     }
489 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)490   } catch (...) {
491     this->__set_badbit_and_consider_rethrow();
492   }
493 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
494   return *this;
495 }
496 
497 template <class _CharT, class _Traits>
498 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
__put_character_sequence(basic_ostream<_CharT,_Traits> & __os,const _CharT * __str,size_t __len)499 __put_character_sequence(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str, size_t __len) {
500 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
501   try {
502 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
503     typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
504     if (__s) {
505       typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
506       if (std::__pad_and_output(
507               _Ip(__os),
508               __str,
509               (__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
510               __str + __len,
511               __os,
512               __os.fill())
513               .failed())
514         __os.setstate(ios_base::badbit | ios_base::failbit);
515     }
516 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
517   } catch (...) {
518     __os.__set_badbit_and_consider_rethrow();
519   }
520 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
521   return __os;
522 }
523 
524 template <class _CharT, class _Traits>
525 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) {
526   return std::__put_character_sequence(__os, &__c, 1);
527 }
528 
529 template <class _CharT, class _Traits>
530 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) {
531 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
532   try {
533 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
534     typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
535     if (__s) {
536       _CharT __c = __os.widen(__cn);
537       typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
538       if (std::__pad_and_output(
539               _Ip(__os),
540               &__c,
541               (__os.flags() & ios_base::adjustfield) == ios_base::left ? &__c + 1 : &__c,
542               &__c + 1,
543               __os,
544               __os.fill())
545               .failed())
546         __os.setstate(ios_base::badbit | ios_base::failbit);
547     }
548 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)549   } catch (...) {
550     __os.__set_badbit_and_consider_rethrow();
551   }
552 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
553   return __os;
554 }
555 
556 template <class _Traits>
557 _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, char __c) {
558   return std::__put_character_sequence(__os, &__c, 1);
559 }
560 
561 template <class _Traits>
562 _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
563   return std::__put_character_sequence(__os, (char*)&__c, 1);
564 }
565 
566 template <class _Traits>
567 _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
568   return std::__put_character_sequence(__os, (char*)&__c, 1);
569 }
570 
571 template <class _CharT, class _Traits>
572 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
573 operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) {
574   return std::__put_character_sequence(__os, __str, _Traits::length(__str));
575 }
576 
577 template <class _CharT, class _Traits>
578 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
579 operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) {
580 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
581   try {
582 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
583     typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
584     if (__s) {
585       typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
586       size_t __len   = char_traits<char>::length(__strn);
587       const int __bs = 100;
588       _CharT __wbb[__bs];
589       _CharT* __wb = __wbb;
590       unique_ptr<_CharT, void (*)(void*)> __h(0, free);
591       if (__len > __bs) {
592         __wb = (_CharT*)malloc(__len * sizeof(_CharT));
593         if (__wb == 0)
594           __throw_bad_alloc();
595         __h.reset(__wb);
596       }
597       for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
598         *__p = __os.widen(*__strn);
599       if (std::__pad_and_output(
600               _Ip(__os),
601               __wb,
602               (__os.flags() & ios_base::adjustfield) == ios_base::left ? __wb + __len : __wb,
603               __wb + __len,
604               __os,
605               __os.fill())
606               .failed())
607         __os.setstate(ios_base::badbit | ios_base::failbit);
608     }
609 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
catch(...)610   } catch (...) {
611     __os.__set_badbit_and_consider_rethrow();
612   }
613 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
614   return __os;
615 }
616 
617 template <class _Traits>
618 _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, const char* __str) {
619   return std::__put_character_sequence(__os, __str, _Traits::length(__str));
620 }
621 
622 template <class _Traits>
623 _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
624 operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) {
625   const char* __s = (const char*)__str;
626   return std::__put_character_sequence(__os, __s, _Traits::length(__s));
627 }
628 
629 template <class _Traits>
630 _LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
631 operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) {
632   const char* __s = (const char*)__str;
633   return std::__put_character_sequence(__os, __s, _Traits::length(__s));
634 }
635 
636 template <class _CharT, class _Traits>
put(char_type __c)637 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::put(char_type __c) {
638 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
639   try {
640 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
641     sentry __s(*this);
642     if (__s) {
643       typedef ostreambuf_iterator<_CharT, _Traits> _Op;
644       _Op __o(*this);
645       *__o = __c;
646       if (__o.failed())
647         this->setstate(ios_base::badbit);
648     }
649 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
650   } catch (...) {
651     this->__set_badbit_and_consider_rethrow();
652   }
653 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
654   return *this;
655 }
656 
657 template <class _CharT, class _Traits>
write(const char_type * __s,streamsize __n)658 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) {
659 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
660   try {
661 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
662     sentry __sen(*this);
663     if (__sen && __n) {
664       if (this->rdbuf()->sputn(__s, __n) != __n)
665         this->setstate(ios_base::badbit);
666     }
667 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
668   } catch (...) {
669     this->__set_badbit_and_consider_rethrow();
670   }
671 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
672   return *this;
673 }
674 
675 template <class _CharT, class _Traits>
flush()676 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::flush() {
677 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
678   try {
679 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
680     if (this->rdbuf()) {
681       sentry __s(*this);
682       if (__s) {
683         if (this->rdbuf()->pubsync() == -1)
684           this->setstate(ios_base::badbit);
685       }
686     }
687 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
688   } catch (...) {
689     this->__set_badbit_and_consider_rethrow();
690   }
691 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
692   return *this;
693 }
694 
695 template <class _CharT, class _Traits>
tellp()696 typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>::tellp() {
697   if (this->fail())
698     return pos_type(-1);
699   return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
700 }
701 
702 template <class _CharT, class _Traits>
seekp(pos_type __pos)703 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) {
704   sentry __s(*this);
705   if (!this->fail()) {
706     if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
707       this->setstate(ios_base::failbit);
708   }
709   return *this;
710 }
711 
712 template <class _CharT, class _Traits>
seekp(off_type __off,ios_base::seekdir __dir)713 basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) {
714   sentry __s(*this);
715   if (!this->fail()) {
716     if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
717       this->setstate(ios_base::failbit);
718   }
719   return *this;
720 }
721 
722 template <class _CharT, class _Traits>
endl(basic_ostream<_CharT,_Traits> & __os)723 _LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) {
724   __os.put(__os.widen('\n'));
725   __os.flush();
726   return __os;
727 }
728 
729 template <class _CharT, class _Traits>
ends(basic_ostream<_CharT,_Traits> & __os)730 _LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) {
731   __os.put(_CharT());
732   return __os;
733 }
734 
735 template <class _CharT, class _Traits>
flush(basic_ostream<_CharT,_Traits> & __os)736 _LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) {
737   __os.flush();
738   return __os;
739 }
740 
741 template <class _Stream, class _Tp, class = void>
742 struct __is_ostreamable : false_type {};
743 
744 template <class _Stream, class _Tp>
745 struct __is_ostreamable<_Stream, _Tp, decltype(std::declval<_Stream>() << std::declval<_Tp>(), void())> : true_type {};
746 
747 template <class _Stream,
748           class _Tp,
749           __enable_if_t<_And<is_base_of<ios_base, _Stream>, __is_ostreamable<_Stream&, const _Tp&> >::value, int> = 0>
750 _LIBCPP_HIDE_FROM_ABI _Stream&& operator<<(_Stream&& __os, const _Tp& __x) {
751   __os << __x;
752   return std::move(__os);
753 }
754 
755 template <class _CharT, class _Traits, class _Allocator>
756 basic_ostream<_CharT, _Traits>&
757 operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Allocator>& __str) {
758   return std::__put_character_sequence(__os, __str.data(), __str.size());
759 }
760 
761 template <class _CharT, class _Traits>
762 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
763 operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __sv) {
764   return std::__put_character_sequence(__os, __sv.data(), __sv.size());
765 }
766 
767 template <class _CharT, class _Traits>
768 inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
769 operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec) {
770   return __os << __ec.category().name() << ':' << __ec.value();
771 }
772 
773 template <class _CharT, class _Traits, class _Yp>
774 inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
775 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p) {
776   return __os << __p.get();
777 }
778 
779 template <
780     class _CharT,
781     class _Traits,
782     class _Yp,
783     class _Dp,
784     __enable_if_t<is_same<void,
785                           __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>()
786                                              << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
787                   int> = 0>
788 inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
789 operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) {
790   return __os << __p.get();
791 }
792 
793 template <class _CharT, class _Traits, size_t _Size>
794 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
795 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) {
796   return __os << __x.template to_string<_CharT, _Traits>(std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
797                                                          std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
798 }
799 
800 #if _LIBCPP_STD_VER >= 20
801 
802 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
803 template <class _Traits>
804 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
805 
806 template <class _Traits>
807 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
808 
809 template <class _Traits>
810 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
811 
812 template <class _Traits>
813 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
814 
815 template <class _Traits>
816 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
817 
818 template <class _Traits>
819 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
820 
821 #  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
822 
823 #  ifndef _LIBCPP_HAS_NO_CHAR8_T
824 template <class _Traits>
825 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
826 
827 template <class _Traits>
828 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
829 
830 template <class _Traits>
831 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
832 
833 template <class _Traits>
834 basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
835 #  endif
836 
837 template <class _Traits>
838 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
839 
840 template <class _Traits>
841 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
842 
843 template <class _Traits>
844 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
845 
846 template <class _Traits>
847 basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
848 
849 #endif // _LIBCPP_STD_VER >= 20
850 
851 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
852 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
853 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
854 #endif
855 
856 _LIBCPP_END_NAMESPACE_STD
857 
858 _LIBCPP_POP_MACROS
859 
860 #endif // _LIBCPP___OSTREAM_BASIC_OSTREAM_H
861