11.2.0/bits/locale_conv.h

// wstring_convert implementation -*- C++ -*-

// Copyright (C) 2015-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file bits/locale_conv.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{locale}
 */

#ifndef _LOCALE_CONV_H
#define _LOCALE_CONV_H 1

#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else

#include <streambuf>
#include <bits/stringfwd.h>
#include <bits/allocator.h>
#include <bits/codecvt.h>
#include <bits/unique_ptr.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  /**
   * @addtogroup locales
   * @{
   */

  template<typename _OutStr, typename _InChar, typename _Codecvt,
           typename _State, typename _Fn>
    bool
    __do_str_codecvt(const _InChar* __first, const _InChar* __last,
                     _OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
                     size_t& __count, _Fn __fn)
    {
      if (__first == __last)
        {
          __outstr.clear();
          __count = 0;
          return true;
        }

      size_t __outchars = 0;
      auto __next = __first;
      const auto __maxlen = __cvt.max_length() + 1;

      codecvt_base::result __result;
      do
        {
          __outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
          auto __outnext = &__outstr.front() + __outchars;
          auto const __outlast = &__outstr.back() + 1;
          __result = (__cvt.*__fn)(__state, __next, __last, __next,
                                        __outnext, __outlast, __outnext);
          __outchars = __outnext - &__outstr.front();
        }
      while (__result == codecvt_base::partial && __next != __last
             && ptrdiff_t(__outstr.size() - __outchars) < __maxlen);

      if (__result == codecvt_base::error)
        {
          __count = __next - __first;
          return false;
        }

      // The codecvt facet will only return noconv when the types are
      // the same, so avoid instantiating basic_string::assign otherwise
      if _GLIBCXX17_CONSTEXPR (is_same<typename _Codecvt::intern_type,
                                       typename _Codecvt::extern_type>())
        if (__result == codecvt_base::noconv)
          {
            __outstr.assign(__first, __last);
            __count = __last - __first;
            return true;
          }

      __outstr.resize(__outchars);
      __count = __next - __first;
      return true;
    }

  // Convert narrow character string to wide.
  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
                     basic_string<_CharT, _Traits, _Alloc>& __outstr,
                     const codecvt<_CharT, char, _State>& __cvt,
                     _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
        = codecvt_base::result
          (_Codecvt::*)(_State&, const char*, const char*, const char*&,
                        _CharT*, _CharT*, _CharT*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::in;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
                              __count, __fn);
    }

  // As above, but with no __count parameter
  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
                     basic_string<_CharT, _Traits, _Alloc>& __outstr,
                     const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
    }

  // As above, but returns false for partial conversion
  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in_all(const char* __first, const char* __last,
                         basic_string<_CharT, _Traits, _Alloc>& __outstr,
                         const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
        && (__n == size_t(__last - __first));
    }

  // Convert wide character string to narrow.
  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
                      basic_string<char, _Traits, _Alloc>& __outstr,
                      const codecvt<_CharT, char, _State>& __cvt,
                      _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
        = codecvt_base::result
          (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
                        char*, char*, char*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::out;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
                              __count, __fn);
    }

  // As above, but with no __count parameter
  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
                      basic_string<char, _Traits, _Alloc>& __outstr,
                      const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
    }

  // As above, but returns false for partial conversions
  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
                          basic_string<char, _Traits, _Alloc>& __outstr,
                          const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
        && (__n == size_t(__last - __first));
    }

#ifdef _GLIBCXX_USE_CHAR8_T

  // Convert wide character string to narrow.
  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
                      basic_string<char8_t, _Traits, _Alloc>& __outstr,
                      const codecvt<_CharT, char8_t, _State>& __cvt,
                      _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char8_t, _State>;
      using _ConvFn
        = codecvt_base::result
          (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
                        char8_t*, char8_t*, char8_t*&) const;
      _ConvFn __fn = &codecvt<_CharT, char8_t, _State>::out;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
                              __count, __fn);
    }

  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
                      basic_string<char8_t, _Traits, _Alloc>& __outstr,
                      const codecvt<_CharT, char8_t, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
    }

#endif  // _GLIBCXX_USE_CHAR8_T

#ifdef _GLIBCXX_USE_WCHAR_T

