← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to system/lib/libcxx/string.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/lib/libcxx/string.cpp
 
1
//===------------------------- string.cpp ---------------------------------===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is dual licensed under the MIT and the University of Illinois Open
 
6
// Source Licenses. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
 
 
10
#include "string"
 
11
#include "cstdlib"
 
12
#include "cwchar"
 
13
#include "cerrno"
 
14
#ifdef _WIN32
 
15
#include "support/win32/support.h"
 
16
#endif // _WIN32
 
17
 
 
18
_LIBCPP_BEGIN_NAMESPACE_STD
 
19
 
 
20
template class __basic_string_common<true>;
 
21
 
 
22
template class basic_string<char>;
 
23
template class basic_string<wchar_t>;
 
24
 
 
25
template
 
26
    string
 
27
    operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);
 
28
 
 
29
int
 
30
stoi(const string& str, size_t* idx, int base)
 
31
{
 
32
    char* ptr;
 
33
    const char* const p = str.c_str();
 
34
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
35
    errno = 0;
 
36
    long r = strtol(p, &ptr, base);
 
37
    swap(errno, errno_save);
 
38
#ifndef _LIBCPP_NO_EXCEPTIONS
 
39
    if (errno_save == ERANGE || r < numeric_limits<int>::min() ||
 
40
                                numeric_limits<int>::max() < r)
 
41
        throw out_of_range("stoi: out of range");
 
42
    if (ptr == p)
 
43
        throw invalid_argument("stoi: no conversion");
 
44
#endif  // _LIBCPP_NO_EXCEPTIONS
 
45
    if (idx)
 
46
        *idx = static_cast<size_t>(ptr - p);
 
47
    return static_cast<int>(r);
 
48
}
 
49
 
 
50
int
 
51
stoi(const wstring& str, size_t* idx, int base)
 
52
{
 
53
    wchar_t* ptr;
 
54
    const wchar_t* const p = str.c_str();
 
55
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
56
    errno = 0;
 
57
    long r = wcstol(p, &ptr, base);
 
58
    swap(errno, errno_save);
 
59
#ifndef _LIBCPP_NO_EXCEPTIONS
 
60
    if (errno_save == ERANGE || r < numeric_limits<int>::min() ||
 
61
                                numeric_limits<int>::max() < r)
 
62
        throw out_of_range("stoi: out of range");
 
63
    if (ptr == p)
 
64
        throw invalid_argument("stoi: no conversion");
 
65
#endif  // _LIBCPP_NO_EXCEPTIONS
 
66
    if (idx)
 
67
        *idx = static_cast<size_t>(ptr - p);
 
68
    return static_cast<int>(r);
 
69
}
 
70
 
 
71
long
 
72
stol(const string& str, size_t* idx, int base)
 
73
{
 
74
    char* ptr;
 
75
    const char* const p = str.c_str();
 
76
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
77
    errno = 0;
 
78
    long r = strtol(p, &ptr, base);
 
79
    swap(errno, errno_save);
 
80
#ifndef _LIBCPP_NO_EXCEPTIONS
 
81
    if (errno_save == ERANGE)
 
82
        throw out_of_range("stol: out of range");
 
83
    if (ptr == p)
 
84
        throw invalid_argument("stol: no conversion");
 
85
#endif  // _LIBCPP_NO_EXCEPTIONS
 
86
    if (idx)
 
87
        *idx = static_cast<size_t>(ptr - p);
 
88
    return r;
 
89
}
 
90
 
 
91
long
 
92
stol(const wstring& str, size_t* idx, int base)
 
93
{
 
94
    wchar_t* ptr;
 
95
    const wchar_t* const p = str.c_str();
 
96
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
97
    errno = 0;
 
98
    long r = wcstol(p, &ptr, base);
 
99
    swap(errno, errno_save);
 
100
#ifndef _LIBCPP_NO_EXCEPTIONS
 
101
    if (errno_save == ERANGE)
 
102
        throw out_of_range("stol: out of range");
 
103
    if (ptr == p)
 
104
        throw invalid_argument("stol: no conversion");
 
105
#endif  // _LIBCPP_NO_EXCEPTIONS
 
106
    if (idx)
 
107
        *idx = static_cast<size_t>(ptr - p);
 
108
    return r;
 
109
}
 
