reflow comments in wtf/text

third_party/WebKit/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) 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 44 matching lines @@
               "StringImpl should stay small");
 
 #ifdef STRING_STATS
 
 static Mutex& statsMutex() {
   DEFINE_STATIC_LOCAL(Mutex, mutex, ());
   return mutex;
 }
 
 static HashSet<void*>& liveStrings() {
-  // Notice that we can't use HashSet<StringImpl*> because then HashSet would dedup identical strings.
+  // Notice that we can't use HashSet<StringImpl*> because then HashSet would
+  // dedup identical strings.
   DEFINE_STATIC_LOCAL(HashSet<void*>, strings, ());
   return strings;
 }
 
 void addStringForStats(StringImpl* string) {
   MutexLocker locker(statsMutex());
   liveStrings().add(string);
 }
 
 void removeStringForStats(StringImpl* string) {
@@ skipping 596 matching lines @@
     // Do a faster loop for the case where all the characters are ASCII.
     LChar ored = 0;
     for (int i = 0; i < length; ++i) {
       LChar c = characters8()[i];
       ored |= c;
       data8[i] = toASCIIUpper(c);
     }
     if (!(ored & ~0x7F))
       return newImpl.release();
 
-    // Do a slower implementation for cases that include non-ASCII Latin-1 characters.
+    // Do a slower implementation for cases that include non-ASCII Latin-1
+    // characters.
     int numberSharpSCharacters = 0;
 
     // There are two special cases.
-    //  1. latin-1 characters when converted to upper case are 16 bit characters.
+    //  1. latin-1 characters when converted to upper case are 16 bit
+    //     characters.
     //  2. Lower case sharp-S converts to "SS" (two characters)
     for (int32_t i = 0; i < length; ++i) {
       LChar c = characters8()[i];
       if (UNLIKELY(c == smallLetterSharpSCharacter))
         ++numberSharpSCharacters;
       UChar upper = static_cast<UChar>(Unicode::toUpper(c));
       if (UNLIKELY(upper > 0xff)) {
-        // Since this upper-cased character does not fit in an 8-bit string, we need to take the 16-bit path.
+        // Since this upper-cased character does not fit in an 8-bit string, we
+        // need to take the 16-bit path.
         goto upconvert;
       }
       data8[i] = static_cast<LChar>(upper);
     }
 
     if (!numberSharpSCharacters)
       return newImpl.release();
 
-    // We have numberSSCharacters sharp-s characters, but none of the other special characters.
+    // We have numberSSCharacters sharp-s characters, but none of the other
+    // special characters.
     newImpl = createUninitialized(m_length + numberSharpSCharacters, data8);
 
     LChar* dest = data8;
 
     for (int32_t i = 0; i < length; ++i) {
       LChar c = characters8()[i];
       if (c == smallLetterSharpSCharacter) {
         *dest++ = 'S';
         *dest++ = 'S';
       } else {
@@ skipping 172 matching lines @@
 
     for (int32_t i = 0; i < length; ++i) {
       LChar c = characters8()[i];
       data[i] = toASCIILower(c);
       ored |= c;
     }
 
     if (!(ored & ~0x7F))
       return newImpl.release();
 
-    // Do a slower implementation for cases that include non-ASCII Latin-1 characters.
+    // Do a slower implementation for cases that include non-ASCII Latin-1
+    // characters.
     for (int32_t i = 0; i < length; ++i)
       data[i] = static_cast<LChar>(Unicode::toLower(characters8()[i]));
 
     return newImpl.release();
   }
 
   // Do a faster loop for the case where all the characters are ASCII.
   UChar* data;
   RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
   UChar ored = 0;
@@ skipping 348 matching lines @@
 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.
+  // 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];
   }
 
@@ skipping 47 matching lines @@
                       searchLength, matchLength);
 }
 
 template <typename SearchCharacterType, typename MatchCharacterType>
 ALWAYS_INLINE static size_t findIgnoringCaseInternal(
     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.
+  // 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 kNotFound;
     ++i;
   }
@@ skipping 34 matching lines @@
                                   searchLength, matchLength);
 }
 
 template <typename SearchCharacterType, typename MatchCharacterType>
 ALWAYS_INLINE static size_t findIgnoringASCIICaseInternal(
     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.
+  // 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 (!equalIgnoringASCIICase(searchCharacters + i, matchCharacters,
                                  matchLength)) {
     if (i == delta)
       return kNotFound;
     ++i;
   }
@@ skipping 43 matching lines @@
 template <typename SearchCharacterType, typename MatchCharacterType>
 ALWAYS_INLINE static size_t reverseFindInternal(
     const SearchCharacterType* searchCharacters,
     const MatchCharacterType* matchCharacters,
     unsigned index,
     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.
+  // delta is the number of additional times to test; delta == 0 means test only
+  // once.
   unsigned delta = min(index, length - matchLength);
 
   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
@@ skipping 706 matching lines @@
     } else if (localeIdMatchesLang(localeIdentifier, "lt")) {
       // TODO(rob.buis) implement upper-casing rules for lt
       // like in StringImpl::upper(locale).
     }
   }
 
   return toUpper(c);
 }
 
 }  // namespace WTF