WTF::notFound looks too much like a local variable.

Source/wtf/text/StringImpl.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 955 matching lines @@
 {
     if (is8Bit())
         return WTF::find(characters8(), m_length, matchFunction, start);
     return WTF::find(characters16(), m_length, matchFunction, start);
 }
 
 size_t StringImpl::find(const LChar* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (!matchString)
-        return notFound;
+        return kNotFound;
     size_t matchStringLength = strlen(reinterpret_cast<const char*>(matchString));
     RELEASE_ASSERT(matchStringLength <= numeric_limits<unsigned>::max());
     unsigned matchLength = matchStringLength;
     if (!matchLength)
         return min(index, length());
 
     // Optimization 1: fast case for strings of length 1.
     if (matchLength == 1)
         return WTF::find(characters16(), length(), *matchString, index);
 
     // Check index & matchLength are in range.
     if (index > length())
-        return notFound;
+        return kNotFound;
     unsigned searchLength = length() - index;
     if (matchLength > searchLength)
-        return notFound;
+        return kNotFound;
     // delta is the number of additional times to test; delta == 0 means test only once.
     unsigned delta = searchLength - matchLength;
 
     const UChar* searchCharacters = characters16() + index;
 
     // Optimization 2: keep a running hash of the strings,
     // only call equal if the hashes match.
     unsigned searchHash = 0;
     unsigned matchHash = 0;
     for (unsigned i = 0; i < matchLength; ++i) {
         searchHash += searchCharacters[i];
         matchHash += matchString[i];
     }
 
     unsigned i = 0;
     // keep looping until we match
     while (searchHash != matchHash || !equal(searchCharacters + i, matchString, matchLength)) {
         if (i == delta)
-            return notFound;
+            return kNotFound;
         searchHash += searchCharacters[i + matchLength];
         searchHash -= searchCharacters[i];
         ++i;
     }
     return index + i;
 }
 
 template<typename CharType>
 ALWAYS_INLINE size_t findIgnoringCaseInternal(const CharType* searchCharacters, const LChar* matchString, unsigned index, unsigned searchLength, unsigned matchLength)
 {
     // delta is the number of additional times to test; delta == 0 means test only once.
     unsigned delta = searchLength - matchLength;
 
     unsigned i = 0;
     while (!equalIgnoringCase(searchCharacters + i, matchString, matchLength)) {
         if (i == delta)
-            return notFound;
+            return kNotFound;
         ++i;
     }
     return index + i;
 }
 
 size_t StringImpl::findIgnoringCase(const LChar* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (!matchString)
-        return notFound;
+        return kNotFound;
     size_t matchStringLength = strlen(reinterpret_cast<const char*>(matchString));
     RELEASE_ASSERT(matchStringLength <= numeric_limits<unsigned>::max());
     unsigned matchLength = matchStringLength;
     if (!matchLength)
         return min(index, length());
 
     // Check index & matchLength are in range.
     if (index > length())
-        return notFound;
+        return kNotFound;
     unsigned searchLength = length() - index;
     if (matchLength > searchLength)
-        return notFound;
+        return kNotFound;
 
     if (is8Bit())
         return findIgnoringCaseInternal(characters8() + index, matchString, index, searchLength, matchLength);
     return findIgnoringCaseInternal(characters16() + index, matchString, index, searchLength, matchLength);
 }
 
 template <typename SearchCharacterType, typename MatchCharacterType>
 ALWAYS_INLINE static size_t findInternal(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned searchLength, 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 = searchLength - matchLength;
 
     unsigned searchHash = 0;
     unsigned matchHash = 0;
 
     for (unsigned i = 0; i < matchLength; ++i) {
         searchHash += searchCharacters[i];
         matchHash += matchCharacters[i];
     }
 
     unsigned i = 0;
     // keep looping until we match
     while (searchHash != matchHash || !equal(searchCharacters + i, matchCharacters, matchLength)) {
         if (i == delta)
-            return notFound;
+            return kNotFound;
         searchHash += searchCharacters[i + matchLength];
         searchHash -= searchCharacters[i];
         ++i;
     }
     return index + i;
 }
 
 size_t StringImpl::find(StringImpl* matchString)
 {
     // Check for null string to match against
     if (UNLIKELY(!matchString))
-        return notFound;
+        return kNotFound;
     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(characters16(), length(), matchString->characters8()[0]);
         return WTF::find(characters16(), length(), matchString->characters16()[0]);
     }
 
     // Check matchLength is in range.
     if (matchLength > length())