_GLIBCXX_BEGIN_NAMESPACE_CXX11

  /// String conversions
  template<typename _Codecvt, typename _Elem = wchar_t,
           typename _Wide_alloc = allocator<_Elem>,
           typename _Byte_alloc = allocator<char>>
    class wstring_convert
    {
    public:
      typedef basic_string<char, char_traits<char>, _Byte_alloc>   byte_string;
      typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
      typedef typename _Codecvt::state_type                        state_type;
      typedef typename wide_string::traits_type::int_type          int_type;

      /// Default constructor.
      wstring_convert() : _M_cvt(new _Codecvt()) { }

      /** Constructor.
       *
       * @param  __pcvt The facet to use for conversions.
       *
       * Takes ownership of @p __pcvt and will delete it in the destructor.
       */
      explicit
      wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt)
      {
        if (!_M_cvt)
          __throw_logic_error("wstring_convert");
      }

      /** Construct with an initial converstion state.
       *
       * @param  __pcvt The facet to use for conversions.
       * @param  __state Initial conversion state.
       *
       * Takes ownership of @p __pcvt and will delete it in the destructor.
       * The object's conversion state will persist between conversions.
       */
      wstring_convert(_Codecvt* __pcvt, state_type __state)
      : _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
      {
        if (!_M_cvt)
          __throw_logic_error("wstring_convert");
      }

      /** Construct with error strings.
       *
       * @param  __byte_err A string to return on failed conversions.
       * @param  __wide_err A wide string to return on failed conversions.
       */
      explicit
      wstring_convert(const byte_string& __byte_err,
                      const wide_string& __wide_err = wide_string())
      : _M_cvt(new _Codecvt),
        _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
        _M_with_strings(true)
      {
        if (!_M_cvt)
          __throw_logic_error("wstring_convert");
      }

      ~wstring_convert() = default;

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 2176. Special members for wstring_convert and wbuffer_convert
      wstring_convert(const wstring_convert&) = delete;
      wstring_convert& operator=(const wstring_convert&) = delete;

      /// @{ Convert from bytes.
      wide_string
      from_bytes(char __byte)
      {
        char __bytes[2] = { __byte };
        return from_bytes(__bytes, __bytes+1);
      }

      wide_string
      from_bytes(const char* __ptr)
      { return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }

      wide_string
      from_bytes(const byte_string& __str)
      {
        auto __ptr = __str.data();
        return from_bytes(__ptr, __ptr + __str.size());
      }

      wide_string
      from_bytes(const char* __first, const char* __last)
      {
        if (!_M_with_cvtstate)
          _M_state = state_type();
        wide_string __out{ _M_wide_err_string.get_allocator() };
        if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
                             _M_count))
          return __out;
        if (_M_with_strings)
          return _M_wide_err_string;
        __throw_range_error("wstring_convert::from_bytes");
      }
      /// @}

      /// @{ Convert to bytes.
      byte_string
      to_bytes(_Elem __wchar)
      {
        _Elem __wchars[2] = { __wchar };
        return to_bytes(__wchars, __wchars+1);
      }

      byte_string
      to_bytes(const _Elem* __ptr)
      {
        return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
      }

      byte_string
      to_bytes(const wide_string& __wstr)
      {
        auto __ptr = __wstr.data();
        return to_bytes(__ptr, __ptr + __wstr.size());
      }

      byte_string
      to_bytes(const _Elem* __first, const _Elem* __last)
      {
        if (!_M_with_cvtstate)
          _M_state = state_type();
        byte_string __out{ _M_byte_err_string.get_allocator() };
        if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
                              _M_count))
          return __out;
        if (_M_with_strings)
          return _M_byte_err_string;
        __throw_range_error("wstring_convert::to_bytes");
      }
      /// @}

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 2174. wstring_convert::converted() should be noexcept
      /// The number of elements successfully converted in the last conversion.
      size_t converted() const noexcept { return _M_count; }

      /// The final conversion state of the last conversion.
      state_type state() const { return _M_state; }

    private:
      unique_ptr<_Codecvt>      _M_cvt;
      byte_string               _M_byte_err_string;
      wide_string               _M_wide_err_string;
      state_type                _M_state = state_type();
      size_t                    _M_count = 0;
      bool                      _M_with_cvtstate = false;
      bool                      _M_with_strings = false;
    };