110
 
 
111
unsigned long
 
112
stoul(const string& str, size_t* idx, int base)
 
113
{
 
114
    char* ptr;
 
115
    const char* const p = str.c_str();
 
116
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
117
    errno = 0;
 
118
    unsigned long r = strtoul(p, &ptr, base);
 
119
    swap(errno, errno_save);
 
120
#ifndef _LIBCPP_NO_EXCEPTIONS
 
121
    if (errno_save == ERANGE)
 
122
        throw out_of_range("stoul: out of range");
 
123
    if (ptr == p)
 
124
        throw invalid_argument("stoul: no conversion");
 
125
#endif  // _LIBCPP_NO_EXCEPTIONS
 
126
    if (idx)
 
127
        *idx = static_cast<size_t>(ptr - p);
 
128
    return r;
 
129
}
 
130
 
 
131
unsigned long
 
132
stoul(const wstring& str, size_t* idx, int base)
 
133
{
 
134
    wchar_t* ptr;
 
135
    const wchar_t* const p = str.c_str();
 
136
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
137
    errno = 0;
 
138
    unsigned long r = wcstoul(p, &ptr, base);
 
139
    swap(errno, errno_save);
 
140
#ifndef _LIBCPP_NO_EXCEPTIONS
 
141
    if (errno_save == ERANGE)
 
142
        throw out_of_range("stoul: out of range");
 
143
    if (ptr == p)
 
144
        throw invalid_argument("stoul: no conversion");
 
145
#endif  // _LIBCPP_NO_EXCEPTIONS
 
146
    if (idx)
 
147
        *idx = static_cast<size_t>(ptr - p);
 
148
    return r;
 
149
}
 
150
 
 
151
long long
 
152
stoll(const string& str, size_t* idx, int base)
 
153
{
 
154
    char* ptr;
 
155
    const char* const p = str.c_str();
 
156
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
157
    errno = 0;
 
158
    long long r = strtoll(p, &ptr, base);
 
159
    swap(errno, errno_save);
 
160
#ifndef _LIBCPP_NO_EXCEPTIONS
 
161
    if (errno_save == ERANGE)
 
162
        throw out_of_range("stoll: out of range");
 
163
    if (ptr == p)
 
164
        throw invalid_argument("stoll: no conversion");
 
165
#endif  // _LIBCPP_NO_EXCEPTIONS
 
166
    if (idx)
 
167
        *idx = static_cast<size_t>(ptr - p);
 
168
    return r;
 
169
}
 
170
 
 
171
long long
 
172
stoll(const wstring& str, size_t* idx, int base)
 
173
{
 
174
    wchar_t* ptr;
 
175
    const wchar_t* const p = str.c_str();
 
176
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
177
    errno = 0;
 
178
    long long r = wcstoll(p, &ptr, base);
 
179
    swap(errno, errno_save);
 
180
#ifndef _LIBCPP_NO_EXCEPTIONS
 
181
    if (errno_save == ERANGE)
 
182
        throw out_of_range("stoll: out of range");
 
183
    if (ptr == p)
 
184
        throw invalid_argument("stoll: no conversion");
 
185
#endif  // _LIBCPP_NO_EXCEPTIONS
 
186
    if (idx)
 
187
        *idx = static_cast<size_t>(ptr - p);
 
188
    return r;
 
189
}
 
190
 
 
191
unsigned long long
 
192
stoull(const string& str, size_t* idx, int base)
 
193
{
 
194
    char* ptr;
 
195
    const char* const p = str.c_str();
 
196
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
197
    errno = 0;
 
198
    unsigned long long r = strtoull(p, &ptr, base);
 
199
    swap(errno, errno_save);
 
200
#ifndef _LIBCPP_NO_EXCEPTIONS
 
201
    if (errno_save == ERANGE)
 
202
        throw out_of_range("stoull: out of range");
 
203
    if (ptr == p)
 
204
        throw invalid_argument("stoull: no conversion");
 
205
#endif  // _LIBCPP_NO_EXCEPTIONS
 
206
    if (idx)
 
207
        *idx = static_cast<size_t>(ptr - p);
 
208
    return r;
 
209
}
 
