Changeset 18712 in webkit for trunk/JavaScriptCore

Timestamp:

Jan 9, 2007, 6:54:26 AM (18 years ago)

Author:

darin

Message:

JavaScriptCore:

Reviewed by Maciej.

• fix ​http://bugs.webkit.org/show_bug.cgi?id=12174 improve Unicode use (less WTF::Unicode:: prefix, centralized character names)

• wtf/unicode/icu/UnicodeIcu.h: Change parameter and return types to UChar32 and UChar. Removed unneeded type casts and added some const to functions that lacked it. Removed WTF::Unicode::memcmp. (WTF::Unicode::umemcasecmp): Renamed from strcasecmp since this doesn't work on 0-terminated strings as the str functions do.
• wtf/unicode/qt4/UnicodeQt4.h: Ditto.

• got rid of namespace prefixes from most uses of WTF::Unicode

• kjs/function.cpp: (KJS::isStrWhiteSpace): (KJS::escapeStringForPrettyPrinting):
• kjs/lexer.cpp: (KJS::Lexer::isWhiteSpace): (KJS::Lexer::isIdentStart): (KJS::Lexer::isIdentPart):
• kjs/string_object.cpp: (KJS::StringProtoFunc::callAsFunction):

WebCore:

Reviewed by Maciej.

• fix ​http://bugs.webkit.org/show_bug.cgi?id=12174 improve Unicode use (less WTF::Unicode:: prefix, centralized character names)

• got rid of namespace prefixes from most uses of WTF::Unicode

• updated for removal of WTF::Unicode::memcmp
• updated for renaming of WTF::Unicode::strcasecmp to umemcasecmp.

• unified constants for special Unicode characters in a new CharacterNames.h header