_GLIBCXX_END_NAMESPACE_CXX11

  /// Buffer conversions
  template<typename _Codecvt, typename _Elem = wchar_t,
           typename _Tr = char_traits<_Elem>>
    class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
    {
      typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;

    public:
      typedef typename _Codecvt::state_type state_type;

      /// Default constructor.
      wbuffer_convert() : wbuffer_convert(nullptr) { }

      /** Constructor.
       *
       * @param  __bytebuf The underlying byte stream buffer.
       * @param  __pcvt    The facet to use for conversions.
       * @param  __state   Initial conversion state.
       *
       * Takes ownership of @p __pcvt and will delete it in the destructor.
       */
      explicit
      wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt,
                      state_type __state = state_type())
      : _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
      {
        if (!_M_cvt)
          __throw_logic_error("wbuffer_convert");

        _M_always_noconv = _M_cvt->always_noconv();

        if (_M_buf)
          {
            this->setp(_M_put_area, _M_put_area + _S_buffer_length);
            this->setg(_M_get_area + _S_putback_length,
                       _M_get_area + _S_putback_length,
                       _M_get_area + _S_putback_length);
          }
      }

      ~wbuffer_convert() = default;

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 2176. Special members for wstring_convert and wbuffer_convert
      wbuffer_convert(const wbuffer_convert&) = delete;
      wbuffer_convert& operator=(const wbuffer_convert&) = delete;

      streambuf* rdbuf() const noexcept { return _M_buf; }

      streambuf*
      rdbuf(streambuf *__bytebuf) noexcept
      {
        auto __prev = _M_buf;
        _M_buf = __bytebuf;
        return __prev;
      }

      /// The conversion state following the last conversion.
      state_type state() const noexcept { return _M_state; }

    protected:
      int
      sync()
      { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }

      typename _Wide_streambuf::int_type
      overflow(typename _Wide_streambuf::int_type __out)
      {
        if (!_M_buf || !_M_conv_put())
          return _Tr::eof();
        else if (!_Tr::eq_int_type(__out, _Tr::eof()))
          return this->sputc(__out);
        return _Tr::not_eof(__out);
      }

      typename _Wide_streambuf::int_type
      underflow()
      {
        if (!_M_buf)
          return _Tr::eof();

        if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
          return _Tr::to_int_type(*this->gptr());
        else
          return _Tr::eof();
      }

      streamsize
      xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
      {
        if (!_M_buf || __n == 0)
          return 0;
        streamsize __done = 0;
        do
        {
          auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
                                           __n - __done);
          _Tr::copy(this->pptr(), __s + __done, __nn);
          this->pbump(__nn);
          __done += __nn;
        } while (__done < __n && _M_conv_put());
        return __done;
      }

    private:
      // fill the get area from converted contents of the byte stream buffer
      bool
      _M_conv_get()
      {
        const streamsize __pb1 = this->gptr() - this->eback();
        const streamsize __pb2 = _S_putback_length;
        const streamsize __npb = std::min(__pb1, __pb2);

        _Tr::move(_M_get_area + _S_putback_length - __npb,
                  this->gptr() - __npb, __npb);

        streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
        __nbytes = std::min(__nbytes, _M_buf->in_avail());
        if (__nbytes < 1)
          __nbytes = 1;
        __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
        if (__nbytes < 1)
          return false;
        __nbytes += _M_unconv;

        // convert _M_get_buf into _M_get_area

        _Elem* __outbuf = _M_get_area + _S_putback_length;
        _Elem* __outnext = __outbuf;
        const char* __bnext = _M_get_buf;

        codecvt_base::result __result;
        if (_M_always_noconv)
          __result = codecvt_base::noconv;
        else
          {
            _Elem* __outend = _M_get_area + _S_buffer_length;

            __result = _M_cvt->in(_M_state,
                                  __bnext, __bnext + __nbytes, __bnext,
                                  __outbuf, __outend, __outnext);
          }

        if (__result == codecvt_base::noconv)
          {
            // cast is safe because noconv means _Elem is same type as char
            auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
            _Tr::copy(__outbuf, __get_buf, __nbytes);
            _M_unconv = 0;
            return true;
          }

        if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
          char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);

        this->setg(__outbuf, __outbuf, __outnext);

        return __result != codecvt_base::error;
      }

      // unused
      bool
      _M_put(...)
      { return false; }

      bool
      _M_put(const char* __p, streamsize __n)
      {
        if (_M_buf->sputn(__p, __n) < __n)
          return false;
        return true;
      }

      // convert the put area and write to the byte stream buffer
      bool
      _M_conv_put()
      {
        _Elem* const __first = this->pbase();
        const _Elem* const __last = this->pptr();
        const streamsize __pending = __last - __first;

        if (_M_always_noconv)
          return _M_put(__first, __pending);

        char __outbuf[2 * _S_buffer_length];

        const _Elem* __next = __first;
        const _Elem* __start;
        do
          {
            __start = __next;
            char* __outnext = __outbuf;
            char* const __outlast = __outbuf + sizeof(__outbuf);
            auto __result = _M_cvt->out(_M_state, __next, __last, __next,
                                        __outnext, __outlast, __outnext);
            if (__result == codecvt_base::error)
              return false;
            else if (__result == codecvt_base::noconv)
              return _M_put(__next, __pending);

            if (!_M_put(__outbuf, __outnext - __outbuf))
              return false;
          }
        while (__next != __last && __next != __start);

        if (__next != __last)
          _Tr::move(__first, __next, __last - __next);

        this->pbump(__first - __next);
        return __next != __first;
      }

      streambuf*                _M_buf;
      unique_ptr<_Codecvt>      _M_cvt;
      state_type                _M_state;

      static const streamsize   _S_buffer_length = 32;
      static const streamsize   _S_putback_length = 3;
      _Elem                     _M_put_area[_S_buffer_length];
      _Elem                     _M_get_area[_S_buffer_length];
      streamsize                _M_unconv = 0;
      char                      _M_get_buf[_S_buffer_length-_S_putback_length];
      bool                      _M_always_noconv;
    };

