Diff
Modified: trunk/Source/_javascript_Core/API/JSValue.mm (291799 => 291800)
--- trunk/Source/_javascript_Core/API/JSValue.mm 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/API/JSValue.mm 2022-03-24 16:55:40 UTC (rev 291800)
@@ -1179,7 +1179,7 @@
return;
// Try to find a matching valueWith<Foo>:context: method.
auto type = adoptSystem<char[]>(method_copyReturnType(method));
- StructHandlers::iterator iter = structHandlers->find(String { type.get() });
+ StructHandlers::iterator iter = structHandlers->find(type.get());
if (iter == structHandlers->end())
return;
StructTagHandler& handler = iter->value;
@@ -1217,7 +1217,7 @@
static StructHandlers* structHandlers = createStructHandlerMap();
- StructHandlers::iterator iter = structHandlers->find(String { encodedType });
+ StructHandlers::iterator iter = structHandlers->find(encodedType);
if (iter == structHandlers->end())
return 0;
return &iter->value;
Modified: trunk/Source/_javascript_Core/API/JSWrapperMap.mm (291799 => 291800)
--- trunk/Source/_javascript_Core/API/JSWrapperMap.mm 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/API/JSWrapperMap.mm 2022-03-24 16:55:40 UTC (rev 291800)
@@ -451,7 +451,7 @@
forEachMethodInClass(currentClass, ^(Method method) {
SEL selector = method_getName(method);
const char* name = sel_getName(selector);
- auto iter = initTable.find(String { name });
+ auto iter = initTable.find(name);
if (iter == initTable.end())
return;
Modified: trunk/Source/_javascript_Core/inspector/agents/InspectorAuditAgent.cpp (291799 => 291800)
--- trunk/Source/_javascript_Core/inspector/agents/InspectorAuditAgent.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/inspector/agents/InspectorAuditAgent.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -92,7 +92,7 @@
if (injectedScript.hasNoValue())
return makeUnexpected(errorString);
- auto functionString = makeString("(function(WebInspectorAudit) { \"use strict\"; return eval(`(", String { test }.replace('`', "\\`"_s), ")`)(WebInspectorAudit); })");
+ auto functionString = makeString("(function(WebInspectorAudit) { \"use strict\"; return eval(`(", String { test }.replace('`', "\\`"), ")`)(WebInspectorAudit); })");
InjectedScript::ExecuteOptions options;
options.objectGroup = "audit"_s;
Modified: trunk/Source/_javascript_Core/jit/ExecutableAllocator.cpp (291799 => 291800)
--- trunk/Source/_javascript_Core/jit/ExecutableAllocator.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/jit/ExecutableAllocator.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -1153,7 +1153,7 @@
{
if (fd == -1) {
String path { Options::dumpJITMemoryPath() };
- path = path.replace("%pid"_s, String::number(getCurrentProcessID()));
+ path = path.replace("%pid", String::number(getCurrentProcessID()));
fd = open(FileSystem::fileSystemRepresentation(path).data(), O_CREAT | O_TRUNC | O_APPEND | O_WRONLY | O_EXLOCK | O_NONBLOCK, 0666);
RELEASE_ASSERT(fd != -1);
}
Modified: trunk/Source/_javascript_Core/runtime/ExceptionHelpers.cpp (291799 => 291800)
--- trunk/Source/_javascript_Core/runtime/ExceptionHelpers.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/runtime/ExceptionHelpers.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -161,7 +161,7 @@
return defaultApproximateSourceError(originalMessage, sourceText);
ASSERT(occurrence == ErrorInstance::FoundExactSource);
- auto notAFunctionIndex = originalMessage.reverseFind("is not a function"_s);
+ auto notAFunctionIndex = originalMessage.reverseFind("is not a function");
RELEASE_ASSERT(notAFunctionIndex != notFound);
StringView displayValue;
if (originalMessage.is8Bit())
@@ -197,7 +197,7 @@
return defaultApproximateSourceError(originalMessage, sourceText);
ASSERT(occurrence == ErrorInstance::FoundExactSource);
- auto inIndex = sourceText.reverseFind("in"_s);
+ auto inIndex = sourceText.reverseFind("in");
if (inIndex == notFound) {
// This should basically never happen, since JS code must use the literal
// text "in" for the `in` operation. However, if we fail to find "in"
@@ -218,7 +218,7 @@
return defaultApproximateSourceError(originalMessage, sourceText);
ASSERT(occurrence == ErrorInstance::FoundExactSource);
- auto instanceofIndex = sourceText.reverseFind("instanceof"_s);
+ auto instanceofIndex = sourceText.reverseFind("instanceof");
// This can happen when Symbol.hasInstance function is directly called.
if (instanceofIndex == notFound)
return originalMessage;
@@ -246,7 +246,7 @@
if (occurrence == ErrorInstance::FoundApproximateSource)
return defaultApproximateSourceError(originalMessage, sourceText);
- auto extendsIndex = sourceText.reverseFind("extends"_s);
+ auto extendsIndex = sourceText.reverseFind("extends");
if (extendsIndex == notFound || sourceText.find("extends") != extendsIndex)
return makeString(originalMessage, " (evaluating '", sourceText, "')");
Modified: trunk/Source/_javascript_Core/runtime/TypeProfiler.cpp (291799 => 291800)
--- trunk/Source/_javascript_Core/runtime/TypeProfiler.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/runtime/TypeProfiler.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -53,9 +53,9 @@
dataLog("\t\t", location->m_globalVariableID == TypeProfilerReturnStatement ? "[Return Statement]" : "[Normal Statement]", "\n");
- dataLog("\t\t#Local#\n\t\t", location->m_instructionTypeSet->dumpTypes().replace("\n"_s, "\n\t\t"_s), "\n");
+ dataLog("\t\t#Local#\n\t\t", location->m_instructionTypeSet->dumpTypes().replace("\n", "\n\t\t"), "\n");
if (location->m_globalTypeSet)
- dataLog("\t\t#Global#\n\t\t", location->m_globalTypeSet->dumpTypes().replace("\n"_s, "\n\t\t"_s), "\n");
+ dataLog("\t\t#Global#\n\t\t", location->m_globalTypeSet->dumpTypes().replace("\n", "\n\t\t"), "\n");
}
void TypeProfiler::insertNewLocation(TypeLocation* location)
Modified: trunk/Source/_javascript_Core/runtime/TypeSet.cpp (291799 => 291800)
--- trunk/Source/_javascript_Core/runtime/TypeSet.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/runtime/TypeSet.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -348,7 +348,7 @@
builder.append(':');
for (auto& key : m_fields) {
String property = key.get();
- property.replace(":"_s, "\\:"_s); // Ensure that hash({"foo:", "bar"}) != hash({"foo", ":bar"}) because we're using colons as a separator and colons are legal characters in field names in JS.
+ property.replace(":", "\\:"); // Ensure that hash({"foo:", "bar"}) != hash({"foo", ":bar"}) because we're using colons as a separator and colons are legal characters in field names in JS.
builder.append(property);
}
Modified: trunk/Source/_javascript_Core/tools/FunctionOverrides.cpp (291799 => 291800)
--- trunk/Source/_javascript_Core/tools/FunctionOverrides.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/_javascript_Core/tools/FunctionOverrides.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -130,7 +130,7 @@
FunctionOverridesAssertScope assertScope;
String origProviderStr = origCode.provider()->source().toString();
unsigned origStart = origCode.startOffset();
- unsigned origFunctionStart = origProviderStr.reverseFind("function"_s, origStart);
+ unsigned origFunctionStart = origProviderStr.reverseFind("function", origStart);
unsigned origBraceStart = origProviderStr.find('{', origStart);
unsigned headerLength = origBraceStart - origFunctionStart;
String origHeader = origProviderStr.substring(origFunctionStart, headerLength);
@@ -147,8 +147,8 @@
info.lineCount = 1; // Faking it. This doesn't really matter for now.
info.startColumn = 1;
info.endColumn = 1; // Faking it. This doesn't really matter for now.
- info.parametersStartOffset = newProviderStr.find("(");
- info.typeProfilingStartOffset = newProviderStr.find("{");
+ info.parametersStartOffset = newProviderStr.find('(');
+ info.typeProfilingStartOffset = newProviderStr.find('{');
info.typeProfilingEndOffset = newProviderStr.length() - 1;
info.sourceCode =
Modified: trunk/Source/WTF/ChangeLog (291799 => 291800)
--- trunk/Source/WTF/ChangeLog 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WTF/ChangeLog 2022-03-24 16:55:40 UTC (rev 291800)
@@ -1,3 +1,39 @@
+2022-03-24 Chris Dumez <cdu...@apple.com>
+
+ String's find() / reverseFind() / replace() should take in a StringView instead of a String
+ https://bugs.webkit.org/show_bug.cgi?id=238287
+
+ Reviewed by Darin Adler.
+
+ String's find() / reverseFind() / replace() should take in a StringView instead of a String
+ to avoid unnecessary String construction in many cases. We should probably do the same for
+ more String functions where we don't really need a String parameter, but those will be
+ addressed separately.
+
+ * wtf/text/AtomString.h:
+ * wtf/text/StringCommon.h:
+ (WTF::findCommon): Deleted.
+ * wtf/text/StringImpl.cpp:
+ (WTF::StringImpl::find):
+ (WTF::StringImpl::findIgnoringASCIICase const):
+ (WTF::StringImpl::reverseFind):
+ (WTF::StringImpl::replace):
+ * wtf/text/StringImpl.h:
+ * wtf/text/StringView.h:
+ (WTF::findCommon):
+ (WTF::findIgnoringASCIICase):
+ (WTF::String::find const):
+ (WTF::String::findIgnoringASCIICase const):
+ (WTF::String::reverseFind const):
+ (WTF::String::contains const):
+ (WTF::String::containsIgnoringASCIICase const):
+ (WTF::String::replace):
+ (WTF::AtomString::find const):
+ (WTF::AtomString::findIgnoringASCIICase const):
+ (WTF::AtomString::contains const):
+ (WTF::AtomString::containsIgnoringASCIICase const):
+ * wtf/text/WTFString.h:
+
2022-03-23 Chris Dumez <cdu...@apple.com>
Inline String(ASCIILiteral) constructor so the compiler can optimize out strlen()
Modified: trunk/Source/WTF/wtf/text/AtomString.h (291799 => 291800)
--- trunk/Source/WTF/wtf/text/AtomString.h 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WTF/wtf/text/AtomString.h 2022-03-24 16:55:40 UTC (rev 291800)
@@ -114,14 +114,14 @@
bool contains(UChar character) const { return m_string.contains(character); }
bool contains(const LChar* string) const { return m_string.contains(string); }
- bool contains(const String& string) const { return m_string.contains(string); }
- bool containsIgnoringASCIICase(const String& string) const { return m_string.containsIgnoringASCIICase(string); }
+ bool contains(StringView) const;
+ bool containsIgnoringASCIICase(StringView) const;
size_t find(UChar character, unsigned start = 0) const { return m_string.find(character, start); }
size_t find(const LChar* string, unsigned start = 0) const { return m_string.find(string, start); }
- size_t find(const String& string, unsigned start = 0) const { return m_string.find(string, start); }
- size_t findIgnoringASCIICase(const String& string) const { return m_string.findIgnoringASCIICase(string); }
- size_t findIgnoringASCIICase(const String& string, unsigned startOffset) const { return m_string.findIgnoringASCIICase(string, startOffset); }
+ size_t find(StringView, unsigned start = 0) const;
+ size_t findIgnoringASCIICase(StringView) const;
+ size_t findIgnoringASCIICase(StringView, unsigned start) const;
size_t find(CodeUnitMatchFunction matchFunction, unsigned start = 0) const { return m_string.find(matchFunction, start); }
bool startsWith(const String& string) const { return m_string.startsWith(string); }
Modified: trunk/Source/WTF/wtf/text/StringCommon.h (291799 => 291800)
--- trunk/Source/WTF/wtf/text/StringCommon.h 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WTF/wtf/text/StringCommon.h 2022-03-24 16:55:40 UTC (rev 291800)
@@ -480,33 +480,6 @@
return matchLength < searchLength ? findIgnoringASCIICase(source, matchCharacters, 0, searchLength, matchLength) : notFound;
}
-template<typename StringClassA, typename StringClassB>
-size_t findIgnoringASCIICase(const StringClassA& source, const StringClassB& stringToFind, unsigned startOffset)
-{
- unsigned sourceStringLength = source.length();
- unsigned matchLength = stringToFind.length();
- if (!matchLength)
- return std::min(startOffset, sourceStringLength);
-
- // Check startOffset & matchLength are in range.
- if (startOffset > sourceStringLength)
- return notFound;
- unsigned searchLength = sourceStringLength - startOffset;
- if (matchLength > searchLength)
- return notFound;
-
- if (source.is8Bit()) {
- if (stringToFind.is8Bit())
- return findIgnoringASCIICase(source.characters8(), stringToFind.characters8(), startOffset, searchLength, matchLength);
- return findIgnoringASCIICase(source.characters8(), stringToFind.characters16(), startOffset, searchLength, matchLength);
- }
-
- if (stringToFind.is8Bit())
- return findIgnoringASCIICase(source.characters16(), stringToFind.characters8(), startOffset, searchLength, matchLength);
-
- return findIgnoringASCIICase(source.characters16(), stringToFind.characters16(), startOffset, searchLength, matchLength);
-}
-
template <typename SearchCharacterType, typename MatchCharacterType>
ALWAYS_INLINE static size_t findInner(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned searchLength, unsigned matchLength)
{
@@ -559,39 +532,6 @@
return find(characters, length, static_cast<LChar>(matchCharacter), index);
}
-template<typename StringClass>
-size_t findCommon(const StringClass& haystack, const StringClass& needle, unsigned start)
-{
- unsigned needleLength = needle.length();
-
- if (needleLength == 1) {
- if (haystack.is8Bit())
- return WTF::find(haystack.characters8(), haystack.length(), needle[0], start);
- return WTF::find(haystack.characters16(), haystack.length(), needle[0], start);
- }
-
- if (start > haystack.length())
- return notFound;
-
- if (!needleLength)
- return start;
-
- unsigned searchLength = haystack.length() - start;
- if (needleLength > searchLength)
- return notFound;
-
- if (haystack.is8Bit()) {
- if (needle.is8Bit())
- return findInner(haystack.characters8() + start, needle.characters8(), start, searchLength, needleLength);
- return findInner(haystack.characters8() + start, needle.characters16(), start, searchLength, needleLength);
- }
-
- if (needle.is8Bit())
- return findInner(haystack.characters16() + start, needle.characters8(), start, searchLength, needleLength);
-
- return findInner(haystack.characters16() + start, needle.characters16(), start, searchLength, needleLength);
-}
-
// This is marked inline since it's mostly used in non-inline functions for each string type.
// When used directly in code it's probably OK to be inline; maybe the loop will be unrolled.
template<typename CharacterType> inline bool equalLettersIgnoringASCIICase(const CharacterType* characters, const char* lowercaseLetters, unsigned length)
Modified: trunk/Source/WTF/wtf/text/StringImpl.cpp (291799 => 291800)
--- trunk/Source/WTF/wtf/text/StringImpl.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WTF/wtf/text/StringImpl.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -842,7 +842,7 @@
return WTF::find(characters16(), m_length, matchFunction, start);
}
-size_t StringImpl::find(const LChar* matchString, unsigned index)
+size_t StringImpl::find(const LChar* matchString, unsigned start)
{
// Check for null or empty string to match against
if (!matchString)
@@ -852,19 +852,19 @@
CRASH();
unsigned matchLength = matchStringLength;
if (!matchLength)
- return std::min(index, length());
+ return std::min(start, length());
// Optimization 1: fast case for strings of length 1.
if (matchLength == 1) {
if (is8Bit())
- return WTF::find(characters8(), length(), matchString[0], index);
- return WTF::find(characters16(), length(), *matchString, index);
+ return WTF::find(characters8(), length(), matchString[0], start);
+ return WTF::find(characters16(), length(), *matchString, start);
}
- // Check index & matchLength are in range.
- if (index > length())
+ // Check start & matchLength are in range.
+ if (start > length())
return notFound;
- unsigned searchLength = length() - index;
+ unsigned searchLength = length() - start;
if (matchLength > searchLength)
return notFound;
// delta is the number of additional times to test; delta == 0 means test only once.
@@ -874,7 +874,7 @@
// only call equal if the hashes match.
if (is8Bit()) {
- const LChar* searchCharacters = characters8() + index;
+ const LChar* searchCharacters = characters8() + start;
unsigned searchHash = 0;
unsigned matchHash = 0;
@@ -891,10 +891,10 @@
searchHash -= searchCharacters[i];
++i;
}
- return index + i;
+ return start + i;
}
- const UChar* searchCharacters = characters16() + index;
+ const UChar* searchCharacters = characters16() + start;
unsigned searchHash = 0;
unsigned matchHash = 0;
@@ -911,26 +911,26 @@
searchHash -= searchCharacters[i];
++i;
}
- return index + i;
+ return start + i;
}
-size_t StringImpl::find(StringImpl* matchString)
+size_t StringImpl::find(StringView matchString)
{
// Check for null string to match against
if (UNLIKELY(!matchString))
return notFound;
- unsigned matchLength = matchString->length();
+ unsigned matchLength = matchString.length();
// Optimization 1: fast case for strings of length 1.
if (matchLength == 1) {
if (is8Bit()) {
- if (matchString->is8Bit())
- return WTF::find(characters8(), length(), matchString->characters8()[0]);
- return WTF::find(characters8(), length(), matchString->characters16()[0]);
+ if (matchString.is8Bit())
+ return WTF::find(characters8(), length(), matchString.characters8()[0]);
+ return WTF::find(characters8(), length(), matchString.characters16()[0]);
}
- if (matchString->is8Bit())
- return WTF::find(characters16(), length(), matchString->characters8()[0]);
- return WTF::find(characters16(), length(), matchString->characters16()[0]);
+ if (matchString.is8Bit())
+ return WTF::find(characters16(), length(), matchString.characters8()[0]);
+ return WTF::find(characters16(), length(), matchString.characters16()[0]);
}
// Check matchLength is in range.
@@ -942,65 +942,55 @@
return 0;
if (is8Bit()) {
- if (matchString->is8Bit())
- return findInner(characters8(), matchString->characters8(), 0, length(), matchLength);
- return findInner(characters8(), matchString->characters16(), 0, length(), matchLength);
+ if (matchString.is8Bit())
+ return findInner(characters8(), matchString.characters8(), 0, length(), matchLength);
+ return findInner(characters8(), matchString.characters16(), 0, length(), matchLength);
}
- if (matchString->is8Bit())
- return findInner(characters16(), matchString->characters8(), 0, length(), matchLength);
+ if (matchString.is8Bit())
+ return findInner(characters16(), matchString.characters8(), 0, length(), matchLength);
- return findInner(characters16(), matchString->characters16(), 0, length(), matchLength);
+ return findInner(characters16(), matchString.characters16(), 0, length(), matchLength);
}
-size_t StringImpl::find(StringImpl* matchString, unsigned index)
+size_t StringImpl::find(StringView matchString, unsigned start)
{
// Check for null or empty string to match against
if (UNLIKELY(!matchString))
return notFound;
- return findCommon(*this, *matchString, index);
+ return findCommon(StringView { *this }, matchString, start);
}
-size_t StringImpl::findIgnoringASCIICase(const StringImpl& matchString) const
+size_t StringImpl::findIgnoringASCIICase(StringView matchString) const
{
- return ::WTF::findIgnoringASCIICase(*this, matchString, 0);
-}
-
-size_t StringImpl::findIgnoringASCIICase(const StringImpl& matchString, unsigned startOffset) const
-{
- return ::WTF::findIgnoringASCIICase(*this, matchString, startOffset);
-}
-
-size_t StringImpl::findIgnoringASCIICase(const StringImpl* matchString) const
-{
if (!matchString)
return notFound;
- return ::WTF::findIgnoringASCIICase(*this, *matchString, 0);
+ return ::WTF::findIgnoringASCIICase(*this, matchString, 0);
}
-size_t StringImpl::findIgnoringASCIICase(const StringImpl* matchString, unsigned startOffset) const
+size_t StringImpl::findIgnoringASCIICase(StringView matchString, unsigned start) const
{
if (!matchString)
return notFound;
- return ::WTF::findIgnoringASCIICase(*this, *matchString, startOffset);
+ return ::WTF::findIgnoringASCIICase(*this, matchString, start);
}
-size_t StringImpl::reverseFind(UChar character, unsigned index)
+size_t StringImpl::reverseFind(UChar character, unsigned start)
{
if (is8Bit())
- return WTF::reverseFind(characters8(), m_length, character, index);
- return WTF::reverseFind(characters16(), m_length, character, index);
+ return WTF::reverseFind(characters8(), m_length, character, start);
+ return WTF::reverseFind(characters16(), m_length, character, start);
}
template <typename SearchCharacterType, typename MatchCharacterType>
-ALWAYS_INLINE static size_t reverseFindInner(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned length, unsigned matchLength)
+ALWAYS_INLINE static size_t reverseFindInner(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned start, unsigned length, unsigned matchLength)
{
// Optimization: keep a running hash of the strings,
// only call equal if the hashes match.
// delta is the number of additional times to test; delta == 0 means test only once.
- unsigned delta = std::min(index, length - matchLength);
+ unsigned delta = std::min(start, length - matchLength);
unsigned searchHash = 0;
unsigned matchHash = 0;
@@ -1020,66 +1010,66 @@
return delta;
}
-size_t StringImpl::reverseFind(StringImpl* matchString, unsigned index)
+size_t StringImpl::reverseFind(StringView matchString, unsigned start)
{
// Check for null or empty string to match against
if (!matchString)
return notFound;
- unsigned matchLength = matchString->length();
+ unsigned matchLength = matchString.length();
unsigned ourLength = length();
if (!matchLength)
- return std::min(index, ourLength);
+ return std::min(start, ourLength);
// Optimization 1: fast case for strings of length 1.
if (matchLength == 1) {
if (is8Bit())
- return WTF::reverseFind(characters8(), ourLength, (*matchString)[0], index);
- return WTF::reverseFind(characters16(), ourLength, (*matchString)[0], index);
+ return WTF::reverseFind(characters8(), ourLength, matchString[0], start);
+ return WTF::reverseFind(characters16(), ourLength, matchString[0], start);
}
- // Check index & matchLength are in range.
+ // Check start & matchLength are in range.
if (matchLength > ourLength)
return notFound;
if (is8Bit()) {
- if (matchString->is8Bit())
- return reverseFindInner(characters8(), matchString->characters8(), index, ourLength, matchLength);
- return reverseFindInner(characters8(), matchString->characters16(), index, ourLength, matchLength);
+ if (matchString.is8Bit())
+ return reverseFindInner(characters8(), matchString.characters8(), start, ourLength, matchLength);
+ return reverseFindInner(characters8(), matchString.characters16(), start, ourLength, matchLength);
}
- if (matchString->is8Bit())
- return reverseFindInner(characters16(), matchString->characters8(), index, ourLength, matchLength);
+ if (matchString.is8Bit())
+ return reverseFindInner(characters16(), matchString.characters8(), start, ourLength, matchLength);
- return reverseFindInner(characters16(), matchString->characters16(), index, ourLength, matchLength);
+ return reverseFindInner(characters16(), matchString.characters16(), start, ourLength, matchLength);
}
-ALWAYS_INLINE static bool equalInner(const StringImpl& string, unsigned startOffset, const char* matchString, unsigned matchLength)
+ALWAYS_INLINE static bool equalInner(const StringImpl& string, unsigned start, const char* matchString, unsigned matchLength)
{
ASSERT(matchLength <= string.length());
- ASSERT(startOffset + matchLength <= string.length());
+ ASSERT(start + matchLength <= string.length());
if (string.is8Bit())
- return equal(string.characters8() + startOffset, reinterpret_cast<const LChar*>(matchString), matchLength);
- return equal(string.characters16() + startOffset, reinterpret_cast<const LChar*>(matchString), matchLength);
+ return equal(string.characters8() + start, reinterpret_cast<const LChar*>(matchString), matchLength);
+ return equal(string.characters16() + start, reinterpret_cast<const LChar*>(matchString), matchLength);
}
-ALWAYS_INLINE static bool equalInner(const StringImpl& string, unsigned startOffset, const StringImpl& matchString)
+ALWAYS_INLINE static bool equalInner(const StringImpl& string, unsigned start, const StringImpl& matchString)
{
- if (startOffset > string.length())
+ if (start > string.length())
return false;
if (matchString.length() > string.length())
return false;
- if (matchString.length() + startOffset > string.length())
+ if (matchString.length() + start > string.length())
return false;
if (string.is8Bit()) {
if (matchString.is8Bit())
- return equal(string.characters8() + startOffset, matchString.characters8(), matchString.length());
- return equal(string.characters8() + startOffset, matchString.characters16(), matchString.length());
+ return equal(string.characters8() + start, matchString.characters8(), matchString.length());
+ return equal(string.characters8() + start, matchString.characters16(), matchString.length());
}
if (matchString.is8Bit())
- return equal(string.characters16() + startOffset, matchString.characters8(), matchString.length());
- return equal(string.characters16() + startOffset, matchString.characters16(), matchString.length());
+ return equal(string.characters16() + start, matchString.characters8(), matchString.length());
+ return equal(string.characters16() + start, matchString.characters16(), matchString.length());
}
bool StringImpl::startsWith(const StringImpl* string) const
@@ -1112,9 +1102,9 @@
return matchLength <= length() && equalInner(*this, 0, matchString, matchLength);
}
-bool StringImpl::hasInfixStartingAt(const StringImpl& matchString, unsigned startOffset) const
+bool StringImpl::hasInfixStartingAt(const StringImpl& matchString, unsigned start) const
{
- return equalInner(*this, startOffset, matchString);
+ return equalInner(*this, start, matchString);
}
bool StringImpl::endsWith(StringImpl* suffix)
@@ -1415,29 +1405,29 @@
return newImpl;
}
-Ref<StringImpl> StringImpl::replace(StringImpl* pattern, StringImpl* replacement)
+Ref<StringImpl> StringImpl::replace(StringView pattern, StringView replacement)
{
if (!pattern || !replacement)
return *this;
- unsigned patternLength = pattern->length();
+ unsigned patternLength = pattern.length();
if (!patternLength)
return *this;
-
- unsigned repStrLength = replacement->length();
+
+ unsigned repStrLength = replacement.length();
size_t srcSegmentStart = 0;
unsigned matchCount = 0;
-
+
// Count the matches.
while ((srcSegmentStart = find(pattern, srcSegmentStart)) != notFound) {
++matchCount;
srcSegmentStart += patternLength;
}
-
+
// If we have 0 matches, we don't have to do any more work
if (!matchCount)
return *this;
-
+
unsigned newSize = m_length - matchCount * patternLength;
if (repStrLength && matchCount > MaxLength / repStrLength)
CRASH();
@@ -1447,7 +1437,7 @@
newSize += matchCount * repStrLength;
-
+
// Construct the new data
size_t srcSegmentEnd;
unsigned srcSegmentLength;
@@ -1454,8 +1444,8 @@
srcSegmentStart = 0;
unsigned dstOffset = 0;
bool srcIs8Bit = is8Bit();
- bool replacementIs8Bit = replacement->is8Bit();
-
+ bool replacementIs8Bit = replacement.is8Bit();
+
// There are 4 cases:
// 1. This and replacement are both 8 bit.
// 2. This and replacement are both 16 bit.
@@ -1469,7 +1459,7 @@
srcSegmentLength = srcSegmentEnd - srcSegmentStart;
copyCharacters(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength);
dstOffset += srcSegmentLength;
- copyCharacters(data + dstOffset, replacement->m_data8, repStrLength);
+ copyCharacters(data + dstOffset, replacement.characters8(), repStrLength);
dstOffset += repStrLength;
srcSegmentStart = srcSegmentEnd + patternLength;
}
@@ -1496,10 +1486,10 @@
dstOffset += srcSegmentLength;
if (replacementIs8Bit) {
// Cases 2 & 3.
- copyCharacters(data + dstOffset, replacement->m_data8, repStrLength);
+ copyCharacters(data + dstOffset, replacement.characters8(), repStrLength);
} else {
// Case 4
- copyCharacters(data + dstOffset, replacement->m_data16, repStrLength);
+ copyCharacters(data + dstOffset, replacement.characters16(), repStrLength);
}
dstOffset += repStrLength;
srcSegmentStart = srcSegmentEnd + patternLength;
Modified: trunk/Source/WTF/wtf/text/StringImpl.h (291799 => 291800)
--- trunk/Source/WTF/wtf/text/StringImpl.h 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WTF/wtf/text/StringImpl.h 2022-03-24 16:55:40 UTC (rev 291800)
@@ -428,18 +428,15 @@
size_t find(LChar character, unsigned start = 0);
size_t find(char character, unsigned start = 0);
size_t find(UChar character, unsigned start = 0);
- WTF_EXPORT_PRIVATE size_t find(CodeUnitMatchFunction, unsigned index = 0);
- WTF_EXPORT_PRIVATE size_t find(const LChar*, unsigned index = 0);
- ALWAYS_INLINE size_t find(const char* string, unsigned index = 0) { return find(reinterpret_cast<const LChar*>(string), index); }
- WTF_EXPORT_PRIVATE size_t find(StringImpl*);
- WTF_EXPORT_PRIVATE size_t find(StringImpl*, unsigned index);
- WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl&) const;
- WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl&, unsigned startOffset) const;
- WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl*) const;
- WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl*, unsigned startOffset) const;
+ WTF_EXPORT_PRIVATE size_t find(CodeUnitMatchFunction, unsigned start = 0);
+ WTF_EXPORT_PRIVATE size_t find(const LChar*, unsigned start = 0);
+ WTF_EXPORT_PRIVATE size_t find(StringView);
+ WTF_EXPORT_PRIVATE size_t find(StringView, unsigned start);
+ WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(StringView) const;
+ WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(StringView, unsigned start) const;
- WTF_EXPORT_PRIVATE size_t reverseFind(UChar, unsigned index = MaxLength);
- WTF_EXPORT_PRIVATE size_t reverseFind(StringImpl*, unsigned index = MaxLength);
+ WTF_EXPORT_PRIVATE size_t reverseFind(UChar, unsigned start = MaxLength);
+ WTF_EXPORT_PRIVATE size_t reverseFind(StringView, unsigned start = MaxLength);
WTF_EXPORT_PRIVATE bool startsWith(const StringImpl*) const;
WTF_EXPORT_PRIVATE bool startsWith(const StringImpl&) const;
@@ -448,7 +445,7 @@
WTF_EXPORT_PRIVATE bool startsWith(UChar) const;
WTF_EXPORT_PRIVATE bool startsWith(const char*, unsigned matchLength) const;
template<unsigned matchLength> bool startsWith(const char (&prefix)[matchLength]) const { return startsWith(prefix, matchLength - 1); }
- WTF_EXPORT_PRIVATE bool hasInfixStartingAt(const StringImpl&, unsigned startOffset) const;
+ WTF_EXPORT_PRIVATE bool hasInfixStartingAt(const StringImpl&, unsigned start) const;
WTF_EXPORT_PRIVATE bool endsWith(StringImpl*);
WTF_EXPORT_PRIVATE bool endsWith(StringImpl&);
@@ -464,8 +461,8 @@
ALWAYS_INLINE Ref<StringImpl> replace(UChar pattern, const char* replacement, unsigned replacementLength) { return replace(pattern, reinterpret_cast<const LChar*>(replacement), replacementLength); }
WTF_EXPORT_PRIVATE Ref<StringImpl> replace(UChar, const LChar*, unsigned replacementLength);
Ref<StringImpl> replace(UChar, const UChar*, unsigned replacementLength);
- WTF_EXPORT_PRIVATE Ref<StringImpl> replace(StringImpl*, StringImpl*);
- WTF_EXPORT_PRIVATE Ref<StringImpl> replace(unsigned index, unsigned length, StringImpl*);
+ WTF_EXPORT_PRIVATE Ref<StringImpl> replace(StringView, StringView);
+ WTF_EXPORT_PRIVATE Ref<StringImpl> replace(unsigned start, unsigned length, StringImpl*);
WTF_EXPORT_PRIVATE UCharDirection defaultWritingDirection(bool* hasStrongDirectionality = nullptr);
@@ -592,12 +589,12 @@
template<unsigned length> bool equalLettersIgnoringASCIICase(const StringImpl*, const char (&lowercaseLetters)[length]);
template<typename CodeUnit, typename CodeUnitMatchFunction, std::enable_if_t<std::is_invocable_r_v<bool, CodeUnitMatchFunction, CodeUnit>>* = nullptr>
-size_t find(const CodeUnit*, unsigned length, CodeUnitMatchFunction&&, unsigned index = 0);
+size_t find(const CodeUnit*, unsigned length, CodeUnitMatchFunction&&, unsigned start = 0);
-template<typename CharacterType> size_t reverseFindLineTerminator(const CharacterType*, unsigned length, unsigned index = StringImpl::MaxLength);
-template<typename CharacterType> size_t reverseFind(const CharacterType*, unsigned length, CharacterType matchCharacter, unsigned index = StringImpl::MaxLength);
-size_t reverseFind(const UChar*, unsigned length, LChar matchCharacter, unsigned index = StringImpl::MaxLength);
-size_t reverseFind(const LChar*, unsigned length, UChar matchCharacter, unsigned index = StringImpl::MaxLength);
+template<typename CharacterType> size_t reverseFindLineTerminator(const CharacterType*, unsigned length, unsigned start = StringImpl::MaxLength);
+template<typename CharacterType> size_t reverseFind(const CharacterType*, unsigned length, CharacterType matchCharacter, unsigned start = StringImpl::MaxLength);
+size_t reverseFind(const UChar*, unsigned length, LChar matchCharacter, unsigned start = StringImpl::MaxLength);
+size_t reverseFind(const LChar*, unsigned length, UChar matchCharacter, unsigned start = StringImpl::MaxLength);
template<size_t inlineCapacity> bool equalIgnoringNullity(const Vector<UChar, inlineCapacity>&, StringImpl*);
@@ -642,54 +639,54 @@
}
template<typename CodeUnit, typename CodeUnitMatchFunction, std::enable_if_t<std::is_invocable_r_v<bool, CodeUnitMatchFunction, CodeUnit>>*>
-inline size_t find(const CodeUnit* characters, unsigned length, CodeUnitMatchFunction&& matchFunction, unsigned index)
+inline size_t find(const CodeUnit* characters, unsigned length, CodeUnitMatchFunction&& matchFunction, unsigned start)
{
- while (index < length) {
- if (matchFunction(characters[index]))
- return index;
- ++index;
+ while (start < length) {
+ if (matchFunction(characters[start]))
+ return start;
+ ++start;
}
return notFound;
}
-template<typename CharacterType> inline size_t reverseFindLineTerminator(const CharacterType* characters, unsigned length, unsigned index)
+template<typename CharacterType> inline size_t reverseFindLineTerminator(const CharacterType* characters, unsigned length, unsigned start)
{
if (!length)
return notFound;
- if (index >= length)
- index = length - 1;
- auto character = characters[index];
+ if (start >= length)
+ start = length - 1;
+ auto character = characters[start];
while (character != '\n' && character != '\r') {
- if (!index--)
+ if (!start--)
return notFound;
- character = characters[index];
+ character = characters[start];
}
- return index;
+ return start;
}
-template<typename CharacterType> inline size_t reverseFind(const CharacterType* characters, unsigned length, CharacterType matchCharacter, unsigned index)
+template<typename CharacterType> inline size_t reverseFind(const CharacterType* characters, unsigned length, CharacterType matchCharacter, unsigned start)
{
if (!length)
return notFound;
- if (index >= length)
- index = length - 1;
- while (characters[index] != matchCharacter) {
- if (!index--)
+ if (start >= length)
+ start = length - 1;
+ while (characters[start] != matchCharacter) {
+ if (!start--)
return notFound;
}
- return index;
+ return start;
}
-ALWAYS_INLINE size_t reverseFind(const UChar* characters, unsigned length, LChar matchCharacter, unsigned index)
+ALWAYS_INLINE size_t reverseFind(const UChar* characters, unsigned length, LChar matchCharacter, unsigned start)
{
- return reverseFind(characters, length, static_cast<UChar>(matchCharacter), index);
+ return reverseFind(characters, length, static_cast<UChar>(matchCharacter), start);
}
-inline size_t reverseFind(const LChar* characters, unsigned length, UChar matchCharacter, unsigned index)
+inline size_t reverseFind(const LChar* characters, unsigned length, UChar matchCharacter, unsigned start)
{
if (!isLatin1(matchCharacter))
return notFound;
- return reverseFind(characters, length, static_cast<LChar>(matchCharacter), index);
+ return reverseFind(characters, length, static_cast<LChar>(matchCharacter), start);
}
inline size_t StringImpl::find(LChar character, unsigned start)
Modified: trunk/Source/WTF/wtf/text/StringView.h (291799 => 291800)
--- trunk/Source/WTF/wtf/text/StringView.h 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WTF/wtf/text/StringView.h 2022-03-24 16:55:40 UTC (rev 291800)
@@ -145,7 +145,7 @@
size_t reverseFind(UChar, unsigned index = std::numeric_limits<unsigned>::max()) const;
WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(StringView) const;
- WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(StringView, unsigned startOffset) const;
+ WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(StringView, unsigned start) const;
WTF_EXPORT_PRIVATE String convertToASCIILowercase() const;
WTF_EXPORT_PRIVATE String convertToASCIIUppercase() const;
@@ -158,7 +158,7 @@
WTF_EXPORT_PRIVATE bool contains(const char*) const;
WTF_EXPORT_PRIVATE bool containsIgnoringASCIICase(StringView) const;
- WTF_EXPORT_PRIVATE bool containsIgnoringASCIICase(StringView, unsigned startOffset) const;
+ WTF_EXPORT_PRIVATE bool containsIgnoringASCIICase(StringView, unsigned start) const;
template<bool isSpecialCharacter(UChar)> bool isAllSpecialCharacters() const;
@@ -606,11 +606,11 @@
return WTF::find(characters16(), m_length, std::forward<CodeUnitMatchFunction>(matchFunction), start);
}
-inline size_t StringView::reverseFind(UChar character, unsigned index) const
+inline size_t StringView::reverseFind(UChar character, unsigned start) const
{
if (is8Bit())
- return WTF::reverseFind(characters8(), m_length, character, index);
- return WTF::reverseFind(characters16(), m_length, character, index);
+ return WTF::reverseFind(characters8(), m_length, character, start);
+ return WTF::reverseFind(characters16(), m_length, character, start);
}
#if !CHECK_STRINGVIEW_LIFETIME
@@ -1099,6 +1099,142 @@
return false;
}
+inline size_t findCommon(StringView haystack, StringView needle, unsigned start)
+{
+ unsigned needleLength = needle.length();
+
+ if (needleLength == 1) {
+ if (haystack.is8Bit())
+ return WTF::find(haystack.characters8(), haystack.length(), needle[0], start);
+ return WTF::find(haystack.characters16(), haystack.length(), needle[0], start);
+ }
+
+ if (start > haystack.length())
+ return notFound;
+
+ if (!needleLength)
+ return start;
+
+ unsigned searchLength = haystack.length() - start;
+ if (needleLength > searchLength)
+ return notFound;
+
+ if (haystack.is8Bit()) {
+ if (needle.is8Bit())
+ return findInner(haystack.characters8() + start, needle.characters8(), start, searchLength, needleLength);
+ return findInner(haystack.characters8() + start, needle.characters16(), start, searchLength, needleLength);
+ }
+
+ if (needle.is8Bit())
+ return findInner(haystack.characters16() + start, needle.characters8(), start, searchLength, needleLength);
+
+ return findInner(haystack.characters16() + start, needle.characters16(), start, searchLength, needleLength);
+}
+
+inline size_t findIgnoringASCIICase(StringView source, StringView stringToFind, unsigned start)
+{
+ unsigned sourceStringLength = source.length();
+ unsigned matchLength = stringToFind.length();
+ if (!matchLength)
+ return std::min(start, sourceStringLength);
+
+ // Check start & matchLength are in range.
+ if (start > sourceStringLength)
+ return notFound;
+ unsigned searchLength = sourceStringLength - start;
+ if (matchLength > searchLength)
+ return notFound;
+
+ if (source.is8Bit()) {
+ if (stringToFind.is8Bit())
+ return findIgnoringASCIICase(source.characters8(), stringToFind.characters8(), start, searchLength, matchLength);
+ return findIgnoringASCIICase(source.characters8(), stringToFind.characters16(), start, searchLength, matchLength);
+ }
+
+ if (stringToFind.is8Bit())
+ return findIgnoringASCIICase(source.characters16(), stringToFind.characters8(), start, searchLength, matchLength);
+
+ return findIgnoringASCIICase(source.characters16(), stringToFind.characters16(), start, searchLength, matchLength);
+}
+
+inline size_t String::find(StringView string) const
+{
+ return m_impl ? m_impl->find(string) : notFound;
+}
+inline size_t String::find(StringView string, unsigned start) const
+{
+ return m_impl ? m_impl->find(string, start) : notFound;
+}
+
+inline size_t String::findIgnoringASCIICase(StringView string) const
+{
+ return m_impl ? m_impl->findIgnoringASCIICase(string) : notFound;
+}
+
+inline size_t String::findIgnoringASCIICase(StringView string, unsigned start) const
+{
+ return m_impl ? m_impl->findIgnoringASCIICase(string, start) : notFound;
+}
+
+inline size_t String::reverseFind(StringView string, unsigned start) const
+{
+ return m_impl ? m_impl->reverseFind(string, start) : notFound;
+}
+
+inline bool String::contains(StringView string) const
+{
+ return find(string) != notFound;
+}
+
+inline bool String::containsIgnoringASCIICase(StringView string) const
+{
+ return findIgnoringASCIICase(string) != notFound;
+}
+
+inline bool String::containsIgnoringASCIICase(StringView string, unsigned start) const
+{
+ return findIgnoringASCIICase(string, start) != notFound;
+}
+
+inline String& String::replace(StringView target, StringView replacement)
+{
+ if (m_impl)
+ m_impl = m_impl->replace(target, replacement);
+ return *this;
+}
+
+inline String& String::replace(unsigned start, unsigned length, const String& replacement)
+{
+ if (m_impl)
+ m_impl = m_impl->replace(start, length, replacement.impl());
+ return *this;
+}
+
+inline size_t AtomString::find(StringView string, unsigned start) const
+{
+ return m_string.find(string, start);
+}
+
+inline size_t AtomString::findIgnoringASCIICase(StringView string) const
+{
+ return m_string.findIgnoringASCIICase(string);
+}
+
+inline size_t AtomString::findIgnoringASCIICase(StringView string, unsigned start) const
+{
+ return m_string.findIgnoringASCIICase(string, start);
+}
+
+inline bool AtomString::contains(StringView string) const
+{
+ return m_string.contains(string);
+}
+
+inline bool AtomString::containsIgnoringASCIICase(StringView string) const
+{
+ return m_string.containsIgnoringASCIICase(string);
+}
+
} // namespace WTF
using WTF::append;
Modified: trunk/Source/WTF/wtf/text/WTFString.h (291799 => 291800)
--- trunk/Source/WTF/wtf/text/WTFString.h 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WTF/wtf/text/WTFString.h 2022-03-24 16:55:40 UTC (rev 291800)
@@ -159,18 +159,17 @@
// Find a single character or string, also with match function & latin1 forms.
size_t find(UChar character, unsigned start = 0) const { return m_impl ? m_impl->find(character, start) : notFound; }
- size_t find(const String& string) const { return m_impl ? m_impl->find(string.impl()) : notFound; }
- size_t find(const String& string, unsigned start) const { return m_impl ? m_impl->find(string.impl(), start) : notFound; }
- size_t findIgnoringASCIICase(const String& string) const { return m_impl ? m_impl->findIgnoringASCIICase(string.impl()) : notFound; }
- size_t findIgnoringASCIICase(const String& string, unsigned startOffset) const { return m_impl ? m_impl->findIgnoringASCIICase(string.impl(), startOffset) : notFound; }
+ size_t find(StringView) const;
+ size_t find(StringView, unsigned start) const;
+ size_t findIgnoringASCIICase(StringView) const;
+ size_t findIgnoringASCIICase(StringView, unsigned start) const;
size_t find(CodeUnitMatchFunction matchFunction, unsigned start = 0) const { return m_impl ? m_impl->find(matchFunction, start) : notFound; }
size_t find(const LChar* string, unsigned start = 0) const { return m_impl ? m_impl->find(string, start) : notFound; }
- size_t find(const char* string, unsigned start = 0) const { return m_impl ? m_impl->find(string, start) : notFound; }
// Find the last instance of a single character or string.
size_t reverseFind(UChar character, unsigned start = MaxLength) const { return m_impl ? m_impl->reverseFind(character, start) : notFound; }
- size_t reverseFind(const String& string, unsigned start = MaxLength) const { return m_impl ? m_impl->reverseFind(string.impl(), start) : notFound; }
+ size_t reverseFind(StringView, unsigned start = MaxLength) const;
WTF_EXPORT_PRIVATE Vector<UChar> charactersWithNullTermination() const;
WTF_EXPORT_PRIVATE Vector<UChar> charactersWithoutNullTermination() const;
@@ -179,15 +178,15 @@
bool contains(UChar character) const { return find(character) != notFound; }
bool contains(const LChar* string) const { return find(string) != notFound; }
- bool contains(const String& string) const { return find(string) != notFound; }
- bool containsIgnoringASCIICase(const String& string) const { return findIgnoringASCIICase(string) != notFound; }
- bool containsIgnoringASCIICase(const String& string, unsigned startOffset) const { return findIgnoringASCIICase(string, startOffset) != notFound; }
+ bool contains(StringView) const;
+ bool containsIgnoringASCIICase(StringView) const;
+ bool containsIgnoringASCIICase(StringView, unsigned start) const;
bool startsWith(const String& string) const { return m_impl ? m_impl->startsWith(string.impl()) : string.isEmpty(); }
bool startsWithIgnoringASCIICase(const String& string) const { return m_impl ? m_impl->startsWithIgnoringASCIICase(string.impl()) : string.isEmpty(); }
bool startsWith(UChar character) const { return m_impl && m_impl->startsWith(character); }
template<unsigned matchLength> bool startsWith(const char (&prefix)[matchLength]) const { return m_impl ? m_impl->startsWith<matchLength>(prefix) : !matchLength; }
- bool hasInfixStartingAt(const String& prefix, unsigned startOffset) const { return m_impl && prefix.impl() && m_impl->hasInfixStartingAt(*prefix.impl(), startOffset); }
+ bool hasInfixStartingAt(const String& prefix, unsigned start) const { return m_impl && prefix.impl() && m_impl->hasInfixStartingAt(*prefix.impl(), start); }
bool endsWith(const String& string) const { return m_impl ? m_impl->endsWith(string.impl()) : string.isEmpty(); }
bool endsWithIgnoringASCIICase(const String& string) const { return m_impl ? m_impl->endsWithIgnoringASCIICase(string.impl()) : string.isEmpty(); }
@@ -206,7 +205,7 @@
String& replace(UChar target, UChar replacement);
String& replace(UChar target, const String& replacement);
- String& replace(const String& target, const String& replacement);
+ String& replace(StringView target, StringView replacement);
String& replace(unsigned start, unsigned length, const String& replacement);
template<unsigned characterCount> String& replaceWithLiteral(UChar target, const char (&replacement)[characterCount]);
@@ -507,20 +506,6 @@
return *this;
}
-inline String& String::replace(const String& target, const String& replacement)
-{
- if (m_impl)
- m_impl = m_impl->replace(target.impl(), replacement.impl());
- return *this;
-}
-
-inline String& String::replace(unsigned start, unsigned length, const String& replacement)
-{
- if (m_impl)
- m_impl = m_impl->replace(start, length, replacement.impl());
- return *this;
-}
-
template<unsigned characterCount> ALWAYS_INLINE String& String::replaceWithLiteral(UChar target, const char (&characters)[characterCount])
{
if (m_impl)
Modified: trunk/Source/WebCore/ChangeLog (291799 => 291800)
--- trunk/Source/WebCore/ChangeLog 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/ChangeLog 2022-03-24 16:55:40 UTC (rev 291800)
@@ -1,3 +1,19 @@
+2022-03-24 Chris Dumez <cdu...@apple.com>
+
+ String's find() / reverseFind() / replace() should take in a StringView instead of a String
+ https://bugs.webkit.org/show_bug.cgi?id=238287
+
+ Reviewed by Darin Adler.
+
+ * Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
+ (WebCore::IDBServer::SQLiteIDBBackingStore::decodeDatabaseName):
+ * html/HTMLTextAreaElement.cpp:
+ (WebCore::HTMLTextAreaElement::setValueCommon):
+ * page/UserContentURLPattern.cpp:
+ (WebCore::UserContentURLPattern::parse):
+ * platform/mediastream/CaptureDevice.h:
+ (WebCore::CaptureDevice::label const):
+
2022-03-24 Alan Bujtas <za...@apple.com>
[LFC][IFC] Do not construct a TextRun for measuring a single whitespace when simplified content measuring can be used
Modified: trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp (291799 => 291800)
--- trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -176,7 +176,7 @@
if (!mimeType)
return std::nullopt;
if (equalIgnoringASCIICase(mimeType->type, "multipart") && equalIgnoringASCIICase(mimeType->subtype, "form-data")) {
- auto iterator = mimeType->parameters.find("boundary"_s);
+ auto iterator = mimeType->parameters.find("boundary");
if (iterator != mimeType->parameters.end())
return iterator->value;
}
Modified: trunk/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp (291799 => 291800)
--- trunk/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -928,7 +928,7 @@
return emptyString();
String name = encodedName;
- name.replace("%2E"_s, "."_s);
+ name.replace("%2E", ".");
return FileSystem::decodeFromFilename(name);
}
Modified: trunk/Source/WebCore/PAL/pal/text/DecodeEscapeSequences.h (291799 => 291800)
--- trunk/Source/WebCore/PAL/pal/text/DecodeEscapeSequences.h 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/PAL/pal/text/DecodeEscapeSequences.h 2022-03-24 16:55:40 UTC (rev 291800)
@@ -39,7 +39,7 @@
// See <http://en.wikipedia.org/wiki/Percent-encoding#Non-standard_implementations>.
struct Unicode16BitEscapeSequence {
enum { SequenceSize = 6 }; // e.g. %u26C4
- static size_t findInString(StringView string, size_t startPosition) { return string.find(StringView("%u"), startPosition); }
+ static size_t findInString(StringView string, size_t startPosition) { return string.find("%u", startPosition); }
static size_t findEndOfRun(StringView string, size_t startPosition, size_t endPosition)
{
size_t runEnd = startPosition;
Modified: trunk/Source/WebCore/PAL/pal/text/win/TextCodecWin.cpp (291799 => 291800)
--- trunk/Source/WebCore/PAL/pal/text/win/TextCodecWin.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/PAL/pal/text/win/TextCodecWin.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -105,7 +105,7 @@
i = codePageCharsets().set(cpInfo.uiCodePage, name).iterator;
}
if (i != codePageCharsets().end()) {
- HashMap<String, CharsetInfo>::iterator j = knownCharsets().find(String(i->value.data(), i->value.length()));
+ HashMap<String, CharsetInfo>::iterator j = knownCharsets().find(StringView { i->value.data(), i->value.length() });
ASSERT(j != knownCharsets().end());
CharsetInfo& info = j->value;
info.m_name = i->value.data();
Modified: trunk/Source/WebCore/html/HTMLTextAreaElement.cpp (291799 => 291800)
--- trunk/Source/WebCore/html/HTMLTextAreaElement.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/html/HTMLTextAreaElement.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -395,7 +395,7 @@
// Code elsewhere normalizes line endings added by the user via the keyboard or pasting.
// We normalize line endings coming from _javascript_ here.
String normalizedValue = newValue.isNull() ? emptyString() : newValue;
- normalizedValue.replace("\r\n"_s, "\n"_s);
+ normalizedValue.replace("\r\n", "\n");
normalizedValue.replace('\r', '\n');
// Return early because we don't want to move the caret or trigger other side effects
Modified: trunk/Source/WebCore/page/UserContentURLPattern.cpp (291799 => 291800)
--- trunk/Source/WebCore/page/UserContentURLPattern.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/page/UserContentURLPattern.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -63,15 +63,15 @@
bool UserContentURLPattern::parse(const String& pattern)
{
- static NeverDestroyed<const String> schemeSeparator(MAKE_STATIC_STRING_IMPL("://"));
+ static constexpr ASCIILiteral schemeSeparator = "://"_s;
- size_t schemeEndPos = pattern.find(schemeSeparator);
+ size_t schemeEndPos = pattern.find(StringView { schemeSeparator });
if (schemeEndPos == notFound)
return false;
m_scheme = pattern.left(schemeEndPos);
- unsigned hostStartPos = schemeEndPos + schemeSeparator.get().length();
+ unsigned hostStartPos = schemeEndPos + schemeSeparator.length();
if (hostStartPos >= pattern.length())
return false;
Modified: trunk/Source/WebCore/platform/graphics/texmap/TextureMapperContextAttributes.cpp (291799 => 291800)
--- trunk/Source/WebCore/platform/graphics/texmap/TextureMapperContextAttributes.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/platform/graphics/texmap/TextureMapperContextAttributes.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -55,8 +55,8 @@
attributes.isGLES2Compliant = true;
String extensionsString(reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
- attributes.supportsNPOTTextures = extensionsString.contains("GL_OES_texture_npot"_s);
- attributes.supportsUnpackSubimage = extensionsString.contains("GL_EXT_unpack_subimage"_s);
+ attributes.supportsNPOTTextures = extensionsString.contains("GL_OES_texture_npot");
+ attributes.supportsUnpackSubimage = extensionsString.contains("GL_EXT_unpack_subimage");
#else
attributes.isGLES2Compliant = false;
attributes.supportsNPOTTextures = true;
Modified: trunk/Source/WebCore/platform/mediastream/CaptureDevice.h (291799 => 291800)
--- trunk/Source/WebCore/platform/mediastream/CaptureDevice.h 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/platform/mediastream/CaptureDevice.h 2022-03-24 16:55:40 UTC (rev 291800)
@@ -52,7 +52,7 @@
{
static NeverDestroyed<String> airPods(MAKE_STATIC_STRING_IMPL("AirPods"));
- if ((m_type == DeviceType::Microphone || m_type == DeviceType::Speaker) && m_label.contains(airPods))
+ if ((m_type == DeviceType::Microphone || m_type == DeviceType::Speaker) && m_label.contains(airPods.get()))
return airPods;
return m_label;
Modified: trunk/Source/WebCore/platform/network/curl/AuthenticationChallengeCurl.cpp (291799 => 291800)
--- trunk/Source/WebCore/platform/network/curl/AuthenticationChallengeCurl.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/platform/network/curl/AuthenticationChallengeCurl.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -117,7 +117,7 @@
String realm;
auto authHeader = response.httpHeaderField(response.isUnauthorized() ? wwwAuthenticate : proxyAuthenticate);
- auto realmPos = authHeader.findIgnoringASCIICase(realmString);
+ auto realmPos = authHeader.findIgnoringASCIICase(realmString.get());
if (realmPos != notFound) {
realm = authHeader.substring(realmPos + realmString.get().length());
realm = realm.left(realm.find(','));
Modified: trunk/Source/WebCore/platform/network/curl/CurlCacheEntry.cpp (291799 => 291800)
--- trunk/Source/WebCore/platform/network/curl/CurlCacheEntry.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/platform/network/curl/CurlCacheEntry.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -166,7 +166,7 @@
Vector<String>::const_iterator it = headerFields.begin();
Vector<String>::const_iterator end = headerFields.end();
while (it != end) {
- size_t splitPosition = it->find(":");
+ size_t splitPosition = it->find(':');
if (splitPosition != notFound)
m_cachedResponse.setHTTPHeaderField(it->left(splitPosition), it->substring(splitPosition+1).stripWhiteSpace());
++it;
Modified: trunk/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp (291799 => 291800)
--- trunk/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/platform/network/curl/CurlMultipartHandle.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -52,15 +52,15 @@
std::optional<String> CurlMultipartHandle::extractBoundary(const CurlResponse& response)
{
for (auto header : response.headers) {
- auto splitPosistion = header.find(":");
- if (splitPosistion == notFound)
+ auto splitPosition = header.find(':');
+ if (splitPosition == notFound)
continue;
- auto key = header.left(splitPosistion).stripWhiteSpace();
+ auto key = header.left(splitPosition).stripWhiteSpace();
if (!equalIgnoringASCIICase(key, "Content-Type"))
continue;
- auto contentType = header.substring(splitPosistion + 1).stripWhiteSpace();
+ auto contentType = header.substring(splitPosition + 1).stripWhiteSpace();
auto mimeType = extractMIMETypeFromMediaType(contentType);
if (!equalIgnoringASCIICase(mimeType, "multipart/x-mixed-replace"))
continue;
Modified: trunk/Source/WebCore/platform/network/curl/CurlRequest.cpp (291799 => 291800)
--- trunk/Source/WebCore/platform/network/curl/CurlRequest.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebCore/platform/network/curl/CurlRequest.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -536,7 +536,7 @@
headerFields.remove(0);
for (auto& header : headerFields) {
- auto pos = header.find(":");
+ auto pos = header.find(':');
if (pos != notFound) {
auto key = header.left(pos).stripWhiteSpace();
auto value = header.substring(pos + 1).stripWhiteSpace();
Modified: trunk/Source/WebDriver/WebDriverService.cpp (291799 => 291800)
--- trunk/Source/WebDriver/WebDriverService.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebDriver/WebDriverService.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -116,7 +116,7 @@
#if USE(INSPECTOR_SOCKET_SERVER)
if (!targetString.isEmpty()) {
- auto position = targetString.reverseFind(":"_s);
+ auto position = targetString.reverseFind(':');
if (position != notFound) {
m_targetAddress = targetString.left(position);
m_targetPort = parseIntegerAllowingTrailingJunk<uint16_t>(StringView { targetString }.substring(position + 1)).value_or(0);
@@ -617,7 +617,7 @@
if (!unhandledPromptBehavior || !deserializeUnhandledPromptBehavior(unhandledPromptBehavior))
return nullptr;
result->setString(it->key, unhandledPromptBehavior);
- } else if (it->key.find(":") != notFound) {
+ } else if (it->key.find(':') != notFound) {
if (!platformValidateCapability(it->key, it->value))
return nullptr;
result->setValue(it->key, it->value.copyRef());
Modified: trunk/Source/WebKit/ChangeLog (291799 => 291800)
--- trunk/Source/WebKit/ChangeLog 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebKit/ChangeLog 2022-03-24 16:55:40 UTC (rev 291800)
@@ -1,3 +1,13 @@
+2022-03-24 Chris Dumez <cdu...@apple.com>
+
+ String's find() / reverseFind() / replace() should take in a StringView instead of a String
+ https://bugs.webkit.org/show_bug.cgi?id=238287
+
+ Reviewed by Darin Adler.
+
+ * WebProcess/WebCoreSupport/WebContextMenuClient.cpp:
+ (WebKit::WebContextMenuClient::searchWithGoogle):
+
2022-03-24 Adrian Perez de Castro <ape...@igalia.com>
[GTK] REGRESSION(r291613): Build broken with USE_GTK4 + ENABLE_ACCESSIBILITY
Modified: trunk/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp (291799 => 291800)
--- trunk/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -55,7 +55,7 @@
size_t languagesCount = languages.size();
// Ignore "C" locale.
- size_t cLocalePosition = languages.find("c");
+ size_t cLocalePosition = languages.find("c"_s);
if (cLocalePosition != notFound)
languagesCount--;
Modified: trunk/Source/WebKit/Shared/mac/AuxiliaryProcessMac.mm (291799 => 291800)
--- trunk/Source/WebKit/Shared/mac/AuxiliaryProcessMac.mm 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebKit/Shared/mac/AuxiliaryProcessMac.mm 2022-03-24 16:55:40 UTC (rev 291800)
@@ -645,7 +645,7 @@
auto userDirectorySuffix = parameters.extraInitializationData.find("user-directory-suffix");
if (userDirectorySuffix != parameters.extraInitializationData.end()) {
String suffix = userDirectorySuffix->value;
- auto firstPathSeparator = suffix.find("/");
+ auto firstPathSeparator = suffix.find('/');
if (firstPathSeparator != notFound)
suffix.truncate(firstPathSeparator);
return suffix;
Modified: trunk/Source/WebKit/WebProcess/WebCoreSupport/WebContextMenuClient.cpp (291799 => 291800)
--- trunk/Source/WebKit/WebProcess/WebCoreSupport/WebContextMenuClient.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebKit/WebProcess/WebCoreSupport/WebContextMenuClient.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -61,7 +61,7 @@
auto searchString = frame->editor().selectedText();
searchString.stripWhiteSpace();
searchString = encodeWithURLEscapeSequences(searchString);
- searchString.replace("%20"_s, "+"_s);
+ searchString.replace("%20", "+");
auto searchURL = URL { "https://www.google.com/search?q=" + searchString + "&ie=UTF-8&oe=UTF-8" };
WebCore::UserGestureIndicator indicator { WebCore::ProcessingUserGesture };
Modified: trunk/Source/WebKitLegacy/win/ChangeLog (291799 => 291800)
--- trunk/Source/WebKitLegacy/win/ChangeLog 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebKitLegacy/win/ChangeLog 2022-03-24 16:55:40 UTC (rev 291800)
@@ -1,3 +1,13 @@
+2022-03-24 Chris Dumez <cdu...@apple.com>
+
+ String's find() / reverseFind() / replace() should take in a StringView instead of a String
+ https://bugs.webkit.org/show_bug.cgi?id=238287
+
+ Reviewed by Darin Adler.
+
+ * WebCoreSupport/WebContextMenuClient.cpp:
+ (WebContextMenuClient::searchWithGoogle):
+
2022-03-04 Chris Dumez <cdu...@apple.com>
Home link on weather.gov is not working
Modified: trunk/Source/WebKitLegacy/win/WebCoreSupport/WebContextMenuClient.cpp (291799 => 291800)
--- trunk/Source/WebKitLegacy/win/WebCoreSupport/WebContextMenuClient.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Source/WebKitLegacy/win/WebCoreSupport/WebContextMenuClient.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -58,7 +58,7 @@
auto searchString = frame->editor().selectedText();
searchString.stripWhiteSpace();
searchString = encodeWithURLEscapeSequences(searchString);
- searchString.replace("%20"_s, "+"_s);
+ searchString.replace("%20", "+");
auto searchURL = URL { "https://www.google.com/search?q=" + searchString + "&ie=UTF-8&oe=UTF-8" };
WebCore::UserGestureIndicator indicator { WebCore::ProcessingUserGesture };
Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp (291799 => 291800)
--- trunk/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp 2022-03-24 15:55:34 UTC (rev 291799)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp 2022-03-24 16:55:40 UTC (rev 291800)
@@ -334,13 +334,13 @@
TEST(WTF, StringImplFindIgnoringASCIICaseOnNull)
{
auto reference = stringFromUTF8("ABCÉEFG");
- EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr));
- EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 0));
- EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 3));
- EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 7));
- EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 8));
- EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 42));
- EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, std::numeric_limits<unsigned>::max()));
+ EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(StringView { }));
+ EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(StringView { }, 0));
+ EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(StringView { }, 3));
+ EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(StringView { }, 7));
+ EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(StringView { }, 8));
+ EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(StringView { }, 42));
+ EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(StringView { }, std::numeric_limits<unsigned>::max()));
}
TEST(WTF, StringImplFindIgnoringASCIICaseOnEmpty)
