LCOM1920-T02G10

// -*- C++ -*-

//===----------------------------------------------------------------------===//

//

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

#define _LIBCPP___STD_STREAM

#include <__config>

#include <ostream>

#include <istream>

#include <__locale>

#include <cstdio>

#include <__undef_min_max>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

#pragma GCC system_header

#endif

_LIBCPP_BEGIN_NAMESPACE_STD

static const int __limit = 8;

// __stdinbuf

template <class _CharT>

class _LIBCPP_HIDDEN __stdinbuf

    : public basic_streambuf<_CharT, char_traits<_CharT> >

{

public:

    typedef _CharT                           char_type;

    typedef char_traits<char_type>           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;

    typedef typename traits_type::state_type state_type;

    __stdinbuf(FILE* __fp, state_type* __st);

protected:

    virtual int_type underflow();

    virtual int_type uflow();

    virtual int_type pbackfail(int_type __c = traits_type::eof());

    virtual void imbue(const locale& __loc);

private:

    FILE* __file_;

    const codecvt<char_type, char, state_type>* __cv_;

    state_type* __st_;

    int __encoding_;

    int_type __last_consumed_;

    bool __last_consumed_is_next_;

    bool __always_noconv_;

    __stdinbuf(const __stdinbuf&);

    __stdinbuf& operator=(const __stdinbuf&);

    int_type __getchar(bool __consume);

};

template <class _CharT>

__stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)

    : __file_(__fp),

      __st_(__st),

      __last_consumed_(traits_type::eof()),

      __last_consumed_is_next_(false)

{

    imbue(this->getloc());

}

template <class _CharT>

void

__stdinbuf<_CharT>::imbue(const locale& __loc)

{

    __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);

    __encoding_ = __cv_->encoding();

    __always_noconv_ = __cv_->always_noconv();

    if (__encoding_ > __limit)

        __throw_runtime_error("unsupported locale for standard input");

}

template <class _CharT>

typename __stdinbuf<_CharT>::int_type

__stdinbuf<_CharT>::underflow()

{

    return __getchar(false);

}

template <class _CharT>

typename __stdinbuf<_CharT>::int_type

__stdinbuf<_CharT>::uflow()

{

    return __getchar(true);

}

template <class _CharT>

typename __stdinbuf<_CharT>::int_type

__stdinbuf<_CharT>::__getchar(bool __consume)

{

    if (__last_consumed_is_next_)

    {

        int_type __result = __last_consumed_;

        if (__consume)

        {

            __last_consumed_ = traits_type::eof();

            __last_consumed_is_next_ = false;

        }

        return __result;

    }

    char __extbuf[__limit];

    int __nread = _VSTD::max(1, __encoding_);

    for (int __i = 0; __i < __nread; ++__i)

    {

        int __c = getc(__file_);

        if (__c == EOF)

            return traits_type::eof();

        __extbuf[__i] = static_cast<char>(__c);

    }

    char_type __1buf;

    if (__always_noconv_)

        __1buf = static_cast<char_type>(__extbuf[0]);

    else

    {

        const char* __enxt;

        char_type* __inxt;

        codecvt_base::result __r;

        do

        {

            state_type __sv_st = *__st_;

            __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt,

                                   &__1buf, &__1buf + 1, __inxt);

            switch (__r)

            {

            case _VSTD::codecvt_base::ok:

                break;

            case codecvt_base::partial:

                *__st_ = __sv_st;

                if (__nread == sizeof(__extbuf))

                    return traits_type::eof();

                {

                    int __c = getc(__file_);

                    if (__c == EOF)

                        return traits_type::eof();

                    __extbuf[__nread] = static_cast<char>(__c);

                }

                ++__nread;

                break;

            case codecvt_base::error:

                return traits_type::eof();

            case _VSTD::codecvt_base::noconv:

                __1buf = static_cast<char_type>(__extbuf[0]);

                break;

            }

        } while (__r == _VSTD::codecvt_base::partial);

    }

    if (!__consume)

    {

        for (int __i = __nread; __i > 0;)

        {

            if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)

                return traits_type::eof();

        }

    }

    else

        __last_consumed_ = traits_type::to_int_type(__1buf);

    return traits_type::to_int_type(__1buf);

}

template <class _CharT>

typename __stdinbuf<_CharT>::int_type

__stdinbuf<_CharT>::pbackfail(int_type __c)

