diff options
Diffstat (limited to 'tests/libcxx/include/ostream')
| -rw-r--r-- | tests/libcxx/include/ostream | 1291 |
1 files changed, 1291 insertions, 0 deletions
diff --git a/tests/libcxx/include/ostream b/tests/libcxx/include/ostream new file mode 100644 index 00000000..2627da2e --- /dev/null +++ b/tests/libcxx/include/ostream @@ -0,0 +1,1291 @@ +// -*- C++ -*- +//===-------------------------- ostream -----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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=(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<<(basic_streambuf<char_type,traits>* sb); + + // 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); +}; + +// 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 charT, class traits, class T> + basic_ostream<charT, traits>& + operator<<(basic_ostream<charT, traits>&& os, const T& x); + +} // std + +*/ + +#include <__config> +#include <ios> +#include <streambuf> +#include <locale> +#include <iterator> +#include <bitset> + +#pragma GCC system_header + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _CharT, class _Traits> +class _LIBCPP_VISIBLE 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_type>* __sb); + virtual ~basic_ostream(); +protected: +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + basic_ostream(basic_ostream&& __rhs); +#endif + + // 27.7.2.3 Assign/swap +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + basic_ostream& operator=(basic_ostream&& __rhs); +#endif + void swap(basic_ostream& __rhs); +public: + + // 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<char_type, traits_type>& + (*__pf)(basic_ios<char_type,traits_type>&)); + 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<<(basic_streambuf<char_type, traits_type>* __sb); + + // 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 __pos); + basic_ostream& seekp(off_type __off, ios_base::seekdir __dir); + +protected: + _LIBCPP_ALWAYS_INLINE + basic_ostream() {} // extension, intentially does not initialize +}; + +template <class _CharT, class _Traits> +class _LIBCPP_VISIBLE basic_ostream<_CharT, _Traits>::sentry +{ + bool __ok_; + basic_ostream<_CharT, _Traits>& __os_; + + sentry(const sentry&); // = delete; + sentry& operator=(const sentry&); // = delete; + +public: + explicit sentry(basic_ostream<_CharT, _Traits>& __os); + ~sentry(); + + _LIBCPP_ALWAYS_INLINE + // 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_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + if (__os_.rdbuf()->pubsync() == -1) + __os_.setstate(ios_base::badbit); +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + } +#endif // _LIBCPP_NO_EXCEPTIONS + } +} + +template <class _CharT, class _Traits> +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<char_type, traits_type>* __sb) +{ + this->init(__sb); +} + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _CharT, class _Traits> +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) +{ + this->move(__rhs); +} + +template <class _CharT, class _Traits> +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) +{ + swap(__rhs); + return *this; +} + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>::~basic_ostream() +{ +} + +template <class _CharT, class _Traits> +inline _LIBCPP_INLINE_VISIBILITY +void +basic_ostream<_CharT, _Traits>::swap(basic_ostream& __rhs) +{ + basic_ios<char_type, traits_type>::swap(__rhs); +} + +template <class _CharT, class _Traits> +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(basic_ostream& (*__pf)(basic_ostream&)) +{ + return __pf(*this); +} + +template <class _CharT, class _Traits> +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(basic_ios<char_type, traits_type>& + (*__pf)(basic_ios<char_type,traits_type>&)) +{ + __pf(*this); + return *this; +} + +template <class _CharT, class _Traits> +inline _LIBCPP_INLINE_VISIBILITY +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(ios_base& (*__pf)(ios_base&)) +{ + __pf(*this); + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + if (__sb) + { +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typedef istreambuf_iterator<_CharT, _Traits> _I; + typedef ostreambuf_iterator<_CharT, _Traits> _O; + _I __i(__sb); + _I __eof; + _O __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_NO_EXCEPTIONS + } + catch (...) + { + this->__set_failbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + } + else + this->setstate(ios_base::badbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(bool __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(short __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_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> > _F; + const _F& __f = use_facet<_F>(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_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(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_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(int __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_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> > _F; + const _F& __f = use_facet<_F>(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_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(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_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(long __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(long long __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(float __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(double __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(long double __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::operator<<(const void* __n) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + sentry __s(*this); + if (__s) + { + typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _F; + const _F& __f = use_facet<_F>(this->getloc()); + if (__f.put(*this, *this, this->fill(), __n).failed()) + this->setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + this->__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return *this; +} + +template<class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<_CharT, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<_CharT, _Traits> _I; + if (__pad_and_output(_I(__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_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<_CharT, _Traits>::sentry __s(__os); + if (__s) + { + _CharT __c = __os.widen(__cn); + typedef ostreambuf_iterator<_CharT, _Traits> _I; + if (__pad_and_output(_I(__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_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _Traits> +basic_ostream<char, _Traits>& +operator<<(basic_ostream<char, _Traits>& __os, char __c) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<char, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<char, _Traits> _I; + if (__pad_and_output(_I(__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_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _Traits> +basic_ostream<char, _Traits>& +operator<<(basic_ostream<char, _Traits>& __os, signed char __c) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<char, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<char, _Traits> _I; + if (__pad_and_output(_I(__os), + (char*)&__c, + (__os.flags() & ios_base::adjustfield) == ios_base::left ? + (char*)&__c + 1 : + (char*)&__c, + (char*)&__c + 1, + __os, + __os.fill()).failed()) + __os.setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _Traits> +basic_ostream<char, _Traits>& +operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<char, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<char, _Traits> _I; + if (__pad_and_output(_I(__os), + (char*)&__c, + (__os.flags() & ios_base::adjustfield) == ios_base::left ? + (char*)&__c + 1 : + (char*)&__c, + (char*)&__c + 1, + __os, + __os.fill()).failed()) + __os.setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<_CharT, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<_CharT, _Traits> _I; + size_t __len = _Traits::length(__str); + if (__pad_and_output(_I(__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_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<_CharT, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<_CharT, _Traits> _I; + 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 (__pad_and_output(_I(__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_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _Traits> +basic_ostream<char, _Traits>& +operator<<(basic_ostream<char, _Traits>& __os, const char* __str) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<char, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<char, _Traits> _I; + size_t __len = _Traits::length(__str); + if (__pad_and_output(_I(__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_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _Traits> +basic_ostream<char, _Traits>& +operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<char, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<char, _Traits> _I; + size_t __len = _Traits::length((const char*)__str); + if (__pad_and_output(_I(__os), + (const char*)__str, + (__os.flags() & ios_base::adjustfield) == ios_base::left ? + (const char*)__str + __len : + (const char*)__str, + (const char*)__str + __len, + __os, + __os.fill()).failed()) + __os.setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template<class _Traits> +basic_ostream<char, _Traits>& +operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif // _LIBCPP_NO_EXCEPTIONS + typename basic_ostream<char, _Traits>::sentry __s(__os); + if (__s) + { + typedef ostreambuf_iterator<char, _Traits> _I; + size_t __len = _Traits::length((const char*)__str); + if (__pad_and_output(_I(__os), + (const char*)__str, + (__os.flags() & ios_base::adjustfield) == ios_base::left ? + (const char*)__str + __len : + (const char*)__str, + (const char*)__str + __len, + __os, + __os.fill()).failed()) + __os.setstate(ios_base::badbit | ios_base::failbit); + } +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + __os.__set_badbit_and_consider_rethrow(); + } +#endif // _LIBCPP_NO_EXCEPTIONS + return __os; +} + +template <class _CharT, class _Traits> +basic_ostream<_CharT, _Traits>& +basic_ostream<_CharT, _Traits>::put(char_type __c) +{ +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { |