<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[37532] trunk/JavaScriptCore</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/37532">37532</a></dd>
<dt>Author</dt> <dd>darin@apple.com</dd>
<dt>Date</dt> <dd>2008-10-12 15:51:13 -0700 (Sun, 12 Oct 2008)</dd>
</dl>

<h3>Log Message</h3>
<pre>2008-10-12  Darin Adler  &lt;darin@apple.com&gt;

        Reviewed by Sam Weinig.

        * wtf/unicode/icu/UnicodeIcu.h: Fixed indentation to match WebKit coding style.
        * wtf/unicode/qt4/UnicodeQt4.h: Ditto.</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkJavaScriptCoreChangeLog">trunk/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkJavaScriptCorewtfunicodeicuUnicodeIcuh">trunk/JavaScriptCore/wtf/unicode/icu/UnicodeIcu.h</a></li>
<li><a href="#trunkJavaScriptCorewtfunicodeqt4UnicodeQt4h">trunk/JavaScriptCore/wtf/unicode/qt4/UnicodeQt4.h</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/ChangeLog (37531 => 37532)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/ChangeLog        2008-10-12 22:49:46 UTC (rev 37531)
+++ trunk/JavaScriptCore/ChangeLog        2008-10-12 22:51:13 UTC (rev 37532)
</span><span class="lines">@@ -2,6 +2,13 @@
</span><span class="cx"> 
</span><span class="cx">         Reviewed by Sam Weinig.
</span><span class="cx"> 
</span><ins>+        * wtf/unicode/icu/UnicodeIcu.h: Fixed indentation to match WebKit coding style.
+        * wtf/unicode/qt4/UnicodeQt4.h: Ditto.
+
+2008-10-12  Darin Adler  &lt;darin@apple.com&gt;
+
+        Reviewed by Sam Weinig.
+
</ins><span class="cx">         - https://bugs.webkit.org/show_bug.cgi?id=21556
</span><span class="cx">           Bug 21556: non-ASCII digits are allowed in places where only ASCII should be
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkJavaScriptCorewtfunicodeicuUnicodeIcuh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/wtf/unicode/icu/UnicodeIcu.h (37531 => 37532)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/wtf/unicode/icu/UnicodeIcu.h        2008-10-12 22:49:46 UTC (rev 37531)
+++ trunk/JavaScriptCore/wtf/unicode/icu/UnicodeIcu.h        2008-10-12 22:51:13 UTC (rev 37532)
</span><span class="lines">@@ -1,8 +1,7 @@
</span><span class="cx"> /*
</span><del>- *  This file is part of the KDE libraries
</del><span class="cx">  *  Copyright (C) 2006 George Staikos &lt;staikos@kde.org&gt;
</span><span class="cx">  *  Copyright (C) 2006 Alexey Proskuryakov &lt;ap@nypop.com&gt;
</span><del>- *  Copyright (C) 2007 Apple Computer, Inc. All rights reserved.
</del><ins>+ *  Copyright (C) 2007 Apple Inc. All rights reserved.
</ins><span class="cx">  *
</span><span class="cx">  *  This library is free software; you can redistribute it and/or
</span><span class="cx">  *  modify it under the terms of the GNU Library General Public
</span><span class="lines">@@ -24,200 +23,197 @@
</span><span class="cx"> #ifndef KJS_UNICODE_ICU_H
</span><span class="cx"> #define KJS_UNICODE_ICU_H
</span><span class="cx"> 
</span><ins>+#include &lt;stdlib.h&gt;
</ins><span class="cx"> #include &lt;unicode/uchar.h&gt;
</span><span class="cx"> #include &lt;unicode/ustring.h&gt;
</span><span class="cx"> #include &lt;unicode/utf16.h&gt;
</span><span class="cx"> 
</span><del>-#include &lt;stdlib.h&gt;
-
</del><span class="cx"> namespace WTF {
</span><del>-  namespace Unicode {
</del><ins>+namespace Unicode {
</ins><span class="cx"> 
</span><del>-    enum Direction {
-      LeftToRight = U_LEFT_TO_RIGHT,
-      RightToLeft = U_RIGHT_TO_LEFT,
-      EuropeanNumber = U_EUROPEAN_NUMBER,
-      EuropeanNumberSeparator = U_EUROPEAN_NUMBER_SEPARATOR,
-      EuropeanNumberTerminator = U_EUROPEAN_NUMBER_TERMINATOR,
-      ArabicNumber = U_ARABIC_NUMBER,
-      CommonNumberSeparator = U_COMMON_NUMBER_SEPARATOR,
-      BlockSeparator = U_BLOCK_SEPARATOR,
-      SegmentSeparator = U_SEGMENT_SEPARATOR,
-      WhiteSpaceNeutral = U_WHITE_SPACE_NEUTRAL,
-      OtherNeutral = U_OTHER_NEUTRAL,
-      LeftToRightEmbedding = U_LEFT_TO_RIGHT_EMBEDDING,
-      LeftToRightOverride = U_LEFT_TO_RIGHT_OVERRIDE,
-      RightToLeftArabic = U_RIGHT_TO_LEFT_ARABIC,
-      RightToLeftEmbedding = U_RIGHT_TO_LEFT_EMBEDDING,
-      RightToLeftOverride = U_RIGHT_TO_LEFT_OVERRIDE,
-      PopDirectionalFormat = U_POP_DIRECTIONAL_FORMAT,
-      NonSpacingMark = U_DIR_NON_SPACING_MARK,
-      BoundaryNeutral = U_BOUNDARY_NEUTRAL
-    };
</del><ins>+enum Direction {
+    LeftToRight = U_LEFT_TO_RIGHT,
+    RightToLeft = U_RIGHT_TO_LEFT,
+    EuropeanNumber = U_EUROPEAN_NUMBER,
+    EuropeanNumberSeparator = U_EUROPEAN_NUMBER_SEPARATOR,
+    EuropeanNumberTerminator = U_EUROPEAN_NUMBER_TERMINATOR,
+    ArabicNumber = U_ARABIC_NUMBER,
+    CommonNumberSeparator = U_COMMON_NUMBER_SEPARATOR,
+    BlockSeparator = U_BLOCK_SEPARATOR,
+    SegmentSeparator = U_SEGMENT_SEPARATOR,
+    WhiteSpaceNeutral = U_WHITE_SPACE_NEUTRAL,
+    OtherNeutral = U_OTHER_NEUTRAL,
+    LeftToRightEmbedding = U_LEFT_TO_RIGHT_EMBEDDING,
+    LeftToRightOverride = U_LEFT_TO_RIGHT_OVERRIDE,
+    RightToLeftArabic = U_RIGHT_TO_LEFT_ARABIC,
+    RightToLeftEmbedding = U_RIGHT_TO_LEFT_EMBEDDING,
+    RightToLeftOverride = U_RIGHT_TO_LEFT_OVERRIDE,
+    PopDirectionalFormat = U_POP_DIRECTIONAL_FORMAT,
+    NonSpacingMark = U_DIR_NON_SPACING_MARK,
+    BoundaryNeutral = U_BOUNDARY_NEUTRAL
+};
</ins><span class="cx"> 
</span><del>-    enum DecompositionType {
-      DecompositionNone = U_DT_NONE,
-      DecompositionCanonical = U_DT_CANONICAL,
-      DecompositionCompat = U_DT_COMPAT,
-      DecompositionCircle = U_DT_CIRCLE,
-      DecompositionFinal = U_DT_FINAL,
-      DecompositionFont = U_DT_FONT,
-      DecompositionFraction = U_DT_FRACTION,
-      DecompositionInitial = U_DT_INITIAL,
-      DecompositionIsolated = U_DT_ISOLATED,
-      DecompositionMedial = U_DT_MEDIAL,
-      DecompositionNarrow = U_DT_NARROW,
-      DecompositionNoBreak = U_DT_NOBREAK,
-      DecompositionSmall = U_DT_SMALL,
-      DecompositionSquare = U_DT_SQUARE,
-      DecompositionSub = U_DT_SUB,
-      DecompositionSuper = U_DT_SUPER,
-      DecompositionVertical = U_DT_VERTICAL,
-      DecompositionWide = U_DT_WIDE,
-    };
</del><ins>+enum DecompositionType {
+    DecompositionNone = U_DT_NONE,
+    DecompositionCanonical = U_DT_CANONICAL,
+    DecompositionCompat = U_DT_COMPAT,
+    DecompositionCircle = U_DT_CIRCLE,
+    DecompositionFinal = U_DT_FINAL,
+    DecompositionFont = U_DT_FONT,
+    DecompositionFraction = U_DT_FRACTION,
+    DecompositionInitial = U_DT_INITIAL,
+    DecompositionIsolated = U_DT_ISOLATED,
+    DecompositionMedial = U_DT_MEDIAL,
+    DecompositionNarrow = U_DT_NARROW,
+    DecompositionNoBreak = U_DT_NOBREAK,
+    DecompositionSmall = U_DT_SMALL,
+    DecompositionSquare = U_DT_SQUARE,
+    DecompositionSub = U_DT_SUB,
+    DecompositionSuper = U_DT_SUPER,
+    DecompositionVertical = U_DT_VERTICAL,
+    DecompositionWide = U_DT_WIDE,
+};
</ins><span class="cx"> 
</span><del>-    enum CharCategory {
-      NoCategory =  0,
-      Other_NotAssigned = U_MASK(U_GENERAL_OTHER_TYPES),
-      Letter_Uppercase = U_MASK(U_UPPERCASE_LETTER),
-      Letter_Lowercase = U_MASK(U_LOWERCASE_LETTER),
-      Letter_Titlecase = U_MASK(U_TITLECASE_LETTER),
-      Letter_Modifier = U_MASK(U_MODIFIER_LETTER),
-      Letter_Other = U_MASK(U_OTHER_LETTER),
</del><ins>+enum CharCategory {
+    NoCategory =  0,
+    Other_NotAssigned = U_MASK(U_GENERAL_OTHER_TYPES),
+    Letter_Uppercase = U_MASK(U_UPPERCASE_LETTER),
+    Letter_Lowercase = U_MASK(U_LOWERCASE_LETTER),
+    Letter_Titlecase = U_MASK(U_TITLECASE_LETTER),
+    Letter_Modifier = U_MASK(U_MODIFIER_LETTER),
+    Letter_Other = U_MASK(U_OTHER_LETTER),
</ins><span class="cx"> 
</span><del>-      Mark_NonSpacing = U_MASK(U_NON_SPACING_MARK),
-      Mark_Enclosing = U_MASK(U_ENCLOSING_MARK),
-      Mark_SpacingCombining = U_MASK(U_COMBINING_SPACING_MARK),
</del><ins>+    Mark_NonSpacing = U_MASK(U_NON_SPACING_MARK),
+    Mark_Enclosing = U_MASK(U_ENCLOSING_MARK),
+    Mark_SpacingCombining = U_MASK(U_COMBINING_SPACING_MARK),
</ins><span class="cx"> 
</span><del>-      Number_DecimalDigit = U_MASK(U_DECIMAL_DIGIT_NUMBER),
-      Number_Letter = U_MASK(U_LETTER_NUMBER),
-      Number_Other = U_MASK(U_OTHER_NUMBER),
</del><ins>+    Number_DecimalDigit = U_MASK(U_DECIMAL_DIGIT_NUMBER),
+    Number_Letter = U_MASK(U_LETTER_NUMBER),
+    Number_Other = U_MASK(U_OTHER_NUMBER),
</ins><span class="cx"> 
</span><del>-      Separator_Space = U_MASK(U_SPACE_SEPARATOR),
-      Separator_Line = U_MASK(U_LINE_SEPARATOR),
-      Separator_Paragraph = U_MASK(U_PARAGRAPH_SEPARATOR),
</del><ins>+    Separator_Space = U_MASK(U_SPACE_SEPARATOR),
+    Separator_Line = U_MASK(U_LINE_SEPARATOR),
+    Separator_Paragraph = U_MASK(U_PARAGRAPH_SEPARATOR),
</ins><span class="cx"> 
</span><del>-      Other_Control = U_MASK(U_CONTROL_CHAR),
-      Other_Format = U_MASK(U_FORMAT_CHAR),
-      Other_PrivateUse = U_MASK(U_PRIVATE_USE_CHAR),
-      Other_Surrogate = U_MASK(U_SURROGATE),
</del><ins>+    Other_Control = U_MASK(U_CONTROL_CHAR),
+    Other_Format = U_MASK(U_FORMAT_CHAR),
+    Other_PrivateUse = U_MASK(U_PRIVATE_USE_CHAR),
+    Other_Surrogate = U_MASK(U_SURROGATE),
</ins><span class="cx"> 
</span><del>-      Punctuation_Dash = U_MASK(U_DASH_PUNCTUATION),
-      Punctuation_Open = U_MASK(U_START_PUNCTUATION),
-      Punctuation_Close = U_MASK(U_END_PUNCTUATION),
-      Punctuation_Connector = U_MASK(U_CONNECTOR_PUNCTUATION),
-      Punctuation_Other = U_MASK(U_OTHER_PUNCTUATION),
</del><ins>+    Punctuation_Dash = U_MASK(U_DASH_PUNCTUATION),
+    Punctuation_Open = U_MASK(U_START_PUNCTUATION),
+    Punctuation_Close = U_MASK(U_END_PUNCTUATION),
+    Punctuation_Connector = U_MASK(U_CONNECTOR_PUNCTUATION),
+    Punctuation_Other = U_MASK(U_OTHER_PUNCTUATION),
</ins><span class="cx"> 
</span><del>-      Symbol_Math = U_MASK(U_MATH_SYMBOL),
-      Symbol_Currency = U_MASK(U_CURRENCY_SYMBOL),
-      Symbol_Modifier = U_MASK(U_MODIFIER_SYMBOL),
-      Symbol_Other = U_MASK(U_OTHER_SYMBOL),
</del><ins>+    Symbol_Math = U_MASK(U_MATH_SYMBOL),
+    Symbol_Currency = U_MASK(U_CURRENCY_SYMBOL),
+    Symbol_Modifier = U_MASK(U_MODIFIER_SYMBOL),
+    Symbol_Other = U_MASK(U_OTHER_SYMBOL),
</ins><span class="cx"> 
</span><del>-      Punctuation_InitialQuote = U_MASK(U_INITIAL_PUNCTUATION),
-      Punctuation_FinalQuote = U_MASK(U_FINAL_PUNCTUATION)
-    };
</del><ins>+    Punctuation_InitialQuote = U_MASK(U_INITIAL_PUNCTUATION),
+    Punctuation_FinalQuote = U_MASK(U_FINAL_PUNCTUATION)
+};
</ins><span class="cx"> 
</span><del>-    inline UChar32 foldCase(UChar32 c)
-    {
-      return u_foldCase(c, U_FOLD_CASE_DEFAULT);
-    }
</del><ins>+inline UChar32 foldCase(UChar32 c)
+{
+    return u_foldCase(c, U_FOLD_CASE_DEFAULT);
+}
</ins><span class="cx"> 
</span><del>-    inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
-    {
-      UErrorCode status = U_ZERO_ERROR;
-      int realLength = u_strFoldCase(result, resultLength, src, srcLength, U_FOLD_CASE_DEFAULT, &amp;status);
-      *error = !U_SUCCESS(status);
-      return realLength;
-    }
</del><ins>+inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    int realLength = u_strFoldCase(result, resultLength, src, srcLength, U_FOLD_CASE_DEFAULT, &amp;status);
+    *error = !U_SUCCESS(status);
+    return realLength;
+}
</ins><span class="cx"> 
</span><del>-    inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
-    {
-      UErrorCode status = U_ZERO_ERROR;
-      int realLength = u_strToLower(result, resultLength, src, srcLength, &quot;&quot;, &amp;status);
-      *error = !!U_FAILURE(status);
-      return realLength;
-    }
</del><ins>+inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    int realLength = u_strToLower(result, resultLength, src, srcLength, &quot;&quot;, &amp;status);
+    *error = !!U_FAILURE(status);
+    return realLength;
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 toLower(UChar32 c)
-    {
-      return u_tolower(c);
-    }
</del><ins>+inline UChar32 toLower(UChar32 c)
+{
+    return u_tolower(c);
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 toUpper(UChar32 c)
-    {
-      return u_toupper(c);
-    }
</del><ins>+inline UChar32 toUpper(UChar32 c)
+{
+    return u_toupper(c);
+}
</ins><span class="cx"> 
</span><del>-    inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
-    {
-      UErrorCode status = U_ZERO_ERROR;
-      int realLength = u_strToUpper(result, resultLength, src, srcLength, &quot;&quot;, &amp;status);
-      *error = !!U_FAILURE(status);
-      return realLength;
-    }
</del><ins>+inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength, bool* error)
+{
+    UErrorCode status = U_ZERO_ERROR;
+    int realLength = u_strToUpper(result, resultLength, src, srcLength, &quot;&quot;, &amp;status);
+    *error = !!U_FAILURE(status);
+    return realLength;
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 toTitleCase(UChar32 c)
-    {
-      return u_totitle(c);
-    }
</del><ins>+inline UChar32 toTitleCase(UChar32 c)
+{
+    return u_totitle(c);
+}
</ins><span class="cx"> 
</span><del>-    inline bool isArabicChar(UChar32 c)
-    {
-        return ublock_getCode(c) == UBLOCK_ARABIC;
-    }
</del><ins>+inline bool isArabicChar(UChar32 c)
+{
+      return ublock_getCode(c) == UBLOCK_ARABIC;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isSeparatorSpace(UChar32 c)
-    {
-      return u_charType(c) == U_SPACE_SEPARATOR;
-    }
</del><ins>+inline bool isSeparatorSpace(UChar32 c)
+{
+    return u_charType(c) == U_SPACE_SEPARATOR;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isPrintableChar(UChar32 c)
-    {
-      return !!u_isprint(c);
-    }
-    
-    inline bool isPunct(UChar32 c)
-    {
-      return !!u_ispunct(c);
-    }
</del><ins>+inline bool isPrintableChar(UChar32 c)
+{
+    return !!u_isprint(c);
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 mirroredChar(UChar32 c)
-    {
-      return u_charMirror(c);
-    }
</del><ins>+inline bool isPunct(UChar32 c)
+{
+    return !!u_ispunct(c);
+}
</ins><span class="cx"> 
</span><del>-    inline CharCategory category(UChar32 c)
-    {
-      return static_cast&lt;CharCategory&gt;(U_GET_GC_MASK(c));
-    }
</del><ins>+inline UChar32 mirroredChar(UChar32 c)
+{
+    return u_charMirror(c);
+}
</ins><span class="cx"> 
</span><del>-    inline Direction direction(UChar32 c)
-    {
-      return static_cast&lt;Direction&gt;(u_charDirection(c));
-    }
</del><ins>+inline CharCategory category(UChar32 c)
+{
+    return static_cast&lt;CharCategory&gt;(U_GET_GC_MASK(c));
+}
</ins><span class="cx"> 
</span><del>-    inline bool isLower(UChar32 c)
-    {
-      return !!u_islower(c);
-    }
</del><ins>+inline Direction direction(UChar32 c)
+{
+    return static_cast&lt;Direction&gt;(u_charDirection(c));
+}
</ins><span class="cx"> 
</span><del>-    inline uint8_t combiningClass(UChar32 c)
-    {
-      return u_getCombiningClass(c);
-    }
</del><ins>+inline bool isLower(UChar32 c)
+{
+    return !!u_islower(c);
+}
</ins><span class="cx"> 
</span><del>-    inline DecompositionType decompositionType(UChar32 c)
-    {
-      return static_cast&lt;DecompositionType&gt;(u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE));
-    }
</del><ins>+inline uint8_t combiningClass(UChar32 c)
+{
+    return u_getCombiningClass(c);
+}
</ins><span class="cx"> 
</span><del>-    inline int umemcasecmp(const UChar* a, const UChar* b, int len)
-    {
-      return u_memcasecmp(a, b, len, U_FOLD_CASE_DEFAULT);
-    }
</del><ins>+inline DecompositionType decompositionType(UChar32 c)
+{
+    return static_cast&lt;DecompositionType&gt;(u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE));
+}
</ins><span class="cx"> 
</span><del>-  }
</del><ins>+inline int umemcasecmp(const UChar* a, const UChar* b, int len)
+{
+    return u_memcasecmp(a, b, len, U_FOLD_CASE_DEFAULT);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><ins>+} }
+
</ins><span class="cx"> #endif
</span><del>-// vim: ts=2 sw=2 et
</del></span></pre></div>
<a id="trunkJavaScriptCorewtfunicodeqt4UnicodeQt4h"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/wtf/unicode/qt4/UnicodeQt4.h (37531 => 37532)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/wtf/unicode/qt4/UnicodeQt4.h        2008-10-12 22:49:46 UTC (rev 37531)
+++ trunk/JavaScriptCore/wtf/unicode/qt4/UnicodeQt4.h        2008-10-12 22:51:13 UTC (rev 37532)
</span><span class="lines">@@ -1,5 +1,4 @@
</span><span class="cx"> /*
</span><del>- *  This file is part of the KDE libraries
</del><span class="cx">  *  Copyright (C) 2006 George Staikos &lt;staikos@kde.org&gt;
</span><span class="cx">  *  Copyright (C) 2006 Alexey Proskuryakov &lt;ap@nypop.com&gt;
</span><span class="cx">  *
</span><span class="lines">@@ -95,433 +94,432 @@
</span><span class="cx"> #define U_MASK(x) ((uint32_t)1&lt;&lt;(x))
</span><span class="cx"> 
</span><span class="cx"> namespace WTF {
</span><del>-  namespace Unicode {
</del><ins>+namespace Unicode {
</ins><span class="cx"> 
</span><del>-    enum Direction {
-      LeftToRight = QChar::DirL,
-      RightToLeft = QChar::DirR,
-      EuropeanNumber = QChar::DirEN,
-      EuropeanNumberSeparator = QChar::DirES,
-      EuropeanNumberTerminator = QChar::DirET,
-      ArabicNumber = QChar::DirAN,
-      CommonNumberSeparator = QChar::DirCS,
-      BlockSeparator = QChar::DirB,
-      SegmentSeparator = QChar::DirS,
-      WhiteSpaceNeutral = QChar::DirWS,
-      OtherNeutral = QChar::DirON,
-      LeftToRightEmbedding = QChar::DirLRE,
-      LeftToRightOverride = QChar::DirLRO,
-      RightToLeftArabic = QChar::DirAL,
-      RightToLeftEmbedding = QChar::DirRLE,
-      RightToLeftOverride = QChar::DirRLO,
-      PopDirectionalFormat = QChar::DirPDF,
-      NonSpacingMark = QChar::DirNSM,
-      BoundaryNeutral = QChar::DirBN
-    };
</del><ins>+enum Direction {
+    LeftToRight = QChar::DirL,
+    RightToLeft = QChar::DirR,
+    EuropeanNumber = QChar::DirEN,
+    EuropeanNumberSeparator = QChar::DirES,
+    EuropeanNumberTerminator = QChar::DirET,
+    ArabicNumber = QChar::DirAN,
+    CommonNumberSeparator = QChar::DirCS,
+    BlockSeparator = QChar::DirB,
+    SegmentSeparator = QChar::DirS,
+    WhiteSpaceNeutral = QChar::DirWS,
+    OtherNeutral = QChar::DirON,
+    LeftToRightEmbedding = QChar::DirLRE,
+    LeftToRightOverride = QChar::DirLRO,
+    RightToLeftArabic = QChar::DirAL,
+    RightToLeftEmbedding = QChar::DirRLE,
+    RightToLeftOverride = QChar::DirRLO,
+    PopDirectionalFormat = QChar::DirPDF,
+    NonSpacingMark = QChar::DirNSM,
+    BoundaryNeutral = QChar::DirBN
+};
</ins><span class="cx"> 
</span><del>-    enum DecompositionType {
-      DecompositionNone = QChar::NoDecomposition,
-      DecompositionCanonical = QChar::Canonical,
-      DecompositionCompat = QChar::Compat,
-      DecompositionCircle = QChar::Circle,
-      DecompositionFinal = QChar::Final,
-      DecompositionFont = QChar::Font,
-      DecompositionFraction = QChar::Fraction,
-      DecompositionInitial = QChar::Initial,
-      DecompositionIsolated = QChar::Isolated,
-      DecompositionMedial = QChar::Medial,
-      DecompositionNarrow = QChar::Narrow,
-      DecompositionNoBreak = QChar::NoBreak,
-      DecompositionSmall = QChar::Small,
-      DecompositionSquare = QChar::Square,
-      DecompositionSub = QChar::Sub,
-      DecompositionSuper = QChar::Super,
-      DecompositionVertical = QChar::Vertical,
-      DecompositionWide = QChar::Wide
-    };
</del><ins>+enum DecompositionType {
+    DecompositionNone = QChar::NoDecomposition,
+    DecompositionCanonical = QChar::Canonical,
+    DecompositionCompat = QChar::Compat,
+    DecompositionCircle = QChar::Circle,
+    DecompositionFinal = QChar::Final,
+    DecompositionFont = QChar::Font,
+    DecompositionFraction = QChar::Fraction,
+    DecompositionInitial = QChar::Initial,
+    DecompositionIsolated = QChar::Isolated,
+    DecompositionMedial = QChar::Medial,
+    DecompositionNarrow = QChar::Narrow,
+    DecompositionNoBreak = QChar::NoBreak,
+    DecompositionSmall = QChar::Small,
+    DecompositionSquare = QChar::Square,
+    DecompositionSub = QChar::Sub,
+    DecompositionSuper = QChar::Super,
+    DecompositionVertical = QChar::Vertical,
+    DecompositionWide = QChar::Wide
+};
</ins><span class="cx"> 
</span><del>-    enum CharCategory {
-      NoCategory = 0,
-      Mark_NonSpacing = U_MASK(QChar::Mark_NonSpacing),
-      Mark_SpacingCombining = U_MASK(QChar::Mark_SpacingCombining),
-      Mark_Enclosing = U_MASK(QChar::Mark_Enclosing),
-      Number_DecimalDigit = U_MASK(QChar::Number_DecimalDigit),
-      Number_Letter = U_MASK(QChar::Number_Letter),
-      Number_Other = U_MASK(QChar::Number_Other),
-      Separator_Space = U_MASK(QChar::Separator_Space),
-      Separator_Line = U_MASK(QChar::Separator_Line),
-      Separator_Paragraph = U_MASK(QChar::Separator_Paragraph),
-      Other_Control = U_MASK(QChar::Other_Control),
-      Other_Format = U_MASK(QChar::Other_Format),
-      Other_Surrogate = U_MASK(QChar::Other_Surrogate),
-      Other_PrivateUse = U_MASK(QChar::Other_PrivateUse),
-      Other_NotAssigned = U_MASK(QChar::Other_NotAssigned),
-      Letter_Uppercase = U_MASK(QChar::Letter_Uppercase),
-      Letter_Lowercase = U_MASK(QChar::Letter_Lowercase),
-      Letter_Titlecase = U_MASK(QChar::Letter_Titlecase),
-      Letter_Modifier = U_MASK(QChar::Letter_Modifier),
-      Letter_Other = U_MASK(QChar::Letter_Other),
-      Punctuation_Connector = U_MASK(QChar::Punctuation_Connector),
-      Punctuation_Dash = U_MASK(QChar::Punctuation_Dash),
-      Punctuation_Open = U_MASK(QChar::Punctuation_Open),
-      Punctuation_Close = U_MASK(QChar::Punctuation_Close),
-      Punctuation_InitialQuote = U_MASK(QChar::Punctuation_InitialQuote),
-      Punctuation_FinalQuote = U_MASK(QChar::Punctuation_FinalQuote),
-      Punctuation_Other = U_MASK(QChar::Punctuation_Other),
-      Symbol_Math = U_MASK(QChar::Symbol_Math),
-      Symbol_Currency = U_MASK(QChar::Symbol_Currency),
-      Symbol_Modifier = U_MASK(QChar::Symbol_Modifier),
-      Symbol_Other = U_MASK(QChar::Symbol_Other),
-    };
</del><ins>+enum CharCategory {
+    NoCategory = 0,
+    Mark_NonSpacing = U_MASK(QChar::Mark_NonSpacing),
+    Mark_SpacingCombining = U_MASK(QChar::Mark_SpacingCombining),
+    Mark_Enclosing = U_MASK(QChar::Mark_Enclosing),
+    Number_DecimalDigit = U_MASK(QChar::Number_DecimalDigit),
+    Number_Letter = U_MASK(QChar::Number_Letter),
+    Number_Other = U_MASK(QChar::Number_Other),
+    Separator_Space = U_MASK(QChar::Separator_Space),
+    Separator_Line = U_MASK(QChar::Separator_Line),
+    Separator_Paragraph = U_MASK(QChar::Separator_Paragraph),
+    Other_Control = U_MASK(QChar::Other_Control),
+    Other_Format = U_MASK(QChar::Other_Format),
+    Other_Surrogate = U_MASK(QChar::Other_Surrogate),
+    Other_PrivateUse = U_MASK(QChar::Other_PrivateUse),
+    Other_NotAssigned = U_MASK(QChar::Other_NotAssigned),
+    Letter_Uppercase = U_MASK(QChar::Letter_Uppercase),
+    Letter_Lowercase = U_MASK(QChar::Letter_Lowercase),
+    Letter_Titlecase = U_MASK(QChar::Letter_Titlecase),
+    Letter_Modifier = U_MASK(QChar::Letter_Modifier),
+    Letter_Other = U_MASK(QChar::Letter_Other),
+    Punctuation_Connector = U_MASK(QChar::Punctuation_Connector),
+    Punctuation_Dash = U_MASK(QChar::Punctuation_Dash),
+    Punctuation_Open = U_MASK(QChar::Punctuation_Open),
+    Punctuation_Close = U_MASK(QChar::Punctuation_Close),
+    Punctuation_InitialQuote = U_MASK(QChar::Punctuation_InitialQuote),
+    Punctuation_FinalQuote = U_MASK(QChar::Punctuation_FinalQuote),
+    Punctuation_Other = U_MASK(QChar::Punctuation_Other),
+    Symbol_Math = U_MASK(QChar::Symbol_Math),
+    Symbol_Currency = U_MASK(QChar::Symbol_Currency),
+    Symbol_Modifier = U_MASK(QChar::Symbol_Modifier),
+    Symbol_Other = U_MASK(QChar::Symbol_Other),
+};
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> #if QT_VERSION &gt;= 0x040300
</span><del>-    // FIXME: handle surrogates correctly in all methods
</del><span class="cx"> 
</span><del>-    inline UChar32 toLower(UChar32 ch)
-    {
-      return QChar::toLower(ch);
-    }
</del><ins>+// FIXME: handle surrogates correctly in all methods
</ins><span class="cx"> 
</span><del>-    inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
-    {
-        const UChar *e = src + srcLength;
-        const UChar *s = src;
-        UChar *r = result;
-        uint rindex = 0;
</del><ins>+inline UChar32 toLower(UChar32 ch)
+{
+    return QChar::toLower(ch);
+}
</ins><span class="cx"> 
</span><del>-        // this avoids one out of bounds check in the loop
-        if (s &lt; e &amp;&amp; QChar(*s).isLowSurrogate()) {
-            if (r)
-                r[rindex] = *s++;
-            ++rindex;
-        }
</del><ins>+inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
+{
+    const UChar *e = src + srcLength;
+    const UChar *s = src;
+    UChar *r = result;
+    uint rindex = 0;
</ins><span class="cx"> 
</span><del>-        int needed = 0;
-        while (s &lt; e &amp;&amp; (rindex &lt; uint(resultLength) || !r)) {
-            uint c = *s;
-            if (QChar(c).isLowSurrogate() &amp;&amp; QChar(*(s - 1)).isHighSurrogate())
-                c = QChar::surrogateToUcs4(*(s - 1), c);
-            const QUnicodeTables::Properties *prop = QUnicodeTables::properties(c);
-            if (prop-&gt;lowerCaseSpecial) {
-                QString qstring;
-                if (c &lt; 0x10000) {
-                    qstring += QChar(c);
-                } else {
-                    qstring += QChar(*(s-1));
-                    qstring += QChar(*s);
-                }
-                qstring = qstring.toLower();
-                for (int i = 0; i &lt; qstring.length(); ++i) {
-                    if (rindex &gt;= uint(resultLength)) {
-                        needed += qstring.length() - i;
-                        break;
-                    }
-                    if (r)
-                        r[rindex] = qstring.at(i).unicode();
-                    ++rindex;
-                }
</del><ins>+    // this avoids one out of bounds check in the loop
+    if (s &lt; e &amp;&amp; QChar(*s).isLowSurrogate()) {
+        if (r)
+            r[rindex] = *s++;
+        ++rindex;
+    }
+
+    int needed = 0;
+    while (s &lt; e &amp;&amp; (rindex &lt; uint(resultLength) || !r)) {
+        uint c = *s;
+        if (QChar(c).isLowSurrogate() &amp;&amp; QChar(*(s - 1)).isHighSurrogate())
+            c = QChar::surrogateToUcs4(*(s - 1), c);
+        const QUnicodeTables::Properties *prop = QUnicodeTables::properties(c);
+        if (prop-&gt;lowerCaseSpecial) {
+            QString qstring;
+            if (c &lt; 0x10000) {
+                qstring += QChar(c);
</ins><span class="cx">             } else {
</span><ins>+                qstring += QChar(*(s-1));
+                qstring += QChar(*s);
+            }
+            qstring = qstring.toLower();
+            for (int i = 0; i &lt; qstring.length(); ++i) {
+                if (rindex &gt;= uint(resultLength)) {
+                    needed += qstring.length() - i;
+                    break;
+                }
</ins><span class="cx">                 if (r)
</span><del>-                    r[rindex] = *s + prop-&gt;lowerCaseDiff;
</del><ins>+                    r[rindex] = qstring.at(i).unicode();
</ins><span class="cx">                 ++rindex;
</span><span class="cx">             }
</span><del>-            ++s;
</del><ins>+        } else {
+            if (r)
+                r[rindex] = *s + prop-&gt;lowerCaseDiff;
+            ++rindex;
</ins><span class="cx">         }
</span><del>-        if (s &lt; e)
-            needed += e - s;
-        *error = (needed != 0);
-        if (rindex &lt; uint(resultLength))
-            r[rindex] = 0;
-        return rindex + needed;
</del><ins>+        ++s;
</ins><span class="cx">     }
</span><ins>+    if (s &lt; e)
+        needed += e - s;
+    *error = (needed != 0);
+    if (rindex &lt; uint(resultLength))
+        r[rindex] = 0;
+    return rindex + needed;
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 toUpper(UChar32 ch)
-    {
-      return QChar::toUpper(ch);
-    }
</del><ins>+inline UChar32 toUpper(UChar32 ch)
+{
+    return QChar::toUpper(ch);
+}
</ins><span class="cx"> 
</span><del>-    inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
-    {
-        const UChar *e = src + srcLength;
-        const UChar *s = src;
-        UChar *r = result;
-        int rindex = 0;
</del><ins>+inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
+{
+    const UChar *e = src + srcLength;
+    const UChar *s = src;
+    UChar *r = result;
+    int rindex = 0;
</ins><span class="cx"> 
</span><del>-        // this avoids one out of bounds check in the loop
-        if (s &lt; e &amp;&amp; QChar(*s).isLowSurrogate()) {
-            if (r)
-                r[rindex] = *s++;
-            ++rindex;
-        }
</del><ins>+    // this avoids one out of bounds check in the loop
+    if (s &lt; e &amp;&amp; QChar(*s).isLowSurrogate()) {
+        if (r)
+            r[rindex] = *s++;
+        ++rindex;
+    }
</ins><span class="cx"> 
</span><del>-        int needed = 0;
-        while (s &lt; e &amp;&amp; (rindex &lt; resultLength || !r)) {
-            uint c = *s;
-            if (QChar(c).isLowSurrogate() &amp;&amp; QChar(*(s - 1)).isHighSurrogate())
-                c = QChar::surrogateToUcs4(*(s - 1), c);
-            const QUnicodeTables::Properties *prop = QUnicodeTables::properties(c);
-            if (prop-&gt;upperCaseSpecial) {
-                QString qstring;
-                if (c &lt; 0x10000) {
-                    qstring += QChar(c);
-                } else {
-                    qstring += QChar(*(s-1));
-                    qstring += QChar(*s);
-                }
-                qstring = qstring.toUpper();
-                for (int i = 0; i &lt; qstring.length(); ++i) {
-                    if (rindex &gt;= resultLength) {
-                        needed += qstring.length() - i;
-                        break;
-                    }
-                    if (r)
-                        r[rindex] = qstring.at(i).unicode();
-                    ++rindex;
-                }
</del><ins>+    int needed = 0;
+    while (s &lt; e &amp;&amp; (rindex &lt; resultLength || !r)) {
+        uint c = *s;
+        if (QChar(c).isLowSurrogate() &amp;&amp; QChar(*(s - 1)).isHighSurrogate())
+            c = QChar::surrogateToUcs4(*(s - 1), c);
+        const QUnicodeTables::Properties *prop = QUnicodeTables::properties(c);
+        if (prop-&gt;upperCaseSpecial) {
+            QString qstring;
+            if (c &lt; 0x10000) {
+                qstring += QChar(c);
</ins><span class="cx">             } else {
</span><ins>+                qstring += QChar(*(s-1));
+                qstring += QChar(*s);
+            }
+            qstring = qstring.toUpper();
+            for (int i = 0; i &lt; qstring.length(); ++i) {
+                if (rindex &gt;= resultLength) {
+                    needed += qstring.length() - i;
+                    break;
+                }
</ins><span class="cx">                 if (r)
</span><del>-                    r[rindex] = *s + prop-&gt;upperCaseDiff;
</del><ins>+                    r[rindex] = qstring.at(i).unicode();
</ins><span class="cx">                 ++rindex;
</span><span class="cx">             }
</span><del>-            ++s;
</del><ins>+        } else {
+            if (r)
+                r[rindex] = *s + prop-&gt;upperCaseDiff;
+            ++rindex;
</ins><span class="cx">         }
</span><del>-        if (s &lt; e)
-            needed += e - s;
-        *error = (needed != 0);
-        if (rindex &lt; resultLength)
-            r[rindex] = 0;
-        return rindex + needed;
</del><ins>+        ++s;
</ins><span class="cx">     }
</span><ins>+    if (s &lt; e)
+        needed += e - s;
+    *error = (needed != 0);
+    if (rindex &lt; resultLength)
+        r[rindex] = 0;
+    return rindex + needed;
+}
</ins><span class="cx"> 
</span><del>-    inline int toTitleCase(UChar32 c)
-    {
-      return QChar::toTitleCase(c);
-    }
</del><ins>+inline int toTitleCase(UChar32 c)
+{
+    return QChar::toTitleCase(c);
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 foldCase(UChar32 c)
-    {
-      return QChar::toCaseFolded(c);
-    }
</del><ins>+inline UChar32 foldCase(UChar32 c)
+{
+    return QChar::toCaseFolded(c);
+}
</ins><span class="cx"> 
</span><del>-    inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
-    {
-      // FIXME: handle special casing. Easiest with some low level API in Qt
-      *error = false;
-      if (resultLength &lt; srcLength) {
</del><ins>+inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
+{
+    // FIXME: handle special casing. Easiest with some low level API in Qt
+    *error = false;
+    if (resultLength &lt; srcLength) {
</ins><span class="cx">         *error = true;
</span><span class="cx">         return srcLength;
</span><del>-      }
-      for (int i = 0; i &lt; srcLength; ++i)
-        result[i] = QChar::toCaseFolded(ushort(src[i]));
-      return srcLength;
</del><span class="cx">     }
</span><ins>+    for (int i = 0; i &lt; srcLength; ++i)
+        result[i] = QChar::toCaseFolded(ushort(src[i]));
+    return srcLength;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isArabicChar(UChar32 c)
-    {
-        return c &gt;= 0x0600 &amp;&amp; c &lt;= 0x06FF;
-    }
</del><ins>+inline bool isArabicChar(UChar32 c)
+{
+    return c &gt;= 0x0600 &amp;&amp; c &lt;= 0x06FF;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isPrintableChar(UChar32 c)
-    {
-      const uint test = U_MASK(QChar::Other_Control) |
-                        U_MASK(QChar::Other_NotAssigned);
-      return !(U_MASK(QChar::category(c)) &amp; test);
-    }
</del><ins>+inline bool isPrintableChar(UChar32 c)
+{
+    const uint test = U_MASK(QChar::Other_Control) |
+                      U_MASK(QChar::Other_NotAssigned);
+    return !(U_MASK(QChar::category(c)) &amp; test);
+}
</ins><span class="cx"> 
</span><del>-    inline bool isSeparatorSpace(UChar32 c)
-    {
-      return QChar::category(c) == QChar::Separator_Space;
-    }
</del><ins>+inline bool isSeparatorSpace(UChar32 c)
+{
+    return QChar::category(c) == QChar::Separator_Space;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isPunct(UChar32 c)
-    {
-      const uint test = U_MASK(QChar::Punctuation_Connector) |
-                        U_MASK(QChar::Punctuation_Dash) |
-                        U_MASK(QChar::Punctuation_Open) |
-                        U_MASK(QChar::Punctuation_Close) |
-                        U_MASK(QChar::Punctuation_InitialQuote) |
-                        U_MASK(QChar::Punctuation_FinalQuote) |
-                        U_MASK(QChar::Punctuation_Other);
-      return U_MASK(QChar::category(c)) &amp; test;
-    }
</del><ins>+inline bool isPunct(UChar32 c)
+{
+    const uint test = U_MASK(QChar::Punctuation_Connector) |
+                      U_MASK(QChar::Punctuation_Dash) |
+                      U_MASK(QChar::Punctuation_Open) |
+                      U_MASK(QChar::Punctuation_Close) |
+                      U_MASK(QChar::Punctuation_InitialQuote) |
+                      U_MASK(QChar::Punctuation_FinalQuote) |
+                      U_MASK(QChar::Punctuation_Other);
+    return U_MASK(QChar::category(c)) &amp; test;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isLower(UChar32 c)
-    {
-      return QChar::category(c) == QChar::Letter_Lowercase;
-    }
</del><ins>+inline bool isLower(UChar32 c)
+{
+    return QChar::category(c) == QChar::Letter_Lowercase;
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 mirroredChar(UChar32 c)
-    {
-      return QChar::mirroredChar(c);
-    }
</del><ins>+inline UChar32 mirroredChar(UChar32 c)
+{
+    return QChar::mirroredChar(c);
+}
</ins><span class="cx"> 
</span><del>-    inline uint8_t combiningClass(UChar32 c)
-    {
-      return QChar::combiningClass(c);
-    }
</del><ins>+inline uint8_t combiningClass(UChar32 c)
+{
+    return QChar::combiningClass(c);
+}
</ins><span class="cx"> 
</span><del>-    inline DecompositionType decompositionType(UChar32 c)
-    {
-      return (DecompositionType)QChar::decompositionTag(c);
-    }
</del><ins>+inline DecompositionType decompositionType(UChar32 c)
+{
+    return (DecompositionType)QChar::decompositionTag(c);
+}
</ins><span class="cx"> 
</span><del>-    inline int umemcasecmp(const UChar* a, const UChar* b, int len)
-    {
-      // handle surrogates correctly
-      for (int i = 0; i &lt; len; ++i) {
-          uint c1 = QChar::toCaseFolded(ushort(a[i]));
-          uint c2 = QChar::toCaseFolded(ushort(b[i]));
-          if (c1 != c2)
-              return c1 - c2;
-      }
-      return 0;
</del><ins>+inline int umemcasecmp(const UChar* a, const UChar* b, int len)
+{
+    // handle surrogates correctly
+    for (int i = 0; i &lt; len; ++i) {
+        uint c1 = QChar::toCaseFolded(ushort(a[i]));
+        uint c2 = QChar::toCaseFolded(ushort(b[i]));
+        if (c1 != c2)
+            return c1 - c2;
</ins><span class="cx">     }
</span><ins>+    return 0;
+}
</ins><span class="cx"> 
</span><del>-    inline Direction direction(UChar32 c)
-    {
-      return (Direction)QChar::direction(c);
-    }
</del><ins>+inline Direction direction(UChar32 c)
+{
+    return (Direction)QChar::direction(c);
+}
</ins><span class="cx"> 
</span><del>-    inline CharCategory category(UChar32 c)
-    {
-      return (CharCategory) U_MASK(QChar::category(c));
-    }
</del><ins>+inline CharCategory category(UChar32 c)
+{
+    return (CharCategory) U_MASK(QChar::category(c));
+}
</ins><span class="cx"> 
</span><span class="cx"> #else
</span><span class="cx"> 
</span><del>-    inline UChar32 toLower(UChar32 ch)
-    {
-      if (ch &gt; 0xffff)
</del><ins>+inline UChar32 toLower(UChar32 ch)
+{
+    if (ch &gt; 0xffff)
</ins><span class="cx">         return ch;
</span><del>-      return QChar((unsigned short)ch).toLower().unicode();
-    }
</del><ins>+    return QChar((unsigned short)ch).toLower().unicode();
+}
</ins><span class="cx"> 
</span><del>-    inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
-    {
-      *error = false;
-      if (resultLength &lt; srcLength) {
-        *error = true;
-        return srcLength;
-      }
-      for (int i = 0; i &lt; srcLength; ++i)
-        result[i] = QChar(src[i]).toLower().unicode();
-      return srcLength;
-    }
</del><ins>+inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
+{
+  *error = false;
+  if (resultLength &lt; srcLength) {
+    *error = true;
+    return srcLength;
+  }
+  for (int i = 0; i &lt; srcLength; ++i)
+    result[i] = QChar(src[i]).toLower().unicode();
+  return srcLength;
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 toUpper(UChar32 ch)
-    {
-      if (ch &gt; 0xffff)
</del><ins>+inline UChar32 toUpper(UChar32 ch)
+{
+    if (ch &gt; 0xffff)
</ins><span class="cx">         return ch;
</span><del>-      return QChar((unsigned short)ch).toUpper().unicode();
-    }
</del><ins>+    return QChar((unsigned short)ch).toUpper().unicode();
+}
</ins><span class="cx"> 
</span><del>-    inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
-    {
-      *error = false;
-      if (resultLength &lt; srcLength) {
</del><ins>+inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
+{
+    *error = false;
+    if (resultLength &lt; srcLength) {
</ins><span class="cx">         *error = true;
</span><span class="cx">         return srcLength;
</span><del>-      }
-      for (int i = 0; i &lt; srcLength; ++i)
-        result[i] = QChar(src[i]).toUpper().unicode();
-      return srcLength;
</del><span class="cx">     }
</span><ins>+    for (int i = 0; i &lt; srcLength; ++i)
+        result[i] = QChar(src[i]).toUpper().unicode();
+    return srcLength;
+}
</ins><span class="cx"> 
</span><del>-    inline int toTitleCase(UChar32 c)
-    {
-      if (c &gt; 0xffff)
</del><ins>+inline int toTitleCase(UChar32 c)
+{
+    if (c &gt; 0xffff)
</ins><span class="cx">         return c;
</span><del>-      return QChar((unsigned short)c).toUpper().unicode();
-    }
</del><ins>+    return QChar((unsigned short)c).toUpper().unicode();
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 foldCase(UChar32 c)
-    {
-      if (c &gt; 0xffff)
</del><ins>+inline UChar32 foldCase(UChar32 c)
+{
+    if (c &gt; 0xffff)
</ins><span class="cx">         return c;
</span><del>-      return QChar((unsigned short)c).toLower().unicode();
-    }
</del><ins>+    return QChar((unsigned short)c).toLower().unicode();
+}
</ins><span class="cx"> 
</span><del>-    inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
-    {
-      return toLower(result, resultLength, src, srcLength, error);
-    }
</del><ins>+inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
+{
+    return toLower(result, resultLength, src, srcLength, error);
+}
</ins><span class="cx"> 
</span><del>-    inline bool isPrintableChar(UChar32 c)
-    {
-      return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).isPrint();
-    }
</del><ins>+inline bool isPrintableChar(UChar32 c)
+{
+    return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).isPrint();
+}
</ins><span class="cx"> 
</span><del>-    inline bool isArabicChar(UChar32 c)
-    {
-        return c &gt;= 0x0600 &amp;&amp; c &lt;= 0x06FF;
-    }
</del><ins>+inline bool isArabicChar(UChar32 c)
+{
+    return c &gt;= 0x0600 &amp;&amp; c &lt;= 0x06FF;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isSeparatorSpace(UChar32 c)
-    {
-      return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).category() == QChar::Separator_Space;
-    }
</del><ins>+inline bool isSeparatorSpace(UChar32 c)
+{
+    return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).category() == QChar::Separator_Space;
+}
</ins><span class="cx"> 
</span><del>-    inline bool isPunct(UChar32 c)
-    {
-      return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).isPunct();
-    }
</del><ins>+inline bool isPunct(UChar32 c)
+{
+    return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).isPunct();
+}
</ins><span class="cx"> 
</span><del>-    inline bool isLower(UChar32 c)
-    {
-      return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).category() == QChar::Letter_Lowercase;
-    }
</del><ins>+inline bool isLower(UChar32 c)
+{
+    return (c &amp; 0xffff0000) == 0 &amp;&amp; QChar((unsigned short)c).category() == QChar::Letter_Lowercase;
+}
</ins><span class="cx"> 
</span><del>-    inline UChar32 mirroredChar(UChar32 c)
-    {
-      if (c &gt; 0xffff)
</del><ins>+inline UChar32 mirroredChar(UChar32 c)
+{
+    if (c &gt; 0xffff)
</ins><span class="cx">         return c;
</span><del>-      return QChar(c).mirroredChar().unicode();
-    }
</del><ins>+    return QChar(c).mirroredChar().unicode();
+}
</ins><span class="cx"> 
</span><del>-    inline uint8_t combiningClass(UChar32 c)
-    {
-      if (c &gt; 0xffff)
</del><ins>+inline uint8_t combiningClass(UChar32 c)
+{
+    if (c &gt; 0xffff)
</ins><span class="cx">         return 0;
</span><del>-      return QChar((unsigned short)c).combiningClass();
-    }
</del><ins>+    return QChar((unsigned short)c).combiningClass();
+}
</ins><span class="cx"> 
</span><del>-    inline DecompositionType decompositionType(UChar32 c)
-    {
-      if (c &gt; 0xffff)
</del><ins>+inline DecompositionType decompositionType(UChar32 c)
+{
+    if (c &gt; 0xffff)
</ins><span class="cx">         return DecompositionNone;
</span><del>-      return (DecompositionType)QChar(c).decompositionTag();
-    }
</del><ins>+    return (DecompositionType)QChar(c).decompositionTag();
+}
</ins><span class="cx"> 
</span><del>-    inline int umemcasecmp(const UChar* a, const UChar* b, int len)
-    {
-      for (int i = 0; i &lt; len; ++i) {
</del><ins>+inline int umemcasecmp(const UChar* a, const UChar* b, int len)
+{
+    for (int i = 0; i &lt; len; ++i) {
</ins><span class="cx">         QChar c1 = QChar(a[i]).toLower();
</span><span class="cx">         QChar c2 = QChar(b[i]).toLower();
</span><span class="cx">         if (c1 != c2)
</span><del>-          return c1.unicode() - c2.unicode();
-      }
-      return 0;
</del><ins>+        return c1.unicode() - c2.unicode();
</ins><span class="cx">     }
</span><ins>+    return 0;
+}
</ins><span class="cx"> 
</span><del>-    inline Direction direction(UChar32 c)
-    {
-      if (c &gt; 0xffff)
</del><ins>+inline Direction direction(UChar32 c)
+{
+    if (c &gt; 0xffff)
</ins><span class="cx">         return LeftToRight;
</span><del>-      return (Direction)QChar(c).direction();
-    }
</del><ins>+    return (Direction)QChar(c).direction();
+}
</ins><span class="cx"> 
</span><del>-    inline CharCategory category(UChar32 c)
-    {
-      if (c &gt; 0xffff)
</del><ins>+inline CharCategory category(UChar32 c)
+{
+    if (c &gt; 0xffff)
</ins><span class="cx">         return NoCategory;
</span><del>-      return (CharCategory) U_MASK(QChar(c).category());
-    }
</del><ins>+    return (CharCategory) U_MASK(QChar(c).category());
+}
</ins><span class="cx"> 
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-  }
-}
</del><ins>+} }
</ins><span class="cx"> 
</span><span class="cx"> #endif
</span><del>-// vim: ts=2 sw=2 et
</del></span></pre>
</div>
</div>

</body>
</html>