string_util.cc 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430
  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. #include "base/strings/string_util.h"
  5. #include <ctype.h>
  6. #include <errno.h>
  7. #include <math.h>
  8. #include <stdarg.h>
  9. #include <stdint.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #include <wchar.h>
  15. #include <wctype.h>
  16. #include <algorithm>
  17. #include <limits>
  18. #include <type_traits>
  19. #include <vector>
  20. #include "base/check_op.h"
  21. #include "base/no_destructor.h"
  22. #include "base/strings/string_util_internal.h"
  23. #include "base/strings/utf_string_conversion_utils.h"
  24. #include "base/strings/utf_string_conversions.h"
  25. #include "base/third_party/icu/icu_utf.h"
  26. #include "build/build_config.h"
  27. namespace base {
  28. bool IsWprintfFormatPortable(const wchar_t* format) {
  29. for (const wchar_t* position = format; *position != '\0'; ++position) {
  30. if (*position == '%') {
  31. bool in_specification = true;
  32. bool modifier_l = false;
  33. while (in_specification) {
  34. // Eat up characters until reaching a known specifier.
  35. if (*++position == '\0') {
  36. // The format string ended in the middle of a specification. Call
  37. // it portable because no unportable specifications were found. The
  38. // string is equally broken on all platforms.
  39. return true;
  40. }
  41. if (*position == 'l') {
  42. // 'l' is the only thing that can save the 's' and 'c' specifiers.
  43. modifier_l = true;
  44. } else if (((*position == 's' || *position == 'c') && !modifier_l) ||
  45. *position == 'S' || *position == 'C' || *position == 'F' ||
  46. *position == 'D' || *position == 'O' || *position == 'U') {
  47. // Not portable.
  48. return false;
  49. }
  50. if (wcschr(L"diouxXeEfgGaAcspn%", *position)) {
  51. // Portable, keep scanning the rest of the format string.
  52. in_specification = false;
  53. }
  54. }
  55. }
  56. }
  57. return true;
  58. }
  59. std::string ToLowerASCII(StringPiece str) {
  60. return internal::ToLowerASCIIImpl(str);
  61. }
  62. std::u16string ToLowerASCII(StringPiece16 str) {
  63. return internal::ToLowerASCIIImpl(str);
  64. }
  65. std::string ToUpperASCII(StringPiece str) {
  66. return internal::ToUpperASCIIImpl(str);
  67. }
  68. std::u16string ToUpperASCII(StringPiece16 str) {
  69. return internal::ToUpperASCIIImpl(str);
  70. }
  71. int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b) {
  72. return internal::CompareCaseInsensitiveASCIIT(a, b);
  73. }
  74. int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
  75. return internal::CompareCaseInsensitiveASCIIT(a, b);
  76. }
  77. const std::string& EmptyString() {
  78. static const base::NoDestructor<std::string> s;
  79. return *s;
  80. }
  81. const std::u16string& EmptyString16() {
  82. static const base::NoDestructor<std::u16string> s16;
  83. return *s16;
  84. }
  85. bool ReplaceChars(StringPiece16 input,
  86. StringPiece16 replace_chars,
  87. StringPiece16 replace_with,
  88. std::u16string* output) {
  89. return internal::ReplaceCharsT(input, replace_chars, replace_with, output);
  90. }
  91. bool ReplaceChars(StringPiece input,
  92. StringPiece replace_chars,
  93. StringPiece replace_with,
  94. std::string* output) {
  95. return internal::ReplaceCharsT(input, replace_chars, replace_with, output);
  96. }
  97. bool RemoveChars(StringPiece16 input,
  98. StringPiece16 remove_chars,
  99. std::u16string* output) {
  100. return internal::ReplaceCharsT(input, remove_chars, StringPiece16(), output);
  101. }
  102. bool RemoveChars(StringPiece input,
  103. StringPiece remove_chars,
  104. std::string* output) {
  105. return internal::ReplaceCharsT(input, remove_chars, StringPiece(), output);
  106. }
  107. bool TrimString(StringPiece16 input,
  108. StringPiece16 trim_chars,
  109. std::u16string* output) {
  110. return internal::TrimStringT(input, trim_chars, TRIM_ALL, output) !=
  111. TRIM_NONE;
  112. }
  113. bool TrimString(StringPiece input,
  114. StringPiece trim_chars,
  115. std::string* output) {
  116. return internal::TrimStringT(input, trim_chars, TRIM_ALL, output) !=
  117. TRIM_NONE;
  118. }
  119. StringPiece16 TrimString(StringPiece16 input,
  120. StringPiece16 trim_chars,
  121. TrimPositions positions) {
  122. return internal::TrimStringPieceT(input, trim_chars, positions);
  123. }
  124. StringPiece TrimString(StringPiece input,
  125. StringPiece trim_chars,
  126. TrimPositions positions) {
  127. return internal::TrimStringPieceT(input, trim_chars, positions);
  128. }
  129. void TruncateUTF8ToByteSize(const std::string& input,
  130. const size_t byte_size,
  131. std::string* output) {
  132. DCHECK(output);
  133. if (byte_size > input.length()) {
  134. *output = input;
  135. return;
  136. }
  137. DCHECK_LE(byte_size,
  138. static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
  139. // Note: This cast is necessary because CBU8_NEXT uses int32_ts.
  140. int32_t truncation_length = static_cast<int32_t>(byte_size);
  141. int32_t char_index = truncation_length - 1;
  142. const char* data = input.data();
  143. // Using CBU8, we will move backwards from the truncation point
  144. // to the beginning of the string looking for a valid UTF8
  145. // character. Once a full UTF8 character is found, we will
  146. // truncate the string to the end of that character.
  147. while (char_index >= 0) {
  148. int32_t prev = char_index;
  149. base_icu::UChar32 code_point = 0;
  150. CBU8_NEXT(reinterpret_cast<const uint8_t*>(data), char_index,
  151. truncation_length, code_point);
  152. if (!IsValidCharacter(code_point)) {
  153. char_index = prev - 1;
  154. } else {
  155. break;
  156. }
  157. }
  158. if (char_index >= 0 )
  159. *output = input.substr(0, static_cast<size_t>(char_index));
  160. else
  161. output->clear();
  162. }
  163. TrimPositions TrimWhitespace(StringPiece16 input,
  164. TrimPositions positions,
  165. std::u16string* output) {
  166. return internal::TrimStringT(input, StringPiece16(kWhitespaceUTF16),
  167. positions, output);
  168. }
  169. StringPiece16 TrimWhitespace(StringPiece16 input,
  170. TrimPositions positions) {
  171. return internal::TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16),
  172. positions);
  173. }
  174. TrimPositions TrimWhitespaceASCII(StringPiece input,
  175. TrimPositions positions,
  176. std::string* output) {
  177. return internal::TrimStringT(input, StringPiece(kWhitespaceASCII), positions,
  178. output);
  179. }
  180. StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions) {
  181. return internal::TrimStringPieceT(input, StringPiece(kWhitespaceASCII),
  182. positions);
  183. }
  184. std::u16string CollapseWhitespace(StringPiece16 text,
  185. bool trim_sequences_with_line_breaks) {
  186. return internal::CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
  187. }
  188. std::string CollapseWhitespaceASCII(StringPiece text,
  189. bool trim_sequences_with_line_breaks) {
  190. return internal::CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
  191. }
  192. bool ContainsOnlyChars(StringPiece input, StringPiece characters) {
  193. return input.find_first_not_of(characters) == StringPiece::npos;
  194. }
  195. bool ContainsOnlyChars(StringPiece16 input, StringPiece16 characters) {
  196. return input.find_first_not_of(characters) == StringPiece16::npos;
  197. }
  198. bool IsStringASCII(StringPiece str) {
  199. return internal::DoIsStringASCII(str.data(), str.length());
  200. }
  201. bool IsStringASCII(StringPiece16 str) {
  202. return internal::DoIsStringASCII(str.data(), str.length());
  203. }
  204. #if defined(WCHAR_T_IS_UTF32)
  205. bool IsStringASCII(WStringPiece str) {
  206. return internal::DoIsStringASCII(str.data(), str.length());
  207. }
  208. #endif
  209. bool IsStringUTF8(StringPiece str) {
  210. return internal::DoIsStringUTF8<IsValidCharacter>(str);
  211. }
  212. bool IsStringUTF8AllowingNoncharacters(StringPiece str) {
  213. return internal::DoIsStringUTF8<IsValidCodepoint>(str);
  214. }
  215. bool EqualsASCII(StringPiece16 str, StringPiece ascii) {
  216. return std::equal(ascii.begin(), ascii.end(), str.begin(), str.end());
  217. }
  218. bool StartsWith(StringPiece str,
  219. StringPiece search_for,
  220. CompareCase case_sensitivity) {
  221. return internal::StartsWithT(str, search_for, case_sensitivity);
  222. }
  223. bool StartsWith(StringPiece16 str,
  224. StringPiece16 search_for,
  225. CompareCase case_sensitivity) {
  226. return internal::StartsWithT(str, search_for, case_sensitivity);
  227. }
  228. bool EndsWith(StringPiece str,
  229. StringPiece search_for,
  230. CompareCase case_sensitivity) {
  231. return internal::EndsWithT(str, search_for, case_sensitivity);
  232. }
  233. bool EndsWith(StringPiece16 str,
  234. StringPiece16 search_for,
  235. CompareCase case_sensitivity) {
  236. return internal::EndsWithT(str, search_for, case_sensitivity);
  237. }
  238. char HexDigitToInt(char c) {
  239. DCHECK(IsHexDigit(c));
  240. if (c >= '0' && c <= '9')
  241. return static_cast<char>(c - '0');
  242. return (c >= 'A' && c <= 'F') ? static_cast<char>(c - 'A' + 10)
  243. : static_cast<char>(c - 'a' + 10);
  244. }
  245. static const char* const kByteStringsUnlocalized[] = {
  246. " B",
  247. " kB",
  248. " MB",
  249. " GB",
  250. " TB",
  251. " PB"
  252. };
  253. std::u16string FormatBytesUnlocalized(int64_t bytes) {
  254. double unit_amount = static_cast<double>(bytes);
  255. size_t dimension = 0;
  256. const int kKilo = 1024;
  257. while (unit_amount >= kKilo &&
  258. dimension < std::size(kByteStringsUnlocalized) - 1) {
  259. unit_amount /= kKilo;
  260. dimension++;
  261. }
  262. char buf[64];
  263. if (bytes != 0 && dimension > 0 && unit_amount < 100) {
  264. base::snprintf(buf, std::size(buf), "%.1lf%s", unit_amount,
  265. kByteStringsUnlocalized[dimension]);
  266. } else {
  267. base::snprintf(buf, std::size(buf), "%.0lf%s", unit_amount,
  268. kByteStringsUnlocalized[dimension]);
  269. }
  270. return ASCIIToUTF16(buf);
  271. }
  272. void ReplaceFirstSubstringAfterOffset(std::u16string* str,
  273. size_t start_offset,
  274. StringPiece16 find_this,
  275. StringPiece16 replace_with) {
  276. internal::DoReplaceMatchesAfterOffset(
  277. str, start_offset, internal::MakeSubstringMatcher(find_this),
  278. replace_with, internal::ReplaceType::REPLACE_FIRST);
  279. }
  280. void ReplaceFirstSubstringAfterOffset(std::string* str,
  281. size_t start_offset,
  282. StringPiece find_this,
  283. StringPiece replace_with) {
  284. internal::DoReplaceMatchesAfterOffset(
  285. str, start_offset, internal::MakeSubstringMatcher(find_this),
  286. replace_with, internal::ReplaceType::REPLACE_FIRST);
  287. }
  288. void ReplaceSubstringsAfterOffset(std::u16string* str,
  289. size_t start_offset,
  290. StringPiece16 find_this,
  291. StringPiece16 replace_with) {
  292. internal::DoReplaceMatchesAfterOffset(
  293. str, start_offset, internal::MakeSubstringMatcher(find_this),
  294. replace_with, internal::ReplaceType::REPLACE_ALL);
  295. }
  296. void ReplaceSubstringsAfterOffset(std::string* str,
  297. size_t start_offset,
  298. StringPiece find_this,
  299. StringPiece replace_with) {
  300. internal::DoReplaceMatchesAfterOffset(
  301. str, start_offset, internal::MakeSubstringMatcher(find_this),
  302. replace_with, internal::ReplaceType::REPLACE_ALL);
  303. }
  304. char* WriteInto(std::string* str, size_t length_with_null) {
  305. return internal::WriteIntoT(str, length_with_null);
  306. }
  307. char16_t* WriteInto(std::u16string* str, size_t length_with_null) {
  308. return internal::WriteIntoT(str, length_with_null);
  309. }
  310. std::string JoinString(span<const std::string> parts, StringPiece separator) {
  311. return internal::JoinStringT(parts, separator);
  312. }
  313. std::u16string JoinString(span<const std::u16string> parts,
  314. StringPiece16 separator) {
  315. return internal::JoinStringT(parts, separator);
  316. }
  317. std::string JoinString(span<const StringPiece> parts, StringPiece separator) {
  318. return internal::JoinStringT(parts, separator);
  319. }
  320. std::u16string JoinString(span<const StringPiece16> parts,
  321. StringPiece16 separator) {
  322. return internal::JoinStringT(parts, separator);
  323. }
  324. std::string JoinString(std::initializer_list<StringPiece> parts,
  325. StringPiece separator) {
  326. return internal::JoinStringT(parts, separator);
  327. }
  328. std::u16string JoinString(std::initializer_list<StringPiece16> parts,
  329. StringPiece16 separator) {
  330. return internal::JoinStringT(parts, separator);
  331. }
  332. std::u16string ReplaceStringPlaceholders(
  333. StringPiece16 format_string,
  334. const std::vector<std::u16string>& subst,
  335. std::vector<size_t>* offsets) {
  336. return internal::DoReplaceStringPlaceholders(format_string, subst, offsets);
  337. }
  338. std::string ReplaceStringPlaceholders(StringPiece format_string,
  339. const std::vector<std::string>& subst,
  340. std::vector<size_t>* offsets) {
  341. return internal::DoReplaceStringPlaceholders(format_string, subst, offsets);
  342. }
  343. std::u16string ReplaceStringPlaceholders(const std::u16string& format_string,
  344. const std::u16string& a,
  345. size_t* offset) {
  346. std::vector<size_t> offsets;
  347. std::u16string result =
  348. ReplaceStringPlaceholders(format_string, {a}, &offsets);
  349. DCHECK_EQ(1U, offsets.size());
  350. if (offset)
  351. *offset = offsets[0];
  352. return result;
  353. }
  354. size_t strlcpy(char* dst, const char* src, size_t dst_size) {
  355. return internal::lcpyT(dst, src, dst_size);
  356. }
  357. size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
  358. return internal::lcpyT(dst, src, dst_size);
  359. }
  360. } // namespace base