-        return notFound;
+        return kNotFound;
 
     // Check for empty string to match against
     if (UNLIKELY(!matchLength))
         return 0;
 
     if (is8Bit()) {
         if (matchString->is8Bit())
             return findInternal(characters8(), matchString->characters8(), 0, length(), matchLength);
         return findInternal(characters8(), matchString->characters16(), 0, length(), matchLength);
     }
 
     if (matchString->is8Bit())
         return findInternal(characters16(), matchString->characters8(), 0, length(), matchLength);
 
     return findInternal(characters16(), matchString->characters16(), 0, length(), matchLength);
 }
 
 size_t StringImpl::find(StringImpl* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (UNLIKELY(!matchString))
-        return notFound;
+        return kNotFound;
 
     unsigned matchLength = matchString->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)[0], index);
     }
 
     if (UNLIKELY(!matchLength))
         return min(index, length());
 
     // Check index & matchLength are in range.
     if (index > length())
-        return notFound;
+        return kNotFound;
     unsigned searchLength = length() - index;
     if (matchLength > searchLength)
-        return notFound;
+        return kNotFound;
 
     if (is8Bit()) {
         if (matchString->is8Bit())
             return findInternal(characters8() + index, matchString->characters8(), index, searchLength, matchLength);
         return findInternal(characters8() + index, matchString->characters16(), index, searchLength, matchLength);
     }
 
     if (matchString->is8Bit())
         return findInternal(characters16() + index, matchString->characters8(), index, searchLength, matchLength);
 
     return findInternal(characters16() + index, matchString->characters16(), index, searchLength, matchLength);
 }
 
 template <typename SearchCharacterType, typename MatchCharacterType>
 ALWAYS_INLINE static size_t findIgnoringCaseInner(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned searchLength, unsigned matchLength)
 {
     // delta is the number of additional times to test; delta == 0 means test only once.
     unsigned delta = searchLength - matchLength;
 
     unsigned i = 0;
     // keep looping until we match
     while (!equalIgnoringCase(searchCharacters + i, matchCharacters, matchLength)) {
         if (i == delta)
-            return notFound;
+            return kNotFound;
         ++i;
     }
     return index + i;
 }
 
 size_t StringImpl::findIgnoringCase(StringImpl* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (!matchString)
-        return notFound;
+        return kNotFound;
     unsigned matchLength = matchString->length();
     if (!matchLength)
         return min(index, length());
 
     // Check index & matchLength are in range.
     if (index > length())
-        return notFound;
+        return kNotFound;
     unsigned searchLength = length() - index;
     if (matchLength > searchLength)
-        return notFound;
+        return kNotFound;
 
     if (is8Bit()) {
         if (matchString->is8Bit())
             return findIgnoringCaseInner(characters8() + index, matchString->characters8(), index, searchLength, matchLength);
         return findIgnoringCaseInner(characters8() + index, matchString->characters16(), index, searchLength, matchLength);
     }
 
     if (matchString->is8Bit())
         return findIgnoringCaseInner(characters16() + index, matchString->characters8(), index, searchLength, matchLength);
 
@@ skipping 39 matching lines @@
     unsigned searchHash = 0;
     unsigned matchHash = 0;
     for (unsigned i = 0; i < matchLength; ++i) {
         searchHash += searchCharacters[delta + i];
         matchHash += matchCharacters[i];
     }
 
     // keep looping until we match
     while (searchHash != matchHash || !equal(searchCharacters + delta, matchCharacters, matchLength)) {
         if (!delta)
-            return notFound;
+            return kNotFound;
         --delta;
         searchHash -= searchCharacters[delta + matchLength];
         searchHash += searchCharacters[delta];
     }
     return delta;
 }
 
 size_t StringImpl::reverseFind(StringImpl* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (!matchString)
-        return notFound;
+        return kNotFound;
     unsigned matchLength = matchString->length();
     unsigned ourLength = length();
     if (!matchLength)
         return min(index, 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);
     }
 
     // Check index & matchLength are in range.
     if (matchLength > ourLength)
