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