wtf/unicode/qt4/UnicodeQt4.h

   1 /*
   2  *  Copyright (C) 2006 George Staikos <staikos@kde.org>
   3  *  Copyright (C) 2006 Alexey Proskuryakov <ap@nypop.com>
   4  *  Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Library General Public
   8  *  License as published by the Free Software Foundation; either
   9  *  version 2 of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Library General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Library General Public License
  17  *  along with this library; see the file COPYING.LIB.  If not, write to
  18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  *  Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #ifndef WTF_UNICODE_QT4_H
  24 #define WTF_UNICODE_QT4_H
  25
  26 #include "UnicodeMacrosFromICU.h"
  27
  28 #include <QChar>
  29 #include <QString>
  30
  31 #include <config.h>
  32
  33 #include <stdint.h>
  34 #if USE(QT_ICU_TEXT_BREAKING)
  35 #include <unicode/ubrk.h>
  36 #endif
  37
  38 QT_BEGIN_NAMESPACE
  39 namespace QUnicodeTables {
  40     struct Properties {
  41         ushort category : 8;
  42         ushort line_break_class : 8;
  43         ushort direction : 8;
  44         ushort combiningClass :8;
  45         ushort joining : 2;
  46         signed short digitValue : 6; /* 5 needed */
  47         ushort unicodeVersion : 4;
  48         ushort lowerCaseSpecial : 1;
  49         ushort upperCaseSpecial : 1;
  50         ushort titleCaseSpecial : 1;
  51         ushort caseFoldSpecial : 1; /* currently unused */
  52         signed short mirrorDiff : 16;
  53         signed short lowerCaseDiff : 16;
  54         signed short upperCaseDiff : 16;
  55         signed short titleCaseDiff : 16;
  56         signed short caseFoldDiff : 16;
  57     };
  58     Q_CORE_EXPORT const Properties * QT_FASTCALL properties(uint ucs4);
  59     Q_CORE_EXPORT const Properties * QT_FASTCALL properties(ushort ucs2);
  60 }
  61 QT_END_NAMESPACE
  62
  63 // ugly hack to make UChar compatible with JSChar in API/JSStringRef.h
  64 #if defined(Q_OS_WIN) || COMPILER(WINSCW) || (COMPILER(RVCT) && !OS(LINUX))
  65 typedef wchar_t UChar;
  66 #else
  67 typedef uint16_t UChar;
  68 #endif
  69
  70 #if !USE(QT_ICU_TEXT_BREAKING)
  71 typedef uint32_t UChar32;
  72 #endif
  73
  74 namespace WTF {
  75 namespace Unicode {
  76
  77 enum Direction {
  78     LeftToRight = QChar::DirL,
  79     RightToLeft = QChar::DirR,
  80     EuropeanNumber = QChar::DirEN,
  81     EuropeanNumberSeparator = QChar::DirES,
  82     EuropeanNumberTerminator = QChar::DirET,
  83     ArabicNumber = QChar::DirAN,
  84     CommonNumberSeparator = QChar::DirCS,
  85     BlockSeparator = QChar::DirB,
  86     SegmentSeparator = QChar::DirS,
  87     WhiteSpaceNeutral = QChar::DirWS,
  88     OtherNeutral = QChar::DirON,
  89     LeftToRightEmbedding = QChar::DirLRE,
  90     LeftToRightOverride = QChar::DirLRO,
  91     RightToLeftArabic = QChar::DirAL,
  92     RightToLeftEmbedding = QChar::DirRLE,
  93     RightToLeftOverride = QChar::DirRLO,
  94     PopDirectionalFormat = QChar::DirPDF,
  95     NonSpacingMark = QChar::DirNSM,
  96     BoundaryNeutral = QChar::DirBN
  97 };
  98
  99 enum DecompositionType {
 100     DecompositionNone = QChar::NoDecomposition,
 101     DecompositionCanonical = QChar::Canonical,
 102     DecompositionCompat = QChar::Compat,
 103     DecompositionCircle = QChar::Circle,
 104     DecompositionFinal = QChar::Final,
 105     DecompositionFont = QChar::Font,
 106     DecompositionFraction = QChar::Fraction,
 107     DecompositionInitial = QChar::Initial,
 108     DecompositionIsolated = QChar::Isolated,
 109     DecompositionMedial = QChar::Medial,
 110     DecompositionNarrow = QChar::Narrow,
 111     DecompositionNoBreak = QChar::NoBreak,
 112     DecompositionSmall = QChar::Small,
 113     DecompositionSquare = QChar::Square,
 114     DecompositionSub = QChar::Sub,
 115     DecompositionSuper = QChar::Super,
 116     DecompositionVertical = QChar::Vertical,
 117     DecompositionWide = QChar::Wide
 118 };
 119
 120 enum CharCategory {
 121     NoCategory = 0,
 122     Mark_NonSpacing = U_MASK(QChar::Mark_NonSpacing),
 123     Mark_SpacingCombining = U_MASK(QChar::Mark_SpacingCombining),
 124     Mark_Enclosing = U_MASK(QChar::Mark_Enclosing),
 125     Number_DecimalDigit = U_MASK(QChar::Number_DecimalDigit),
 126     Number_Letter = U_MASK(QChar::Number_Letter),
 127     Number_Other = U_MASK(QChar::Number_Other),
 128     Separator_Space = U_MASK(QChar::Separator_Space),
 129     Separator_Line = U_MASK(QChar::Separator_Line),
 130     Separator_Paragraph = U_MASK(QChar::Separator_Paragraph),
 131     Other_Control = U_MASK(QChar::Other_Control),
 132     Other_Format = U_MASK(QChar::Other_Format),
 133     Other_Surrogate = U_MASK(QChar::Other_Surrogate),
 134     Other_PrivateUse = U_MASK(QChar::Other_PrivateUse),
 135     Other_NotAssigned = U_MASK(QChar::Other_NotAssigned),
 136     Letter_Uppercase = U_MASK(QChar::Letter_Uppercase),
 137     Letter_Lowercase = U_MASK(QChar::Letter_Lowercase),
 138     Letter_Titlecase = U_MASK(QChar::Letter_Titlecase),
 139     Letter_Modifier = U_MASK(QChar::Letter_Modifier),
 140     Letter_Other = U_MASK(QChar::Letter_Other),
 141     Punctuation_Connector = U_MASK(QChar::Punctuation_Connector),
 142     Punctuation_Dash = U_MASK(QChar::Punctuation_Dash),
 143     Punctuation_Open = U_MASK(QChar::Punctuation_Open),
 144     Punctuation_Close = U_MASK(QChar::Punctuation_Close),
 145     Punctuation_InitialQuote = U_MASK(QChar::Punctuation_InitialQuote),
 146     Punctuation_FinalQuote = U_MASK(QChar::Punctuation_FinalQuote),
 147     Punctuation_Other = U_MASK(QChar::Punctuation_Other),
 148     Symbol_Math = U_MASK(QChar::Symbol_Math),
 149     Symbol_Currency = U_MASK(QChar::Symbol_Currency),
 150     Symbol_Modifier = U_MASK(QChar::Symbol_Modifier),
 151     Symbol_Other = U_MASK(QChar::Symbol_Other)
 152 };
 153
 154
 155 // FIXME: handle surrogates correctly in all methods
 156
 157 inline UChar32 toLower(UChar32 ch)
 158 {
 159     return QChar::toLower(uint32_t(ch));
 160 }
 161
 162 inline int toLower(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
 163 {
 164     const UChar *e = src + srcLength;
 165     const UChar *s = src;
 166     UChar *r = result;
 167     uint rindex = 0;
 168
 169     // this avoids one out of bounds check in the loop
 170     if (s < e && QChar(*s).isLowSurrogate()) {
 171         if (r)
 172             r[rindex] = *s++;
 173         ++rindex;
 174     }
 175
 176     int needed = 0;
 177     while (s < e && (rindex < uint(resultLength) || !r)) {
 178         uint c = *s;
 179         if (QChar(c).isLowSurrogate() && QChar(*(s - 1)).isHighSurrogate())
 180             c = QChar::surrogateToUcs4(*(s - 1), c);
 181         const QUnicodeTables::Properties *prop = QUnicodeTables::properties(c);
 182         if (prop->lowerCaseSpecial) {
 183             QString qstring;
 184             if (c < 0x10000) {
 185                 qstring += QChar(c);
 186             } else {
 187                 qstring += QChar(*(s-1));
 188                 qstring += QChar(*s);
 189             }
 190             qstring = qstring.toLower();
 191             for (int i = 0; i < qstring.length(); ++i) {
 192                 if (rindex >= uint(resultLength)) {
 193                     needed += qstring.length() - i;
 194                     break;
 195                 }
 196                 if (r)
 197                     r[rindex] = qstring.at(i).unicode();
 198                 ++rindex;
 199             }
 200         } else {
 201             if (r)
 202                 r[rindex] = *s + prop->lowerCaseDiff;
 203             ++rindex;
 204         }
 205         ++s;
 206     }
 207     if (s < e)
 208         needed += e - s;
 209     *error = (needed != 0);
 210     if (rindex < uint(resultLength))
 211         r[rindex] = 0;
 212     return rindex + needed;
 213 }
 214
 215 inline UChar32 toUpper(UChar32 c)
 216 {
 217     return QChar::toUpper(uint32_t(c));
 218 }
 219
 220 inline int toUpper(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
 221 {
 222     const UChar *e = src + srcLength;
 223     const UChar *s = src;
 224     UChar *r = result;
 225     int rindex = 0;
 226
 227     // this avoids one out of bounds check in the loop
 228     if (s < e && QChar(*s).isLowSurrogate()) {
 229         if (r)
 230             r[rindex] = *s++;
 231         ++rindex;
 232     }
 233
 234     int needed = 0;
 235     while (s < e && (rindex < resultLength || !r)) {
 236         uint c = *s;
 237         if (QChar(c).isLowSurrogate() && QChar(*(s - 1)).isHighSurrogate())
 238             c = QChar::surrogateToUcs4(*(s - 1), c);
 239         const QUnicodeTables::Properties *prop = QUnicodeTables::properties(c);
 240         if (prop->upperCaseSpecial) {
 241             QString qstring;
 242             if (c < 0x10000) {
 243                 qstring += QChar(c);
 244             } else {
 245                 qstring += QChar(*(s-1));
 246                 qstring += QChar(*s);
 247             }
 248             qstring = qstring.toUpper();
 249             for (int i = 0; i < qstring.length(); ++i) {
 250                 if (rindex >= resultLength) {
 251                     needed += qstring.length() - i;
 252                     break;
 253                 }
 254                 if (r)
 255                     r[rindex] = qstring.at(i).unicode();
 256                 ++rindex;
 257             }
 258         } else {
 259             if (r)
 260                 r[rindex] = *s + prop->upperCaseDiff;
 261             ++rindex;
 262         }
 263         ++s;
 264     }
 265     if (s < e)
 266         needed += e - s;
 267     *error = (needed != 0);
 268     if (rindex < resultLength)
 269         r[rindex] = 0;
 270     return rindex + needed;
 271 }
 272
 273 inline int toTitleCase(UChar32 c)
 274 {
 275     return QChar::toTitleCase(uint32_t(c));
 276 }
 277
 278 inline UChar32 foldCase(UChar32 c)
 279 {
 280     return QChar::toCaseFolded(uint32_t(c));
 281 }
 282
 283 inline int foldCase(UChar* result, int resultLength, const UChar* src, int srcLength,  bool* error)
 284 {
 285     // FIXME: handle special casing. Easiest with some low level API in Qt
 286     *error = false;
 287     if (resultLength < srcLength) {
 288         *error = true;
 289         return srcLength;
 290     }
 291     for (int i = 0; i < srcLength; ++i)
 292         result[i] = QChar::toCaseFolded(ushort(src[i]));
 293     return srcLength;
 294 }
 295
 296 inline bool isArabicChar(UChar32 c)
 297 {
 298     return c >= 0x0600 && c <= 0x06FF;
 299 }
 300
 301 inline bool isPrintableChar(UChar32 c)
 302 {
 303     const uint test = U_MASK(QChar::Other_Control) |
 304                       U_MASK(QChar::Other_NotAssigned);
 305     return !(U_MASK(QChar::category(uint32_t(c))) & test);
 306 }
 307
 308 inline bool isSeparatorSpace(UChar32 c)
 309 {
 310     return QChar::category(uint32_t(c)) == QChar::Separator_Space;
 311 }
 312
 313 inline bool isPunct(UChar32 c)
 314 {
 315     const uint test = U_MASK(QChar::Punctuation_Connector) |
 316                       U_MASK(QChar::Punctuation_Dash) |
 317                       U_MASK(QChar::Punctuation_Open) |
 318                       U_MASK(QChar::Punctuation_Close) |
 319                       U_MASK(QChar::Punctuation_InitialQuote) |
 320                       U_MASK(QChar::Punctuation_FinalQuote) |
 321                       U_MASK(QChar::Punctuation_Other);
 322     return U_MASK(QChar::category(uint32_t(c))) & test;
 323 }
 324
 325 inline bool isLower(UChar32 c)
 326 {
 327     return QChar::category(uint32_t(c)) == QChar::Letter_Lowercase;
 328 }
 329
 330 inline bool hasLineBreakingPropertyComplexContext(UChar32)
 331 {
 332     // FIXME: Implement this to return whether the character has line breaking property SA (Complex Context).
 333     return false;
 334 }
 335
 336 inline UChar32 mirroredChar(UChar32 c)
 337 {
 338     return QChar::mirroredChar(uint32_t(c));
 339 }
 340
 341 inline uint8_t combiningClass(UChar32 c)
 342 {
 343     return QChar::combiningClass(uint32_t(c));
 344 }
 345
 346 inline DecompositionType decompositionType(UChar32 c)
 347 {
 348     return (DecompositionType)QChar::decompositionTag(c);
 349 }
 350
 351 inline int umemcasecmp(const UChar* a, const UChar* b, int len)
 352 {
 353     // handle surrogates correctly
 354     for (int i = 0; i < len; ++i) {
 355         uint c1 = QChar::toCaseFolded(ushort(a[i]));
 356         uint c2 = QChar::toCaseFolded(ushort(b[i]));
 357         if (c1 != c2)
 358             return c1 - c2;
 359     }
 360     return 0;
 361 }
 362
 363 inline Direction direction(UChar32 c)
 364 {
 365     return (Direction)QChar::direction(uint32_t(c));
 366 }
 367
 368 inline CharCategory category(UChar32 c)
 369 {
 370     return (CharCategory) U_MASK(QChar::category(uint32_t(c)));
 371 }
 372
 373 } }
 374
 375 #endif // WTF_UNICODE_QT4_H