string_util_win.h 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef BASE_STRINGS_STRING_UTIL_WIN_H_
  5. #define BASE_STRINGS_STRING_UTIL_WIN_H_
  6. #include <stdarg.h>
  7. #include <stddef.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <wchar.h>
  11. #include <string>
  12. #include <vector>
  13. #include "base/check.h"
  14. #include "base/containers/span.h"
  15. #include "base/strings/string_piece.h"
  16. #include "base/strings/string_util.h"
  17. namespace base {
  18. // Chromium code style is to not use malloc'd strings; this is only for use
  19. // for interaction with APIs that require it.
  20. inline char* strdup(const char* str) {
  21. return _strdup(str);
  22. }
  23. inline int vsnprintf(char* buffer, size_t size,
  24. const char* format, va_list arguments) {
  25. int length = vsnprintf_s(buffer, size, size - 1, format, arguments);
  26. if (length < 0)
  27. return _vscprintf(format, arguments);
  28. return length;
  29. }
  30. inline int vswprintf(wchar_t* buffer, size_t size,
  31. const wchar_t* format, va_list arguments) {
  32. DCHECK(IsWprintfFormatPortable(format));
  33. int length = _vsnwprintf_s(buffer, size, size - 1, format, arguments);
  34. if (length < 0)
  35. return _vscwprintf(format, arguments);
  36. return length;
  37. }
  38. // Utility functions to access the underlying string buffer as a wide char
  39. // pointer.
  40. //
  41. // Note: These functions violate strict aliasing when char16_t and wchar_t are
  42. // unrelated types. We thus pass -fno-strict-aliasing to the compiler on
  43. // non-Windows platforms [1], and rely on it being off in Clang's CL mode [2].
  44. //
  45. // [1] https://crrev.com/b9a0976622/build/config/compiler/BUILD.gn#244
  46. // [2]
  47. // https://github.com/llvm/llvm-project/blob/1e28a66/clang/lib/Driver/ToolChains/Clang.cpp#L3949
  48. inline wchar_t* as_writable_wcstr(char16_t* str) {
  49. return reinterpret_cast<wchar_t*>(str);
  50. }
  51. inline wchar_t* as_writable_wcstr(std::u16string& str) {
  52. return reinterpret_cast<wchar_t*>(data(str));
  53. }
  54. inline const wchar_t* as_wcstr(const char16_t* str) {
  55. return reinterpret_cast<const wchar_t*>(str);
  56. }
  57. inline const wchar_t* as_wcstr(StringPiece16 str) {
  58. return reinterpret_cast<const wchar_t*>(str.data());
  59. }
  60. // Utility functions to access the underlying string buffer as a char16_t
  61. // pointer.
  62. inline char16_t* as_writable_u16cstr(wchar_t* str) {
  63. return reinterpret_cast<char16_t*>(str);
  64. }
  65. inline char16_t* as_writable_u16cstr(std::wstring& str) {
  66. return reinterpret_cast<char16_t*>(data(str));
  67. }
  68. inline const char16_t* as_u16cstr(const wchar_t* str) {
  69. return reinterpret_cast<const char16_t*>(str);
  70. }
  71. inline const char16_t* as_u16cstr(WStringPiece str) {
  72. return reinterpret_cast<const char16_t*>(str.data());
  73. }
  74. // Utility functions to convert between base::WStringPiece and
  75. // base::StringPiece16.
  76. inline WStringPiece AsWStringPiece(StringPiece16 str) {
  77. return WStringPiece(as_wcstr(str.data()), str.size());
  78. }
  79. inline StringPiece16 AsStringPiece16(WStringPiece str) {
  80. return StringPiece16(as_u16cstr(str.data()), str.size());
  81. }
  82. inline std::wstring AsWString(StringPiece16 str) {
  83. return std::wstring(as_wcstr(str.data()), str.size());
  84. }
  85. inline std::u16string AsString16(WStringPiece str) {
  86. return std::u16string(as_u16cstr(str.data()), str.size());
  87. }
  88. // The following section contains overloads of the cross-platform APIs for
  89. // std::wstring and base::WStringPiece.
  90. BASE_EXPORT bool IsStringASCII(WStringPiece str);
  91. BASE_EXPORT std::wstring ToLowerASCII(WStringPiece str);
  92. BASE_EXPORT std::wstring ToUpperASCII(WStringPiece str);
  93. BASE_EXPORT int CompareCaseInsensitiveASCII(WStringPiece a, WStringPiece b);
  94. inline bool EqualsCaseInsensitiveASCII(WStringPiece a, WStringPiece b) {
  95. return internal::EqualsCaseInsensitiveASCIIT(a, b);
  96. }
  97. inline bool EqualsCaseInsensitiveASCII(WStringPiece a, StringPiece b) {
  98. return internal::EqualsCaseInsensitiveASCIIT(a, b);
  99. }
  100. inline bool EqualsCaseInsensitiveASCII(StringPiece a, WStringPiece b) {
  101. return internal::EqualsCaseInsensitiveASCIIT(a, b);
  102. }
  103. BASE_EXPORT bool RemoveChars(WStringPiece input,
  104. WStringPiece remove_chars,
  105. std::wstring* output);
  106. BASE_EXPORT bool ReplaceChars(WStringPiece input,
  107. WStringPiece replace_chars,
  108. WStringPiece replace_with,
  109. std::wstring* output);
  110. BASE_EXPORT bool TrimString(WStringPiece input,
  111. WStringPiece trim_chars,
  112. std::wstring* output);
  113. BASE_EXPORT WStringPiece TrimString(WStringPiece input,
  114. WStringPiece trim_chars,
  115. TrimPositions positions);
  116. BASE_EXPORT TrimPositions TrimWhitespace(WStringPiece input,
  117. TrimPositions positions,
  118. std::wstring* output);
  119. BASE_EXPORT WStringPiece TrimWhitespace(WStringPiece input,
  120. TrimPositions positions);
  121. BASE_EXPORT std::wstring CollapseWhitespace(
  122. WStringPiece text,
  123. bool trim_sequences_with_line_breaks);
  124. BASE_EXPORT bool ContainsOnlyChars(WStringPiece input, WStringPiece characters);
  125. BASE_EXPORT bool EqualsASCII(StringPiece16 str, StringPiece ascii);
  126. BASE_EXPORT bool StartsWith(
  127. WStringPiece str,
  128. WStringPiece search_for,
  129. CompareCase case_sensitivity = CompareCase::SENSITIVE);
  130. BASE_EXPORT bool EndsWith(
  131. WStringPiece str,
  132. WStringPiece search_for,
  133. CompareCase case_sensitivity = CompareCase::SENSITIVE);
  134. BASE_EXPORT void ReplaceFirstSubstringAfterOffset(std::wstring* str,
  135. size_t start_offset,
  136. WStringPiece find_this,
  137. WStringPiece replace_with);
  138. BASE_EXPORT void ReplaceSubstringsAfterOffset(std::wstring* str,
  139. size_t start_offset,
  140. WStringPiece find_this,
  141. WStringPiece replace_with);
  142. BASE_EXPORT wchar_t* WriteInto(std::wstring* str, size_t length_with_null);
  143. BASE_EXPORT std::wstring JoinString(span<const std::wstring> parts,
  144. WStringPiece separator);
  145. BASE_EXPORT std::wstring JoinString(span<const WStringPiece> parts,
  146. WStringPiece separator);
  147. BASE_EXPORT std::wstring JoinString(std::initializer_list<WStringPiece> parts,
  148. WStringPiece separator);
  149. BASE_EXPORT std::wstring ReplaceStringPlaceholders(
  150. WStringPiece format_string,
  151. const std::vector<std::wstring>& subst,
  152. std::vector<size_t>* offsets);
  153. } // namespace base
  154. #endif // BASE_STRINGS_STRING_UTIL_WIN_H_