stdex
Additional custom or not Standard C++ covered algorithms
Loading...
Searching...
No Matches
string.hpp
1/*
2 SPDX-License-Identifier: MIT
3 Copyright © 2016-2023 Amebis
4*/
5
6#pragma once
7
8#include "sal.hpp"
9#include <assert.h>
10#include <ctype.h>
11#include <locale.h>
12#include <stdarg.h>
13#include <stdint.h>
14#include <memory>
15#include <stdexcept>
16
17namespace stdex
18{
19#ifdef _WIN32
20 using locale_t = _locale_t;
21
22 inline locale_t create_locale(_In_ int category, _In_z_ const char* locale) { return _create_locale(category, locale); }
23 inline locale_t create_locale(_In_ int category, _In_z_ const wchar_t* locale) { return _wcreate_locale(category, locale); }
24 inline void free_locale(_In_opt_ _locale_t locale) { _free_locale(locale); }
25#else
26 using locale_t = ::locale_t;
27#endif
28
32 struct free_locale_delete
33 {
37 void operator()(_In_ locale_t locale) const
38 {
39 free_locale(locale);
40 }
41 };
42
46 using locale = std::unique_ptr<__crt_locale_pointers, free_locale_delete>;
47
51 static locale locale_C(_create_locale(LC_ALL, "C"));
52
56#ifdef _WIN32
57 typedef wchar_t utf16_t;
58#else
59 typedef char16_t utf16_t;
60#endif
61
67 inline bool is_high_surrogate(_In_ utf16_t chr)
68 {
69 return 0xd800 < chr && chr < 0xdc00;
70 }
71
77 inline bool is_low_surrogate(_In_ utf16_t chr)
78 {
79 return 0xdc00 < chr && chr < 0xe000;
80 }
81
87 inline bool is_surrogate_pair(_In_reads_(2) const utf16_t* str)
88 {
89 return is_high_surrogate(str[0]) && is_low_surrogate(str[1]);
90 }
91
97 inline char32_t surrogate_pair_to_ucs4(_In_reads_(2) const utf16_t* str)
98 {
99 assert(is_surrogate_pair(str));
100 return
101 ((char32_t)(str[0] - 0xd800) << 10) +
102 (char32_t)(str[1] - 0xdc00) +
103 0x10000;
104 }
105
111 inline void ucs4_to_surrogate_pair(_Out_writes_(2) utf16_t* str, _In_ char32_t chr)
112 {
113 assert(chr >= 0x10000);
114 chr -= 0x10000;
115 str[0] = 0xd800 + (char32_t)((chr >> 10) & 0x3ff);
116 str[1] = 0xdc00 + (char32_t)(chr & 0x3ff);
117 }
118
124 inline bool iscombining(_In_ char32_t chr)
125 {
126 return
127 0x0300 <= chr && chr < 0x0370 ||
128 0x1dc0 <= chr && chr < 0x1e00 ||
129 0x20d0 <= chr && chr < 0x2100 ||
130 0xfe20 <= chr && chr < 0xfe30;
131 }
132
138 template <class T>
139 inline size_t islbreak(_In_ T chr)
140 {
141 return chr == '\n' || chr == '\r';
142 }
143
150 template <class T>
151 inline size_t islbreak(_In_reads_or_z_opt_(count) const T* chr, _In_ size_t count)
152 {
153 _Analysis_assume_(chr || !count);
154 if (count >= 2 && (chr[0] == '\r' && chr[1] == '\n' || chr[0] == '\n' && chr[1] == '\r'))
155 return 2;
156 if (count > 1 && (chr[0] == '\n' || chr[0] == '\r'))
157 return 1;
158 return 0;
159 }
160
167 inline size_t glyphlen(_In_reads_or_z_opt_(count) const wchar_t* glyph, _In_ size_t count)
168 {
169 _Analysis_assume_(glyph || !count);
170 if (count) {
171#ifdef _WIN32
172 size_t i = count < 2 || !is_surrogate_pair(glyph) ? 1 : 2;
173#else
174 size_t i = 1;
175#endif
176 for (; i < count && iscombining(glyph[i]); ++i);
177 return i;
178 }
179 return 0;
180 }
181
189 template <class T>
190 inline size_t strlen(_In_z_ const T* str)
191 {
192 assert(str);
193 size_t i;
194 for (i = 0; str[i]; ++i);
195 return i;
196 }
197
206 template <class T>
207 inline size_t strnlen(_In_reads_or_z_opt_(count) const T* str, _In_ size_t count)
208 {
209 assert(str || !count);
210 size_t i;
211 for (i = 0; i < count && str[i]; ++i);
212 return i;
213 }
214
215 constexpr auto npos{ static_cast<size_t>(-1) };
216
225 template <class T>
226 inline size_t strchr(_In_z_ const T* str, _In_ T chr)
227 {
228 assert(str);
229 for (size_t i = 0; str[i]; ++i)
230 if (str[i] == chr) return i;
231 return npos;
232 }
233
243 template <class T>
244 inline size_t strnchr(
245 _In_reads_or_z_opt_(count) const T* str,
246 _In_ size_t count,
247 _In_ T chr)
248 {
249 assert(str || !count);
250 for (size_t i = 0; i < count && str[i]; ++i)
251 if (str[i] == chr) return i;
252 return npos;
253 }
254
264 template <class T>
265 inline size_t strrnchr(
266 _In_reads_or_z_opt_(count) const T* str,
267 _In_ size_t count,
268 _In_ T chr)
269 {
270 assert(str || !count);
271 size_t z = npos;
272 for (size_t i = 0; i < count && str[i]; ++i)
273 if (str[i] == chr) z = i;
274 return z;
275 }
276
286 template <class T>
287 inline size_t strnichr(
288 _In_reads_or_z_opt_(count) const T* str,
289 _In_ size_t count,
290 _In_ T chr,
291 _In_ const std::locale& locale)
292 {
293 assert(str || !count);
294 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
295 chr = ctype.tolower(chr);
296 for (size_t i = 0; i < count && str[i]; ++i)
297 if (ctype.tolower(str[i]) == chr) return i;
298 return npos;
299 }
300
310 template <class T>
311 inline size_t strrnichr(
312 _In_reads_or_z_opt_(count) const T* str,
313 _In_ size_t count,
314 _In_ T chr,
315 _In_ const std::locale& locale)
316 {
317 assert(str || !count);
318 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
319 chr = ctype.tolower(chr);
320 size_t z = npos;
321 for (size_t i = 0; i < count && str[i]; ++i)
322 if (ctype.tolower(str[i]) == chr) z = i;
323 return z;
324 }
325
336 template <class T1, class T2>
337 inline int strncmp(
338 _In_reads_or_z_opt_(count1) const T1* str1, _In_ size_t count1,
339 _In_reads_or_z_opt_(count2) const T2* str2, _In_ size_t count2)
340 {
341 assert(str1 || !count1);
342 assert(str2 || !count2);
343 size_t i; T1 a; T2 b;
344 for (i = 0; i < count1 && i < count2 && ((a = str1[i]) | (b = str2[i])); ++i) {
345 if (a > b) return +1;
346 if (a < b) return -1;
347 }
348 if (i < count1 && str1[i]) return +1;
349 if (i < count2 && str2[i]) return -1;
350 return 0;
351 }
352
363 template <class T>
364 inline int strncoll(
365 _In_reads_or_z_opt_(count1) const T* str1, _In_ size_t count1,
366 _In_reads_or_z_opt_(count2) const T* str2, _In_ size_t count2,
367 _In_ const std::locale& locale)
368 {
369 assert(str1 || !count1);
370 assert(str2 || !count2);
371 auto& collate = std::use_facet<std::collate<T>>(locale);
372 return collate.compare(str1, str1 + count1, str2, str2 + count2);
373 }
374
385 template <class T1, class T2>
386 inline int strnicmp(
387 _In_reads_or_z_opt_(count1) const T1* str1, _In_ size_t count1,
388 _In_reads_or_z_opt_(count2) const T2* str2, _In_ size_t count2,
389 _In_ const std::locale& locale)
390 {
391 assert(str1 || !count1);
392 assert(str2 || !count2);
393 size_t i; T1 a; T2 b;
394 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
395 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
396 for (i = 0; i < count1 && i < count2 && ((a = ctype1.tolower(str1[i])) | (b = ctype2.tolower(str2[i]))); i++) {
397 if (a > b) return +1;
398 if (a < b) return -1;
399 }
400 if (i < count1 && str1[i]) return +1;
401 if (i < count2 && str2[i]) return -1;
402 return 0;
403 }
404
413 template <class T1, class T2>
414 inline size_t strstr(
415 _In_z_ const T1* str,
416 _In_z_ const T2* sample)
417 {
418 assert(str);
419 assert(sample);
420 for (size_t offset = 0;; ++offset) {
421 for (size_t i = offset, j = 0;; ++i, ++j) {
422 if (!sample[j])
423 return offset;
424 if (!str[i])
425 return npos;
426 if (str[i] != sample[j])
427 break;
428 }
429 }
430 }
431
441 template <class T1, class T2>
442 inline size_t strnstr(
443 _In_reads_or_z_opt_(count) const T1* str,
444 _In_ size_t count,
445 _In_z_ const T2* sample)
446 {
447 assert(str || !count);
448 assert(sample);
449 for (size_t offset = 0;; ++offset) {
450 for (size_t i = offset, j = 0;; ++i, ++j) {
451 if (!sample[j])
452 return offset;
453 if (i >= count || !str[i])
454 return npos;
455 if (str[i] != sample[j])
456 break;
457 }
458 }
459 }
460
469 template <class T1, class T2>
470 inline size_t stristr(
471 _In_z_ const T1* str,
472 _In_z_ const T2* sample,
473 _In_ const std::locale& locale)
474 {
475 assert(str);
476 assert(sample);
477 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
478 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
479 for (size_t offset = 0;; ++offset) {
480 for (size_t i = offset, j = 0;; ++i, ++j) {
481 if (!sample[j])
482 return offset;
483 if (!str[i])
484 return npos;
485 if (ctype1.tolower(str[i]) != ctype2.tolower(sample[j]))
486 break;
487 }
488 }
489 }
490
500 template <class T1, class T2>
501 inline size_t strnistr(
502 _In_reads_or_z_opt_(count) const T1* str,
503 _In_ size_t count,
504 _In_z_ const T2* sample,
505 _In_ const std::locale& locale)
506 {
507 assert(str || !count);
508 assert(sample);
509 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
510 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
511 for (size_t offset = 0;; ++offset) {
512 for (size_t i = offset, j = 0;; ++i, ++j) {
513 if (!sample[j])
514 return offset;
515 if (i >= count || !str[i])
516 return npos;
517 if (ctype1.tolower(str[i]) != ctype2.tolower(sample[j]))
518 break;
519 }
520 }
521 }
522
531 template <class T1, class T2>
532 inline size_t strcpy(
533 _Out_writes_z_(_String_length_(src) + 1) T1* dst,
534 _In_z_ const T2* src)
535 {
536 assert(dst && src);
537 for (size_t i = 0; ; ++i) {
538 if ((dst[i] = src[i]) == 0)
539 return i;
540 }
541 }
542
552 template <class T1, class T2>
553 inline size_t strncpy(
554 _Out_writes_(count) _Post_maybez_ T1* dst,
555 _In_reads_or_z_opt_(count) const T2* src, _In_ size_t count)
556 {
557 assert(dst && src || !count);
558 for (size_t i = 0; ; ++i) {
559 if (i >= count)
560 return i;
561 if ((dst[i] = src[i]) == 0)
562 return i;
563 }
564 }
565
576 template <class T1, class T2>
577 inline size_t strncpy(
578 _Out_writes_(count_dst) _Post_maybez_ T1* dst, _In_ size_t count_dst,
579 _In_reads_or_z_opt_(count_src) const T2* src, _In_ size_t count_src)
580 {
581 assert(dst || !count_dst);
582 assert(src || !count_src);
583 for (size_t i = 0; ; ++i)
584 {
585 if (i > count_dst)
586 return i;
587 if (i > count_src) {
588 dst[i] = 0;
589 return i;
590 }
591 if ((dst[i] = src[i]) == 0)
592 return i;
593 }
594 }
595
604 template <class T1, class T2>
605 inline size_t strcat(
606 _In_z_ _Out_writes_z_(_String_length_(dst) + _String_length_(src) + 1) T1* dst,
607 _In_z_ const T2* src)
608 {
609 assert(dst && src);
610 for (size_t i = 0, j = stdex::strlen<T1>(dst); ; ++i, ++j) {
611 if ((dst[j] = src[i]) == 0)
612 return j;
613 }
614 }
615
625 template <class T1, class T2>
626 inline size_t strncat(
627 _Out_writes_(count) _Post_maybez_ T1* dst,
628 _In_reads_or_z_opt_(count) const T2* src, _In_ size_t count)
629 {
630 assert(dst && src || !count);
631 for (size_t i = 0, j = stdex::strlen<T1>(dst); ; ++i, ++j) {
632 if (i >= count)
633 return j;
634 if ((dst[j] = src[i]) == 0)
635 return j;
636 }
637 }
638
649 template <class T1, class T2>
650 inline size_t strncat(
651 _Out_writes_(count_dst) _Post_maybez_ T1* dst, _In_ size_t count_dst,
652 _In_reads_or_z_opt_(count_src) const T2* src, _In_ size_t count_src)
653 {
654 assert(dst || !count_dst);
655 assert(src || !count_src);
656 for (size_t i = 0, j = stdex::strnlen<T1>(dst, count_dst); ; ++i, ++j)
657 {
658 if (j > count_dst)
659 return j;
660 if (i > count_src) {
661 dst[j] = 0;
662 return j;
663 }
664 if ((dst[j] = src[i]) == 0)
665 return j;
666 }
667 }
668
679 template <class T>
680 inline _Check_return_ _Ret_maybenull_z_ T* strdup(_In_opt_z_ const T* str)
681 {
682 if (!str) _Unlikely_
683 return nullptr;
684 size_t count = strlen(str) + 1;
685 T* dst = new T[count];
686 strncpy(dst, count, str, SIZE_MAX);
687 return dst;
688 }
689
701 template <class T>
702 inline _Ret_z_ T* strndup(
703 _In_reads_or_z_opt_(count) const T* str,
704 _In_ size_t count)
705 {
706 T* dst = new T[count];
707 strncpy(dst, count, str, SIZE_MAX);
708 return dst;
709 }
710
720 template <class T>
721 inline size_t crlf2nl(_Out_writes_z_(strlen(src)) T* dst, _In_z_ const T* src)
722 {
723 assert(dst);
724 assert(src);
725 size_t i, j;
726 for (i = j = 0; src[j];) {
727 if (src[j] != '\r' || src[j + 1] != '\n')
728 dst[i++] = src[j++];
729 else {
730 dst[i++] = '\n';
731 j += 2;
732 }
733 }
734 dst[i] = 0;
735 return i;
736 }
737
739 template <class T, class T_bin>
740 inline T_bin strtoint(
741 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
742 _Out_opt_ size_t* end,
743 _In_ int radix,
744 _Out_ uint8_t& flags)
745 {
746 assert(str || !count);
747 assert(radix == 0 || 2 <= radix && radix <= 36);
748
749 size_t i = 0;
750 T_bin value = 0, digit,
751 max_ui = (T_bin)-1,
752 max_ui_pre1, max_ui_pre2;
753
754 flags = 0;
755
756 // Skip leading spaces.
757 for (;; ++i) {
758 if (i >= count || !str[i]) goto error;
759 if (!isspace(str[i])) break;
760 }
761
762 // Read the sign.
763 if (str[i] == '+') {
764 flags &= ~0x01;
765 ++i;
766 if (i >= count || !str[i]) goto error;
767 }
768 else if (str[i] == '-') {
769 flags |= 0x01;
770 ++i;
771 if (i >= count || !str[i]) goto error;
772 }
773
774 if (radix == 16) {
775 // On hexadecimal, allow leading 0x.
776 if (str[i] == '0' && i + 1 < count && (str[i + 1] == 'x' || str[i + 1] == 'X')) {
777 i += 2;
778 if (i >= count || !str[i]) goto error;
779 }
780 }
781 else if (!radix) {
782 // Autodetect radix.
783 if (str[i] == '0') {
784 ++i;
785 if (i >= count || !str[i]) goto error;
786 if (str[i] == 'x' || str[i] == 'X') {
787 radix = 16;
788 ++i;
789 if (i >= count || !str[i]) goto error;
790 }
791 else
792 radix = 8;
793 }
794 else
795 radix = 10;
796 }
797
798 // We have the radix.
799 max_ui_pre1 = max_ui / (T_bin)radix;
800 max_ui_pre2 = max_ui % (T_bin)radix;
801 for (;;) {
802 if ('0' <= str[i] && str[i] <= '9')
803 digit = (T_bin)str[i] - '0';
804 else if ('A' <= str[i] && str[i] <= 'Z')
805 digit = (T_bin)str[i] - 'A' + '\x0a';
806 else if ('a' <= str[i] && str[i] <= 'z')
807 digit = (T_bin)str[i] - 'a' + '\x0a';
808 else
809 goto error;
810 if (digit >= (T_bin)radix)
811 goto error;
812
813 if (value < max_ui_pre1 || // Multiplication nor addition will not overflow.
814 value == max_ui_pre1 && digit <= max_ui_pre2) // Small digits will not overflow.
815 value = value * (T_bin)radix + digit;
816 else {
817 // Overflow!
818 flags |= 0x02;
819 }
820
821 ++i;
822 if (i >= count || !str[i])
823 goto error;
824 }
825
826 error:
827 if (end) *end = i;
828 return value;
829 }
831
842 template <class T, class T_bin>
843 T_bin strtoint(
844 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
845 _Out_opt_ size_t* end,
846 _In_ int radix)
847 {
848 uint8_t flags;
849 T_bin value;
850
851 switch (sizeof(T_bin)) {
852 case 1:
853 value = (T_bin)strtoint<T, uint8_t>(str, count, end, radix, flags);
854 if ((flags & 0x01) && (value & 0x80)) {
855 // Sign bit is 1 => overflow.
856 flags |= 0x02;
857 }
858 return (flags & 0x02) ?
859 (flags & 0x01) ? (T_bin)0x80 : (T_bin)0x7f :
860 (flags & 0x01) ? -value : value;
861
862 case 2:
863 value = (T_bin)strtoint<T, uint16_t>(str, count, end, radix, flags);
864 if ((flags & 0x01) && (value & 0x8000)) {
865 // Sign bit is 1 => overflow.
866 flags |= 0x02;
867 }
868 return (flags & 0x02) ?
869 (flags & 0x01) ? (T_bin)0x8000 : (T_bin)0x7fff :
870 (flags & 0x01) ? -value : value;
871
872 case 4:
873 value = (T_bin)strtoint<T, uint32_t>(str, count, end, radix, flags);
874 if ((flags & 0x01) && (value & 0x80000000)) {
875 // Sign bit is 1 => overflow.
876 flags |= 0x02;
877 }
878 return (flags & 0x02) ?
879 (flags & 0x01) ? (T_bin)0x80000000 : (T_bin)0x7fffffff :
880 (flags & 0x01) ? -value : value;
881
882 case 8:
883 value = (T_bin)strtoint<T, uint64_t>(str, count, end, radix, flags);
884 if ((flags & 0x01) && (value & 0x8000000000000000)) {
885 // Sign bit is 1 => overflow.
886 flags |= 0x02;
887 }
888 return (flags & 0x02) ?
889 (flags & 0x01) ? (T_bin)0x8000000000000000 : (T_bin)0x7fffffffffffffff :
890 (flags & 0x01) ? -value : value;
891
892 default:
893 throw std::invalid_argument("Unsupported bit length");
894 }
895 }
896
907 template <class T, class T_bin>
908 inline T_bin strtouint(
909 _In_reads_or_z_opt_(count) const T* str,
910 _In_ size_t count,
911 _Out_opt_ size_t* end,
912 _In_ int radix)
913 {
914 uint8_t flags;
915 T_bin value;
916
917 switch (sizeof(T_bin)) {
918 case 1: value = (T_bin)strtoint<T, uint8_t>(str, count, end, radix, flags); break;
919 case 2: value = (T_bin)strtoint<T, uint16_t>(str, count, end, radix, flags); break;
920 case 4: value = (T_bin)strtoint<T, uint32_t>(str, count, end, radix, flags); break;
921 case 8: value = (T_bin)strtoint<T, uint64_t>(str, count, end, radix, flags); break;
922 default: throw std::invalid_argument("Unsupported bit length");
923 }
924
925 return (flags & 0x02) ?
926 (flags & 0x01) ? (T_bin)0 : (T_bin)-1 :
927 (flags & 0x01) ? ~value : value;
928 }
929
940 template <class T>
941 inline int32_t strto32(
942 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
943 _Out_opt_ size_t* end,
944 _In_ int radix)
945 {
946 return strtoint<T, int32_t>(str, count, end, radix);
947 }
948
959 template <class T>
960 inline int64_t strto64(
961 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
962 _Out_opt_ size_t* end,
963 _In_ int radix)
964 {
965 return strtoint<T, int64_t>(str, count, end, radix);
966 }
967
979 template <class T>
980 inline intptr_t strtoi(
981 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
982 _Out_opt_ size_t* end,
983 _In_ int radix)
984 {
985#if defined(_WIN64) || defined(__LP64__)
986 return (intptr_t)strto64(str, count, end, radix);
987#else
988 return (intptr_t)strto32(str, count, end, radix);
989#endif
990 }
991
1002 template <class T>
1003 inline uint32_t strtou32(
1004 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1005 _Out_opt_ size_t* end,
1006 _In_ int radix)
1007 {
1008 return strtouint<T, uint32_t>(str, count, end, radix);
1009 }
1010
1021 template <class T>
1022 inline uint64_t strtou64(
1023 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1024 _Out_opt_ size_t* end,
1025 _In_ int radix)
1026 {
1027 return strtouint<T, uint64_t>(str, count, end, radix);
1028 }
1029
1041 template <class T>
1042 inline size_t strtoui(
1043 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1044 _Out_opt_ size_t* end,
1045 _In_ int radix)
1046 {
1047#if defined(_WIN64) || defined(__LP64__)
1048 return (size_t)strtou64(str, count, end, radix);
1049#else
1050 return (size_t)strtou32(str, count, end, radix);
1051#endif
1052 }
1053
1055 inline int vsnprintf(_Out_z_cap_(capacity) char *str, _In_ size_t capacity, _In_z_ _Printf_format_string_params_(2) const char *format, _In_opt_ locale_t locale, _In_ va_list arg)
1056 {
1057 int r;
1058#ifdef _WIN32
1059 // Don't use _vsnprintf_s(). It terminates the string even if we want to print to the edge of the buffer.
1060#pragma warning(suppress: 4996)
1061 r = _vsnprintf_l(str, capacity, format, locale, arg);
1062#else
1063 r = vsnprintf(str, capacity, format, arg);
1064#endif
1065 if (r == -1 && strnlen(str, capacity) == capacity) {
1066 // Buffer overrun. Estimate buffer size for the next iteration.
1067 capacity += std::max<size_t>(capacity / 8, 0x80);
1068 if (capacity > INT_MAX)
1069 throw std::invalid_argument("string too big");
1070 return (int)capacity;
1071 }
1072 return r;
1073 }
1074
1075 inline int vsnprintf(_Out_z_cap_(capacity) wchar_t *str, _In_ size_t capacity, _In_z_ _Printf_format_string_params_(2) const wchar_t *format, _In_opt_ locale_t locale, _In_ va_list arg)
1076 {
1077 int r;
1078
1079#ifdef _WIN32
1080 // Don't use _vsnwprintf_s(). It terminates the string even if we want to print to the edge of the buffer.
1081#pragma warning(suppress: 4996)
1082 r = _vsnwprintf_l(str, capacity, format, locale, arg);
1083#else
1084 r = vswprintf(str, capacity, format, arg);
1085#endif
1086 if (r == -1 && strnlen(str, capacity) == capacity) {
1087 // Buffer overrun. Estimate buffer size for the next iteration.
1088 capacity += std::max<size_t>(capacity / 8, 0x80);
1089 if (capacity > INT_MAX)
1090 throw std::invalid_argument("string too big");
1091 return (int)capacity;
1092 }
1093 return r;
1094 }
1096
1105 template<class _Elem, class _Traits, class _Ax>
1106 inline void vappendf(_Inout_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_params_(2) const _Elem *format, _In_opt_ locale_t locale, _In_ va_list arg)
1107 {
1108 _Elem buf[1024/sizeof(_Elem)];
1109
1110 // Try with stack buffer first.
1111 int count = vsnprintf(buf, _countof(buf) - 1, format, locale, arg);
1112 if (count >= 0) {
1113 // Copy from stack.
1114 str.append(buf, count);
1115 } else {
1116 for (size_t capacity = 2*1024/sizeof(_Elem);; capacity *= 2) {
1117 // Allocate on heap and retry.
1118 auto buf_dyn = std::make_unique<_Elem[]>(capacity);
1119 count = vsnprintf(buf_dyn.get(), capacity - 1, format, locale, arg);
1120 if (count >= 0) {
1121 str.append(buf_dyn.get(), count);
1122 break;
1123 }
1124 }
1125 }
1126 }
1127
1135 template<class _Elem, class _Traits, class _Ax>
1136 inline void appendf(_Inout_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_params_(2) const _Elem *format, _In_opt_ locale_t locale, ...)
1137 {
1138 va_list arg;
1139 va_start(arg, locale);
1140 vappendf(str, format, locale, arg);
1141 va_end(arg);
1142 }
1143
1152 template<class _Elem, class _Traits, class _Ax>
1153 inline void vsprintf(_Inout_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_params_(2) const _Elem *format, _In_opt_ locale_t locale, _In_ va_list arg)
1154 {
1155 str.clear();
1156 vappendf(str, format, locale, arg);
1157 }
1158
1166 template<class _Elem, class _Traits, class _Ax>
1167 inline void sprintf(_Inout_ std::basic_string<_Elem, _Traits, _Ax> &str, _In_z_ _Printf_format_string_params_(2) const _Elem *format, _In_opt_ locale_t locale, ...)
1168 {
1169 va_list arg;
1170 va_start(arg, locale);
1171 vsprintf(str, format, locale, arg);
1172 va_end(arg);
1173 }
1174
1184 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
1185 inline std::basic_string<_Elem, _Traits, _Ax> vsprintf(_In_z_ _Printf_format_string_params_(2) const _Elem *format, _In_opt_ locale_t locale, _In_ va_list arg)
1186 {
1187 std::basic_string<_Elem, _Traits, _Ax> str;
1188 vappendf(str, format, locale, arg);
1189 return str;
1190 }
1191
1200 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
1201 inline std::basic_string<_Elem, _Traits, _Ax> sprintf(_In_z_ _Printf_format_string_params_(2) const _Elem *format, _In_opt_ locale_t locale, ...)
1202 {
1203 va_list arg;
1204 va_start(arg, locale);
1205 auto str = vsprintf(format, locale, arg);
1206 va_end(arg);
1207 return str;
1208 }
1209}
stdex::free_locale_delete
Deleter for unique_ptr using free_locale.
Definition string.hpp:33
stdex::free_locale_delete::operator()
void operator()(locale_t locale) const
Delete a pointer.
Definition string.hpp:37
Generated on Mon Sep 11 2023 11:06:18 for stdex by doxygen 1.9.8