-        return notFound;
+        return kNotFound;
 
     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(characters16(), matchString->characters8(), index, ourLength, matchLength);
 
     return reverseFindInner(characters16(), matchString->characters16(), index, ourLength, matchLength);
 }
 
 template <typename SearchCharacterType, typename MatchCharacterType>
 ALWAYS_INLINE static size_t reverseFindIgnoringCaseInner(const SearchCharacterType* searchCharacters, const MatchCharacterType* matchCharacters, unsigned index, unsigned length, unsigned matchLength)
 {
     // delta is the number of additional times to test; delta == 0 means test only once.
     unsigned delta = min(index, length - matchLength);
 
     // keep looping until we match
     while (!equalIgnoringCase(searchCharacters + delta, matchCharacters, matchLength)) {
         if (!delta)
-            return notFound;
+            return kNotFound;
         --delta;
     }
     return delta;
 }
 
 size_t StringImpl::reverseFindIgnoringCase(StringImpl* matchString, unsigned index)
 {
     // Check for null or empty string to match against
     if (!matchString)
-        return notFound;
+        return kNotFound;
     unsigned matchLength = matchString->length();
     unsigned ourLength = length();
     if (!matchLength)
         return min(index, ourLength);
 
     // Check index & matchLength are in range.
     if (matchLength > ourLength)
-        return notFound;
+        return kNotFound;
 
     if (is8Bit()) {
         if (matchString->is8Bit())
             return reverseFindIgnoringCaseInner(characters8(), matchString->characters8(), index, ourLength, matchLength);
         return reverseFindIgnoringCaseInner(characters8(), matchString->characters16(), index, ourLength, matchLength);
     }
 
     if (matchString->is8Bit())
         return reverseFindIgnoringCaseInner(characters16(), matchString->characters8(), index, ourLength, matchLength);
 
@@ skipping 172 matching lines @@
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, const LChar* replacement, unsigned repStrLength)
 {
     ASSERT(replacement);
 
     size_t srcSegmentStart = 0;
     unsigned matchCount = 0;
 
     // Count the matches.
-    while ((srcSegmentStart = find(pattern, srcSegmentStart)) != notFound) {
+    while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
         ++matchCount;
         ++srcSegmentStart;
     }
 
     // If we have 0 matches then we don't have to do any more work.
     if (!matchCount)
         return this;
 
     RELEASE_ASSERT(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
 
     unsigned replaceSize = matchCount * repStrLength;
     unsigned newSize = m_length - matchCount;
     RELEASE_ASSERT(newSize < (numeric_limits<unsigned>::max() - replaceSize));
 
     newSize += replaceSize;
 
     // Construct the new data.
     size_t srcSegmentEnd;
     unsigned srcSegmentLength;
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
 
     if (is8Bit()) {
         LChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
-        while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
+        while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
             srcSegmentLength = srcSegmentEnd - srcSegmentStart;
             memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
             dstOffset += srcSegmentLength;
             memcpy(data + dstOffset, replacement, repStrLength * sizeof(LChar));
             dstOffset += repStrLength;
             srcSegmentStart = srcSegmentEnd + 1;
         }
 
         srcSegmentLength = m_length - srcSegmentStart;
         memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
 
         ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
-    while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
+    while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
         srcSegmentLength = srcSegmentEnd - srcSegmentStart;
         memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
         dstOffset += srcSegmentLength;
         for (unsigned i = 0; i < repStrLength; ++i)
             data[i + dstOffset] = replacement[i];
 
         dstOffset += repStrLength;
         srcSegmentStart = srcSegmentEnd + 1;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
     memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
     ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, const UChar* replacement, unsigned repStrLength)
 {
     ASSERT(replacement);
 
     size_t srcSegmentStart = 0;
     unsigned matchCount = 0;
 
     // Count the matches.
-    while ((srcSegmentStart = find(pattern, srcSegmentStart)) != notFound) {
+    while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
         ++matchCount;
         ++srcSegmentStart;
     }
 
     // If we have 0 matches then we don't have to do any more work.
     if (!matchCount)
         return this;
 
     RELEASE_ASSERT(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
 
     unsigned replaceSize = matchCount * repStrLength;
     unsigned newSize = m_length - matchCount;
     RELEASE_ASSERT(newSize < (numeric_limits<unsigned>::max() - replaceSize));
 
     newSize += replaceSize;
 
     // Construct the new data.
     size_t srcSegmentEnd;
     unsigned srcSegmentLength;
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
 
     if (is8Bit()) {
         UChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
-        while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
+        while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
             srcSegmentLength = srcSegmentEnd - srcSegmentStart;
             for (unsigned i = 0; i < srcSegmentLength; ++i)
                 data[i + dstOffset] = characters8()[i + srcSegmentStart];
 
             dstOffset += srcSegmentLength;
             memcpy(data + dstOffset, replacement, repStrLength * sizeof(UChar));
 
             dstOffset += repStrLength;
             srcSegmentStart = srcSegmentEnd + 1;
         }
 
         srcSegmentLength = m_length - srcSegmentStart;
         for (unsigned i = 0; i < srcSegmentLength; ++i)
             data[i + dstOffset] = characters8()[i + srcSegmentStart];
 
         ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
-    while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
+    while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
         srcSegmentLength = srcSegmentEnd - srcSegmentStart;
         memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
         dstOffset += srcSegmentLength;
         memcpy(data + dstOffset, replacement, repStrLength * sizeof(UChar));
 
         dstOffset += repStrLength;
         srcSegmentStart = srcSegmentEnd + 1;
     }
 
@@ skipping 12 matching lines @@
 
     unsigned patternLength = pattern->length();
     if (!patternLength)
         return this;
 
     unsigned repStrLength = replacement->length();
     size_t srcSegmentStart = 0;
     unsigned matchCount = 0;
 
     // Count the matches.
-    while ((srcSegmentStart = find(pattern, srcSegmentStart)) != notFound) {
+    while ((srcSegmentStart = find(pattern, srcSegmentStart)) != kNotFound) {
         ++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;
     RELEASE_ASSERT(!repStrLength || matchCount <= numeric_limits<unsigned>::max() / repStrLength);
@@ skipping 13 matching lines @@
 
     // There are 4 cases:
     // 1. This and replacement are both 8 bit.
     // 2. This and replacement are both 16 bit.
     // 3. This is 8 bit and replacement is 16 bit.
     // 4. This is 16 bit and replacement is 8 bit.
     if (srcIs8Bit && replacementIs8Bit) {
         // Case 1
         LChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
-        while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
+        while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
             srcSegmentLength = srcSegmentEnd - srcSegmentStart;
             memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
             dstOffset += srcSegmentLength;
             memcpy(data + dstOffset, replacement->characters8(), repStrLength * sizeof(LChar));
             dstOffset += repStrLength;
             srcSegmentStart = srcSegmentEnd + patternLength;
         }
 
         srcSegmentLength = m_length - srcSegmentStart;
         memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
 
         ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
-    while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
+    while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != kNotFound) {
         srcSegmentLength = srcSegmentEnd - srcSegmentStart;
         if (srcIs8Bit) {
             // Case 3.
             for (unsigned i = 0; i < srcSegmentLength; ++i)
                 data[i + dstOffset] = characters8()[i + srcSegmentStart];
         } else {
             // Case 2 & 4.
             memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
         }
         dstOffset += srcSegmentLength;
@@ skipping 241 matching lines @@
 
 size_t StringImpl::sizeInBytes() const
 {
     size_t size = length();
     if (!is8Bit())
         size *= 2;
     return size + sizeof(*this);
 }
 
 } // namespace WTF