210
 
 
211
unsigned long long
 
212
stoull(const wstring& str, size_t* idx, int base)
 
213
{
 
214
    wchar_t* ptr;
 
215
    const wchar_t* const p = str.c_str();
 
216
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
217
    errno = 0;
 
218
    unsigned long long r = wcstoull(p, &ptr, base);
 
219
    swap(errno, errno_save);
 
220
#ifndef _LIBCPP_NO_EXCEPTIONS
 
221
    if (errno_save == ERANGE)
 
222
        throw out_of_range("stoull: out of range");
 
223
    if (ptr == p)
 
224
        throw invalid_argument("stoull: no conversion");
 
225
#endif  // _LIBCPP_NO_EXCEPTIONS
 
226
    if (idx)
 
227
        *idx = static_cast<size_t>(ptr - p);
 
228
    return r;
 
229
}
 
230
 
 
231
float
 
232
stof(const string& str, size_t* idx)
 
233
{
 
234
    char* ptr;
 
235
    const char* const p = str.c_str();
 
236
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
237
    errno = 0;
 
238
    float r = strtof(p, &ptr);
 
239
    swap(errno, errno_save);
 
240
#ifndef _LIBCPP_NO_EXCEPTIONS
 
241
    if (errno_save == ERANGE)
 
242
        throw out_of_range("stof: out of range");
 
243
    if (ptr == p)
 
244
        throw invalid_argument("stof: no conversion");
 
245
#endif  // _LIBCPP_NO_EXCEPTIONS
 
246
    if (idx)
 
247
        *idx = static_cast<size_t>(ptr - p);
 
248
    return r;
 
249
}
 
250
 
 
251
float
 
252
stof(const wstring& str, size_t* idx)
 
253
{
 
254
    wchar_t* ptr;
 
255
    const wchar_t* const p = str.c_str();
 
256
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
257
    errno = 0;
 
258
    float r = wcstof(p, &ptr);
 
259
    swap(errno, errno_save);
 
260
#ifndef _LIBCPP_NO_EXCEPTIONS
 
261
    if (errno_save == ERANGE)
 
262
        throw out_of_range("stof: out of range");
 
263
    if (ptr == p)
 
264
        throw invalid_argument("stof: no conversion");
 
265
#endif  // _LIBCPP_NO_EXCEPTIONS
 
266
    if (idx)
 
267
        *idx = static_cast<size_t>(ptr - p);
 
268
    return r;
 
269
}
 
270
 
 
271
double
 
272
stod(const string& str, size_t* idx)
 
273
{
 
274
    char* ptr;
 
275
    const char* const p = str.c_str();
 
276
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
277
    errno = 0;
 
278
    double r = strtod(p, &ptr);
 
279
    swap(errno, errno_save);
 
280
#ifndef _LIBCPP_NO_EXCEPTIONS
 
281
    if (errno_save == ERANGE)
 
282
        throw out_of_range("stod: out of range");
 
283
    if (ptr == p)
 
284
        throw invalid_argument("stod: no conversion");
 
285
#endif  // _LIBCPP_NO_EXCEPTIONS
 
286
    if (idx)
 
287
        *idx = static_cast<size_t>(ptr - p);
 
288
    return r;
 
289
}
 
290
 
 
291
double
 
292
stod(const wstring& str, size_t* idx)
 
293
{
 
294
    wchar_t* ptr;
 
295
    const wchar_t* const p = str.c_str();
 
296
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
297
    errno = 0;
 
298
    double r = wcstod(p, &ptr);
 
299
    swap(errno, errno_save);
 
300
#ifndef _LIBCPP_NO_EXCEPTIONS
 
301
    if (errno_save == ERANGE)
 
302
        throw out_of_range("stod: out of range");
 
303
    if (ptr == p)
 
304
        throw invalid_argument("stod: no conversion");
 
305
#endif  // _LIBCPP_NO_EXCEPTIONS
 
306
    if (idx)
 
307
        *idx = static_cast<size_t>(ptr - p);
 
308
    return r;
 
309
}
 
