1 // wstring_convert implementation -*- C++ -*- 2 3 // Copyright (C) 2015-2022 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(__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(__pb1, __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(__nbytes, _M_buf->in_avail()); 520 if (__nbytes < 1) 521 __nbytes = 1; 522 __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __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(_M_get_buf, __bnext, _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(__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
Indexes created Tue Feb 24 01:34:59 UTC 2026