#endif  // _GLIBCXX_USE_WCHAR_T

  /// @} group locales

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#endif // __cplusplus

#endif /* _LOCALE_CONV_H */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	18822 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// wstring_convert implementation -- C++ --
2
3	// Copyright (C) 2015-2021 Free Software Foundation, Inc.
4	//
5	// This file is part of the GNU ISO C++ Library. This library is free
6	// software; you can redistribute it and/or modify it under the
7	// terms of the GNU General Public License as published by the
8	// Free Software Foundation; either version 3, or (at your option)
9	// any later version.
10
11	// This library is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	// GNU General Public License for more details.
15
16	// Under Section 7 of GPL version 3, you are granted additional
17	// permissions described in the GCC Runtime Library Exception, version
18	// 3.1, as published by the Free Software Foundation.
19
20	// You should have received a copy of the GNU General Public License and
21	// a copy of the GCC Runtime Library Exception along with this program;
22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23	// <http://www.gnu.org/licenses/>.
24
25	/** @file bits/locale_conv.h
26	* This is an internal header file, included by other library headers.
27	* Do not attempt to use it directly. @headername{locale}
28	*/
29
30	#ifndef _LOCALE_CONV_H
31	#define _LOCALE_CONV_H 1
32
33	#if __cplusplus < 201103L
34	# include <bits/c++0x_warning.h>
35	#else
36
37	#include <streambuf>
38	#include <bits/stringfwd.h>
39	#include <bits/allocator.h>
40	#include <bits/codecvt.h>
41	#include <bits/unique_ptr.h>
42
43	namespace std _GLIBCXX_VISIBILITY(default)
44	{
45	_GLIBCXX_BEGIN_NAMESPACE_VERSION
46
47	/**
48	* @addtogroup locales
49	* @{
50	*/
51
52	template<typename _OutStr, typename _InChar, typename _Codecvt,
53	typename _State, typename _Fn>
54	bool
55	__do_str_codecvt(const _InChar* __first, const _InChar* __last,
56	_OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
57	size_t& __count, _Fn __fn)
58	{
59	if (__first == __last)
60	{
61	__outstr.clear();
62	__count = 0;
63	return true;
64	}
65
66	size_t __outchars = 0;
67	auto __next = __first;
68	const auto __maxlen = __cvt.max_length() + 1;
69
70	codecvt_base::result __result;
71	do
72	{
73	__outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
74	auto __outnext = &__outstr.front() + __outchars;
75	auto const __outlast = &__outstr.back() + 1;
76	__result = (__cvt.*__fn)(__state, __next, __last, __next,
77	__outnext, __outlast, __outnext);
78	__outchars = __outnext - &__outstr.front();
79	}
80	while (__result == codecvt_base::partial && __next != __last
81	&& ptrdiff_t(__outstr.size() - __outchars) < __maxlen);
82
83	if (__result == codecvt_base::error)
84	{
85	__count = __next - __first;
86	return false;
87	}
88
89	// The codecvt facet will only return noconv when the types are
90	// the same, so avoid instantiating basic_string::assign otherwise
91	if _GLIBCXX17_CONSTEXPR (is_same<typename _Codecvt::intern_type,
92	typename _Codecvt::extern_type>())
93	if (__result == codecvt_base::noconv)
94	{
95	__outstr.assign(__first, __last);
96	__count = __last - __first;
97	return true;
98	}
99
100	__outstr.resize(__outchars);
101	__count = __next - __first;
102	return true;
103	}
104
105	// Convert narrow character string to wide.
106	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
107	inline bool
108	__str_codecvt_in(const char* __first, const char* __last,
109	basic_string<_CharT, _Traits, _Alloc>& __outstr,
110	const codecvt<_CharT, char, _State>& __cvt,
111	_State& __state, size_t& __count)
112	{
113	using _Codecvt = codecvt<_CharT, char, _State>;
114	using _ConvFn
115	= codecvt_base::result
116	(_Codecvt::)(_State&, const char, const char, const char&,
117	_CharT, _CharT, _CharT*&) const;
118	_ConvFn __fn = &codecvt<_CharT, char, _State>::in;
119	return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
120	__count, __fn);
121	}
122
123	// As above, but with no __count parameter
124	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
125	inline bool
126	__str_codecvt_in(const char* __first, const char* __last,
127	basic_string<_CharT, _Traits, _Alloc>& __outstr,
128	const codecvt<_CharT, char, _State>& __cvt)
129	{
130	_State __state = {};
131	size_t __n;
132	return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
133	}
134
135	// As above, but returns false for partial conversion
136	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
137	inline bool
138	__str_codecvt_in_all(const char* __first, const char* __last,
139	basic_string<_CharT, _Traits, _Alloc>& __outstr,
140	const codecvt<_CharT, char, _State>& __cvt)
141	{
142	_State __state = {};
143	size_t __n;
144	return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
145	&& (__n == size_t(__last - __first));
146	}
147
148	// Convert wide character string to narrow.
149	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
150	inline bool
151	__str_codecvt_out(const _CharT* __first, const _CharT* __last,
152	basic_string<char, _Traits, _Alloc>& __outstr,
153	const codecvt<_CharT, char, _State>& __cvt,
154	_State& __state, size_t& __count)
155	{
156	using _Codecvt = codecvt<_CharT, char, _State>;
157	using _ConvFn
158	= codecvt_base::result
159	(_Codecvt::)(_State&, const _CharT, const _CharT, const _CharT&,
160	char, char, char*&) const;
161	_ConvFn __fn = &codecvt<_CharT, char, _State>::out;
162	return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
163	__count, __fn);
164	}
165
166	// As above, but with no __count parameter
167	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
168	inline bool
169	__str_codecvt_out(const _CharT* __first, const _CharT* __last,
170	basic_string<char, _Traits, _Alloc>& __outstr,
171	const codecvt<_CharT, char, _State>& __cvt)
172	{
173	_State __state = {};
174	size_t __n;
175	return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
176	}
177
178	// As above, but returns false for partial conversions
179	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
180	inline bool
181	__str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
182	basic_string<char, _Traits, _Alloc>& __outstr,
183	const codecvt<_CharT, char, _State>& __cvt)
184	{
185	_State __state = {};
186	size_t __n;
187	return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
188	&& (__n == size_t(__last - __first));
189	}
190
191	#ifdef _GLIBCXX_USE_CHAR8_T
192
193	// Convert wide character string to narrow.
194	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
195	inline bool
196	__str_codecvt_out(const _CharT* __first, const _CharT* __last,
197	basic_string<char8_t, _Traits, _Alloc>& __outstr,
198	const codecvt<_CharT, char8_t, _State>& __cvt,
199	_State& __state, size_t& __count)
200	{
201	using _Codecvt = codecvt<_CharT, char8_t, _State>;
202	using _ConvFn
203	= codecvt_base::result
204	(_Codecvt::)(_State&, const _CharT, const _CharT, const _CharT&,
205	char8_t, char8_t, char8_t*&) const;
206	_ConvFn __fn = &codecvt<_CharT, char8_t, _State>::out;
207	return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
208	__count, __fn);
209	}
210
211	template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
212	inline bool
213	__str_codecvt_out(const _CharT* __first, const _CharT* __last,
214	basic_string<char8_t, _Traits, _Alloc>& __outstr,
215	const codecvt<_CharT, char8_t, _State>& __cvt)
216	{
217	_State __state = {};
218	size_t __n;
219	return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
220	}
221
222	#endif // _GLIBCXX_USE_CHAR8_T
223
224	#ifdef _GLIBCXX_USE_WCHAR_T
225
226	_GLIBCXX_BEGIN_NAMESPACE_CXX11
227
228	/// String conversions
229	template<typename _Codecvt, typename _Elem = wchar_t,
230	typename _Wide_alloc = allocator<_Elem>,
231	typename _Byte_alloc = allocator<char>>
232	class wstring_convert
233	{
234	public:
235	typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
236	typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
237	typedef typename _Codecvt::state_type state_type;
238	typedef typename wide_string::traits_type::int_type int_type;
239
240	/// Default constructor.
241	wstring_convert() : _M_cvt(new _Codecvt()) { }
242
243	/** Constructor.
244	*
245	* @param __pcvt The facet to use for conversions.
246	*
247	* Takes ownership of @p __pcvt and will delete it in the destructor.
248	*/
249	explicit
250	wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt)
251	{
252	if (!_M_cvt)
253	__throw_logic_error("wstring_convert");
254	}
255
256	/** Construct with an initial converstion state.
257	*
258	* @param __pcvt The facet to use for conversions.
259	* @param __state Initial conversion state.
260	*
261	* Takes ownership of @p __pcvt and will delete it in the destructor.
262	* The object's conversion state will persist between conversions.
263	*/
264	wstring_convert(_Codecvt* __pcvt, state_type __state)
265	: _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
266	{
267	if (!_M_cvt)
268	__throw_logic_error("wstring_convert");
269	}
270
271	/** Construct with error strings.
272	*
273	* @param __byte_err A string to return on failed conversions.
274	* @param __wide_err A wide string to return on failed conversions.
275	*/
276	explicit
277	wstring_convert(const byte_string& __byte_err,
278	const wide_string& __wide_err = wide_string())
279	: _M_cvt(new _Codecvt),
280	_M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
281	_M_with_strings(true)
282	{
283	if (!_M_cvt)
284	__throw_logic_error("wstring_convert");
285	}
286
287	~wstring_convert() = default;
288
289	// _GLIBCXX_RESOLVE_LIB_DEFECTS
290	// 2176. Special members for wstring_convert and wbuffer_convert
291	wstring_convert(const wstring_convert&) = delete;
292	wstring_convert& operator=(const wstring_convert&) = delete;
293
294	/// @{ Convert from bytes.
295	wide_string
296	from_bytes(char __byte)
297	{
298	char __bytes[2] = { __byte };
299	return from_bytes(__bytes, __bytes+1);
300	}
301
302	wide_string
303	from_bytes(const char* __ptr)
304	{ return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }
305
306	wide_string
307	from_bytes(const byte_string& __str)
308	{
309	auto __ptr = __str.data();
310	return from_bytes(__ptr, __ptr + __str.size());
311	}
312
313	wide_string
314	from_bytes(const char* __first, const char* __last)
315	{
316	if (!_M_with_cvtstate)
317	_M_state = state_type();
318	wide_string __out{ _M_wide_err_string.get_allocator() };
319	if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
320	_M_count))
321	return __out;
322	if (_M_with_strings)
323	return _M_wide_err_string;
324	__throw_range_error("wstring_convert::from_bytes");
325	}
326	/// @}
327
328	/// @{ Convert to bytes.
329	byte_string
330	to_bytes(_Elem __wchar)
331	{
332	_Elem __wchars[2] = { __wchar };
333	return to_bytes(__wchars, __wchars+1);
334	}
335
336	byte_string
337	to_bytes(const _Elem* __ptr)
338	{
339	return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
340	}
341
342	byte_string
343	to_bytes(const wide_string& __wstr)
344	{
345	auto __ptr = __wstr.data();
346	return to_bytes(__ptr, __ptr + __wstr.size());
347	}
348
349	byte_string
350	to_bytes(const _Elem* __first, const _Elem* __last)
351	{
352	if (!_M_with_cvtstate)
353	_M_state = state_type();
354	byte_string __out{ _M_byte_err_string.get_allocator() };
355	if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
356	_M_count))
357	return __out;
358	if (_M_with_strings)
359	return _M_byte_err_string;
360	__throw_range_error("wstring_convert::to_bytes");
361	}
362	/// @}
363
364	// _GLIBCXX_RESOLVE_LIB_DEFECTS
365	// 2174. wstring_convert::converted() should be noexcept
366	/// The number of elements successfully converted in the last conversion.
367	size_t converted() const noexcept { return _M_count; }
368
369	/// The final conversion state of the last conversion.
370	state_type state() const { return _M_state; }
371
372	private:
373	unique_ptr<_Codecvt> _M_cvt;
374	byte_string _M_byte_err_string;
375	wide_string _M_wide_err_string;
376	state_type _M_state = state_type();
377	size_t _M_count = 0;
378	bool _M_with_cvtstate = false;
379	bool _M_with_strings = false;
380	};
381
382	_GLIBCXX_END_NAMESPACE_CXX11
383
384	/// Buffer conversions
385	template<typename _Codecvt, typename _Elem = wchar_t,
386	typename _Tr = char_traits<_Elem>>
387	class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
388	{
389	typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;
390
391	public:
392	typedef typename _Codecvt::state_type state_type;
393
394	/// Default constructor.
395	wbuffer_convert() : wbuffer_convert(nullptr) { }
396
397	/** Constructor.
398	*
399	* @param __bytebuf The underlying byte stream buffer.
400	* @param __pcvt The facet to use for conversions.
401	* @param __state Initial conversion state.
402	*
403	* Takes ownership of @p __pcvt and will delete it in the destructor.
404	*/
405	explicit
406	wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt,
407	state_type __state = state_type())
408	: _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
409	{
410	if (!_M_cvt)
411	__throw_logic_error("wbuffer_convert");
412
413	_M_always_noconv = _M_cvt->always_noconv();
414
415	if (_M_buf)
416	{
417	this->setp(_M_put_area, _M_put_area + _S_buffer_length);
418	this->setg(_M_get_area + _S_putback_length,
419	_M_get_area + _S_putback_length,
420	_M_get_area + _S_putback_length);
421	}
422	}
423
424	~wbuffer_convert() = default;
425
426	// _GLIBCXX_RESOLVE_LIB_DEFECTS
427	// 2176. Special members for wstring_convert and wbuffer_convert
428	wbuffer_convert(const wbuffer_convert&) = delete;
429	wbuffer_convert& operator=(const wbuffer_convert&) = delete;
430
431	streambuf* rdbuf() const noexcept { return _M_buf; }
432
433	streambuf*
434	rdbuf(streambuf *__bytebuf) noexcept
435	{
436	auto __prev = _M_buf;
437	_M_buf = __bytebuf;
438	return __prev;
439	}
440
441	/// The conversion state following the last conversion.
442	state_type state() const noexcept { return _M_state; }
443
444	protected:
445	int
446	sync()
447	{ return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }
448
449	typename _Wide_streambuf::int_type
450	overflow(typename _Wide_streambuf::int_type __out)
451	{
452	if (!_M_buf \|\| !_M_conv_put())
453	return _Tr::eof();
454	else if (!_Tr::eq_int_type(__out, _Tr::eof()))
455	return this->sputc(__out);
456	return _Tr::not_eof(__out);
457	}
458
459	typename _Wide_streambuf::int_type
460	underflow()
461	{
462	if (!_M_buf)
463	return _Tr::eof();
464
465	if (this->gptr() < this->egptr() \|\| (_M_buf && _M_conv_get()))
466	return _Tr::to_int_type(*this->gptr());
467	else
468	return _Tr::eof();
469	}
470
471	streamsize
472	xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
473	{
474	if (!_M_buf \|\| __n == 0)
475	return 0;
476	streamsize __done = 0;
477	do
478	{
479	auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
480	__n - __done);
481	_Tr::copy(this->pptr(), __s + __done, __nn);
482	this->pbump(__nn);
483	__done += __nn;
484	} while (__done < __n && _M_conv_put());
485	return __done;
486	}
487
488	private:
489	// fill the get area from converted contents of the byte stream buffer
490	bool
491	_M_conv_get()
492	{
493	const streamsize __pb1 = this->gptr() - this->eback();
494	const streamsize __pb2 = _S_putback_length;
495	const streamsize __npb = std::min(__pb1, __pb2);
496
497	_Tr::move(_M_get_area + _S_putback_length - __npb,
498	this->gptr() - __npb, __npb);
499
500	streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
501	__nbytes = std::min(__nbytes, _M_buf->in_avail());
502	if (__nbytes < 1)
503	__nbytes = 1;
504	__nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
505	if (__nbytes < 1)
506	return false;
507	__nbytes += _M_unconv;
508
509	// convert _M_get_buf into _M_get_area
510
511	_Elem* __outbuf = _M_get_area + _S_putback_length;
512	_Elem* __outnext = __outbuf;
513	const char* __bnext = _M_get_buf;
514
515	codecvt_base::result __result;
516	if (_M_always_noconv)
517	__result = codecvt_base::noconv;
518	else
519	{
520	_Elem* __outend = _M_get_area + _S_buffer_length;
521
522	__result = _M_cvt->in(_M_state,
523	__bnext, __bnext + __nbytes, __bnext,
524	__outbuf, __outend, __outnext);
525	}
526
527	if (__result == codecvt_base::noconv)
528	{
529	// cast is safe because noconv means _Elem is same type as char
530	auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
531	_Tr::copy(__outbuf, __get_buf, __nbytes);
532	_M_unconv = 0;
533	return true;
534	}
535
536	if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
537	char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);
538
539	this->setg(__outbuf, __outbuf, __outnext);
540
541	return __result != codecvt_base::error;
542	}
543
544	// unused
545	bool
546	_M_put(...)
547	{ return false; }
548
549	bool
550	_M_put(const char* __p, streamsize __n)
551	{
552	if (_M_buf->sputn(__p, __n) < __n)
553	return false;
554	return true;
555	}
556
557	// convert the put area and write to the byte stream buffer
558	bool
559	_M_conv_put()
560	{
561	_Elem* const __first = this->pbase();
562	const _Elem* const __last = this->pptr();
563	const streamsize __pending = __last - __first;
564
565	if (_M_always_noconv)
566	return _M_put(__first, __pending);
567
568	char __outbuf[2 * _S_buffer_length];
569
570	const _Elem* __next = __first;
571	const _Elem* __start;
572	do
573	{
574	__start = __next;
575	char* __outnext = __outbuf;
576	char* const __outlast = __outbuf + sizeof(__outbuf);
577	auto __result = _M_cvt->out(_M_state, __next, __last, __next,
578	__outnext, __outlast, __outnext);
579	if (__result == codecvt_base::error)
580	return false;
581	else if (__result == codecvt_base::noconv)
582	return _M_put(__next, __pending);
583
584	if (!_M_put(__outbuf, __outnext - __outbuf))
585	return false;
586	}
587	while (__next != __last && __next != __start);
588
589	if (__next != __last)
590	_Tr::move(__first, __next, __last - __next);
591
592	this->pbump(__first - __next);
593	return __next != __first;
594	}
595
596	streambuf* _M_buf;
597	unique_ptr<_Codecvt> _M_cvt;
598	state_type _M_state;
599
600	static const streamsize _S_buffer_length = 32;
601	static const streamsize _S_putback_length = 3;
602	_Elem _M_put_area[_S_buffer_length];
603	_Elem _M_get_area[_S_buffer_length];
604	streamsize _M_unconv = 0;
605	char _M_get_buf[_S_buffer_length-_S_putback_length];
606	bool _M_always_noconv;
607	};
608
609	#endif // _GLIBCXX_USE_WCHAR_T
610
611	/// @} group locales
612
613	_GLIBCXX_END_NAMESPACE_VERSION
614	} // namespace
615
616	#endif // __cplusplus
617
618	#endif /* _LOCALE_CONV_H */