310
 
 
311
long double
 
312
stold(const string& str, size_t* idx)
 
313
{
 
314
    char* ptr;
 
315
    const char* const p = str.c_str();
 
316
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
317
    errno = 0;
 
318
    long double r = strtold(p, &ptr);
 
319
    swap(errno, errno_save);
 
320
#ifndef _LIBCPP_NO_EXCEPTIONS
 
321
    if (errno_save == ERANGE)
 
322
        throw out_of_range("stold: out of range");
 
323
    if (ptr == p)
 
324
        throw invalid_argument("stold: no conversion");
 
325
#endif  // _LIBCPP_NO_EXCEPTIONS
 
326
    if (idx)
 
327
        *idx = static_cast<size_t>(ptr - p);
 
328
    return r;
 
329
}
 
330
 
 
331
long double
 
332
stold(const wstring& str, size_t* idx)
 
333
{
 
334
    wchar_t* ptr;
 
335
    const wchar_t* const p = str.c_str();
 
336
    typename remove_reference<decltype(errno)>::type errno_save = errno;
 
337
    errno = 0;
 
338
    long double r = wcstold(p, &ptr);
 
339
    swap(errno, errno_save);
 
340
#ifndef _LIBCPP_NO_EXCEPTIONS
 
341
    if (errno_save == ERANGE)
 
342
        throw out_of_range("stold: out of range");
 
343
    if (ptr == p)
 
344
        throw invalid_argument("stold: no conversion");
 
345
#endif  // _LIBCPP_NO_EXCEPTIONS
 
346
    if (idx)
 
347
        *idx = static_cast<size_t>(ptr - p);
 
348
    return r;
 
349
}
 
350
 
 
351
string to_string(int val)
 
352
{
 
353
    string s;
 
354
    s.resize(s.capacity());
 
355
    while (true)
 
356
    {
 
357
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%d", val));
 
358
        if (n2 <= s.size())
 
359
        {
 
360
            s.resize(n2);
 
361
            break;
 
362
        }
 
363
        s.resize(n2);
 
364
    }
 
365
    return s;
 
366
}
 
367
 
 
368
string to_string(unsigned val)
 
369
{
 
370
    string s;
 
371
    s.resize(s.capacity());
 
372
    while (true)
 
373
    {
 
374
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%u", val));
 
375
        if (n2 <= s.size())
 
376
        {
 
377
            s.resize(n2);
 
378
            break;
 
379
        }
 
380
        s.resize(n2);
 
381
    }
 
382
    return s;
 
383
}
 
384
 
 
385
string to_string(long val)
 
386
{
 
387
    string s;
 
388
    s.resize(s.capacity());
 
389
    while (true)
 
390
    {
 
391
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%ld", val));
 
392
        if (n2 <= s.size())
 
393
        {
 
394
            s.resize(n2);
 
395
            break;
 
396
        }
 
397
        s.resize(n2);
 
398
    }
 
399
    return s;
 
400
}
 
401
 
 
402
string to_string(unsigned long val)
 
403
{
 
404
    string s;
 
405
    s.resize(s.capacity());
 
406
    while (true)
 
407
    {
 
408
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%lu", val));
 
409
        if (n2 <= s.size())
 
410
        {
 
411
            s.resize(n2);
 
412
            break;
 
413
        }
 
414
        s.resize(n2);
 
415
    }
 
416
    return s;
 
417
}
 
418
 
 
419
string to_string(long long val)
 
420
{
 
421
    string s;
 
422
    s.resize(s.capacity());
 
423
    while (true)
 
424
    {
 
425
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%lld", val));
 
426
        if (n2 <= s.size())
 
427
        {
 
428
            s.resize(n2);
 
429
            break;
 
430
        }
 
431
        s.resize(n2);
 
432
    }
 
433
    return s;
 
434
}
 
435
 
 
436
string to_string(unsigned long long val)
 