• WebCore.xcodeproj/project.pbxproj:
• css/cssparser.cpp: (WebCore::ParseString::lower):
• dom/Document.cpp: (WebCore::isValidNameStart): (WebCore::isValidNamePart):
• dom/Position.cpp: (WebCore::Position::leadingWhitespacePosition): (WebCore::Position::trailingWhitespacePosition):
• editing/CompositeEditCommand.cpp: (WebCore::isWhitespace):
• editing/HTMLInterchange.cpp:
• editing/TextIterator.cpp: (WebCore::CircularSearchBuffer::CircularSearchBuffer): (WebCore::CircularSearchBuffer::append):
• editing/htmlediting.cpp: (WebCore::stringWithRebalancedWhitespace): (WebCore::nonBreakingSpaceString):
• editing/htmlediting.h:
• html/HTMLFontElement.cpp: (WebCore::parseFontSizeNumber):
• html/HTMLParser.cpp: (WebCore::HTMLParser::handleError):
• html/HTMLSelectElement.cpp: (WebCore::stripLeadingWhiteSpace):
• platform/Font.cpp: (WebCore::WidthIterator::advance): (WebCore::WidthIterator::normalizeVoicingMarks):
• platform/GlyphMap.cpp: (WebCore::GlyphMap::locatePage):
• platform/MimeTypeRegistry.h:
• platform/StringHash.h:
• platform/StringImpl.cpp: (WebCore::isSpace): (WebCore::StringImpl::append): (WebCore::StringImpl::insert): (WebCore::StringImpl::truncate): (WebCore::StringImpl::remove): (WebCore::parseLength): (WebCore::StringImpl::isLower): (WebCore::StringImpl::lower): (WebCore::StringImpl::upper): (WebCore::StringImpl::secure): (WebCore::StringImpl::foldCase): (WebCore::StringImpl::capitalize):t (WebCore::StringImpl::toInt): (WebCore::equalIgnoringCase): (WebCore::StringImpl::find):
• platform/TextBoundaries.h:
• platform/TextCodec.h:
• platform/TextCodecLatin1.cpp:
• platform/TextEncoding.h:
• platform/TextEncodingRegistry.h:
• platform/mac/PasteboardMac.mm: (WebCore::Pasteboard::writeSelection):
• platform/mac/TextCodecMac.cpp: (WebCore::TextCodecMac::decode):
• rendering/RenderBlock.cpp: (WebCore::RenderBlock::updateFirstLetter):
• rendering/RenderListMarker.cpp: (WebCore::listMarkerText): (WebCore::RenderListMarker::paint):
• rendering/RenderText.cpp: (WebCore::RenderText::widthFromCache): (WebCore::isSpaceAccordingToStyle): (WebCore::RenderText::setInternalString):
• rendering/RenderTreeAsText.cpp: (WebCore::quoteAndEscapeNonPrintables): (WebCore::operator<<):
• rendering/bidi.cpp: (WebCore::BidiState::BidiState): (WebCore::BidiContext::BidiContext): (WebCore::bidiNext): (WebCore::bidiFirst): (WebCore::BidiIterator::direction): (WebCore::appendRun): (WebCore::embed): (WebCore::RenderBlock::bidiReorderLine): (WebCore::RenderBlock::layoutInlineChildren): (WebCore::skipNonBreakingSpace): (WebCore::RenderBlock::findNextLineBreak):
• rendering/break_lines.cpp: (WebCore::nextBreakablePosition):
• rendering/break_lines.h:
• xml/XPathParser.cpp: (WebCore::XPath::charCat):

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• kjs/function.cpp (modified) (3 diffs)
• kjs/lexer.cpp (modified) (6 diffs)
• kjs/string_object.cpp (modified) (4 diffs)
• wtf/unicode/icu/UnicodeIcu.h (modified) (7 diffs)
• wtf/unicode/qt4/UnicodeQt4.h (modified) (10 diffs)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2007-01-09  Darin Adler  <[email protected]>
+
+        Reviewed by Maciej.
+
+        - fix http://bugs.webkit.org/show_bug.cgi?id=12174
+          improve Unicode use (less WTF::Unicode:: prefix, centralized character names)
+
+        * wtf/unicode/icu/UnicodeIcu.h: Change parameter and return types
+        to UChar32 and UChar. Removed unneeded type casts and added some
+        const to functions that lacked it. Removed WTF::Unicode::memcmp.
+        (WTF::Unicode::umemcasecmp): Renamed from strcasecmp since this
+        doesn't work on 0-terminated strings as the str functions do.
+        * wtf/unicode/qt4/UnicodeQt4.h: Ditto.
+
+        - got rid of namespace prefixes from most uses of WTF::Unicode
+
+        * kjs/function.cpp:
+        (KJS::isStrWhiteSpace):
+        (KJS::escapeStringForPrettyPrinting):
+        * kjs/lexer.cpp:
+        (KJS::Lexer::isWhiteSpace):
+        (KJS::Lexer::isIdentStart):
+        (KJS::Lexer::isIdentPart):
+        * kjs/string_object.cpp:
+        (KJS::StringProtoFunc::callAsFunction):
+
 2007-01-07  David Kilzer  <[email protected]>
 

trunk/JavaScriptCore/kjs/function.cpp

@@ -42 +42 @@
 
 #include <wtf/unicode/Unicode.h>
+
+using namespace WTF;
+using namespace Unicode;
 
 namespace KJS {
@@ -691 +694 @@
             return true;
         default:
-            return WTF::Unicode::isSeparatorSpace(c);
+            return isSeparatorSpace(c);
     }
 }
@@ -966 +969 @@
             break;
         default:
-            if (c < 128 && WTF::Unicode::isPrintableChar(c))
+            if (c < 128 && isPrintableChar(c))
                 escapedString.append(c);
             else {

trunk/JavaScriptCore/kjs/lexer.cpp

@@ -32 +32 @@
 #include <wtf/unicode/Unicode.h>
 
-static bool isDecimalDigit(int);
+using namespace WTF;
+using namespace Unicode;
 
 // we can't specify the namespace in yacc's C output, so do it here
 using namespace KJS;
-
-static Lexer *currLexer = 0;
 
 #ifndef KDE_USE_FINAL
@@ -53 +52 @@
   return Lexer::curr()->lex();
 }
