libcxx/src/string.cpp

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