{

    if (traits_type::eq_int_type(__c, traits_type::eof()))

    {

        if (!__last_consumed_is_next_)

        {

            __c = __last_consumed_;

            __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_,

                                                                 traits_type::eof());

        }

        return __c;

    }

    if (__last_consumed_is_next_)

    {

        char __extbuf[__limit];

        char* __enxt;

        const char_type __ci = traits_type::to_char_type(__last_consumed_);

        const char_type* __inxt;

        switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt,

                                  __extbuf, __extbuf + sizeof(__extbuf), __enxt))

        {

        case _VSTD::codecvt_base::ok:

            break;

        case _VSTD::codecvt_base::noconv:

            __extbuf[0] = static_cast<char>(__last_consumed_);

            __enxt = __extbuf + 1;

            break;

        case codecvt_base::partial:

        case codecvt_base::error:

            return traits_type::eof();

        }

        while (__enxt > __extbuf)

            if (ungetc(*--__enxt, __file_) == EOF)

                return traits_type::eof();

    }

    __last_consumed_ = __c;

    __last_consumed_is_next_ = true;

    return __c;

}

// __stdoutbuf

template <class _CharT>

class _LIBCPP_HIDDEN __stdoutbuf

    : public basic_streambuf<_CharT, char_traits<_CharT> >

{

public:

    typedef _CharT                           char_type;

    typedef char_traits<char_type>           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;

    typedef typename traits_type::state_type state_type;

    __stdoutbuf(FILE* __fp, state_type* __st);

protected:

    virtual int_type overflow (int_type __c = traits_type::eof());

    virtual streamsize xsputn(const char_type* __s, streamsize __n);

    virtual int sync();

    virtual void imbue(const locale& __loc);

private:

    FILE* __file_;

    const codecvt<char_type, char, state_type>* __cv_;

    state_type* __st_;

    bool __always_noconv_;

    __stdoutbuf(const __stdoutbuf&);

    __stdoutbuf& operator=(const __stdoutbuf&);

};

template <class _CharT>

__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)

    : __file_(__fp),

      __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),

      __st_(__st),

      __always_noconv_(__cv_->always_noconv())

{

}

template <class _CharT>

typename __stdoutbuf<_CharT>::int_type

__stdoutbuf<_CharT>::overflow(int_type __c)

{

    char __extbuf[__limit];

    char_type __1buf;

    if (!traits_type::eq_int_type(__c, traits_type::eof()))

    {

        __1buf = traits_type::to_char_type(__c);

        if (__always_noconv_)

        {

            if (fwrite(&__1buf, sizeof(char_type), 1, __file_) != 1)

                return traits_type::eof();

        }

        else

        {

            char* __extbe = __extbuf;

            codecvt_base::result __r;

            char_type* pbase = &__1buf;

            char_type* pptr = pbase + 1;

            do

            {

                const char_type* __e;

                __r = __cv_->out(*__st_, pbase, pptr, __e,

                                        __extbuf,

                                        __extbuf + sizeof(__extbuf),

                                        __extbe);

                if (__e == pbase)

                    return traits_type::eof();

                if (__r == codecvt_base::noconv)

                {

                    if (fwrite(pbase, 1, 1, __file_) != 1)

                        return traits_type::eof();

                }

                else if (__r == codecvt_base::ok || __r == codecvt_base::partial)

                {

                    size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);

                    if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)

                        return traits_type::eof();

                    if (__r == codecvt_base::partial)

                    {

                        pbase = (char_type*)__e;

                    }

                }

                else

                    return traits_type::eof();

            } while (__r == codecvt_base::partial);

        }

    }

    return traits_type::not_eof(__c);

}

template <class _CharT>

streamsize

__stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)

{

    if (__always_noconv_)

        return fwrite(__s, sizeof(char_type), __n, __file_);

    streamsize __i = 0;

    for (; __i < __n; ++__i, ++__s)

        if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())

            break;

    return __i;

}

template <class _CharT>

int

__stdoutbuf<_CharT>::sync()

{

    char __extbuf[__limit];

    codecvt_base::result __r;

    do

    {

        char* __extbe;

        __r = __cv_->unshift(*__st_, __extbuf,

                                    __extbuf + sizeof(__extbuf),

                                    __extbe);

        size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);

        if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)

            return -1;

    } while (__r == codecvt_base::partial);

    if (__r == codecvt_base::error)

        return -1;

    if (fflush(__file_))

        return -1;

    return 0;

}

template <class _CharT>

void

__stdoutbuf<_CharT>::imbue(const locale& __loc)

{

    sync();

    __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);

    __always_noconv_ = __cv_->always_noconv();

}

_LIBCPP_END_NAMESPACE_STD

#endif  // _LIBCPP___STD_STREAM