1 //===-----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef _LIBCPP___LOCALE_DIR_SUPPORT_WINDOWS_H 10 #define _LIBCPP___LOCALE_DIR_SUPPORT_WINDOWS_H 11 12 #include <__config> 13 #include <__cstddef/nullptr_t.h> 14 #include <__utility/forward.h> 15 #include <clocale> // std::lconv & friends 16 #include <cstddef> 17 #include <ctype.h> // ::_isupper_l & friends 18 #include <locale.h> // ::_locale_t 19 #include <stdio.h> // ::_sscanf_l 20 #include <stdlib.h> // ::_strtod_l & friends 21 #include <string.h> // ::_strcoll_l 22 #include <string> 23 #include <time.h> // ::_strftime_l 24 25 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 26 # pragma GCC system_header 27 #endif 28 29 _LIBCPP_BEGIN_NAMESPACE_STD 30 namespace __locale { 31 32 using __lconv_t = std::lconv; 33 34 class __lconv_storage { 35 public: 36 __lconv_storage(const __lconv_t* __lc_input) { 37 __lc_ = *__lc_input; 38 39 __decimal_point_ = __lc_input->decimal_point; 40 __thousands_sep_ = __lc_input->thousands_sep; 41 __grouping_ = __lc_input->grouping; 42 __int_curr_symbol_ = __lc_input->int_curr_symbol; 43 __currency_symbol_ = __lc_input->currency_symbol; 44 __mon_decimal_point_ = __lc_input->mon_decimal_point; 45 __mon_thousands_sep_ = __lc_input->mon_thousands_sep; 46 __mon_grouping_ = __lc_input->mon_grouping; 47 __positive_sign_ = __lc_input->positive_sign; 48 __negative_sign_ = __lc_input->negative_sign; 49 50 __lc_.decimal_point = const_cast<char*>(__decimal_point_.c_str()); 51 __lc_.thousands_sep = const_cast<char*>(__thousands_sep_.c_str()); 52 __lc_.grouping = const_cast<char*>(__grouping_.c_str()); 53 __lc_.int_curr_symbol = const_cast<char*>(__int_curr_symbol_.c_str()); 54 __lc_.currency_symbol = const_cast<char*>(__currency_symbol_.c_str()); 55 __lc_.mon_decimal_point = const_cast<char*>(__mon_decimal_point_.c_str()); 56 __lc_.mon_thousands_sep = const_cast<char*>(__mon_thousands_sep_.c_str()); 57 __lc_.mon_grouping = const_cast<char*>(__mon_grouping_.c_str()); 58 __lc_.positive_sign = const_cast<char*>(__positive_sign_.c_str()); 59 __lc_.negative_sign = const_cast<char*>(__negative_sign_.c_str()); 60 } 61 62 __lconv_t* __get() { return &__lc_; } 63 64 private: 65 __lconv_t __lc_; 66 std::string __decimal_point_; 67 std::string __thousands_sep_; 68 std::string __grouping_; 69 std::string __int_curr_symbol_; 70 std::string __currency_symbol_; 71 std::string __mon_decimal_point_; 72 std::string __mon_thousands_sep_; 73 std::string __mon_grouping_; 74 std::string __positive_sign_; 75 std::string __negative_sign_; 76 }; 77 78 // 79 // Locale management 80 // 81 #define _CATMASK(n) ((1 << (n)) >> 1) 82 #define _LIBCPP_COLLATE_MASK _CATMASK(LC_COLLATE) 83 #define _LIBCPP_CTYPE_MASK _CATMASK(LC_CTYPE) 84 #define _LIBCPP_MONETARY_MASK _CATMASK(LC_MONETARY) 85 #define _LIBCPP_NUMERIC_MASK _CATMASK(LC_NUMERIC) 86 #define _LIBCPP_TIME_MASK _CATMASK(LC_TIME) 87 #define _LIBCPP_MESSAGES_MASK _CATMASK(6) 88 #define _LIBCPP_ALL_MASK \ 89 (_LIBCPP_COLLATE_MASK | _LIBCPP_CTYPE_MASK | _LIBCPP_MESSAGES_MASK | _LIBCPP_MONETARY_MASK | _LIBCPP_NUMERIC_MASK | \ 90 _LIBCPP_TIME_MASK) 91 #define _LIBCPP_LC_ALL LC_ALL 92 93 class __locale_t { 94 public: 95 __locale_t() : __locale_(nullptr), __locale_str_(nullptr), __lc_(nullptr) {} 96 __locale_t(std::nullptr_t) : __locale_(nullptr), __locale_str_(nullptr), __lc_(nullptr) {} 97 __locale_t(::_locale_t __loc, const char* __loc_str) : __locale_(__loc), __locale_str_(__loc_str), __lc_(nullptr) {} 98 __locale_t(const __locale_t& __loc) 99 : __locale_(__loc.__locale_), __locale_str_(__loc.__locale_str_), __lc_(nullptr) {} 100 101 ~__locale_t() { delete __lc_; } 102 103 __locale_t& operator=(const __locale_t& __loc) { 104 __locale_ = __loc.__locale_; 105 __locale_str_ = __loc.__locale_str_; 106 // __lc_ not copied 107 return *this; 108 } 109 110 friend bool operator==(const __locale_t& __left, const __locale_t& __right) { 111 return __left.__locale_ == __right.__locale_; 112 } 113 114 friend bool operator==(const __locale_t& __left, int __right) { return __left.__locale_ == nullptr && __right == 0; } 115 116 friend bool operator==(const __locale_t& __left, long long __right) { 117 return __left.__locale_ == nullptr && __right == 0; 118 } 119 120 friend bool operator==(const __locale_t& __left, std::nullptr_t) { return __left.__locale_ == nullptr; } 121 122 friend bool operator==(int __left, const __locale_t& __right) { return __left == 0 && nullptr == __right.__locale_; } 123 124 friend bool operator==(std::nullptr_t, const __locale_t& __right) { return nullptr == __right.__locale_; } 125 126 friend bool operator!=(const __locale_t& __left, const __locale_t& __right) { return !(__left == __right); } 127 128 friend bool operator!=(const __locale_t& __left, int __right) { return !(__left == __right); } 129 130 friend bool operator!=(const __locale_t& __left, long long __right) { return !(__left == __right); } 131 132 friend bool operator!=(const __locale_t& __left, std::nullptr_t __right) { return !(__left == __right); } 133 134 friend bool operator!=(int __left, const __locale_t& __right) { return !(__left == __right); } 135 136 friend bool operator!=(std::nullptr_t __left, const __locale_t& __right) { return !(__left == __right); } 137 138 operator bool() const { return __locale_ != nullptr; } 139 140 const char* __get_locale() const { return __locale_str_; } 141 142 operator ::_locale_t() const { return __locale_; } 143 144 __lconv_t* __store_lconv(const __lconv_t* __input_lc) { 145 delete __lc_; 146 __lc_ = new __lconv_storage(__input_lc); 147 return __lc_->__get(); 148 } 149 150 private: 151 ::_locale_t __locale_; 152 const char* __locale_str_; 153 __lconv_storage* __lc_ = nullptr; 154 }; 155 156 _LIBCPP_EXPORTED_FROM_ABI __locale_t __newlocale(int __mask, const char* __locale, __locale_t __base); 157 inline _LIBCPP_HIDE_FROM_ABI void __freelocale(__locale_t __loc) { ::_free_locale(__loc); } 158 inline _LIBCPP_HIDE_FROM_ABI char* __setlocale(int __category, const char* __locale) { 159 char* __new_locale = ::setlocale(__category, __locale); 160 if (__new_locale == nullptr) 161 std::__throw_bad_alloc(); 162 return __new_locale; 163 } 164 _LIBCPP_EXPORTED_FROM_ABI __lconv_t* __localeconv(__locale_t& __loc); 165 166 // 167 // Strtonum functions 168 // 169 170 // the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+ 171 #if defined(_LIBCPP_MSVCRT) 172 inline _LIBCPP_HIDE_FROM_ABI float __strtof(const char* __nptr, char** __endptr, __locale_t __loc) { 173 return ::_strtof_l(__nptr, __endptr, __loc); 174 } 175 inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __endptr, __locale_t __loc) { 176 return ::_strtold_l(__nptr, __endptr, __loc); 177 } 178 #else 179 _LIBCPP_EXPORTED_FROM_ABI float __strtof(const char*, char**, __locale_t); 180 _LIBCPP_EXPORTED_FROM_ABI long double __strtold(const char*, char**, __locale_t); 181 #endif 182 183 inline _LIBCPP_HIDE_FROM_ABI double __strtod(const char* __nptr, char** __endptr, __locale_t __loc) { 184 return ::_strtod_l(__nptr, __endptr, __loc); 185 } 186 187 inline _LIBCPP_HIDE_FROM_ABI long long __strtoll(const char* __nptr, char** __endptr, int __base, __locale_t __loc) { 188 return ::_strtoi64_l(__nptr, __endptr, __base, __loc); 189 } 190 inline _LIBCPP_HIDE_FROM_ABI unsigned long long 191 __strtoull(const char* __nptr, char** __endptr, int __base, __locale_t __loc) { 192 return ::_strtoui64_l(__nptr, __endptr, __base, __loc); 193 } 194 195 // 196 // Character manipulation functions 197 // 198 inline _LIBCPP_HIDE_FROM_ABI int __islower(int __c, __locale_t __loc) { return _islower_l(__c, __loc); } 199 200 inline _LIBCPP_HIDE_FROM_ABI int __isupper(int __c, __locale_t __loc) { return _isupper_l(__c, __loc); } 201 202 inline _LIBCPP_HIDE_FROM_ABI int __isdigit(int __c, __locale_t __loc) { return _isdigit_l(__c, __loc); } 203 204 inline _LIBCPP_HIDE_FROM_ABI int __isxdigit(int __c, __locale_t __loc) { return _isxdigit_l(__c, __loc); } 205 206 inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return ::_toupper_l(__c, __loc); } 207 208 inline _LIBCPP_HIDE_FROM_ABI int __tolower(int __c, __locale_t __loc) { return ::_tolower_l(__c, __loc); } 209 210 inline _LIBCPP_HIDE_FROM_ABI int __strcoll(const char* __s1, const char* __s2, __locale_t __loc) { 211 return ::_strcoll_l(__s1, __s2, __loc); 212 } 213 214 inline _LIBCPP_HIDE_FROM_ABI size_t __strxfrm(char* __dest, const char* __src, size_t __n, __locale_t __loc) { 215 return ::_strxfrm_l(__dest, __src, __n, __loc); 216 } 217 218 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 219 inline _LIBCPP_HIDE_FROM_ABI int __iswctype(wint_t __c, wctype_t __type, __locale_t __loc) { 220 return ::_iswctype_l(__c, __type, __loc); 221 } 222 inline _LIBCPP_HIDE_FROM_ABI int __iswspace(wint_t __c, __locale_t __loc) { return ::_iswspace_l(__c, __loc); } 223 inline _LIBCPP_HIDE_FROM_ABI int __iswprint(wint_t __c, __locale_t __loc) { return ::_iswprint_l(__c, __loc); } 224 inline _LIBCPP_HIDE_FROM_ABI int __iswcntrl(wint_t __c, __locale_t __loc) { return ::_iswcntrl_l(__c, __loc); } 225 inline _LIBCPP_HIDE_FROM_ABI int __iswupper(wint_t __c, __locale_t __loc) { return ::_iswupper_l(__c, __loc); } 226 inline _LIBCPP_HIDE_FROM_ABI int __iswlower(wint_t __c, __locale_t __loc) { return ::_iswlower_l(__c, __loc); } 227 inline _LIBCPP_HIDE_FROM_ABI int __iswalpha(wint_t __c, __locale_t __loc) { return ::_iswalpha_l(__c, __loc); } 228 // TODO: use locale to determine blank characters 229 inline _LIBCPP_HIDE_FROM_ABI int __iswblank(wint_t __c, __locale_t /*loc*/) { return (__c == L' ' || __c == L'\t'); } 230 inline _LIBCPP_HIDE_FROM_ABI int __iswdigit(wint_t __c, __locale_t __loc) { return ::_iswdigit_l(__c, __loc); } 231 inline _LIBCPP_HIDE_FROM_ABI int __iswpunct(wint_t __c, __locale_t __loc) { return ::_iswpunct_l(__c, __loc); } 232 inline _LIBCPP_HIDE_FROM_ABI int __iswxdigit(wint_t __c, __locale_t __loc) { return ::_iswxdigit_l(__c, __loc); } 233 inline _LIBCPP_HIDE_FROM_ABI wint_t __towupper(wint_t __c, __locale_t __loc) { return ::_towupper_l(__c, __loc); } 234 inline _LIBCPP_HIDE_FROM_ABI wint_t __towlower(wint_t __c, __locale_t __loc) { return ::_towlower_l(__c, __loc); } 235 236 inline _LIBCPP_HIDE_FROM_ABI int __wcscoll(const wchar_t* __ws1, const wchar_t* __ws2, __locale_t __loc) { 237 return ::_wcscoll_l(__ws1, __ws2, __loc); 238 } 239 240 inline _LIBCPP_HIDE_FROM_ABI size_t __wcsxfrm(wchar_t* __dest, const wchar_t* __src, size_t __n, __locale_t __loc) { 241 return ::_wcsxfrm_l(__dest, __src, __n, __loc); 242 } 243 #endif // !_LIBCPP_HAS_NO_WIDE_CHARACTERS 244 245 #if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800 246 _LIBCPP_EXPORTED_FROM_ABI size_t __strftime(char*, size_t, const char*, const struct tm*, __locale_t); 247 #else 248 inline _LIBCPP_HIDE_FROM_ABI size_t 249 __strftime(char* __ret, size_t __n, const char* __format, const struct tm* __tm, __locale_t __loc) { 250 return ::_strftime_l(__ret, __n, __format, __tm, __loc); 251 } 252 #endif 253 254 // 255 // Other functions 256 // 257 _LIBCPP_EXPORTED_FROM_ABI decltype(MB_CUR_MAX) __mb_len_max(__locale_t); 258 _LIBCPP_EXPORTED_FROM_ABI wint_t __btowc(int, __locale_t); 259 _LIBCPP_EXPORTED_FROM_ABI int __wctob(wint_t, __locale_t); 260 _LIBCPP_EXPORTED_FROM_ABI size_t 261 __wcsnrtombs(char* __restrict, const wchar_t** __restrict, size_t, size_t, mbstate_t* __restrict, __locale_t); 262 _LIBCPP_EXPORTED_FROM_ABI size_t __wcrtomb(char* __restrict, wchar_t, mbstate_t* __restrict, __locale_t); 263 _LIBCPP_EXPORTED_FROM_ABI size_t 264 __mbsnrtowcs(wchar_t* __restrict, const char** __restrict, size_t, size_t, mbstate_t* __restrict, __locale_t); 265 _LIBCPP_EXPORTED_FROM_ABI size_t 266 __mbrtowc(wchar_t* __restrict, const char* __restrict, size_t, mbstate_t* __restrict, __locale_t); 267 268 inline _LIBCPP_HIDE_FROM_ABI int __mbtowc(wchar_t* __pwc, const char* __pmb, size_t __max, __locale_t __loc) { 269 return ::_mbtowc_l(__pwc, __pmb, __max, __loc); 270 } 271 272 _LIBCPP_EXPORTED_FROM_ABI size_t __mbrlen(const char* __restrict, size_t, mbstate_t* __restrict, __locale_t); 273 274 _LIBCPP_EXPORTED_FROM_ABI size_t 275 __mbsrtowcs(wchar_t* __restrict, const char** __restrict, size_t, mbstate_t* __restrict, __locale_t); 276 277 _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 4, 5) int __snprintf( 278 char* __ret, size_t __n, __locale_t __loc, const char* __format, ...); 279 280 _LIBCPP_EXPORTED_FROM_ABI 281 _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __asprintf(char** __ret, __locale_t __loc, const char* __format, ...); 282 283 _LIBCPP_DIAGNOSTIC_PUSH 284 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wgcc-compat") 285 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral") // GCC doesn't support [[gnu::format]] on variadic templates 286 #ifdef _LIBCPP_COMPILER_CLANG_BASED 287 # define _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(...) _LIBCPP_ATTRIBUTE_FORMAT(__VA_ARGS__) 288 #else 289 # define _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(...) /* nothing */ 290 #endif 291 292 template <class... _Args> 293 _LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __sscanf( 294 const char* __dest, __locale_t __loc, const char* __format, _Args&&... __args) { 295 return ::_sscanf_l(__dest, __format, __loc, std::forward<_Args>(__args)...); 296 } 297 _LIBCPP_DIAGNOSTIC_POP 298 #undef _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT 299 300 struct __locale_guard { 301 _LIBCPP_HIDE_FROM_ABI __locale_guard(__locale_t __l) : __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) { 302 // Setting the locale can be expensive even when the locale given is 303 // already the current locale, so do an explicit check to see if the 304 // current locale is already the one we want. 305 const char* __lc = __locale::__setlocale(LC_ALL, nullptr); 306 // If every category is the same, the locale string will simply be the 307 // locale name, otherwise it will be a semicolon-separated string listing 308 // each category. In the second case, we know at least one category won't 309 // be what we want, so we only have to check the first case. 310 if (std::strcmp(__l.__get_locale(), __lc) != 0) { 311 __locale_all = _strdup(__lc); 312 if (__locale_all == nullptr) 313 __throw_bad_alloc(); 314 __locale::__setlocale(LC_ALL, __l.__get_locale()); 315 } 316 } 317 _LIBCPP_HIDE_FROM_ABI ~__locale_guard() { 318 // The CRT documentation doesn't explicitly say, but setlocale() does the 319 // right thing when given a semicolon-separated list of locale settings 320 // for the different categories in the same format as returned by 321 // setlocale(LC_ALL, nullptr). 322 if (__locale_all != nullptr) { 323 __locale::__setlocale(LC_ALL, __locale_all); 324 free(__locale_all); 325 } 326 _configthreadlocale(__status); 327 } 328 int __status; 329 char* __locale_all = nullptr; 330 }; 331 332 } // namespace __locale 333 _LIBCPP_END_NAMESPACE_STD 334 335 #endif // _LIBCPP___LOCALE_DIR_SUPPORT_WINDOWS_H 336