// -*- 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

}  // std

*/

#include <__assert> // all public C++ headers provide the assertion handler

#include <__config>

#include <__memory/shared_ptr.h>

#include <__memory/unique_ptr.h>

#include <bitset>

#include <ios>

#include <locale>

#include <new>

#include <streambuf>

#include <version>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

#  pragma GCC system_header

#endif

_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); }

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::basic_ostream(std::__1::basic_streambuf<char, std::__1::char_traits<char> >*)

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::basic_ostream(std::__1::basic_streambuf<char, std::__1::char_traits<char> >*)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::basic_ostream(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >*)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::basic_ostream(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >*)

    ~basic_ostream() override;

protected:

    inline _LIBCPP_INLINE_VISIBILITY

    basic_ostream(basic_ostream&& __rhs);

    // 27.7.2.3 Assign/swap

    inline _LIBCPP_INLINE_VISIBILITY

    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); }

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::swap(std::__1::basic_ostream<char, std::__1::char_traits<char> >&)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::swap(std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >&)

    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); }

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(std::__1::basic_ostream<char, std::__1::char_traits<char> >& (*)(std::__1::basic_ostream<char, std::__1::char_traits<char> >&))

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >& (*)(std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >&))

    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; }

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(std::__1::basic_ios<char, std::__1::char_traits<char> >& (*)(std::__1::basic_ios<char, std::__1::char_traits<char> >&))

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(std::__1::basic_ios<wchar_t, std::__1::char_traits<wchar_t> >& (*)(std::__1::basic_ios<wchar_t, std::__1::char_traits<wchar_t> >&))

    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1

    basic_ostream& operator<<(ios_base& (*__pf)(ios_base&))

    { __pf(*this); return *this; }

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(std::__1::ios_base& (*)(std::__1::ios_base&))

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(std::__1::ios_base& (*)(std::__1::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);

#if _LIBCPP_STD_VER > 20

    _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 > 14

// LWG 2221 - nullptr. This is not backported to older standards modes.

// See https://reviews.llvm.org/D127033 for more info on the rationale.

    _LIBCPP_INLINE_VISIBILITY

    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_INLINE_VISIBILITY

    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_INLINE_VISIBILITY

    explicit operator bool() const {return __ok_;}

std::__1::basic_ostream<char, std::__1::char_traits<char> >::sentry::operator bool[abi:v160006]() const

Line

Count

Source

295

9.48k

    explicit operator bool() const {return __ok_;}

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::sentry::operator bool[abi:v160006]() const

};

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;

    }

}

std::__1::basic_ostream<char, std::__1::char_traits<char> >::sentry::sentry(std::__1::basic_ostream<char, std::__1::char_traits<char> >&)

Line

Count

Source

302

9.48k

{

303

9.48k

    if (__os.good())

304

9.48k

    {

305

9.48k

        if (__os.tie())

306

0

            __os.tie()->flush();

307

9.48k

        __ok_ = true;

308

9.48k

    }

309

9.48k

}

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::sentry::sentry(std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >&)

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

    }

}

std::__1::basic_ostream<char, std::__1::char_traits<char> >::sentry::~sentry()

Line

Count

Source

313

9.48k

{

314

9.48k

    if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)

315

9.48k

                      && !uncaught_exception())

316

0

    {

317

0

#ifndef _LIBCPP_NO_EXCEPTIONS

318

0

        try

319

0

        {

320

0

#endif // _LIBCPP_NO_EXCEPTIONS

321

0

            if (__os_.rdbuf()->pubsync() == -1)

322

0

                __os_.setstate(ios_base::badbit);

323

0

#ifndef _LIBCPP_NO_EXCEPTIONS

324

0

        }

325

0

        catch (...)

326

0

        {

327

0

        }

328

0

#endif // _LIBCPP_NO_EXCEPTIONS

329

0

    }

330

9.48k

}

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::sentry::~sentry()

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()

{

}

std::__1::basic_ostream<char, std::__1::char_traits<char> >::~basic_ostream()

Line

Count

Source

348

3.60k

{

349

3.60k

}

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::~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_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> _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_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;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(std::__1::basic_streambuf<char, std::__1::char_traits<char> >*)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >*)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(bool)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(bool)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(short)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(short)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(unsigned short)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(unsigned short)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(int)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(int)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(unsigned int)

Line

Count

Source

518

3.74k

{

519

3.74k

#ifndef _LIBCPP_NO_EXCEPTIONS

520

3.74k

    try

521

3.74k

    {

522

3.74k

#endif // _LIBCPP_NO_EXCEPTIONS

523

3.74k

        sentry __s(*this);

524

3.74k

        if (__s)

525

3.74k

        {

526

3.74k

            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;

527

3.74k

            const _Fp& __f = std::use_facet<_Fp>(this->getloc());

528

3.74k

            if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())

529

0

                this->setstate(ios_base::badbit | ios_base::failbit);

530

3.74k

        }

531

3.74k

#ifndef _LIBCPP_NO_EXCEPTIONS

532

3.74k

    }

533

3.74k

    catch (...)

534

3.74k

    {

535

0

        this->__set_badbit_and_consider_rethrow();

536

0

    }

537

3.74k

#endif // _LIBCPP_NO_EXCEPTIONS

538

3.74k

    return *this;

539

3.74k

}

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(unsigned int)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(long)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(long)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(unsigned long)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(unsigned long)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(long long)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(long long)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(unsigned long long)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(unsigned long long)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(float)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(float)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(double)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(double)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(long double)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(long double)

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> > _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        this->__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return *this;

}

Unexecuted instantiation: std::__1::basic_ostream<char, std::__1::char_traits<char> >::operator<<(void const*)

Unexecuted instantiation: std::__1::basic_ostream<wchar_t, std::__1::char_traits<wchar_t> >::operator<<(void const*)

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_NO_EXCEPTIONS

    try

    {

#endif // _LIBCPP_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_NO_EXCEPTIONS

    }

    catch (...)

    {

        __os.__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_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 _VSTD::__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_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> _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_NO_EXCEPTIONS

    }

    catch (...)

    {

        __os.__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_NO_EXCEPTIONS

    return __os;

}

template<class _Traits>

_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&

operator<<(basic_ostream<char, _Traits>& __os, char __c)

{

    return _VSTD::__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 _VSTD::__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 _VSTD::__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 _VSTD::__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_NO_EXCEPTIONS

    try

    {

#endif // _LIBCPP_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_NO_EXCEPTIONS

    }

    catch (...)

    {

        __os.__set_badbit_and_consider_rethrow();

    }

#endif // _LIBCPP_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 _VSTD::__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 _VSTD::__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 _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));

}