Make small-caps work correctly with tr locale

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 512 matching lines @@
 
         if (!(ored & ~0x7F)) {
             for (int32_t i = 0; i < length; ++i)
                 data8[i] = toASCIILower(characters8()[i]);
 
             return newImpl.release();
         }
 
         // Do a slower implementation for cases that include non-ASCII Latin-1 characters.
         for (int32_t i = 0; i < length; ++i)
-            data8[i] = static_cast<LChar>(Unicode::toLower(characters8()[i]));
+            data8[i] = static_cast<LChar>(toLower(characters8()[i]));
 
         return newImpl.release();
     }
 
     const UChar* end = characters16() + m_length;
     for (const UChar* chp = characters16(); chp != end; ++chp) {
         if (UNLIKELY(isASCIIUpper(*chp)))
             noUpper = false;
         ored |= *chp;
     }
@@ skipping 13 matching lines @@
             data16[i] = toASCIILower(c);
         }
         return newImpl.release();
     }
 
     // Do a slower implementation for cases that include non-ASCII characters.
     UChar* data16;
     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
 
     bool error;
-    int32_t realLength = Unicode::toLower(data16, length, characters16(), m_length, &error);
+    int32_t realLength = toLower(data16, length, characters16(), m_length, &error);
     if (!error && realLength == length)
         return newImpl.release();
 
     newImpl = createUninitialized(realLength, data16);
-    Unicode::toLower(data16, realLength, characters16(), m_length, &error);
+    toLower(data16, realLength, characters16(), m_length, &error);
     if (error)
         return this;
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::upper()
 {
     // This function could be optimized for no-op cases the way lower() is,
     // but in empirical testing, few actual calls to upper() are no-ops, so
     // it wouldn't be worth the extra time for pre-scanning.
@@ skipping 18 matching lines @@
         // 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.
         //  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));
+            UChar upper = static_cast<UChar>(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.
                 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.
         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
-                *dest++ = static_cast<LChar>(Unicode::toUpper(c));
+            } else {
+                *dest++ = static_cast<LChar>(toUpper(c));
+            }
         }
 
         return newImpl.release();
     }
 
 upconvert:
     RefPtr<StringImpl> upconverted = upconvertedString();
     const UChar* source16 = upconverted->characters16();
 
     UChar* data16;
     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
 
     // Do a faster loop for the case where all the characters are ASCII.
     UChar ored = 0;
     for (int i = 0; i < length; ++i) {
         UChar c = source16[i];
         ored |= c;
         data16[i] = toASCIIUpper(c);
     }
     if (!(ored & ~0x7F))
         return newImpl.release();
 
     // Do a slower implementation for cases that include non-ASCII characters.
     bool error;
-    int32_t realLength = Unicode::toUpper(data16, length, source16, m_length, &error);
+    int32_t realLength = toUpper(data16, length, source16, m_length, &error);
     if (!error && realLength == length)
         return newImpl;
     newImpl = createUninitialized(realLength, data16);
-    Unicode::toUpper(data16, realLength, source16, m_length, &error);
+    toUpper(data16, realLength, source16, m_length, &error);
     if (error)
         return this;
     return newImpl.release();
 }
 
 static bool inline localeIdMatchesLang(const AtomicString& localeId, const char* lang)
 {
     if (equalIgnoringCase(localeId, lang))
         return true;
     static char localeIdPrefix[4];
@@ skipping 129 matching lines @@
             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.
         for (int32_t i = 0; i < length; ++i)
-            data[i] = static_cast<LChar>(Unicode::toLower(characters8()[i]));
+            data[i] = static_cast<LChar>(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;
     for (int32_t i = 0; i < length; ++i) {
         UChar c = characters16()[i];
@@ skipping 1264 matching lines @@
 }
 
 size_t StringImpl::sizeInBytes() const
 {
     size_t size = length();
     if (!is8Bit())
         size *= 2;
     return size + sizeof(*this);
 }
 
+UChar32 toUpper(UChar32 c, const AtomicString& localeIdentifier)
+{
+    if (!localeIdentifier.isNull()) {
+        if (localeIdMatchesLang(localeIdentifier, "tr") || localeIdMatchesLang(localeIdentifier, "az")) {
+            if (c == 'i')
+                return 0x130; // Latin capital letter i with dot above
+            if (c == 0x131) // Latin small letter dotless i
+                return 'I';
+        } else if (localeIdMatchesLang(localeIdentifier, "lt")) {
+            // FIXME
+        }
+    }
+
+    return toUpper(c);
+}
+
 } // namespace WTF