437
{
 
438
    string s;
 
439
    s.resize(s.capacity());
 
440
    while (true)
 
441
    {
 
442
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%llu", val));
 
443
        if (n2 <= s.size())
 
444
        {
 
445
            s.resize(n2);
 
446
            break;
 
447
        }
 
448
        s.resize(n2);
 
449
    }
 
450
    return s;
 
451
}
 
452
 
 
453
string to_string(float val)
 
454
{
 
455
    string s;
 
456
    s.resize(s.capacity());
 
457
    while (true)
 
458
    {
 
459
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%f", val));
 
460
        if (n2 <= s.size())
 
461
        {
 
462
            s.resize(n2);
 
463
            break;
 
464
        }
 
465
        s.resize(n2);
 
466
    }
 
467
    return s;
 
468
}
 
469
 
 
470
string to_string(double val)
 
471
{
 
472
    string s;
 
473
    s.resize(s.capacity());
 
474
    while (true)
 
475
    {
 
476
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%f", val));
 
477
        if (n2 <= s.size())
 
478
        {
 
479
            s.resize(n2);
 
480
            break;
 
481
        }
 
482
        s.resize(n2);
 
483
    }
 
484
    return s;
 
485
}
 
486
 
 
487
string to_string(long double val)
 
488
{
 
489
    string s;
 
490
    s.resize(s.capacity());
 
491
    while (true)
 
492
    {
 
493
        size_t n2 = static_cast<size_t>(snprintf(&s[0], s.size()+1, "%Lf", val));
 
494
        if (n2 <= s.size())
 
495
        {
 
496
            s.resize(n2);
 
497
            break;
 
498
        }
 
499
        s.resize(n2);
 
500
    }
 
501
    return s;
 
502
}
 
503
 
 
504
wstring to_wstring(int val)
 
505
{
 
506
    const size_t n = (numeric_limits<int>::digits / 3)
 
507
          + ((numeric_limits<int>::digits % 3) != 0)
 
508
          + 1;
 
509
    wstring s(n, wchar_t());
 
510
    s.resize(s.capacity());
 
511
    while (true)
 
512
    {
 
513
        int n2 = swprintf(&s[0], s.size()+1, L"%d", val);
 
514
        if (n2 > 0)
 
515
        {
 
516
            s.resize(static_cast<size_t>(n2));
 
517
            break;
 
518
        }
 
519
        s.resize(2*s.size());
 
520
        s.resize(s.capacity());
 
521
    }
 
522
    return s;
 
523
}
 
524
 
 
525
wstring to_wstring(unsigned val)
 
526
{
 
527
    const size_t n = (numeric_limits<unsigned>::digits / 3)
 
528
          + ((numeric_limits<unsigned>::digits % 3) != 0)
 
529
          + 1;
 
530
    wstring s(n, wchar_t());
 
531
    s.resize(s.capacity());
 
532
    while (true)
 
533
    {
 
534
        int n2 = swprintf(&s[0], s.size()+1, L"%u", val);
 
535
        if (n2 > 0)
 
536
        {
 
537
            s.resize(static_cast<size_t>(n2));
 
538
            break;
 
539
        }
 
540
        s.resize(2*s.size());
 
541
        s.resize(s.capacity());
 
542
    }
 
543
    return s;
 
544
}
 
545
 
 
546
wstring to_wstring(long val)
 
547
{
 
548
    const size_t n = (numeric_limits<long>::digits / 3)
 
549
          + ((numeric_limits<long>::digits % 3) != 0)
 
550
          + 1;
 
551
    wstring s(n, wchar_t());
 
552
    s.resize(s.capacity());
 
553
    while (true)
 
554
    {
 
555
        int n2 = swprintf(&s[0], s.size()+1, L"%ld", val);
 
556
        if (n2 > 0)
 
557
        {
 
558
            s.resize(static_cast<size_t>(n2));
 
559
            break;
 
560
        }
 
561
        s.resize(2*s.size());
 
562
        s.resize(s.capacity());
 
563
    }
 
564
    return s;
 
565
}
 
566
 
 
567
wstring to_wstring(unsigned long val)
 
