<h2>File Contents: //usr/include/c++/8/bits/locale_conv.h</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/bits/locale_conv.h'><textarea name='file_content' rows='10' cols='50'>// wstring_convert implementation -*- C++ -*-

// Copyright (C) 2015-2018 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
// &lt;http://www.gnu.org/licenses/&gt;.

/** @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 &lt; 201103L
# include &lt;bits/c++0x_warning.h&gt;
#else

#include &lt;streambuf&gt;
#include &lt;bits/stringfwd.h&gt;
#include &lt;bits/allocator.h&gt;
#include &lt;bits/codecvt.h&gt;
#include &lt;bits/unique_ptr.h&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

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

  template&lt;typename _OutStr, typename _InChar, typename _Codecvt,
	   typename _State, typename _Fn&gt;
    bool
    __do_str_codecvt(const _InChar* __first, const _InChar* __last,
		     _OutStr&amp; __outstr, const _Codecvt&amp; __cvt, _State&amp; __state,
		     size_t&amp; __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 = &amp;__outstr.front() + __outchars;
	  auto const __outlast = &amp;__outstr.back() + 1;
	  __result = (__cvt.*__fn)(__state, __next, __last, __next,
					__outnext, __outlast, __outnext);
	  __outchars = __outnext - &amp;__outstr.front();
	}
      while (__result == codecvt_base::partial &amp;&amp; __next != __last
	     &amp;&amp; (__outstr.size() - __outchars) &lt; __maxlen);

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

      if (__result == codecvt_base::noconv)
	{
	  __outstr.assign(__first, __last);
	  __count = __last - __first;
	}
      else
	{
	  __outstr.resize(__outchars);
	  __count = __next - __first;
	}

      return true;
    }

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

  template&lt;typename _CharT, typename _Traits, typename _Alloc, typename _State&gt;
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
		     basic_string&lt;_CharT, _Traits, _Alloc&gt;&amp; __outstr,
		     const codecvt&lt;_CharT, char, _State&gt;&amp; __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
    }

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

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

#ifdef _GLIBCXX_USE_WCHAR_T

_GLIBCXX_BEGIN_NAMESPACE_CXX11

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

      /** Default 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 = new _Codecvt()) : _M_cvt(__pcvt)
      {
	if (!_M_cvt)
	  __throw_logic_error(&quot;wstring_convert&quot;);
      }

      /** 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(&quot;wstring_convert&quot;);
      }

      /** 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&amp; __byte_err,
		      const wide_string&amp; __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(&quot;wstring_convert&quot;);
      }

      ~wstring_convert() = default;

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 2176. Special members for wstring_convert and wbuffer_convert
      wstring_convert(const wstring_convert&amp;) = delete;
      wstring_convert&amp; operator=(const wstring_convert&amp;) = 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&lt;char&gt;::length(__ptr)); }

      wide_string
      from_bytes(const byte_string&amp; __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(&quot;wstring_convert::from_bytes&quot;);
      }
      /// @}

      /// @{ 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&amp; __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(&quot;wstring_convert::to_bytes&quot;);
      }
      /// @}

      // _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&lt;_Codecvt&gt;	_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&lt;typename _Codecvt, typename _Elem = wchar_t,
	   typename _Tr = char_traits&lt;_Elem&gt;&gt;
    class wbuffer_convert : public basic_streambuf&lt;_Elem, _Tr&gt;
    {
      typedef basic_streambuf&lt;_Elem, _Tr&gt; _Wide_streambuf;

    public:
      typedef typename _Codecvt::state_type state_type;

      /** Default 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 = 0, _Codecvt* __pcvt = new _Codecvt,
		      state_type __state = state_type())
      : _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
      {
	if (!_M_cvt)
	  __throw_logic_error(&quot;wbuffer_convert&quot;);

	_M_always_noconv = _M_cvt-&gt;always_noconv();

	if (_M_buf)
	  {
	    this-&gt;setp(_M_put_area, _M_put_area + _S_buffer_length);
	    this-&gt;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&amp;) = delete;
      wbuffer_convert&amp; operator=(const wbuffer_convert&amp;) = 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 &amp;&amp; _M_conv_put() &amp;&amp; !_M_buf-&gt;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-&gt;sputc(__out);
	return _Tr::not_eof(__out);
      }

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

	if (this-&gt;gptr() &lt; this-&gt;egptr() || (_M_buf &amp;&amp; _M_conv_get()))
	  return _Tr::to_int_type(*this-&gt;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&lt;streamsize&gt;(this-&gt;epptr() - this-&gt;pptr(),
					   __n - __done);
	  _Tr::copy(this-&gt;pptr(), __s + __done, __nn);
	  this-&gt;pbump(__nn);
	  __done += __nn;
	} while (__done &lt; __n &amp;&amp; _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-&gt;gptr() - this-&gt;eback();
	const streamsize __pb2 = _S_putback_length;
	const streamsize __npb = std::min(__pb1, __pb2);

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

	streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
	__nbytes = std::min(__nbytes, _M_buf-&gt;in_avail());
	if (__nbytes &lt; 1)
	  __nbytes = 1;
	__nbytes = _M_buf-&gt;sgetn(_M_get_buf + _M_unconv, __nbytes);
	if (__nbytes &lt; 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-&gt;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&lt;const _Elem*&gt;(_M_get_buf);
	    _Tr::copy(__outbuf, __get_buf, __nbytes);
	    _M_unconv = 0;
	    return true;
	  }

	if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
	  char_traits&lt;char&gt;::move(_M_get_buf, __bnext, _M_unconv);

	this-&gt;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-&gt;sputn(__p, __n) &lt; __n)
	  return false;
	return true;
      }

      // convert the put area and write to the byte stream buffer
      bool
      _M_conv_put()
      {
	_Elem* const __first = this-&gt;pbase();
	const _Elem* const __last = this-&gt;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-&gt;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 &amp;&amp; __next != __start);

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

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

      streambuf*		_M_buf;
      unique_ptr&lt;_Codecvt&gt;	_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 */
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fbits'>⬅ Back to Directory</a>