+
+namespace KJS {
+
+static Lexer* currLexer = 0;
+
+static bool isDecimalDigit(int);
 
 Lexer::Lexer()
@@ -566 +571 @@
 bool Lexer::isWhiteSpace() const
 {
-  return current == '\t' || current == 0x0b || current == 0x0c || WTF::Unicode::isSeparatorSpace(current);
+  return current == '\t' || current == 0x0b || current == 0x0c || isSeparatorSpace(current);
 }
 
@@ -582 +587 @@
 bool Lexer::isIdentStart(int c)
 {
-  return (WTF::Unicode::category(c) & (WTF::Unicode::Letter_Uppercase
-        | WTF::Unicode::Letter_Lowercase
-        | WTF::Unicode::Letter_Titlecase
-        | WTF::Unicode::Letter_Modifier
-        | WTF::Unicode::Letter_Other))
+  return (category(c) & (Letter_Uppercase | Letter_Lowercase | Letter_Titlecase | Letter_Modifier | Letter_Other))
     || c == '$' || c == '_';
 }
@@ -592 +593 @@
 bool Lexer::isIdentPart(int c)
 {
-  return (WTF::Unicode::category(c) & (WTF::Unicode::Letter_Uppercase
-        | WTF::Unicode::Letter_Lowercase
-        | WTF::Unicode::Letter_Titlecase
-        | WTF::Unicode::Letter_Modifier
-        | WTF::Unicode::Letter_Other
-        | WTF::Unicode::Mark_NonSpacing
-        | WTF::Unicode::Mark_SpacingCombining
-        | WTF::Unicode::Number_DecimalDigit
-        | WTF::Unicode::Punctuation_Connector))
+  return (category(c) & (Letter_Uppercase | Letter_Lowercase | Letter_Titlecase | Letter_Modifier | Letter_Other
+        | Mark_NonSpacing | Mark_SpacingCombining | Number_DecimalDigit | Punctuation_Connector))
     || c == '$' || c == '_';
 }
@@ -912 +906 @@
   return string;
 }
+
+}

trunk/JavaScriptCore/kjs/string_object.cpp

@@ -38 +38 @@
 #endif
 
-using namespace KJS;
+using namespace WTF;
+
+namespace KJS {
 
 // ------------------------------ StringInstance ----------------------------
@@ -684 +686 @@
     uint16_t* destIfNeeded;
 
-    int len = WTF::Unicode::toLower(dataPtr, u.size(), destIfNeeded);
+    int len = Unicode::toLower(dataPtr, u.size(), destIfNeeded);
     if (len >= 0)
         result = jsString(UString(reinterpret_cast<UChar *>(destIfNeeded ? destIfNeeded : dataPtr), len));
@@ -700 +702 @@
     uint16_t* destIfNeeded;
 
-    int len = WTF::Unicode::toUpper(dataPtr, u.size(), destIfNeeded);
+    int len = Unicode::toUpper(dataPtr, u.size(), destIfNeeded);
     if (len >= 0)
         result = jsString(UString(reinterpret_cast<UChar *>(destIfNeeded ? destIfNeeded : dataPtr), len));
@@ -826 +828 @@
   return jsString(s);
 }
+
+}

trunk/JavaScriptCore/wtf/unicode/icu/UnicodeIcu.h

@@ -4 +4 @@
  *  Copyright (C) 2006 George Staikos <[email protected]>
  *  Copyright (C) 2006 Alexey Proskuryakov <[email protected]>
+ *  Copyright (C) 2007 Apple Computer, Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
@@ -118 +119 @@
     };
 
