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 #include <__assert>
10 #include <cerrno>
11 #include <charconv>
12 #include <cstdlib>
13 #include <limits>
14 #include <stdexcept>
15 #include <string>
16
17 #if _LIBCPP_HAS_WIDE_CHARACTERS
18 # include <cwchar>
19 #endif
20
21 _LIBCPP_BEGIN_NAMESPACE_STD
22
23 #ifndef _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
24
25 template <bool>
26 struct __basic_string_common;
27
28 // The struct isn't declared anymore in the headers. It's only here for ABI compatibility.
29 template <>
30 struct __basic_string_common<true> {
31 [[noreturn]] _LIBCPP_EXPORTED_FROM_ABI void __throw_length_error() const;
32 [[noreturn]] _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const;
33 };
34
__throw_length_error() const35 void __basic_string_common<true>::__throw_length_error() const { std::__throw_length_error("basic_string"); }
__throw_out_of_range() const36 void __basic_string_common<true>::__throw_out_of_range() const { std::__throw_out_of_range("basic_string"); }
37
38 #endif // _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
39
40 // Define legacy ABI functions
41 // ---------------------------
42
43 #ifndef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
44
45 template <class _CharT, class _Traits, class _Allocator>
__init(const value_type * __s,size_type __sz,size_type __reserve)46 void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz, size_type __reserve) {
47 if (__libcpp_is_constant_evaluated())
48 __rep_ = __rep();
49 if (__reserve > max_size())
50 __throw_length_error();
51 pointer __p;
52 if (__fits_in_sso(__reserve)) {
53 __set_short_size(__sz);
54 __p = __get_short_pointer();
55 } else {
56 auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__reserve) + 1);
57 __p = __allocation.ptr;
58 __begin_lifetime(__p, __allocation.count);
59 __set_long_pointer(__p);
60 __set_long_cap(__allocation.count);
61 __set_long_size(__sz);
62 }
63 traits_type::copy(std::__to_address(__p), __s, __sz);
64 traits_type::assign(__p[__sz], value_type());
65 __annotate_new(__sz);
66 }
67
68 # define STRING_LEGACY_API(CharT) \
69 template _LIBCPP_EXPORTED_FROM_ABI void basic_string<CharT>::__init(const value_type*, size_type, size_type)
70
71 STRING_LEGACY_API(char);
72 # if _LIBCPP_HAS_WIDE_CHARACTERS
73 STRING_LEGACY_API(wchar_t);
74 # endif
75
76 #endif // _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
77
78 #define _LIBCPP_EXTERN_TEMPLATE_DEFINE(...) template _LIBCPP_EXPORTED_FROM_ABI __VA_ARGS__;
79 #ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
80 _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
81 # if _LIBCPP_HAS_WIDE_CHARACTERS
82 _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
83 # endif
84 #else
85 _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
86 # if _LIBCPP_HAS_WIDE_CHARACTERS
87 _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
88 # endif
89 #endif
90 #undef _LIBCPP_EXTERN_TEMPLATE_DEFINE
91
92 template string operator+ <char, char_traits<char>, allocator<char>>(char const*, string const&);
93
94 namespace {
95
throw_from_string_out_of_range(const string & func)96 inline void throw_from_string_out_of_range(const string& func) {
97 std::__throw_out_of_range((func + ": out of range").c_str());
98 }
99
throw_from_string_invalid_arg(const string & func)100 inline void throw_from_string_invalid_arg(const string& func) {
101 std::__throw_invalid_argument((func + ": no conversion").c_str());
102 }
103
104 // as_integer
105
106 template <typename V, typename S, typename F>
as_integer_helper(const string & func,const S & str,size_t * idx,int base,F f)107 inline V as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f) {
108 typename S::value_type* ptr = nullptr;
109 const typename S::value_type* const p = str.c_str();
110 __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
111 errno = 0;
112 V r = f(p, &ptr, base);
113 swap(errno, errno_save);
114 if (errno_save == ERANGE)
115 throw_from_string_out_of_range(func);
116 if (ptr == p)
117 throw_from_string_invalid_arg(func);
118 if (idx)
119 *idx = static_cast<size_t>(ptr - p);
120 return r;
121 }
122
123 template <typename V, typename S>
124 inline V as_integer(const string& func, const S& s, size_t* idx, int base);
125
126 // string
127 template <>
as_integer(const string & func,const string & s,size_t * idx,int base)128 inline int as_integer(const string& func, const string& s, size_t* idx, int base) {
129 // Use long as no Standard string to integer exists.
130 long r = as_integer_helper<long>(func, s, idx, base, strtol);
131 if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
132 throw_from_string_out_of_range(func);
133 return static_cast<int>(r);
134 }
135
136 template <>
as_integer(const string & func,const string & s,size_t * idx,int base)137 inline long as_integer(const string& func, const string& s, size_t* idx, int base) {
138 return as_integer_helper<long>(func, s, idx, base, strtol);
139 }
140
141 template <>
as_integer(const string & func,const string & s,size_t * idx,int base)142 inline unsigned long as_integer(const string& func, const string& s, size_t* idx, int base) {
143 return as_integer_helper<unsigned long>(func, s, idx, base, strtoul);
144 }
145
146 template <>
as_integer(const string & func,const string & s,size_t * idx,int base)147 inline long long as_integer(const string& func, const string& s, size_t* idx, int base) {
148 return as_integer_helper<long long>(func, s, idx, base, strtoll);
149 }
150
151 template <>
as_integer(const string & func,const string & s,size_t * idx,int base)152 inline unsigned long long as_integer(const string& func, const string& s, size_t* idx, int base) {
153 return as_integer_helper<unsigned long long>(func, s, idx, base, strtoull);
154 }
155
156 #if _LIBCPP_HAS_WIDE_CHARACTERS
157 // wstring
158 template <>
as_integer(const string & func,const wstring & s,size_t * idx,int base)159 inline int as_integer(const string& func, const wstring& s, size_t* idx, int base) {
160 // Use long as no Stantard string to integer exists.
161 long r = as_integer_helper<long>(func, s, idx, base, wcstol);
162 if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
163 throw_from_string_out_of_range(func);
164 return static_cast<int>(r);
165 }
166
167 template <>
as_integer(const string & func,const wstring & s,size_t * idx,int base)168 inline long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
169 return as_integer_helper<long>(func, s, idx, base, wcstol);
170 }
171
172 template <>
as_integer(const string & func,const wstring & s,size_t * idx,int base)173 inline unsigned long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
174 return as_integer_helper<unsigned long>(func, s, idx, base, wcstoul);
175 }
176
177 template <>
as_integer(const string & func,const wstring & s,size_t * idx,int base)178 inline long long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
179 return as_integer_helper<long long>(func, s, idx, base, wcstoll);
180 }
181
182 template <>
as_integer(const string & func,const wstring & s,size_t * idx,int base)183 inline unsigned long long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
184 return as_integer_helper<unsigned long long>(func, s, idx, base, wcstoull);
185 }
186 #endif // _LIBCPP_HAS_WIDE_CHARACTERS
187
188 // as_float
189
190 template <typename V, typename S, typename F>
as_float_helper(const string & func,const S & str,size_t * idx,F f)191 inline V as_float_helper(const string& func, const S& str, size_t* idx, F f) {
192 typename S::value_type* ptr = nullptr;
193 const typename S::value_type* const p = str.c_str();
194 __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
195 errno = 0;
196 V r = f(p, &ptr);
197 swap(errno, errno_save);
198 if (errno_save == ERANGE)
199 throw_from_string_out_of_range(func);
200 if (ptr == p)
201 throw_from_string_invalid_arg(func);
202 if (idx)
203 *idx = static_cast<size_t>(ptr - p);
204 return r;
205 }
206
207 template <typename V, typename S>
208 inline V as_float(const string& func, const S& s, size_t* idx = nullptr);
209
210 template <>
as_float(const string & func,const string & s,size_t * idx)211 inline float as_float(const string& func, const string& s, size_t* idx) {
212 return as_float_helper<float>(func, s, idx, strtof);
213 }
214
215 template <>
as_float(const string & func,const string & s,size_t * idx)216 inline double as_float(const string& func, const string& s, size_t* idx) {
217 return as_float_helper<double>(func, s, idx, strtod);
218 }
219
220 template <>
as_float(const string & func,const string & s,size_t * idx)221 inline long double as_float(const string& func, const string& s, size_t* idx) {
222 return as_float_helper<long double>(func, s, idx, strtold);
223 }
224
225 #if _LIBCPP_HAS_WIDE_CHARACTERS
226 template <>
as_float(const string & func,const wstring & s,size_t * idx)227 inline float as_float(const string& func, const wstring& s, size_t* idx) {
228 return as_float_helper<float>(func, s, idx, wcstof);
229 }
230
231 template <>
as_float(const string & func,const wstring & s,size_t * idx)232 inline double as_float(const string& func, const wstring& s, size_t* idx) {
233 return as_float_helper<double>(func, s, idx, wcstod);
234 }
235
236 template <>
as_float(const string & func,const wstring & s,size_t * idx)237 inline long double as_float(const string& func, const wstring& s, size_t* idx) {
238 return as_float_helper<long double>(func, s, idx, wcstold);
239 }
240 #endif // _LIBCPP_HAS_WIDE_CHARACTERS
241
242 } // unnamed namespace
243
stoi(const string & str,size_t * idx,int base)244 int stoi(const string& str, size_t* idx, int base) { return as_integer<int>("stoi", str, idx, base); }
245
stol(const string & str,size_t * idx,int base)246 long stol(const string& str, size_t* idx, int base) { return as_integer<long>("stol", str, idx, base); }
247
stoul(const string & str,size_t * idx,int base)248 unsigned long stoul(const string& str, size_t* idx, int base) {
249 return as_integer<unsigned long>("stoul", str, idx, base);
250 }
251
stoll(const string & str,size_t * idx,int base)252 long long stoll(const string& str, size_t* idx, int base) { return as_integer<long long>("stoll", str, idx, base); }
253
stoull(const string & str,size_t * idx,int base)254 unsigned long long stoull(const string& str, size_t* idx, int base) {
255 return as_integer<unsigned long long>("stoull", str, idx, base);
256 }
257
stof(const string & str,size_t * idx)258 float stof(const string& str, size_t* idx) { return as_float<float>("stof", str, idx); }
259
stod(const string & str,size_t * idx)260 double stod(const string& str, size_t* idx) { return as_float<double>("stod", str, idx); }
261
stold(const string & str,size_t * idx)262 long double stold(const string& str, size_t* idx) { return as_float<long double>("stold", str, idx); }
263
264 #if _LIBCPP_HAS_WIDE_CHARACTERS
stoi(const wstring & str,size_t * idx,int base)265 int stoi(const wstring& str, size_t* idx, int base) { return as_integer<int>("stoi", str, idx, base); }
266
stol(const wstring & str,size_t * idx,int base)267 long stol(const wstring& str, size_t* idx, int base) { return as_integer<long>("stol", str, idx, base); }
268
stoul(const wstring & str,size_t * idx,int base)269 unsigned long stoul(const wstring& str, size_t* idx, int base) {
270 return as_integer<unsigned long>("stoul", str, idx, base);
271 }
272
stoll(const wstring & str,size_t * idx,int base)273 long long stoll(const wstring& str, size_t* idx, int base) { return as_integer<long long>("stoll", str, idx, base); }
274
stoull(const wstring & str,size_t * idx,int base)275 unsigned long long stoull(const wstring& str, size_t* idx, int base) {
276 return as_integer<unsigned long long>("stoull", str, idx, base);
277 }
278
stof(const wstring & str,size_t * idx)279 float stof(const wstring& str, size_t* idx) { return as_float<float>("stof", str, idx); }
280
stod(const wstring & str,size_t * idx)281 double stod(const wstring& str, size_t* idx) { return as_float<double>("stod", str, idx); }
282
stold(const wstring & str,size_t * idx)283 long double stold(const wstring& str, size_t* idx) { return as_float<long double>("stold", str, idx); }
284 #endif // _LIBCPP_HAS_WIDE_CHARACTERS
285
286 // to_string
287
288 namespace {
289
290 // as_string
291
292 template <typename S, typename P, typename V >
as_string(P sprintf_like,S s,const typename S::value_type * fmt,V a)293 inline S as_string(P sprintf_like, S s, const typename S::value_type* fmt, V a) {
294 typedef typename S::size_type size_type;
295 size_type available = s.size();
296 while (true) {
297 int status = sprintf_like(&s[0], available + 1, fmt, a);
298 if (status >= 0) {
299 size_type used = static_cast<size_type>(status);
300 if (used <= available) {
301 s.resize(used);
302 break;
303 }
304 available = used; // Assume this is advice of how much space we need.
305 } else
306 available = available * 2 + 1;
307 s.resize(available);
308 }
309 return s;
310 }
311
312 template <class S>
313 struct initial_string;
314
315 template <>
316 struct initial_string<string> {
operator ()__anon616fab270211::initial_string317 string operator()() const {
318 string s;
319 s.resize(s.capacity());
320 return s;
321 }
322 };
323
324 #if _LIBCPP_HAS_WIDE_CHARACTERS
325 template <>
326 struct initial_string<wstring> {
operator ()__anon616fab270211::initial_string327 wstring operator()() const {
328 wstring s(20, wchar_t());
329 s.resize(s.capacity());
330 return s;
331 }
332 };
333
334 typedef int (*wide_printf)(wchar_t* __restrict, size_t, const wchar_t* __restrict, ...);
335
get_swprintf()336 inline wide_printf get_swprintf() {
337 # ifndef _LIBCPP_MSVCRT
338 return swprintf;
339 # else
340 return static_cast<int(__cdecl*)(wchar_t* __restrict, size_t, const wchar_t* __restrict, ...)>(_snwprintf);
341 # endif
342 }
343 #endif // _LIBCPP_HAS_WIDE_CHARACTERS
344
345 template <typename S, typename V>
i_to_string(V v)346 S i_to_string(V v) {
347 // numeric_limits::digits10 returns value less on 1 than desired for unsigned numbers.
348 // For example, for 1-byte unsigned value digits10 is 2 (999 can not be represented),
349 // so we need +1 here.
350 constexpr size_t bufsize = numeric_limits<V>::digits10 + 2; // +1 for minus, +1 for digits10
351 char buf[bufsize];
352 const auto res = to_chars(buf, buf + bufsize, v);
353 _LIBCPP_ASSERT_INTERNAL(res.ec == errc(), "bufsize must be large enough to accomodate the value");
354 return S(buf, res.ptr);
355 }
356
357 } // unnamed namespace
358
to_string(int val)359 string to_string(int val) { return i_to_string< string>(val); }
to_string(long val)360 string to_string(long val) { return i_to_string< string>(val); }
to_string(long long val)361 string to_string(long long val) { return i_to_string< string>(val); }
to_string(unsigned val)362 string to_string(unsigned val) { return i_to_string< string>(val); }
to_string(unsigned long val)363 string to_string(unsigned long val) { return i_to_string< string>(val); }
to_string(unsigned long long val)364 string to_string(unsigned long long val) { return i_to_string< string>(val); }
365
366 #if _LIBCPP_HAS_WIDE_CHARACTERS
to_wstring(int val)367 wstring to_wstring(int val) { return i_to_string<wstring>(val); }
to_wstring(long val)368 wstring to_wstring(long val) { return i_to_string<wstring>(val); }
to_wstring(long long val)369 wstring to_wstring(long long val) { return i_to_string<wstring>(val); }
to_wstring(unsigned val)370 wstring to_wstring(unsigned val) { return i_to_string<wstring>(val); }
to_wstring(unsigned long val)371 wstring to_wstring(unsigned long val) { return i_to_string<wstring>(val); }
to_wstring(unsigned long long val)372 wstring to_wstring(unsigned long long val) { return i_to_string<wstring>(val); }
373 #endif
374
to_string(float val)375 string to_string(float val) { return as_string(snprintf, initial_string< string>()(), "%f", val); }
to_string(double val)376 string to_string(double val) { return as_string(snprintf, initial_string< string>()(), "%f", val); }
to_string(long double val)377 string to_string(long double val) { return as_string(snprintf, initial_string< string>()(), "%Lf", val); }
378
379 #if _LIBCPP_HAS_WIDE_CHARACTERS
to_wstring(float val)380 wstring to_wstring(float val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%f", val); }
to_wstring(double val)381 wstring to_wstring(double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%f", val); }
to_wstring(long double val)382 wstring to_wstring(long double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%Lf", val); }
383 #endif
384
385 _LIBCPP_END_NAMESPACE_STD
386