568
{
 
569
    const size_t n = (numeric_limits<unsigned long>::digits / 3)
 
570
          + ((numeric_limits<unsigned long>::digits % 3) != 0)
 
571
          + 1;
 
572
    wstring s(n, wchar_t());
 
573
    s.resize(s.capacity());
 
574
    while (true)
 
575
    {
 
576
        int n2 = swprintf(&s[0], s.size()+1, L"%lu", val);
 
577
        if (n2 > 0)
 
578
        {
 
579
            s.resize(static_cast<size_t>(n2));
 
580
            break;
 
581
        }
 
582
        s.resize(2*s.size());
 
583
        s.resize(s.capacity());
 
584
    }
 
585
    return s;
 
586
}
 
587
 
 
588
wstring to_wstring(long long val)
 
589
{
 
590
    const size_t n = (numeric_limits<long long>::digits / 3)
 
591
          + ((numeric_limits<long long>::digits % 3) != 0)
 
592
          + 1;
 
593
    wstring s(n, wchar_t());
 
594
    s.resize(s.capacity());
 
595
    while (true)
 
596
    {
 
597
        int n2 = swprintf(&s[0], s.size()+1, L"%lld", val);
 
598
        if (n2 > 0)
 
599
        {
 
600
            s.resize(static_cast<size_t>(n2));
 
601
            break;
 
602
        }
 
603
        s.resize(2*s.size());
 
604
        s.resize(s.capacity());
 
605
    }
 
606
    return s;
 
607
}
 
608
 
 
609
wstring to_wstring(unsigned long long val)
 
610
{
 
611
    const size_t n = (numeric_limits<unsigned long long>::digits / 3)
 
612
          + ((numeric_limits<unsigned long long>::digits % 3) != 0)
 
613
          + 1;
 
614
    wstring s(n, wchar_t());
 
615
    s.resize(s.capacity());
 
616
    while (true)
 
617
    {
 
618
        int n2 = swprintf(&s[0], s.size()+1, L"%llu", val);
 
619
        if (n2 > 0)
 
620
        {
 
621
            s.resize(static_cast<size_t>(n2));
 
622
            break;
 
623
        }
 
624
        s.resize(2*s.size());
 
625
        s.resize(s.capacity());
 
626
    }
 
627
    return s;
 
628
}
 
629
 
 
630
wstring to_wstring(float val)
 
631
{
 
632
    const size_t n = 20;
 
633
    wstring s(n, wchar_t());
 
634
    s.resize(s.capacity());
 
635
    while (true)
 
636
    {
 
637
        int n2 = swprintf(&s[0], s.size()+1, L"%f", val);
 
638
        if (n2 > 0)
 
639
        {
 
640
            s.resize(static_cast<size_t>(n2));
 
641
            break;
 
642
        }
 
643
        s.resize(2*s.size());
 
644
        s.resize(s.capacity());
 
645
    }
 
646
    return s;
 
647
}
 
648
 
 
649
wstring to_wstring(double val)
 
650
{
 
651
    const size_t n = 20;
 
652
    wstring s(n, wchar_t());
 
653
    s.resize(s.capacity());
 
654
    while (true)
 
655
    {
 
656
        int n2 = swprintf(&s[0], s.size()+1, L"%f", val);
 
657
        if (n2 > 0)
 
658
        {
 
659
            s.resize(static_cast<size_t>(n2));
 
660
            break;
 
661
        }
 
662
        s.resize(2*s.size());
 
663
        s.resize(s.capacity());
 
664
    }
 
665
    return s;
 
666
}
 
667
 
 
668
wstring to_wstring(long double val)
 
669
{
 
670
    const size_t n = 20;
 
671
    wstring s(n, wchar_t());
 
672
    s.resize(s.capacity());
 
673
    while (true)
 
674
    {
 
675
        int n2 = swprintf(&s[0], s.size()+1, L"%Lf", val);
 
676
        if (n2 > 0)
 
677
        {
 
678
            s.resize(static_cast<size_t>(n2));
 
679
            break;
 
680
        }
 
681
        s.resize(2*s.size());
 
682
        s.resize(s.capacity());
 
683
    }
 
684
    return s;
 
685
}
 
686
 
 
687
_LIBCPP_END_NAMESPACE_STD