-    inline uint32_t foldCase(uint32_t c)
+    inline UChar32 foldCase(UChar32 c)
     {
       return u_foldCase(c, U_FOLD_CASE_DEFAULT);
     }
 
-    inline int foldCase(UChar* result, int resultLength, UChar* src, int srcLength,  bool* error)
+    inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
     {
       UErrorCode status = U_ZERO_ERROR;
-      int32_t realLength = u_strFoldCase(result, resultLength, src, srcLength, U_FOLD_CASE_DEFAULT, &status);
+      int realLength = u_strFoldCase(result, resultLength, src, srcLength, U_FOLD_CASE_DEFAULT, &status);
       *error = !U_SUCCESS(status);
       return realLength;
     }
 
-    inline int toLower(uint16_t* str, int strLength, uint16_t*& destIfNeeded)
+    inline int toLower(UChar* str, int strLength, UChar*& destIfNeeded)
     {
       UErrorCode err = U_ZERO_ERROR;
@@ -137 +138 @@
       destIfNeeded = 0;
 
-      resultLength = u_strToLower(0, 0, reinterpret_cast< ::UChar*>(str), strLength, "", &err);
+      resultLength = u_strToLower(0, 0, str, strLength, "", &err);
 
       if (resultLength <= strLength) {
         err = U_ZERO_ERROR;
-        u_strToLower(reinterpret_cast< ::UChar*>(str), resultLength, reinterpret_cast< ::UChar*>(str), strLength, "", &err);
+        u_strToLower(str, resultLength, str, strLength, "", &err);
       } else {
         err = U_ZERO_ERROR;
-        destIfNeeded = (uint16_t*)malloc(resultLength * sizeof(uint16_t));
-        u_strToLower(reinterpret_cast< ::UChar*>(destIfNeeded), resultLength, reinterpret_cast< ::UChar*>(str), strLength, "", &err);
+        destIfNeeded = static_cast<UChar*>(malloc(resultLength * sizeof(UChar)));
+        u_strToLower(destIfNeeded, resultLength, str, strLength, "", &err);
       }
 
@@ -151 +152 @@
     }
 
-    inline int toLower(UChar* result, int resultLength, UChar* src, int srcLength,  bool* error)
+    inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
     {
       UErrorCode status = U_ZERO_ERROR;
-      int32_t realLength = u_strToLower(result, resultLength, src, srcLength, "", &status);
+      int realLength = u_strToLower(result, resultLength, src, srcLength, "", &status);
       *error = !!U_FAILURE(status);
       return realLength;
     }
 
-    inline int32_t toLower(int32_t c)
+    inline UChar32 toLower(UChar32 c)
     {
       return u_tolower(c);
     }
 
-    inline int32_t toUpper(int32_t c)
+    inline UChar32 toUpper(UChar32 c)
     {
       return u_toupper(c);
     }
 
-    inline int toUpper(uint16_t* str, int strLength, uint16_t*& destIfNeeded)
+    inline int toUpper(UChar* str, int strLength, UChar*& destIfNeeded)
     {
       UErrorCode err = U_ZERO_ERROR;
@@ -175 +176 @@
       destIfNeeded = 0;
 
-      resultLength = u_strToUpper(0, 0, reinterpret_cast< ::UChar*>(str), strLength, "", &err);
+      resultLength = u_strToUpper(0, 0, str, strLength, "", &err);
 
       if (resultLength <= strLength) {
         err = U_ZERO_ERROR;
-        u_strToUpper(reinterpret_cast< ::UChar*>(str), resultLength, reinterpret_cast< ::UChar*>(str), strLength, "", &err);
+        u_strToUpper(str, resultLength, str, strLength, "", &err);
       } else {
         err = U_ZERO_ERROR;
-        destIfNeeded = (uint16_t*)malloc(resultLength * sizeof(uint16_t));
-        u_strToUpper(reinterpret_cast< ::UChar*>(destIfNeeded), resultLength, reinterpret_cast< ::UChar*>(str), strLength, "", &err);
+        destIfNeeded = (UChar*)malloc(resultLength * sizeof(UChar));
+        u_strToUpper(destIfNeeded, resultLength, str, strLength, "", &err);
       }
 
@@ -189 +190 @@
     }
 
