mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-04-09 09:21:41 +00:00
615e6dd1c5
We recently noticed that the unwrap_iter.h file was pushing macros, but
it was pushing them again instead of popping them at the end of the
file. This led to libc++ basically swallowing any custom definition of
these macros in user code:
#define min HELLO
#include <algorithm>
// min is not HELLO anymore, it's not defined
While investigating this issue, I noticed that our push/pop pragmas were
actually entirely wrong too. Indeed, instead of pushing macros like
`move`, we'd push `move(int, int)` in the pragma, which is not a valid
macro name. As a result, we would not actually push macros like `move`
-- instead we'd simply undefine them. This led to the following code not
working:
#define move HELLO
#include <algorithm>
// move is not HELLO anymore
Fixing the pragma push/pop incantations led to a cascade of issues
because we use identifiers like `move` in a large number of places, and
all of these headers would now need to do the push/pop dance.
This patch fixes all these issues. First, it adds a check that we don't
swallow important names like min, max, move or refresh as explained
above. This is done by augmenting the existing
system_reserved_names.gen.py test to also check that the macros are what
we expect after including each header.
Second, it fixes the push/pop pragmas to work properly and adds missing
pragmas to all the files I could detect a failure in via the newly added
test.
rdar://121365472
(cherry picked from commit 7b4622514d232ce5f7110dd8b20d90e81127c467)
1188 lines
42 KiB
C++
1188 lines
42 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_OSTREAM
|
|
#define _LIBCPP_OSTREAM
|
|
|
|
/*
|
|
ostream synopsis
|
|
|
|
template <class charT, class traits = char_traits<charT> >
|
|
class basic_ostream
|
|
: virtual public basic_ios<charT,traits>
|
|
{
|
|
public:
|
|
// types (inherited from basic_ios (27.5.4)):
|
|
typedef charT char_type;
|
|
typedef traits traits_type;
|
|
typedef typename traits_type::int_type int_type;
|
|
typedef typename traits_type::pos_type pos_type;
|
|
typedef typename traits_type::off_type off_type;
|
|
|
|
// 27.7.2.2 Constructor/destructor:
|
|
explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
|
|
basic_ostream(basic_ostream&& rhs);
|
|
virtual ~basic_ostream();
|
|
|
|
// 27.7.2.3 Assign/swap
|
|
basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14
|
|
basic_ostream& operator=(basic_ostream&& rhs);
|
|
void swap(basic_ostream& rhs);
|
|
|
|
// 27.7.2.4 Prefix/suffix:
|
|
class sentry;
|
|
|
|
// 27.7.2.6 Formatted output:
|
|
basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
|
|
basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&));
|
|
basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
|
|
basic_ostream& operator<<(bool n);
|
|
basic_ostream& operator<<(short n);
|
|
basic_ostream& operator<<(unsigned short n);
|
|
basic_ostream& operator<<(int n);
|
|
basic_ostream& operator<<(unsigned int n);
|
|
basic_ostream& operator<<(long n);
|
|
basic_ostream& operator<<(unsigned long n);
|
|
basic_ostream& operator<<(long long n);
|
|
basic_ostream& operator<<(unsigned long long n);
|
|
basic_ostream& operator<<(float f);
|
|
basic_ostream& operator<<(double f);
|
|
basic_ostream& operator<<(long double f);
|
|
basic_ostream& operator<<(const void* p);
|
|
basic_ostream& operator<<(const volatile void* val); // C++23
|
|
basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
|
|
basic_ostream& operator<<(nullptr_t);
|
|
|
|
// 27.7.2.7 Unformatted output:
|
|
basic_ostream& put(char_type c);
|
|
basic_ostream& write(const char_type* s, streamsize n);
|
|
basic_ostream& flush();
|
|
|
|
// 27.7.2.5 seeks:
|
|
pos_type tellp();
|
|
basic_ostream& seekp(pos_type);
|
|
basic_ostream& seekp(off_type, ios_base::seekdir);
|
|
protected:
|
|
basic_ostream(const basic_ostream& rhs) = delete;
|
|
basic_ostream(basic_ostream&& rhs);
|
|
// 27.7.3.3 Assign/swap
|
|
basic_ostream& operator=(basic_ostream& rhs) = delete;
|
|
basic_ostream& operator=(const basic_ostream&& rhs);
|
|
void swap(basic_ostream& rhs);
|
|
};
|
|
|
|
// 27.7.2.6.4 character inserters
|
|
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT);
|
|
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char);
|
|
|
|
// signed and unsigned
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char);
|
|
|
|
// NTBS
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*);
|
|
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*);
|
|
|
|
// signed and unsigned
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*);
|
|
|
|
// swap:
|
|
template <class charT, class traits>
|
|
void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
|
|
|
|
template <class charT, class traits>
|
|
basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
|
|
|
|
template <class charT, class traits>
|
|
basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
|
|
|
|
template <class charT, class traits>
|
|
basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
|
|
|
|
// rvalue stream insertion
|
|
template <class Stream, class T>
|
|
Stream&& operator<<(Stream&& os, const T& x);
|
|
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, wchar_t) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char8_t) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char16_t) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char32_t) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char8_t) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char16_t) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char32_t) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const wchar_t*) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char8_t*) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char16_t*) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char32_t*) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char8_t*) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char16_t*) = delete; // since C++20
|
|
template<class traits>
|
|
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20
|
|
|
|
// [ostream.formatted.print], print functions
|
|
template<class... Args> // since C++23
|
|
void print(ostream& os, format_string<Args...> fmt, Args&&... args);
|
|
template<class... Args> // since C++23
|
|
void println(ostream& os, format_string<Args...> fmt, Args&&... args);
|
|
|
|
void vprint_unicode(ostream& os, string_view fmt, format_args args); // since C++23
|
|
void vprint_nonunicode(ostream& os, string_view fmt, format_args args); // since C++23
|
|
} // std
|
|
|
|
*/
|
|
|
|
#include <__assert> // all public C++ headers provide the assertion handler
|
|
#include <__availability>
|
|
#include <__config>
|
|
#include <__exception/operations.h>
|
|
#include <__fwd/ostream.h>
|
|
#include <__memory/shared_ptr.h>
|
|
#include <__memory/unique_ptr.h>
|
|
#include <__system_error/error_code.h>
|
|
#include <__type_traits/conjunction.h>
|
|
#include <__type_traits/enable_if.h>
|
|
#include <__type_traits/is_base_of.h>
|
|
#include <__type_traits/void_t.h>
|
|
#include <__utility/declval.h>
|
|
#include <bitset>
|
|
#include <cstdio>
|
|
#include <format>
|
|
#include <ios>
|
|
#include <locale>
|
|
#include <new>
|
|
#include <print>
|
|
#include <streambuf>
|
|
#include <string_view>
|
|
#include <version>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
# pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_PUSH_MACROS
|
|
#include <__undef_macros>
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
template <class _CharT, class _Traits>
|
|
class _LIBCPP_TEMPLATE_VIS basic_ostream : virtual public basic_ios<_CharT, _Traits> {
|
|
public:
|
|
// types (inherited from basic_ios (27.5.4)):
|
|
typedef _CharT char_type;
|
|
typedef _Traits traits_type;
|
|
typedef typename traits_type::int_type int_type;
|
|
typedef typename traits_type::pos_type pos_type;
|
|
typedef typename traits_type::off_type off_type;
|
|
|
|
// 27.7.2.2 Constructor/destructor:
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) {
|
|
this->init(__sb);
|
|
}
|
|
~basic_ostream() override;
|
|
|
|
protected:
|
|
inline _LIBCPP_HIDE_FROM_ABI basic_ostream(basic_ostream&& __rhs);
|
|
|
|
// 27.7.2.3 Assign/swap
|
|
inline _LIBCPP_HIDE_FROM_ABI basic_ostream& operator=(basic_ostream&& __rhs);
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_ostream& __rhs) {
|
|
basic_ios<char_type, traits_type>::swap(__rhs);
|
|
}
|
|
|
|
basic_ostream(const basic_ostream& __rhs) = delete;
|
|
basic_ostream& operator=(const basic_ostream& __rhs) = delete;
|
|
|
|
public:
|
|
// 27.7.2.4 Prefix/suffix:
|
|
class _LIBCPP_TEMPLATE_VIS sentry;
|
|
|
|
// 27.7.2.6 Formatted output:
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) {
|
|
return __pf(*this);
|
|
}
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream&
|
|
operator<<(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) {
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
basic_ostream& operator<<(bool __n);
|
|
basic_ostream& operator<<(short __n);
|
|
basic_ostream& operator<<(unsigned short __n);
|
|
basic_ostream& operator<<(int __n);
|
|
basic_ostream& operator<<(unsigned int __n);
|
|
basic_ostream& operator<<(long __n);
|
|
basic_ostream& operator<<(unsigned long __n);
|
|
basic_ostream& operator<<(long long __n);
|
|
basic_ostream& operator<<(unsigned long long __n);
|
|
basic_ostream& operator<<(float __f);
|
|
basic_ostream& operator<<(double __f);
|
|
basic_ostream& operator<<(long double __f);
|
|
basic_ostream& operator<<(const void* __p);
|
|
|
|
#if _LIBCPP_STD_VER >= 23
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(const volatile void* __p) {
|
|
return operator<<(const_cast<const void*>(__p));
|
|
}
|
|
#endif
|
|
|
|
basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
|
|
|
|
#if _LIBCPP_STD_VER >= 17
|
|
// LWG 2221 - nullptr. This is not backported to older standards modes.
|
|
// See https://reviews.llvm.org/D127033 for more info on the rationale.
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(nullptr_t) { return *this << "nullptr"; }
|
|
#endif
|
|
|
|
// 27.7.2.7 Unformatted output:
|
|
basic_ostream& put(char_type __c);
|
|
basic_ostream& write(const char_type* __s, streamsize __n);
|
|
basic_ostream& flush();
|
|
|
|
// 27.7.2.5 seeks:
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type tellp();
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(pos_type __pos);
|
|
inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
|
|
|
|
protected:
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream() {} // extension, intentially does not initialize
|
|
};
|
|
|
|
template <class _CharT, class _Traits>
|
|
class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry {
|
|
bool __ok_;
|
|
basic_ostream<_CharT, _Traits>& __os_;
|
|
|
|
public:
|
|
explicit sentry(basic_ostream<_CharT, _Traits>& __os);
|
|
~sentry();
|
|
sentry(const sentry&) = delete;
|
|
sentry& operator=(const sentry&) = delete;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ok_; }
|
|
};
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os) : __ok_(false), __os_(__os) {
|
|
if (__os.good()) {
|
|
if (__os.tie())
|
|
__os.tie()->flush();
|
|
__ok_ = true;
|
|
}
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>::sentry::~sentry() {
|
|
if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) && !uncaught_exception()) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
if (__os_.rdbuf()->pubsync() == -1)
|
|
__os_.setstate(ios_base::badbit);
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
}
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) {
|
|
this->move(__rhs);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) {
|
|
swap(__rhs);
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>::~basic_ostream() {}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
if (__sb) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
typedef istreambuf_iterator<_CharT, _Traits> _Ip;
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
|
_Ip __i(__sb);
|
|
_Ip __eof;
|
|
_Op __o(*this);
|
|
size_t __c = 0;
|
|
for (; __i != __eof; ++__i, ++__o, ++__c) {
|
|
*__o = *__i;
|
|
if (__o.failed())
|
|
break;
|
|
}
|
|
if (__c == 0)
|
|
this->setstate(ios_base::failbit);
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_failbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} else
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(bool __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(short __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this,
|
|
*this,
|
|
this->fill(),
|
|
__flags == ios_base::oct || __flags == ios_base::hex
|
|
? static_cast<long>(static_cast<unsigned short>(__n))
|
|
: static_cast<long>(__n))
|
|
.failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(int __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this,
|
|
*this,
|
|
this->fill(),
|
|
__flags == ios_base::oct || __flags == ios_base::hex
|
|
? static_cast<long>(static_cast<unsigned int>(__n))
|
|
: static_cast<long>(__n))
|
|
.failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long long __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(float __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(double __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long double __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(const void* __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = std::use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
__put_character_sequence(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str, size_t __len) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s) {
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
if (std::__pad_and_output(
|
|
_Ip(__os),
|
|
__str,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
|
|
__str + __len,
|
|
__os,
|
|
__os.fill())
|
|
.failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) {
|
|
return std::__put_character_sequence(__os, &__c, 1);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s) {
|
|
_CharT __c = __os.widen(__cn);
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
if (std::__pad_and_output(
|
|
_Ip(__os),
|
|
&__c,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ? &__c + 1 : &__c,
|
|
&__c + 1,
|
|
__os,
|
|
__os.fill())
|
|
.failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template <class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, char __c) {
|
|
return std::__put_character_sequence(__os, &__c, 1);
|
|
}
|
|
|
|
template <class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
|
|
return std::__put_character_sequence(__os, (char*)&__c, 1);
|
|
}
|
|
|
|
template <class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
|
|
return std::__put_character_sequence(__os, (char*)&__c, 1);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) {
|
|
return std::__put_character_sequence(__os, __str, _Traits::length(__str));
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s) {
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
size_t __len = char_traits<char>::length(__strn);
|
|
const int __bs = 100;
|
|
_CharT __wbb[__bs];
|
|
_CharT* __wb = __wbb;
|
|
unique_ptr<_CharT, void (*)(void*)> __h(0, free);
|
|
if (__len > __bs) {
|
|
__wb = (_CharT*)malloc(__len * sizeof(_CharT));
|
|
if (__wb == 0)
|
|
__throw_bad_alloc();
|
|
__h.reset(__wb);
|
|
}
|
|
for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
|
|
*__p = __os.widen(*__strn);
|
|
if (std::__pad_and_output(
|
|
_Ip(__os),
|
|
__wb,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ? __wb + __len : __wb,
|
|
__wb + __len,
|
|
__os,
|
|
__os.fill())
|
|
.failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template <class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, const char* __str) {
|
|
return std::__put_character_sequence(__os, __str, _Traits::length(__str));
|
|
}
|
|
|
|
template <class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) {
|
|
const char* __s = (const char*)__str;
|
|
return std::__put_character_sequence(__os, __s, _Traits::length(__s));
|
|
}
|
|
|
|
template <class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) {
|
|
const char* __s = (const char*)__str;
|
|
return std::__put_character_sequence(__os, __s, _Traits::length(__s));
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::put(char_type __c) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
|
_Op __o(*this);
|
|
*__o = __c;
|
|
if (__o.failed())
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
sentry __sen(*this);
|
|
if (__sen && __n) {
|
|
if (this->rdbuf()->sputn(__s, __n) != __n)
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::flush() {
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
if (this->rdbuf()) {
|
|
sentry __s(*this);
|
|
if (__s) {
|
|
if (this->rdbuf()->pubsync() == -1)
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>::tellp() {
|
|
if (this->fail())
|
|
return pos_type(-1);
|
|
return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) {
|
|
sentry __s(*this);
|
|
if (!this->fail()) {
|
|
if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
|
|
this->setstate(ios_base::failbit);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) {
|
|
sentry __s(*this);
|
|
if (!this->fail()) {
|
|
if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
|
|
this->setstate(ios_base::failbit);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) {
|
|
__os.put(__os.widen('\n'));
|
|
__os.flush();
|
|
return __os;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) {
|
|
__os.put(_CharT());
|
|
return __os;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) {
|
|
__os.flush();
|
|
return __os;
|
|
}
|
|
|
|
template <class _Stream, class _Tp, class = void>
|
|
struct __is_ostreamable : false_type {};
|
|
|
|
template <class _Stream, class _Tp>
|
|
struct __is_ostreamable<_Stream, _Tp, decltype(std::declval<_Stream>() << std::declval<_Tp>(), void())> : true_type {};
|
|
|
|
template <class _Stream,
|
|
class _Tp,
|
|
__enable_if_t<_And<is_base_of<ios_base, _Stream>, __is_ostreamable<_Stream&, const _Tp&> >::value, int> = 0>
|
|
_LIBCPP_HIDE_FROM_ABI _Stream&& operator<<(_Stream&& __os, const _Tp& __x) {
|
|
__os << __x;
|
|
return std::move(__os);
|
|
}
|
|
|
|
template <class _CharT, class _Traits, class _Allocator>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Allocator>& __str) {
|
|
return std::__put_character_sequence(__os, __str.data(), __str.size());
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __sv) {
|
|
return std::__put_character_sequence(__os, __sv.data(), __sv.size());
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec) {
|
|
return __os << __ec.category().name() << ':' << __ec.value();
|
|
}
|
|
|
|
template <class _CharT, class _Traits, class _Yp>
|
|
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p) {
|
|
return __os << __p.get();
|
|
}
|
|
|
|
template <
|
|
class _CharT,
|
|
class _Traits,
|
|
class _Yp,
|
|
class _Dp,
|
|
__enable_if_t<is_same<void,
|
|
__void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>()
|
|
<< std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
|
|
int> = 0>
|
|
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) {
|
|
return __os << __p.get();
|
|
}
|
|
|
|
template <class _CharT, class _Traits, size_t _Size>
|
|
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) {
|
|
return __os << __x.template to_string<_CharT, _Traits>(std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
|
|
std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
|
|
}
|
|
|
|
#if _LIBCPP_STD_VER >= 20
|
|
|
|
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
|
|
|
|
# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
|
|
|
|
# ifndef _LIBCPP_HAS_NO_CHAR8_T
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
|
|
# endif
|
|
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
|
|
|
|
template <class _Traits>
|
|
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
|
|
|
|
#endif // _LIBCPP_STD_VER >= 20
|
|
|
|
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
|
|
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
|
|
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
|
|
#endif
|
|
|
|
#if _LIBCPP_STD_VER >= 23
|
|
|
|
template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
|
|
_LIBCPP_HIDE_FROM_ABI inline void
|
|
__vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
|
|
// [ostream.formatted.print]/3
|
|
// Effects: Behaves as a formatted output function
|
|
// ([ostream.formatted.reqmts]) of os, except that:
|
|
// - failure to generate output is reported as specified below, and
|
|
// - any exception thrown by the call to vformat is propagated without regard
|
|
// to the value of os.exceptions() and without turning on ios_base::badbit
|
|
// in the error state of os.
|
|
// After constructing a sentry object, the function initializes an automatic
|
|
// variable via
|
|
// string out = vformat(os.getloc(), fmt, args);
|
|
|
|
ostream::sentry __s(__os);
|
|
if (__s) {
|
|
string __o = std::vformat(__os.getloc(), __fmt, __args);
|
|
if (__write_nl)
|
|
__o += '\n';
|
|
|
|
const char* __str = __o.data();
|
|
size_t __len = __o.size();
|
|
|
|
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
typedef ostreambuf_iterator<char> _Ip;
|
|
if (std::__pad_and_output(
|
|
_Ip(__os),
|
|
__str,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
|
|
__str + __len,
|
|
__os,
|
|
__os.fill())
|
|
.failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
|
|
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
}
|
|
}
|
|
|
|
template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
|
|
_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args) {
|
|
std::__vprint_nonunicode(__os, __fmt, __args, false);
|
|
}
|
|
|
|
// Returns the FILE* associated with the __os.
|
|
// Returns a nullptr when no FILE* is associated with __os.
|
|
// This function is in the dylib since the type of the buffer associated
|
|
// with std::cout, std::cerr, and std::clog is only known in the dylib.
|
|
//
|
|
// This function implements part of the implementation-defined behavior
|
|
// of [ostream.formatted.print]/3
|
|
// If the function is vprint_unicode and os is a stream that refers to
|
|
// a terminal capable of displaying Unicode which is determined in an
|
|
// implementation-defined manner, writes out to the terminal using the
|
|
// native Unicode API;
|
|
// Whether the returned FILE* is "a terminal capable of displaying Unicode"
|
|
// is determined in the same way as the print(FILE*, ...) overloads.
|
|
_LIBCPP_EXPORTED_FROM_ABI FILE* __get_ostream_file(ostream& __os);
|
|
|
|
# ifndef _LIBCPP_HAS_NO_UNICODE
|
|
template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
|
|
_LIBCPP_HIDE_FROM_ABI void
|
|
__vprint_unicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
|
|
#if _LIBCPP_AVAILABILITY_HAS_PRINT == 0
|
|
return std::__vprint_nonunicode(__os, __fmt, __args, __write_nl);
|
|
#else
|
|
FILE* __file = std::__get_ostream_file(__os);
|
|
if (!__file || !__print::__is_terminal(__file))
|
|
return std::__vprint_nonunicode(__os, __fmt, __args, __write_nl);
|
|
|
|
// [ostream.formatted.print]/3
|
|
// If the function is vprint_unicode and os is a stream that refers to a
|
|
// terminal capable of displaying Unicode which is determined in an
|
|
// implementation-defined manner, writes out to the terminal using the
|
|
// native Unicode API; if out contains invalid code units, the behavior is
|
|
// undefined and implementations are encouraged to diagnose it. If the
|
|
// native Unicode API is used, the function flushes os before writing out.
|
|
//
|
|
// This is the path for the native API, start with flushing.
|
|
__os.flush();
|
|
|
|
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
try {
|
|
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
ostream::sentry __s(__os);
|
|
if (__s) {
|
|
# ifndef _LIBCPP_WIN32API
|
|
__print::__vprint_unicode_posix(__file, __fmt, __args, __write_nl, true);
|
|
# elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
|
|
__print::__vprint_unicode_windows(__file, __fmt, __args, __write_nl, true);
|
|
# else
|
|
# error "Windows builds with wchar_t disabled are not supported."
|
|
# endif
|
|
}
|
|
|
|
# ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
|
} catch (...) {
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
# endif // _LIBCPP_HAS_NO_EXCEPTIONS
|
|
#endif // _LIBCPP_AVAILABILITY_HAS_PRINT
|
|
}
|
|
|
|
template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
|
|
_LIBCPP_HIDE_FROM_ABI inline void
|
|
vprint_unicode(ostream& __os, string_view __fmt, format_args __args) {
|
|
std::__vprint_unicode(__os, __fmt, __args, false);
|
|
}
|
|
# endif // _LIBCPP_HAS_NO_UNICODE
|
|
|
|
template <class... _Args>
|
|
_LIBCPP_HIDE_FROM_ABI void
|
|
print(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
|
|
# ifndef _LIBCPP_HAS_NO_UNICODE
|
|
if constexpr (__print::__use_unicode_execution_charset)
|
|
std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), false);
|
|
else
|
|
std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
|
|
# else // _LIBCPP_HAS_NO_UNICODE
|
|
std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
|
|
# endif // _LIBCPP_HAS_NO_UNICODE
|
|
}
|
|
|
|
template <class... _Args>
|
|
_LIBCPP_HIDE_FROM_ABI void
|
|
println(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
|
|
# ifndef _LIBCPP_HAS_NO_UNICODE
|
|
// Note the wording in the Standard is inefficient. The output of
|
|
// std::format is a std::string which is then copied. This solution
|
|
// just appends a newline at the end of the output.
|
|
if constexpr (__print::__use_unicode_execution_charset)
|
|
std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), true);
|
|
else
|
|
std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
|
|
# else // _LIBCPP_HAS_NO_UNICODE
|
|
std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
|
|
# endif // _LIBCPP_HAS_NO_UNICODE
|
|
}
|
|
|
|
#endif // _LIBCPP_STD_VER >= 23
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
|
|
# include <atomic>
|
|
# include <concepts>
|
|
# include <cstdlib>
|
|
# include <iosfwd>
|
|
# include <iterator>
|
|
# include <stdexcept>
|
|
# include <type_traits>
|
|
#endif
|
|
|
|
#endif // _LIBCPP_OSTREAM
|