| // Locale support -*- C++ -*- |
| |
| // Copyright (C) 2014-2022 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/>. |
| |
| // |
| // ISO C++ 14882: 22.1 Locales |
| // |
| |
| // This file defines classes that behave like the standard predefined locale |
| // facets (collate, money_get etc.) except that they forward all virtual |
| // functions to another facet which uses a different std::string ABI, |
| // converting between string types as needed. |
| // When a user replaces one of the relevant facets the corresponding shim in |
| // this file is used so that the replacement facet can be used (via the shim) |
| // in code that uses the other std::string ABI from the replacing code. |
| |
| #ifndef _GLIBCXX_USE_CXX11_ABI |
| # define _GLIBCXX_USE_CXX11_ABI 1 |
| #endif |
| #include <locale> |
| |
| #if ! _GLIBCXX_USE_DUAL_ABI |
| # error This file should not be compiled for this configuration. |
| #endif |
| |
| namespace std _GLIBCXX_VISIBILITY(default) |
| { |
| _GLIBCXX_BEGIN_NAMESPACE_VERSION |
| |
| // Base class of facet shims, holds a reference to the underlying facet |
| // that the shim forwards to. |
| class locale::facet::__shim |
| { |
| public: |
| const facet* _M_get() const { return _M_facet; } |
| |
| __shim(const __shim&) = delete; |
| __shim& operator=(const __shim&) = delete; |
| |
| protected: |
| explicit |
| __shim(const facet* __f) : _M_facet(__f) { __f->_M_add_reference(); } |
| |
| ~__shim() { _M_facet->_M_remove_reference(); } |
| |
| private: |
| const facet* _M_facet; |
| }; |
| |
| namespace __facet_shims |
| { |
| namespace // unnamed |
| { |
| template<typename C> |
| void __destroy_string(void* p) |
| { |
| static_cast<std::basic_string<C>*>(p)->~basic_string(); |
| } |
| } // namespace |
| |
| // Manages a buffer of uninitialized memory that can store a std::string |
| // or std::wstring, using either ABI, and convert to the other ABI. |
| class __any_string |
| { |
| struct __attribute__((may_alias)) __str_rep |
| { |
| union { |
| const void* _M_p; |
| char* _M_pc; |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| wchar_t* _M_pwc; |
| #endif |
| }; |
| size_t _M_len; |
| char _M_unused[16]; |
| |
| operator const char*() const { return _M_pc; } |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| operator const wchar_t*() const { return _M_pwc; } |
| #endif |
| }; |
| union { |
| __str_rep _M_str; |
| char _M_bytes[sizeof(__str_rep)]; |
| }; |
| using __dtor_func = void(*)(void*); |
| __dtor_func _M_dtor = nullptr; |
| |
| #if _GLIBCXX_USE_CXX11_ABI |
| // SSO strings overlay the entire __str_rep structure. |
| static_assert(sizeof(std::string) == sizeof(__str_rep), |
| "std::string changed size!"); |
| #else |
| // COW strings overlay just the pointer, the length is stored manually. |
| static_assert(sizeof(std::string) == sizeof(__str_rep::_M_p), |
| "std::string changed size!"); |
| #endif |
| # ifdef _GLIBCXX_USE_WCHAR_T |
| static_assert(sizeof(std::wstring) == sizeof(std::string), |
| "std::wstring and std::string are different sizes!"); |
| # endif |
| |
| public: |
| __any_string() = default; |
| ~__any_string() { if (_M_dtor) _M_dtor(_M_bytes); } |
| |
| __any_string(const __any_string&) = delete; |
| __any_string& operator=(const __any_string&) = delete; |
| |
| // Store a string (and its length if needed) in the buffer and |
| // set _M_dtor to the function that runs the right destructor. |
| template<typename C> |
| __any_string& |
| operator=(const basic_string<C>& s) |
| { |
| if (_M_dtor) |
| _M_dtor(_M_bytes); |
| ::new(_M_bytes) basic_string<C>(s); |
| #if ! _GLIBCXX_USE_CXX11_ABI |
| _M_str._M_len = s.length(); |
| #endif |
| _M_dtor = __destroy_string<C>; |
| return *this; |
| } |
| |
| // Create a new string with a copy of the characters in the stored string. |
| // The returned object will match the caller's string ABI, even when the |
| // stored string doesn't. |
| template<typename C> |
| _GLIBCXX_DEFAULT_ABI_TAG |
| operator basic_string<C>() const |
| { |
| if (!_M_dtor) |
| __throw_logic_error("uninitialized __any_string"); |
| return basic_string<C>(static_cast<const C*>(_M_str), _M_str._M_len); |
| } |
| }; |
| |
| // This file is compiled twice, with and without this macro defined. |
| // Define tag types to distinguish between the two cases and to allow |
| // overloading on the tag. |
| using current_abi = __bool_constant<_GLIBCXX_USE_CXX11_ABI>; |
| using other_abi = __bool_constant<!_GLIBCXX_USE_CXX11_ABI>; |
| |
| using facet = locale::facet; |
| |
| // Declare the functions that shims defined in this file will call to |
| // perform work in the context of the other ABI. |
| // These will be defined when this file is recompiled for the other ABI |
| // (at which point what is now "current_abi" will become "other_abi"). |
| |
| template<typename C> |
| void |
| __numpunct_fill_cache(other_abi, const facet*, __numpunct_cache<C>*); |
| |
| template<typename C> |
| int |
| __collate_compare(other_abi, const facet*, const C*, const C*, |
| const C*, const C*); |
| |
| template<typename C> |
| void |
| __collate_transform(other_abi, const facet*, __any_string&, |
| const C*, const C*); |
| |
| template<typename C> |
| time_base::dateorder |
| __time_get_dateorder(other_abi, const facet* f); |
| |
| template<typename C> |
| istreambuf_iterator<C> |
| __time_get(other_abi, const facet* f, |
| istreambuf_iterator<C> beg, istreambuf_iterator<C> end, |
| ios_base& io, ios_base::iostate& err, tm* t, char which); |
| |
| template<typename C, bool Intl> |
| void |
| __moneypunct_fill_cache(other_abi, const facet*, |
| __moneypunct_cache<C, Intl>*); |
| |
| template<typename C> |
| istreambuf_iterator<C> |
| __money_get(other_abi, const facet*, |
| istreambuf_iterator<C>, istreambuf_iterator<C>, |
| bool, ios_base&, ios_base::iostate&, |
| long double*, __any_string*); |
| |
| template<typename C> |
| ostreambuf_iterator<C> |
| __money_put(other_abi, const facet*, ostreambuf_iterator<C>, bool, |
| ios_base&, C, long double, const __any_string*); |
| |
| template<typename C> |
| messages_base::catalog |
| __messages_open(other_abi, const facet*, const char*, size_t, |
| const locale&); |
| |
| template<typename C> |
| void |
| __messages_get(other_abi, const facet*, __any_string&, |
| messages_base::catalog, int, int, const C*, size_t); |
| |
| template<typename C> |
| void |
| __messages_close(other_abi, const facet*, messages_base::catalog); |
| |
| #pragma GCC diagnostic push |
| // Suppress -Wabi=2 warnings due to empty struct argument passing changes. |
| // TODO This should use -Wabi=12 but that currently fails (PR c++/87611). |
| #pragma GCC diagnostic ignored "-Wabi" |
| |
| namespace // unnamed |
| { |
| struct __shim_accessor : facet |
| { |
| using facet::__shim; // Redeclare protected member as public. |
| }; |
| using __shim = __shim_accessor::__shim; |
| |
| template<typename _CharT> |
| struct numpunct_shim : std::numpunct<_CharT>, __shim |
| { |
| typedef typename numpunct<_CharT>::__cache_type __cache_type; |
| |
| // f must point to a type derived from numpunct<C>[abi:other] |
| numpunct_shim(const facet* f, __cache_type* c = new __cache_type) |
| : std::numpunct<_CharT>(c), __shim(f), _M_cache(c) |
| { |
| __numpunct_fill_cache(other_abi{}, f, c); |
| } |
| |
| ~numpunct_shim() |
| { |
| // Stop GNU locale's ~numpunct() from freeing the cached string. |
| _M_cache->_M_grouping_size = 0; |
| } |
| |
| // No need to override any virtual functions, the base definitions |
| // will return the cached data. |
| |
| __cache_type* _M_cache; |
| }; |
| |
| template<typename _CharT> |
| struct collate_shim : std::collate<_CharT>, __shim |
| { |
| typedef basic_string<_CharT> string_type; |
| |
| // f must point to a type derived from collate<C>[abi:other] |
| collate_shim(const facet* f) : __shim(f) { } |
| |
| virtual int |
| do_compare(const _CharT* lo1, const _CharT* hi1, |
| const _CharT* lo2, const _CharT* hi2) const |
| { |
| return __collate_compare(other_abi{}, _M_get(), |
| lo1, hi1, lo2, hi2); |
| } |
| |
| virtual string_type |
| do_transform(const _CharT* lo, const _CharT* hi) const |
| { |
| __any_string st; |
| __collate_transform(other_abi{}, _M_get(), st, lo, hi); |
| return st; |
| } |
| }; |
| |
| template<typename _CharT> |
| struct time_get_shim : std::time_get<_CharT>, __shim |
| { |
| typedef typename std::time_get<_CharT>::iter_type iter_type; |
| typedef typename std::time_get<_CharT>::char_type char_type; |
| |
| // f must point to a type derived from time_get<C>[abi:other] |
| time_get_shim(const facet* f) : __shim(f) { } |
| |
| virtual time_base::dateorder |
| do_date_order() const |
| { return __time_get_dateorder<_CharT>(other_abi{}, _M_get()); } |
| |
| virtual iter_type |
| do_get_time(iter_type beg, iter_type end, ios_base& io, |
| ios_base::iostate& err, tm* t) const |
| { |
| return __time_get(other_abi{}, _M_get(), beg, end, io, err, t, |
| 't'); |
| } |
| |
| virtual iter_type |
| do_get_date(iter_type beg, iter_type end, ios_base& io, |
| ios_base::iostate& err, tm* t) const |
| { |
| return __time_get(other_abi{}, _M_get(), beg, end, io, err, t, |
| 'd'); |
| } |
| |
| virtual iter_type |
| do_get_weekday(iter_type beg, iter_type end, ios_base& io, |
| ios_base::iostate& err, tm* t) const |
| { |
| return __time_get(other_abi{}, _M_get(), beg, end, io, err, t, |
| 'w'); |
| } |
| |
| virtual iter_type |
| do_get_monthname(iter_type beg, iter_type end, ios_base& io, |
| ios_base::iostate& err, tm* t) const |
| { |
| return __time_get(other_abi{}, _M_get(), beg, end, io, err, t, |
| 'm'); |
| } |
| |
| virtual iter_type |
| do_get_year(iter_type beg, iter_type end, ios_base& io, |
| ios_base::iostate& err, tm* t) const |
| { |
| return __time_get(other_abi{}, _M_get(), beg, end, io, err, t, |
| 'y'); |
| } |
| }; |
| |
| template<typename _CharT, bool _Intl> |
| struct moneypunct_shim : std::moneypunct<_CharT, _Intl>, __shim |
| { |
| typedef typename moneypunct<_CharT, _Intl>::__cache_type __cache_type; |
| |
| // f must point to a type derived from moneypunct<C>[abi:other] |
| moneypunct_shim(const facet* f, __cache_type* c = new __cache_type) |
| : std::moneypunct<_CharT, _Intl>(c), __shim(f), _M_cache(c) |
| { |
| __moneypunct_fill_cache(other_abi{}, f, c); |
| } |
| |
| ~moneypunct_shim() |
| { |
| // Stop GNU locale's ~moneypunct() from freeing the cached strings. |
| _M_cache->_M_grouping_size = 0; |
| _M_cache->_M_curr_symbol_size = 0; |
| _M_cache->_M_positive_sign_size = 0; |
| _M_cache->_M_negative_sign_size = 0; |
| } |
| |
| // No need to override any virtual functions, the base definitions |
| // will return the cached data. |
| |
| __cache_type* _M_cache; |
| }; |
| |
| template<typename _CharT> |
| struct money_get_shim : std::money_get<_CharT>, __shim |
| { |
| typedef typename std::money_get<_CharT>::iter_type iter_type; |
| typedef typename std::money_get<_CharT>::char_type char_type; |
| typedef typename std::money_get<_CharT>::string_type string_type; |
| |
| // f must point to a type derived from money_get<C>[abi:other] |
| money_get_shim(const facet* f) : __shim(f) { } |
| |
| virtual iter_type |
| do_get(iter_type s, iter_type end, bool intl, ios_base& io, |
| ios_base::iostate& err, long double& units) const |
| { |
| ios_base::iostate err2 = ios_base::goodbit; |
| long double units2; |
| s = __money_get(other_abi{}, _M_get(), s, end, intl, io, err2, |
| &units2, nullptr); |
| if (err2 == ios_base::goodbit) |
| units = units2; |
| else |
| err = err2; |
| return s; |
| } |
| |
| virtual iter_type |
| do_get(iter_type s, iter_type end, bool intl, ios_base& io, |
| ios_base::iostate& err, string_type& digits) const |
| { |
| __any_string st; |
| ios_base::iostate err2 = ios_base::goodbit; |
| s = __money_get(other_abi{}, _M_get(), s, end, intl, io, err2, |
| nullptr, &st); |
| if (err2 == ios_base::goodbit) |
| digits = st; |
| else |
| err = err2; |
| return s; |
| } |
| }; |
| |
| template<typename _CharT> |
| struct money_put_shim : std::money_put<_CharT>, __shim |
| { |
| typedef typename std::money_put<_CharT>::iter_type iter_type; |
| typedef typename std::money_put<_CharT>::char_type char_type; |
| typedef typename std::money_put<_CharT>::string_type string_type; |
| |
| // f must point to a type derived from money_put<C>[abi:other] |
| money_put_shim(const facet* f) : __shim(f) { } |
| |
| virtual iter_type |
| do_put(iter_type s, bool intl, ios_base& io, |
| char_type fill, long double units) const |
| { |
| return __money_put(other_abi{}, _M_get(), s, intl, io, fill, units, |
| nullptr); |
| } |
| |
| virtual iter_type |
| do_put(iter_type s, bool intl, ios_base& io, |
| char_type fill, const string_type& digits) const |
| { |
| __any_string st; |
| st = digits; |
| return __money_put(other_abi{}, _M_get(), s, intl, io, fill, 0.L, |
| &st); |
| } |
| }; |
| |
| template<typename _CharT> |
| struct messages_shim : std::messages<_CharT>, __shim |
| { |
| typedef messages_base::catalog catalog; |
| typedef basic_string<_CharT> string_type; |
| |
| // f must point to a type derived from messages<C>[abi:other] |
| messages_shim(const facet* f) : __shim(f) { } |
| |
| virtual catalog |
| do_open(const basic_string<char>& s, const locale& l) const |
| { |
| return __messages_open<_CharT>(other_abi{}, _M_get(), |
| s.c_str(), s.size(), l); |
| } |
| |
| virtual string_type |
| do_get(catalog c, int set, int msgid, const string_type& dfault) const |
| { |
| __any_string st; |
| __messages_get(other_abi{}, _M_get(), st, c, set, msgid, |
| dfault.c_str(), dfault.size()); |
| return st; |
| } |
| |
| virtual void |
| do_close(catalog c) const |
| { |
| __messages_close<_CharT>(other_abi{}, _M_get(), c); |
| } |
| }; |
| |
| template struct numpunct_shim<char>; |
| template struct collate_shim<char>; |
| template struct moneypunct_shim<char, true>; |
| template struct moneypunct_shim<char, false>; |
| template struct money_get_shim<char>; |
| template struct money_put_shim<char>; |
| template struct messages_shim<char>; |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template struct numpunct_shim<wchar_t>; |
| template struct collate_shim<wchar_t>; |
| template struct moneypunct_shim<wchar_t, true>; |
| template struct moneypunct_shim<wchar_t, false>; |
| template struct money_get_shim<wchar_t>; |
| template struct money_put_shim<wchar_t>; |
| template struct messages_shim<wchar_t>; |
| #endif |
| |
| template<typename C> |
| inline size_t |
| __copy(const C*& dest, const basic_string<C>& s) |
| { |
| auto len = s.length(); |
| C* p = new C[len+1]; |
| s.copy(p, len); |
| p[len] = '\0'; |
| dest = p; |
| return len; |
| } |
| |
| } // namespace |
| |
| // Now define and instantiate the functions that will be called by the |
| // shim facets defined when this file is recompiled for the other ABI. |
| |
| // Cache the values returned by the numpunct facet f. |
| // Sets c->_M_allocated so that the __numpunct_cache destructor will |
| // delete[] the strings allocated by this function. |
| template<typename C> |
| void |
| __numpunct_fill_cache(current_abi, const facet* f, __numpunct_cache<C>* c) |
| { |
| auto* m = static_cast<const numpunct<C>*>(f); |
| |
| c->_M_decimal_point = m->decimal_point(); |
| c->_M_thousands_sep = m->thousands_sep(); |
| |
| c->_M_grouping = nullptr; |
| c->_M_truename = nullptr; |
| c->_M_falsename = nullptr; |
| // set _M_allocated so that if any allocation fails the previously |
| // allocated strings will be deleted in ~__numpunct_cache() |
| c->_M_allocated = true; |
| |
| c->_M_grouping_size = __copy(c->_M_grouping, m->grouping()); |
| c->_M_truename_size = __copy(c->_M_truename, m->truename()); |
| c->_M_falsename_size = __copy(c->_M_falsename, m->falsename()); |
| } |
| |
| template void |
| __numpunct_fill_cache(current_abi, const facet*, __numpunct_cache<char>*); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template void |
| __numpunct_fill_cache(current_abi, const facet*, __numpunct_cache<wchar_t>*); |
| #endif |
| |
| template<typename C> |
| int |
| __collate_compare(current_abi, const facet* f, const C* lo1, const C* hi1, |
| const C* lo2, const C* hi2) |
| { |
| return static_cast<const collate<C>*>(f)->compare(lo1, hi1, lo2, hi2); |
| } |
| |
| template int |
| __collate_compare(current_abi, const facet*, const char*, const char*, |
| const char*, const char*); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template int |
| __collate_compare(current_abi, const facet*, const wchar_t*, const wchar_t*, |
| const wchar_t*, const wchar_t*); |
| #endif |
| |
| template<typename C> |
| void |
| __collate_transform(current_abi, const facet* f, __any_string& st, |
| const C* __lo, const C* __hi) |
| { |
| auto* c = static_cast<const collate<C>*>(f); |
| st = c->transform(__lo, __hi); |
| } |
| |
| template void |
| __collate_transform(current_abi, const facet*, __any_string&, |
| const char*, const char*); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template void |
| __collate_transform(current_abi, const facet*, __any_string&, |
| const wchar_t*, const wchar_t*); |
| #endif |
| |
| // Cache the values returned by the moneypunct facet, f. |
| // Sets c->_M_allocated so that the __moneypunct_cache destructor will |
| // delete[] the strings allocated by this function. |
| template<typename C, bool Intl> |
| void |
| __moneypunct_fill_cache(current_abi, const facet* f, |
| __moneypunct_cache<C, Intl>* c) |
| { |
| auto* m = static_cast<const moneypunct<C, Intl>*>(f); |
| |
| c->_M_decimal_point = m->decimal_point(); |
| c->_M_thousands_sep = m->thousands_sep(); |
| c->_M_frac_digits = m->frac_digits(); |
| |
| c->_M_grouping = nullptr; |
| c->_M_curr_symbol = nullptr; |
| c->_M_positive_sign = nullptr; |
| c->_M_negative_sign = nullptr; |
| // Set _M_allocated so that if any allocation fails the previously |
| // allocated strings will be deleted in ~__moneypunct_cache(). |
| c->_M_allocated = true; |
| |
| c->_M_grouping_size = __copy(c->_M_grouping, m->grouping()); |
| c->_M_curr_symbol_size = __copy(c->_M_curr_symbol, m->curr_symbol()); |
| c->_M_positive_sign_size |
| = __copy(c->_M_positive_sign, m->positive_sign()); |
| c->_M_negative_sign_size |
| = __copy(c->_M_negative_sign, m->negative_sign()); |
| |
| c->_M_pos_format = m->pos_format(); |
| c->_M_neg_format = m->neg_format(); |
| } |
| |
| template void |
| __moneypunct_fill_cache(current_abi, const facet*, |
| __moneypunct_cache<char, true>*); |
| |
| template void |
| __moneypunct_fill_cache(current_abi, const facet*, |
| __moneypunct_cache<char, false>*); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template void |
| __moneypunct_fill_cache(current_abi, const facet*, |
| __moneypunct_cache<wchar_t, true>*); |
| |
| template void |
| __moneypunct_fill_cache(current_abi, const facet*, |
| __moneypunct_cache<wchar_t, false>*); |
| #endif |
| |
| template<typename C> |
| messages_base::catalog |
| __messages_open(current_abi, const facet* f, const char* s, size_t n, |
| const locale& l) |
| { |
| auto* m = static_cast<const messages<C>*>(f); |
| string str(s, n); |
| return m->open(str, l); |
| } |
| |
| template messages_base::catalog |
| __messages_open<char>(current_abi, const facet*, const char*, size_t, |
| const locale&); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template messages_base::catalog |
| __messages_open<wchar_t>(current_abi, const facet*, const char*, size_t, |
| const locale&); |
| #endif |
| |
| template<typename C> |
| void |
| __messages_get(current_abi, const facet* f, __any_string& st, |
| messages_base::catalog c, int set, int msgid, |
| const C* s, size_t n) |
| { |
| auto* m = static_cast<const messages<C>*>(f); |
| st = m->get(c, set, msgid, basic_string<C>(s, n)); |
| } |
| |
| template void |
| __messages_get(current_abi, const facet*, __any_string&, |
| messages_base::catalog, int, int, const char*, size_t); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template void |
| __messages_get(current_abi, const facet*, __any_string&, |
| messages_base::catalog, int, int, const wchar_t*, size_t); |
| #endif |
| |
| template<typename C> |
| void |
| __messages_close(current_abi, const facet* f, messages_base::catalog c) |
| { |
| static_cast<const messages<C>*>(f)->close(c); |
| } |
| |
| template void |
| __messages_close<char>(current_abi, const facet*, messages_base::catalog c); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template void |
| __messages_close<wchar_t>(current_abi, const facet*, |
| messages_base::catalog c); |
| #endif |
| |
| template<typename C> |
| time_base::dateorder |
| __time_get_dateorder(current_abi, const facet* f) |
| { return static_cast<const time_get<C>*>(f)->date_order(); } |
| |
| template time_base::dateorder |
| __time_get_dateorder<char>(current_abi, const facet*); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template time_base::dateorder |
| __time_get_dateorder<wchar_t>(current_abi, const facet*); |
| #endif |
| |
| template<typename C> |
| istreambuf_iterator<C> |
| __time_get(current_abi, const facet* f, |
| istreambuf_iterator<C> beg, istreambuf_iterator<C> end, |
| ios_base& io, ios_base::iostate& err, tm* t, char which) |
| { |
| auto* g = static_cast<const time_get<C>*>(f); |
| switch(which) |
| { |
| case 't': |
| return g->get_time(beg, end, io, err, t); |
| case 'd': |
| return g->get_date(beg, end, io, err, t); |
| case 'w': |
| return g->get_weekday(beg, end, io, err, t); |
| case 'm': |
| return g->get_monthname(beg, end, io, err, t); |
| case 'y': |
| return g->get_year(beg, end, io, err, t); |
| default: |
| __builtin_unreachable(); |
| } |
| } |
| |
| template istreambuf_iterator<char> |
| __time_get(current_abi, const facet*, |
| istreambuf_iterator<char>, istreambuf_iterator<char>, |
| ios_base&, ios_base::iostate&, tm*, char); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template istreambuf_iterator<wchar_t> |
| __time_get(current_abi, const facet*, |
| istreambuf_iterator<wchar_t>, istreambuf_iterator<wchar_t>, |
| ios_base&, ios_base::iostate&, tm*, char); |
| #endif |
| |
| template<typename C> |
| istreambuf_iterator<C> |
| __money_get(current_abi, const facet* f, |
| istreambuf_iterator<C> s, istreambuf_iterator<C> end, |
| bool intl, ios_base& str, ios_base::iostate& err, |
| long double* units, __any_string* digits) |
| { |
| auto* m = static_cast<const money_get<C>*>(f); |
| if (units) |
| return m->get(s, end, intl, str, err, *units); |
| basic_string<C> digits2; |
| s = m->get(s, end, intl, str, err, digits2); |
| if (err == ios_base::goodbit) |
| *digits = digits2; |
| return s; |
| } |
| |
| template istreambuf_iterator<char> |
| __money_get(current_abi, const facet*, |
| istreambuf_iterator<char>, istreambuf_iterator<char>, |
| bool, ios_base&, ios_base::iostate&, |
| long double*, __any_string*); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template istreambuf_iterator<wchar_t> |
| __money_get(current_abi, const facet*, |
| istreambuf_iterator<wchar_t>, istreambuf_iterator<wchar_t>, |
| bool, ios_base&, ios_base::iostate&, |
| long double*, __any_string*); |
| #endif |
| |
| template<typename C> |
| ostreambuf_iterator<C> |
| __money_put(current_abi, const facet* f, ostreambuf_iterator<C> s, |
| bool intl, ios_base& io, C fill, long double units, |
| const __any_string* digits) |
| { |
| auto* m = static_cast<const money_put<C>*>(f); |
| if (digits) |
| return m->put(s, intl, io, fill, *digits); |
| else |
| return m->put(s, intl, io, fill, units); |
| } |
| |
| #pragma GCC diagnostic pop |
| |
| template ostreambuf_iterator<char> |
| __money_put(current_abi, const facet*, ostreambuf_iterator<char>, |
| bool, ios_base&, char, long double, const __any_string*); |
| |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| template ostreambuf_iterator<wchar_t> |
| __money_put(current_abi, const facet*, ostreambuf_iterator<wchar_t>, |
| bool, ios_base&, wchar_t, long double, const __any_string*); |
| #endif |
| |
| } // namespace __facet_shims |
| |
| // Create a new shim facet of type WHICH that forwards calls to F. |
| // F is the replacement facet provided by the user, WHICH is the ID of |
| // F's "other ABI twin" which we are replacing with a shim. |
| const locale::facet* |
| #if _GLIBCXX_USE_CXX11_ABI |
| locale::facet::_M_sso_shim(const locale::id* which) const |
| #else |
| locale::facet::_M_cow_shim(const locale::id* which) const |
| #endif |
| { |
| using namespace __facet_shims; |
| |
| #if __cpp_rtti |
| // If this is already a shim just use its underlying facet. |
| if (auto* p = dynamic_cast<const __shim*>(this)) |
| return p->_M_get(); |
| #endif |
| |
| if (which == &numpunct<char>::id) |
| return new numpunct_shim<char>{this}; |
| if (which == &std::collate<char>::id) |
| return new collate_shim<char>{this}; |
| if (which == &time_get<char>::id) |
| return new time_get_shim<char>{this}; |
| if (which == &money_get<char>::id) |
| return new money_get_shim<char>{this}; |
| if (which == &money_put<char>::id) |
| return new money_put_shim<char>{this}; |
| if (which == &moneypunct<char, true>::id) |
| return new moneypunct_shim<char, true>{this}; |
| if (which == &moneypunct<char, false>::id) |
| return new moneypunct_shim<char, false>{this}; |
| if (which == &std::messages<char>::id) |
| return new messages_shim<char>{this}; |
| #ifdef _GLIBCXX_USE_WCHAR_T |
| if (which == &numpunct<wchar_t>::id) |
| return new numpunct_shim<wchar_t>{this}; |
| if (which == &std::collate<wchar_t>::id) |
| return new collate_shim<wchar_t>{this}; |
| if (which == &time_get<wchar_t>::id) |
| return new time_get_shim<wchar_t>{this}; |
| if (which == &money_get<wchar_t>::id) |
| return new money_get_shim<wchar_t>{this}; |
| if (which == &money_put<wchar_t>::id) |
| return new money_put_shim<wchar_t>{this}; |
| if (which == &moneypunct<wchar_t, true>::id) |
| return new moneypunct_shim<wchar_t, true>{this}; |
| if (which == &moneypunct<wchar_t, false>::id) |
| return new moneypunct_shim<wchar_t, false>{this}; |
| if (which == &std::messages<wchar_t>::id) |
| return new messages_shim<wchar_t>{this}; |
| #endif |
| __throw_logic_error("cannot create shim for unknown locale::facet"); |
| } |
| |
| _GLIBCXX_END_NAMESPACE_VERSION |
| } // namespace std |