-    inline int toUpper(UChar* result, int resultLength, UChar* src, int srcLength,  bool* error)
+    inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
     {
       UErrorCode status = U_ZERO_ERROR;
-      int32_t realLength = u_strToUpper(result, resultLength, src, srcLength, "", &status);
+      int realLength = u_strToUpper(result, resultLength, src, srcLength, "", &status);
       *error = !!U_FAILURE(status);
       return realLength;
     }
 
-    inline int toTitleCase (uint32_t c)
+    inline UChar32 toTitleCase(UChar32 c)
     {
       return u_totitle(c);
     }
 
-    inline bool isFormatChar(int32_t c)
+    inline bool isFormatChar(UChar32 c)
     {
       return u_charType(c) == U_FORMAT_CHAR;
     }
 
-    inline bool isSeparatorSpace(int32_t c)
+    inline bool isSeparatorSpace(UChar32 c)
     {
       return u_charType(c) == U_SPACE_SEPARATOR;
     }
 
-    inline bool isPrintableChar(int32_t c)
+    inline bool isPrintableChar(UChar32 c)
     {
       return !!u_isprint(c);
     }
     
-    inline bool isDigit(int32_t c)
+    inline bool isDigit(UChar32 c)
     {
       return !!u_isdigit(c);
     }
 
-    inline bool isPunct(int32_t c)
+    inline bool isPunct(UChar32 c)
     {
       return !!u_ispunct(c);
     }
 
-    inline int32_t mirroredChar(int32_t c)
+    inline UChar32 mirroredChar(UChar32 c)
     {
       return u_charMirror(c);
     }
 
-    inline CharCategory category(int32_t c)
+    inline CharCategory category(UChar32 c)
     {
       return static_cast<CharCategory>(U_GET_GC_MASK(c));
     }
 
-    inline Direction direction(int c) {
-      return (Direction)u_charDirection(c);
-    }
-
-    inline bool isLower(int32_t c)
+    inline Direction direction(UChar32 c)
+    {
+      return static_cast<Direction>(u_charDirection(c));
+    }
+
+    inline bool isLower(UChar32 c)
     {
       return !!u_islower(c);
     }
 
-    inline bool isUpper(int32_t c)
+    inline bool isUpper(UChar32 c)
     {
       return !!u_isUUppercase(c);
       }
 
-    inline int digitValue(int32_t c)
+    inline int digitValue(UChar32 c)
     {
       return u_charDigitValue(c);
@@ -266 +268 @@
     }
 
-    inline int strcasecmp(const UChar *a, const UChar *b, int len)
+    inline int umemcasecmp(const UChar* a, const UChar* b, int len)
     {
       return u_memcasecmp(a, b, len, U_FOLD_CASE_DEFAULT);
     }
 
-    inline void memset(UChar* dest, UChar ch, int32_t count)
-    {
-      u_memset(dest, ch, count);
-    }
   }
 }

trunk/JavaScriptCore/wtf/unicode/qt4/UnicodeQt4.h

@@ -143 +143 @@
     };
 
-    inline int toLower(uint16_t* str, int strLength, uint16_t*& destIfNeeded)
+    inline int toLower(UChar* str, int strLength, UChar*& destIfNeeded)
     {
       destIfNeeded = 0;
@@ -153 +153 @@
     }
 
-    inline uint16_t toLower(uint16_t ch)
-    {
-      return QChar(ch).toLower().unicode();
-    }
-
-    inline int toLower(UChar* result, int resultLength, UChar* src, int srcLength,  bool* error)
+    inline UChar32 toLower(UChar32 ch)
+    {
+      if (ch > 0xffff)
+        return ch;
+      return QChar((unsigned short)ch).toLower().unicode();
+    }
+
+    inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
     {
       *error = false;
@@ -169 +171 @@
     }
 
