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 "compat.hpp"
9#include <assert.h>
10#include <ctype.h>
11#include <locale.h>
12#include <stdarg.h>
13#include <stdint.h>
14#include <stdio.h>
15#include <stdarg.h>
16#ifdef __APPLE__
17#include <xlocale.h>
18#endif
19#include <locale>
20#include <memory>
21#include <stdexcept>
22
23namespace stdex
24{
25#ifdef _WIN32
26 using locale_t = _locale_t;
27
28 inline locale_t create_locale(_In_ int category, _In_z_ const char* locale) { return _create_locale(category, locale); }
29 inline locale_t create_locale(_In_ int category, _In_z_ const wchar_t* locale) { return _wcreate_locale(category, locale); }
30 inline void free_locale(_In_opt_ locale_t locale) { _free_locale(locale); }
31#else
32 using locale_t = ::locale_t;
33
34 inline locale_t create_locale(_In_ int category, _In_z_ const char* locale)
35 {
36 int mask = 0;
37 switch (category) {
38 case LC_ALL : mask = LC_ALL_MASK ; break;
39 case LC_COLLATE : mask = LC_COLLATE_MASK ; break;
40 case LC_CTYPE : mask = LC_CTYPE_MASK ; break;
41 case LC_MESSAGES: mask = LC_MESSAGES_MASK; break;
42 case LC_MONETARY: mask = LC_MONETARY_MASK; break;
43 case LC_NUMERIC : mask = LC_NUMERIC_MASK ; break;
44 case LC_TIME : mask = LC_TIME_MASK ; break;
45 }
46 return newlocale(mask, locale, LC_GLOBAL_LOCALE);
47 }
48
49 inline void free_locale(_In_opt_ locale_t locale) { freelocale(locale); }
50#endif
51
55 struct free_locale_delete
56 {
60 void operator()(_In_ locale_t locale) const
61 {
62 free_locale(locale);
63 }
64 };
65
69#if defined(_WIN32)
70 using locale = std::unique_ptr<__crt_locale_pointers, free_locale_delete>;
71#elif defined(__APPLE__)
72 using locale = std::unique_ptr<struct _xlocale, free_locale_delete>;
73#else
74 using locale = std::unique_ptr<struct __locale_struct, free_locale_delete>;
75#endif
76
80 static locale locale_C(create_locale(LC_ALL, "C"));
81
85#ifdef _WIN32
86 typedef wchar_t utf16_t;
87#else
88 typedef char16_t utf16_t;
89#endif
90
96 inline bool is_high_surrogate(_In_ utf16_t chr)
97 {
98 return 0xd800 < chr && chr < 0xdc00;
99 }
100
106 inline bool is_low_surrogate(_In_ utf16_t chr)
107 {
108 return 0xdc00 < chr && chr < 0xe000;
109 }
110
116 inline bool is_surrogate_pair(_In_reads_(2) const utf16_t* str)
117 {
118 return is_high_surrogate(str[0]) && is_low_surrogate(str[1]);
119 }
120
126 inline char32_t surrogate_pair_to_ucs4(_In_reads_(2) const utf16_t* str)
127 {
128 assert(is_surrogate_pair(str));
129 return
130 ((char32_t)(str[0] - 0xd800) << 10) +
131 (char32_t)(str[1] - 0xdc00) +
132 0x10000;
133 }
134
140 inline void ucs4_to_surrogate_pair(_Out_writes_(2) utf16_t* str, _In_ char32_t chr)
141 {
142 assert(chr >= 0x10000);
143 chr -= 0x10000;
144 str[0] = 0xd800 + (char32_t)((chr >> 10) & 0x3ff);
145 str[1] = 0xdc00 + (char32_t)(chr & 0x3ff);
146 }
147
153 inline bool iscombining(_In_ char32_t chr)
154 {
155 return
156 (0x0300 <= chr && chr < 0x0370) ||
157 (0x1dc0 <= chr && chr < 0x1e00) ||
158 (0x20d0 <= chr && chr < 0x2100) ||
159 (0xfe20 <= chr && chr < 0xfe30);
160 }
161
167 template <class T>
168 inline size_t islbreak(_In_ T chr)
169 {
170 return chr == '\n' || chr == '\r';
171 }
172
179 template <class T>
180 inline size_t islbreak(_In_reads_or_z_opt_(count) const T* chr, _In_ size_t count)
181 {
182 _Analysis_assume_(chr || !count);
183 if (count >= 2 && ((chr[0] == '\r' && chr[1] == '\n') || (chr[0] == '\n' && chr[1] == '\r')))
184 return 2;
185 if (count > 1 && (chr[0] == '\n' || chr[0] == '\r'))
186 return 1;
187 return 0;
188 }
189
196 inline size_t glyphlen(_In_reads_or_z_opt_(count) const wchar_t* glyph, _In_ size_t count)
197 {
198 _Analysis_assume_(glyph || !count);
199 if (count) {
200#ifdef _WIN32
201 size_t i = count < 2 || !is_surrogate_pair(glyph) ? 1 : 2;
202#else
203 size_t i = 1;
204#endif
205 for (; i < count && iscombining(glyph[i]); ++i);
206 return i;
207 }
208 return 0;
209 }
210
218 template <class T>
219 inline size_t strlen(_In_z_ const T* str)
220 {
221 assert(str);
222 size_t i;
223 for (i = 0; str[i]; ++i);
224 return i;
225 }
226
235 template <class T>
236 inline size_t strnlen(_In_reads_or_z_opt_(count) const T* str, _In_ size_t count)
237 {
238 assert(str || !count);
239 size_t i;
240 for (i = 0; i < count && str[i]; ++i);
241 return i;
242 }
243
244 constexpr auto npos{ static_cast<size_t>(-1) };
245
254 template <class T>
255 inline size_t strchr(_In_z_ const T* str, _In_ T chr)
256 {
257 assert(str);
258 for (size_t i = 0; str[i]; ++i)
259 if (str[i] == chr) return i;
260 return npos;
261 }
262
272 template <class T>
273 inline size_t strnchr(
274 _In_reads_or_z_opt_(count) const T* str,
275 _In_ size_t count,
276 _In_ T chr)
277 {
278 assert(str || !count);
279 for (size_t i = 0; i < count && str[i]; ++i)
280 if (str[i] == chr) return i;
281 return npos;
282 }
283
293 template <class T>
294 inline size_t strrnchr(
295 _In_reads_or_z_opt_(count) const T* str,
296 _In_ size_t count,
297 _In_ T chr)
298 {
299 assert(str || !count);
300 size_t z = npos;
301 for (size_t i = 0; i < count && str[i]; ++i)
302 if (str[i] == chr) z = i;
303 return z;
304 }
305
315 template <class T>
316 inline size_t strnichr(
317 _In_reads_or_z_opt_(count) const T* str,
318 _In_ size_t count,
319 _In_ T chr,
320 _In_ const std::locale& locale)
321 {
322 assert(str || !count);
323 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
324 chr = ctype.tolower(chr);
325 for (size_t i = 0; i < count && str[i]; ++i)
326 if (ctype.tolower(str[i]) == chr) return i;
327 return npos;
328 }
329
339 template <class T>
340 inline size_t strrnichr(
341 _In_reads_or_z_opt_(count) const T* str,
342 _In_ size_t count,
343 _In_ T chr,
344 _In_ const std::locale& locale)
345 {
346 assert(str || !count);
347 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
348 chr = ctype.tolower(chr);
349 size_t z = npos;
350 for (size_t i = 0; i < count && str[i]; ++i)
351 if (ctype.tolower(str[i]) == chr) z = i;
352 return z;
353 }
354
365 template <class T1, class T2>
366 inline int strncmp(
367 _In_reads_or_z_opt_(count1) const T1* str1, _In_ size_t count1,
368 _In_reads_or_z_opt_(count2) const T2* str2, _In_ size_t count2)
369 {
370 assert(str1 || !count1);
371 assert(str2 || !count2);
372 size_t i; T1 a; T2 b;
373 for (i = 0; i < count1 && i < count2 && ((a = str1[i]) | (b = str2[i])); ++i) {
374 if (a > b) return +1;
375 if (a < b) return -1;
376 }
377 if (i < count1 && str1[i]) return +1;
378 if (i < count2 && str2[i]) return -1;
379 return 0;
380 }
381
392 template <class T>
393 inline int strncoll(
394 _In_reads_or_z_opt_(count1) const T* str1, _In_ size_t count1,
395 _In_reads_or_z_opt_(count2) const T* str2, _In_ size_t count2,
396 _In_ const std::locale& locale)
397 {
398 assert(str1 || !count1);
399 assert(str2 || !count2);
400 auto& collate = std::use_facet<std::collate<T>>(locale);
401 return collate.compare(str1, str1 + count1, str2, str2 + count2);
402 }
403
412 template <class T1, class T2>
413 inline int stricmp(_In_z_ const T1* str1, _In_z_ const T2* str2, _In_ const std::locale& locale)
414 {
415 assert(str1);
416 assert(str2);
417 size_t i; T1 a; T2 b;
418 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
419 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
420 for (i = 0; (a = ctype1.tolower(str1[i])) | (b = ctype2.tolower(str2[i])); i++) {
421 if (a > b) return +1;
422 if (a < b) return -1;
423 }
424 if (str1[i]) return +1;
425 if (str2[i]) return -1;
426 return 0;
427 }
428
438 template <class T1, class T2>
439 inline int strnicmp(_In_reads_or_z_opt_(count) const T1* str1, _In_reads_or_z_opt_(count) const T2* str2, _In_ size_t count, _In_ const std::locale& locale)
440 {
441 assert(str1 || !count);
442 assert(str2 || !count);
443 size_t i; T1 a; T2 b;
444 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
445 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
446 for (i = 0; i < count && ((a = ctype1.tolower(str1[i])) | (b = ctype2.tolower(str2[i]))); i++) {
447 if (a > b) return +1;
448 if (a < b) return -1;
449 }
450 if (i < count && str1[i]) return +1;
451 if (i < count && str2[i]) return -1;
452 return 0;
453 }
454
465 template <class T1, class T2>
466 inline int strnicmp(
467 _In_reads_or_z_opt_(count1) const T1* str1, _In_ size_t count1,
468 _In_reads_or_z_opt_(count2) const T2* str2, _In_ size_t count2,
469 _In_ const std::locale& locale)
470 {
471 assert(str1 || !count1);
472 assert(str2 || !count2);
473 size_t i; T1 a; T2 b;
474 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
475 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
476 for (i = 0; i < count1 && i < count2 && ((a = ctype1.tolower(str1[i])) | (b = ctype2.tolower(str2[i]))); i++) {
477 if (a > b) return +1;
478 if (a < b) return -1;
479 }
480 if (i < count1 && str1[i]) return +1;
481 if (i < count2 && str2[i]) return -1;
482 return 0;
483 }
484
493 template <class T1, class T2>
494 inline size_t strstr(
495 _In_z_ const T1* str,
496 _In_z_ const T2* sample)
497 {
498 assert(str);
499 assert(sample);
500 for (size_t offset = 0;; ++offset) {
501 for (size_t i = offset, j = 0;; ++i, ++j) {
502 if (!sample[j])
503 return offset;
504 if (!str[i])
505 return npos;
506 if (str[i] != sample[j])
507 break;
508 }
509 }
510 }
511
521 template <class T1, class T2>
522 inline size_t strnstr(
523 _In_reads_or_z_opt_(count) const T1* str,
524 _In_ size_t count,
525 _In_z_ const T2* sample)
526 {
527 assert(str || !count);
528 assert(sample);
529 for (size_t offset = 0;; ++offset) {
530 for (size_t i = offset, j = 0;; ++i, ++j) {
531 if (!sample[j])
532 return offset;
533 if (i >= count || !str[i])
534 return npos;
535 if (str[i] != sample[j])
536 break;
537 }
538 }
539 }
540
549 template <class T1, class T2>
550 inline size_t stristr(
551 _In_z_ const T1* str,
552 _In_z_ const T2* sample,
553 _In_ const std::locale& locale)
554 {
555 assert(str);
556 assert(sample);
557 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
558 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
559 for (size_t offset = 0;; ++offset) {
560 for (size_t i = offset, j = 0;; ++i, ++j) {
561 if (!sample[j])
562 return offset;
563 if (!str[i])
564 return npos;
565 if (ctype1.tolower(str[i]) != ctype2.tolower(sample[j]))
566 break;
567 }
568 }
569 }
570
580 template <class T1, class T2>
581 inline size_t strnistr(
582 _In_reads_or_z_opt_(count) const T1* str,
583 _In_ size_t count,
584 _In_z_ const T2* sample,
585 _In_ const std::locale& locale)
586 {
587 assert(str || !count);
588 assert(sample);
589 const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
590 const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
591 for (size_t offset = 0;; ++offset) {
592 for (size_t i = offset, j = 0;; ++i, ++j) {
593 if (!sample[j])
594 return offset;
595 if (i >= count || !str[i])
596 return npos;
597 if (ctype1.tolower(str[i]) != ctype2.tolower(sample[j]))
598 break;
599 }
600 }
601 }
602
611 template <class T1, class T2>
612 inline size_t strcpy(
613 _Out_writes_z_(_String_length_(src) + 1) T1* dst,
614 _In_z_ const T2* src)
615 {
616 assert(dst && src);
617 for (size_t i = 0; ; ++i) {
618 if ((dst[i] = src[i]) == 0)
619 return i;
620 }
621 }
622
632 template <class T1, class T2>
633 inline size_t strncpy(
634 _Out_writes_(count) _Post_maybez_ T1* dst,
635 _In_reads_or_z_opt_(count) const T2* src, _In_ size_t count)
636 {
637 assert(dst && src || !count);
638 for (size_t i = 0; ; ++i) {
639 if (i >= count)
640 return i;
641 if ((dst[i] = src[i]) == 0)
642 return i;
643 }
644 }
645
656 template <class T1, class T2>
657 inline size_t strncpy(
658 _Out_writes_(count_dst) _Post_maybez_ T1* dst, _In_ size_t count_dst,
659 _In_reads_or_z_opt_(count_src) const T2* src, _In_ size_t count_src)
660 {
661 assert(dst || !count_dst);
662 assert(src || !count_src);
663 for (size_t i = 0; ; ++i)
664 {
665 if (i > count_dst)
666 return i;
667 if (i > count_src) {
668 dst[i] = 0;
669 return i;
670 }
671 if ((dst[i] = src[i]) == 0)
672 return i;
673 }
674 }
675
684 template <class T1, class T2>
685 inline size_t strcat(
686 _In_z_ _Out_writes_z_(_String_length_(dst) + _String_length_(src) + 1) T1* dst,
687 _In_z_ const T2* src)
688 {
689 assert(dst && src);
690 for (size_t i = 0, j = stdex::strlen<T1>(dst); ; ++i, ++j) {
691 if ((dst[j] = src[i]) == 0)
692 return j;
693 }
694 }
695
705 template <class T1, class T2>
706 inline size_t strncat(
707 _Out_writes_(count) _Post_maybez_ T1* dst,
708 _In_reads_or_z_opt_(count) const T2* src, _In_ size_t count)
709 {
710 assert(dst && src || !count);
711 for (size_t i = 0, j = stdex::strlen<T1>(dst); ; ++i, ++j) {
712 if (i >= count)
713 return j;
714 if ((dst[j] = src[i]) == 0)
715 return j;
716 }
717 }
718
729 template <class T1, class T2>
730 inline size_t strncat(
731 _Out_writes_(count_dst) _Post_maybez_ T1* dst, _In_ size_t count_dst,
732 _In_reads_or_z_opt_(count_src) const T2* src, _In_ size_t count_src)
733 {
734 assert(dst || !count_dst);
735 assert(src || !count_src);
736 for (size_t i = 0, j = stdex::strnlen<T1>(dst, count_dst); ; ++i, ++j)
737 {
738 if (j > count_dst)
739 return j;
740 if (i > count_src) {
741 dst[j] = 0;
742 return j;
743 }
744 if ((dst[j] = src[i]) == 0)
745 return j;
746 }
747 }
748
759 template <class T>
760 inline _Check_return_ _Ret_maybenull_z_ T* strdup(_In_opt_z_ const T* str)
761 {
762 if (!str) _Unlikely_
763 return nullptr;
764 size_t count = strlen(str) + 1;
765 T* dst = new T[count];
766 strncpy(dst, count, str, SIZE_MAX);
767 return dst;
768 }
769
781 template <class T>
782 inline _Ret_z_ T* strndup(
783 _In_reads_or_z_opt_(count) const T* str,
784 _In_ size_t count)
785 {
786 T* dst = new T[count];
787 strncpy(dst, count, str, SIZE_MAX);
788 return dst;
789 }
790
800 template <class T>
801 inline size_t crlf2nl(_Out_writes_z_(strlen(src)) T* dst, _In_z_ const T* src)
802 {
803 assert(dst);
804 assert(src);
805 size_t i, j;
806 for (i = j = 0; src[j];) {
807 if (src[j] != '\r' || src[j + 1] != '\n')
808 dst[i++] = src[j++];
809 else {
810 dst[i++] = '\n';
811 j += 2;
812 }
813 }
814 dst[i] = 0;
815 return i;
816 }
817
819 template <class T, class T_bin>
820 inline T_bin strtoint(
821 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
822 _Out_opt_ size_t* end,
823 _In_ int radix,
824 _Out_ uint8_t& flags)
825 {
826 assert(str || !count);
827 assert(radix == 0 || 2 <= radix && radix <= 36);
828
829 size_t i = 0;
830 T_bin value = 0, digit,
831 max_ui = (T_bin)-1,
832 max_ui_pre1, max_ui_pre2;
833
834 flags = 0;
835
836 // Skip leading spaces.
837 for (;; ++i) {
838 if (i >= count || !str[i]) goto error;
839 if (!isspace(str[i])) break;
840 }
841
842 // Read the sign.
843 if (str[i] == '+') {
844 flags &= ~0x01;
845 ++i;
846 if (i >= count || !str[i]) goto error;
847 }
848 else if (str[i] == '-') {
849 flags |= 0x01;
850 ++i;
851 if (i >= count || !str[i]) goto error;
852 }
853
854 if (radix == 16) {
855 // On hexadecimal, allow leading 0x.
856 if (str[i] == '0' && i + 1 < count && (str[i + 1] == 'x' || str[i + 1] == 'X')) {
857 i += 2;
858 if (i >= count || !str[i]) goto error;
859 }
860 }
861 else if (!radix) {
862 // Autodetect radix.
863 if (str[i] == '0') {
864 ++i;
865 if (i >= count || !str[i]) goto error;
866 if (str[i] == 'x' || str[i] == 'X') {
867 radix = 16;
868 ++i;
869 if (i >= count || !str[i]) goto error;
870 }
871 else
872 radix = 8;
873 }
874 else
875 radix = 10;
876 }
877
878 // We have the radix.
879 max_ui_pre1 = max_ui / (T_bin)radix;
880 max_ui_pre2 = max_ui % (T_bin)radix;
881 for (;;) {
882 if ('0' <= str[i] && str[i] <= '9')
883 digit = (T_bin)str[i] - '0';
884 else if ('A' <= str[i] && str[i] <= 'Z')
885 digit = (T_bin)str[i] - 'A' + '\x0a';
886 else if ('a' <= str[i] && str[i] <= 'z')
887 digit = (T_bin)str[i] - 'a' + '\x0a';
888 else
889 goto error;
890 if (digit >= (T_bin)radix)
891 goto error;
892
893 if (value < max_ui_pre1 || // Multiplication nor addition will not overflow.
894 (value == max_ui_pre1 && digit <= max_ui_pre2)) // Small digits will not overflow.
895 value = value * (T_bin)radix + digit;
896 else {
897 // Overflow!
898 flags |= 0x02;
899 }
900
901 ++i;
902 if (i >= count || !str[i])
903 goto error;
904 }
905
906 error:
907 if (end) *end = i;
908 return value;
909 }
911
922 template <class T, class T_bin>
923 T_bin strtoint(
924 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
925 _Out_opt_ size_t* end,
926 _In_ int radix)
927 {
928 uint8_t flags;
929 T_bin value;
930
931 switch (sizeof(T_bin)) {
932 case 1:
933 value = (T_bin)strtoint<T, uint8_t>(str, count, end, radix, flags);
934 if ((flags & 0x01) && (value & 0x80)) {
935 // Sign bit is 1 => overflow.
936 flags |= 0x02;
937 }
938 return (flags & 0x02) ?
939 (flags & 0x01) ? (T_bin)0x80 : (T_bin)0x7f :
940 (flags & 0x01) ? -value : value;
941
942 case 2:
943 value = (T_bin)strtoint<T, uint16_t>(str, count, end, radix, flags);
944 if ((flags & 0x01) && (value & 0x8000)) {
945 // Sign bit is 1 => overflow.
946 flags |= 0x02;
947 }
948 return (flags & 0x02) ?
949 (flags & 0x01) ? (T_bin)0x8000 : (T_bin)0x7fff :
950 (flags & 0x01) ? -value : value;
951
952 case 4:
953 value = (T_bin)strtoint<T, uint32_t>(str, count, end, radix, flags);
954 if ((flags & 0x01) && (value & 0x80000000)) {
955 // Sign bit is 1 => overflow.
956 flags |= 0x02;
957 }
958 return (flags & 0x02) ?
959 (flags & 0x01) ? (T_bin)0x80000000 : (T_bin)0x7fffffff :
960 (flags & 0x01) ? -value : value;
961
962 case 8:
963 value = (T_bin)strtoint<T, uint64_t>(str, count, end, radix, flags);
964 if ((flags & 0x01) && (value & 0x8000000000000000)) {
965 // Sign bit is 1 => overflow.
966 flags |= 0x02;
967 }
968 return (flags & 0x02) ?
969 (flags & 0x01) ? (T_bin)0x8000000000000000 : (T_bin)0x7fffffffffffffff :
970 (flags & 0x01) ? -value : value;
971
972 default:
973 throw std::invalid_argument("Unsupported bit length");
974 }
975 }
976
987 template <class T, class T_bin>
988 inline T_bin strtouint(
989 _In_reads_or_z_opt_(count) const T* str,
990 _In_ size_t count,
991 _Out_opt_ size_t* end,
992 _In_ int radix)
993 {
994 uint8_t flags;
995 T_bin value;
996
997 switch (sizeof(T_bin)) {
998 case 1: value = (T_bin)strtoint<T, uint8_t>(str, count, end, radix, flags); break;
999 case 2: value = (T_bin)strtoint<T, uint16_t>(str, count, end, radix, flags); break;
1000 case 4: value = (T_bin)strtoint<T, uint32_t>(str, count, end, radix, flags); break;
1001 case 8: value = (T_bin)strtoint<T, uint64_t>(str, count, end, radix, flags); break;
1002 default: throw std::invalid_argument("Unsupported bit length");
1003 }
1004
1005 return (flags & 0x02) ?
1006 (flags & 0x01) ? (T_bin)0 : (T_bin)-1 :
1007 (flags & 0x01) ? ~value : value;
1008 }
1009
1020 template <class T>
1021 inline int32_t strto32(
1022 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1023 _Out_opt_ size_t* end,
1024 _In_ int radix)
1025 {
1026 return strtoint<T, int32_t>(str, count, end, radix);
1027 }
1028
1039 template <class T>
1040 inline int64_t strto64(
1041 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1042 _Out_opt_ size_t* end,
1043 _In_ int radix)
1044 {
1045 return strtoint<T, int64_t>(str, count, end, radix);
1046 }
1047
1059 template <class T>
1060 inline intptr_t strtoi(
1061 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1062 _Out_opt_ size_t* end,
1063 _In_ int radix)
1064 {
1065#if defined(_WIN64) || defined(__LP64__)
1066 return (intptr_t)strto64(str, count, end, radix);
1067#else
1068 return (intptr_t)strto32(str, count, end, radix);
1069#endif
1070 }
1071
1082 template <class T>
1083 inline uint32_t strtou32(
1084 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1085 _Out_opt_ size_t* end,
1086 _In_ int radix)
1087 {
1088 return strtouint<T, uint32_t>(str, count, end, radix);
1089 }
1090
1101 template <class T>
1102 inline uint64_t strtou64(
1103 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1104 _Out_opt_ size_t* end,
1105 _In_ int radix)
1106 {
1107 return strtouint<T, uint64_t>(str, count, end, radix);
1108 }
1109
1121 template <class T>
1122 inline size_t strtoui(
1123 _In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
1124 _Out_opt_ size_t* end,
1125 _In_ int radix)
1126 {
1127#if defined(_WIN64) || defined(__LP64__)
1128 return (size_t)strtou64(str, count, end, radix);
1129#else
1130 return (size_t)strtou32(str, count, end, radix);
1131#endif
1132 }
1133
1135 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)
1136 {
1137 int r;
1138#ifdef _WIN32
1139 // Don't use _vsnprintf_s(). It terminates the string even if we want to print to the edge of the buffer.
1140#pragma warning(suppress: 4996)
1141 r = _vsnprintf_l(str, capacity, format, locale, arg);
1142#else
1143 r = ::vsnprintf(str, capacity, format, arg);
1144#endif
1145 if (r == -1 && strnlen(str, capacity) == capacity) {
1146 // Buffer overrun. Estimate buffer size for the next iteration.
1147 capacity += std::max<size_t>(capacity / 8, 0x80);
1148 if (capacity > INT_MAX)
1149 throw std::invalid_argument("string too big");
1150 return (int)capacity;
1151 }
1152 return r;
1153 }
1154
1155 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)
1156 {
1157 int r;
1158
1159#ifdef _WIN32
1160 // Don't use _vsnwprintf_s(). It terminates the string even if we want to print to the edge of the buffer.
1161#pragma warning(suppress: 4996)
1162 r = _vsnwprintf_l(str, capacity, format, locale, arg);
1163#else
1164 r = vswprintf(str, capacity, format, arg);
1165#endif
1166 if (r == -1 && strnlen(str, capacity) == capacity) {
1167 // Buffer overrun. Estimate buffer size for the next iteration.
1168 capacity += std::max<size_t>(capacity / 8, 0x80);
1169 if (capacity > INT_MAX)
1170 throw std::invalid_argument("string too big");
1171 return (int)capacity;
1172 }
1173 return r;
1174 }
1176
1185 template<class _Elem, class _Traits, class _Ax>
1186 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)
1187 {
1188 _Elem buf[1024/sizeof(_Elem)];
1189
1190 // Try with stack buffer first.
1191 int count = vsnprintf(buf, _countof(buf) - 1, format, locale, arg);
1192 if (count >= 0) {
1193 // Copy from stack.
1194 str.append(buf, count);
1195 } else {
1196 for (size_t capacity = 2*1024/sizeof(_Elem);; capacity *= 2) {
1197 // Allocate on heap and retry.
1198 auto buf_dyn = std::make_unique<_Elem[]>(capacity);
1199 count = vsnprintf(buf_dyn.get(), capacity - 1, format, locale, arg);
1200 if (count >= 0) {
1201 str.append(buf_dyn.get(), count);
1202 break;
1203 }
1204 }
1205 }
1206 }
1207
1215 template<class _Elem, class _Traits, class _Ax>
1216 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, ...)
1217 {
1218 va_list arg;
1219 va_start(arg, locale);
1220 vappendf(str, format, locale, arg);
1221 va_end(arg);
1222 }
1223
1232 template<class _Elem, class _Traits, class _Ax>
1233 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)
1234 {
1235 str.clear();
1236 vappendf(str, format, locale, arg);
1237 }
1238
1246 template<class _Elem, class _Traits, class _Ax>
1247 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, ...)
1248 {
1249 va_list arg;
1250 va_start(arg, locale);
1251 vsprintf(str, format, locale, arg);
1252 va_end(arg);
1253 }
1254
1264 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
1265 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)
1266 {
1267 std::basic_string<_Elem, _Traits, _Ax> str;
1268 vappendf(str, format, locale, arg);
1269 return str;
1270 }
1271
1280 template<class _Elem, class _Traits = std::char_traits<_Elem>, class _Ax = std::allocator<_Elem>>
1281 inline std::basic_string<_Elem, _Traits, _Ax> sprintf(_In_z_ _Printf_format_string_params_(2) const _Elem *format, _In_opt_ locale_t locale, ...)
1282 {
1283 va_list arg;
1284 va_start(arg, locale);
1285 auto str = vsprintf(format, locale, arg);
1286 va_end(arg);
1287 return str;
1288 }
1289
1297 template<class T>
1298 inline void strlwr(_Inout_z_ T* str, _In_ const std::locale& locale)
1299 {
1300 assert(str);
1301 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
1302 for (size_t i = 0; str[i]; ++i)
1303 str[i] = ctype.tolower(str[i]);
1304 }
1305
1314 template<class T>
1315 inline void strlwr(_Inout_updates_z_(count) T* str, _In_ size_t count, _In_ const std::locale& locale)
1316 {
1317 assert(str || !count);
1318 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
1319 for (size_t i = 0; i < count && str[i]; ++i)
1320 str[i] = ctype.tolower(str[i]);
1321 }
1322
1330 template<class T>
1331 inline void strupr(_Inout_z_ T* str, _In_ const std::locale& locale)
1332 {
1333 assert(str);
1334 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
1335 for (size_t i = 0; str[i]; ++i)
1336 str[i] = ctype.toupper(str[i]);
1337 }
1338
1347 template<class T>
1348 inline void strupr
1349 (_Inout_updates_z_(count) T* str, _In_ size_t count, _In_ const std::locale& locale)
1350 {
1351 assert(str || !count);
1352 const auto& ctype = std::use_facet<std::ctype<T>>(locale);
1353 for (size_t i = 0; i < count && str[i]; ++i)
1354 str[i] = ctype.toupper(str[i]);
1355 }
1356}
stdex::free_locale_delete
Deleter for unique_ptr using free_locale.
Definition string.hpp:56
stdex::free_locale_delete::operator()
void operator()(locale_t locale) const
Delete a pointer.
Definition string.hpp:60
Generated on Mon Sep 25 2023 13:05:00 for stdex by doxygen 1.9.8