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