-    inline int toUpper(uint16_t* str, int strLength, uint16_t*& destIfNeeded)
+    inline int toUpper(UChar* str, int strLength, UChar*& destIfNeeded)
     {
       destIfNeeded = 0;
@@ -179 +181 @@
     }
 
-    inline uint16_t toUpper(uint16_t ch)
-    {
-      return QChar(ch).toUpper().unicode();
+    inline UChar32 toUpper(UChar32 ch)
+    {
+      if (ch > 0xffff)
+        return ch;
+      return QChar((unsigned short)ch).toUpper().unicode();
     }
 
@@ -195 +199 @@
     }
 
-    inline int toTitleCase (uint32_t c)
+    inline int toTitleCase(UChar32 c)
     {
       if (c > 0xffff)
         return c;
-      return QChar(c).toUpper().unicode();
-    }
-
-    inline uint32_t foldCase(uint32_t c)
+      return QChar((unsigned short)c).toUpper().unicode();
+    }
+
+    inline UChar32 foldCase(UChar32 c)
     {
       if (c > 0xffff)
         return c;
-      return QChar(c).toLower().unicode();
+      return QChar((unsigned short)c).toLower().unicode();
     }
 
@@ -214 +218 @@
     }
 
-    inline bool isFormatChar(int32_t c)
+    inline bool isFormatChar(UChar32 c)
     {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).category() == QChar::Other_Format;
     }
 
-    inline bool isPrintableChar(int32_t c)
+    inline bool isPrintableChar(UChar32 c)
     {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).isPrint();
     }
 
-    inline bool isSeparatorSpace(int32_t c)
+    inline bool isSeparatorSpace(UChar32 c)
     {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).category() == QChar::Separator_Space;
     }
 
-    inline bool isPunct(int32_t c)
+    inline bool isPunct(UChar32 c)
     {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).isPunct();
     }
 
-    inline bool isDigit(int32_t c)
+    inline bool isDigit(UChar32 c)
     {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).isDigit();
     }
 
-    inline bool isLower(int32_t c)
+    inline bool isLower(UChar32 c)
     {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).category() == QChar::Letter_Lowercase;
     }
 
-    inline bool isUpper(int32_t c)
+    inline bool isUpper(UChar32 c)
     {
       return (c & 0xffff0000) == 0 && QChar((unsigned short)c).category() == QChar::Letter_Uppercase;
     }
 
-    inline int digitValue(int32_t c)
+    inline int digitValue(UChar32 c)
     {
       if (c > 0xffff)
@@ -256 +260 @@
     }
 
-    inline uint16_t mirroredChar(uint16_t c)
-    {
+    inline UChar32 mirroredChar(UChar32 c)
+    {
+      if (c > 0xffff)
+        return c;
       return QChar(c).mirroredChar().unicode();
     }
@@ -275 +281 @@
     }
 
-
-    inline int strcasecmp(const UChar *a, const UChar *b, int len)
+    inline int umemcasecmp(const UChar* a, const UChar* b, int len)
     {
       for (int i = 0; i < len; ++i) {
@@ -287 +292 @@
     }
 
-    inline void memset(UChar* dest, UChar ch, int32_t count)
-    {
-      UChar *end = dest + count;
-      while (dest < end)
-        *dest++ = ch;
-    }
-
-    inline Direction direction(int c) {
+    inline Direction direction(UChar32 c) {
       if (c > 0xffff)
         return LeftToRight;
@@ -300 +298 @@
     }
 
-    inline CharCategory category(int c) {
+    inline CharCategory category(UChar32 c) {
       if (c > 0xffff)
         return (CharCategory) U_MASK(QChar::Letter_Other);
       return (CharCategory) U_MASK(QChar(c).category());
     }
+
   }
 }