i18npool/source/breakiterator/breakiteratorImpl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <breakiteratorImpl.hxx>
  22 #include <unicode/uchar.h>
  23 #include <i18nutil/unicode.hxx>
  24 #include <rtl/ustrbuf.hxx>
  25
  26 using namespace ::com::sun::star::uno;
  27 using namespace ::com::sun::star::lang;
  28 using namespace ::rtl;
  29
  30 namespace com { namespace sun { namespace star { namespace i18n {
  31
  32 BreakIteratorImpl::BreakIteratorImpl( const Reference < XComponentContext >& rxContext ) : m_xContext( rxContext )
  33 {
  34 }
  35
  36 BreakIteratorImpl::BreakIteratorImpl()
  37 {
  38 }
  39
  40 BreakIteratorImpl::~BreakIteratorImpl()
  41 {
  42         // Clear lookuptable
  43         for (size_t l = 0; l < lookupTable.size(); l++)
  44             delete lookupTable[l];
  45         lookupTable.clear();
  46 }
  47
  48 #define LBI getLocaleSpecificBreakIterator(rLocale)
  49
  50 sal_Int32 SAL_CALL BreakIteratorImpl::nextCharacters( const OUString& Text, sal_Int32 nStartPos,
  51         const Locale &rLocale, sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone )
  52         throw(RuntimeException)
  53 {
  54         if (nCount < 0) throw RuntimeException();
  55
  56         return LBI->nextCharacters( Text, nStartPos, rLocale, nCharacterIteratorMode, nCount, nDone);
  57 }
  58
  59 sal_Int32 SAL_CALL BreakIteratorImpl::previousCharacters( const OUString& Text, sal_Int32 nStartPos,
  60         const Locale& rLocale, sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone )
  61         throw(RuntimeException)
  62 {
  63         if (nCount < 0) throw RuntimeException();
  64
  65         return LBI->previousCharacters( Text, nStartPos, rLocale, nCharacterIteratorMode, nCount, nDone);
  66 }
  67
  68 #define isZWSP(c) (ch == 0x200B)
  69
  70 static sal_Int32 skipSpace(const OUString& Text, sal_Int32 nPos, sal_Int32 len, sal_Int16 rWordType, sal_Bool bDirection)
  71 {
  72         sal_uInt32 ch=0;
  73         sal_Int32 pos=nPos;
  74         switch (rWordType) {
  75             case WordType::ANYWORD_IGNOREWHITESPACES:
  76                 if (bDirection)
  77                     while (nPos < len && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch))) nPos=pos;
  78                 else
  79                     while (nPos > 0 && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch))) nPos=pos;
  80             break;
  81             case WordType::DICTIONARY_WORD:
  82                 if (bDirection)
  83                     while (nPos < len && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch) ||
  84                             ! (ch == 0x002E || u_isalnum(ch)))) nPos=pos;
  85                 else
  86                     while (nPos > 0 && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch) ||
  87                             ! (ch == 0x002E || u_isalnum(ch)))) nPos=pos;
  88             break;
  89             case WordType::WORD_COUNT:
  90                 if (bDirection)
  91                     while (nPos < len && (u_isUWhiteSpace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch))) nPos=pos;
  92                 else
  93                     while (nPos > 0 && (u_isUWhiteSpace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch))) nPos=pos;
  94             break;
  95         }
  96         return nPos;
  97 }
  98
  99 Boundary SAL_CALL BreakIteratorImpl::nextWord( const OUString& Text, sal_Int32 nStartPos,
 100         const Locale& rLocale, sal_Int16 rWordType ) throw(RuntimeException)
 101 {
 102         sal_Int32 len = Text.getLength();
 103         if( nStartPos < 0 || len == 0 )
 104             result.endPos = result.startPos = 0;
 105         else if (nStartPos >= len)
 106             result.endPos = result.startPos = len;
 107         else {
 108             result = LBI->nextWord(Text, nStartPos, rLocale, rWordType);
 109
 110             nStartPos = skipSpace(Text, result.startPos, len, rWordType, sal_True);
 111
 112             if ( nStartPos != result.startPos) {
 113                 if( nStartPos >= len )
 114                     result.startPos = result.endPos = len;
 115                 else {
 116                     result = LBI->getWordBoundary(Text, nStartPos, rLocale, rWordType, sal_True);
 117                     // i88041: avoid startPos goes back to nStartPos when switching between Latin and CJK scripts
 118                     if (result.startPos < nStartPos) result.startPos = nStartPos;
 119                 }
 120             }
 121         }
 122         return result;
 123 }
 124
 125 static inline sal_Bool SAL_CALL isCJK( const Locale& rLocale ) {
 126         return rLocale.Language == "zh" || rLocale.Language == "ja" || rLocale.Language == "ko";
 127 }
 128
 129 Boundary SAL_CALL BreakIteratorImpl::previousWord( const OUString& Text, sal_Int32 nStartPos,
 130         const Locale& rLocale, sal_Int16 rWordType) throw(RuntimeException)
 131 {
 132         sal_Int32 len = Text.getLength();
 133         if( nStartPos <= 0 || len == 0 ) {
 134             result.endPos = result.startPos = 0;
 135             return result;
 136         } else if (nStartPos > len) {
 137             result.endPos = result.startPos = len;
 138             return result;
 139         }
 140
 141         sal_Int32 nPos = skipSpace(Text, nStartPos, len, rWordType, sal_False);
 142
 143         // if some spaces are skiped, and the script type is Asian with no CJK rLocale, we have to return
 144         // (nStartPos, -1) for caller to send correct rLocale for loading correct dictionary.
 145         result.startPos = nPos;
 146         if (nPos != nStartPos && nPos > 0 && !isCJK(rLocale) && getScriptClass(Text.iterateCodePoints(&nPos, -1)) == ScriptType::ASIAN) {
 147             result.endPos = -1;
 148             return result;
 149         }
 150
 151         return LBI->previousWord(Text, result.startPos, rLocale, rWordType);
 152 }
 153
 154
 155 Boundary SAL_CALL BreakIteratorImpl::getWordBoundary( const OUString& Text, sal_Int32 nPos, const Locale& rLocale,
 156         sal_Int16 rWordType, sal_Bool bDirection ) throw(RuntimeException)
 157 {
 158         sal_Int32 len = Text.getLength();
 159         if( nPos < 0 || len == 0 )
 160             result.endPos = result.startPos = 0;
 161         else if (nPos > len)
 162             result.endPos = result.startPos = len;
 163         else {
 164             sal_Int32 next, prev;
 165             next = skipSpace(Text, nPos, len, rWordType, sal_True);
 166             prev = skipSpace(Text, nPos, len, rWordType, sal_False);
 167             if (prev == 0 && next == len) {
 168                 result.endPos = result.startPos = nPos;
 169             } else if (prev == 0 && ! bDirection) {
 170                 result.endPos = result.startPos = 0;
 171             } else if (next == len && bDirection) {
 172                 result.endPos = result.startPos = len;
 173             } else {
 174                 if (next != prev) {
 175                     if (next == nPos && next != len)
 176                         bDirection = sal_True;
 177                     else if (prev == nPos && prev != 0)
 178                         bDirection = sal_False;
 179                     else
 180                         nPos = bDirection ? next : prev;
 181                 }
 182                 result = LBI->getWordBoundary(Text, nPos, rLocale, rWordType, bDirection);
 183             }
 184         }
 185         return result;
 186 }
 187
 188 sal_Bool SAL_CALL BreakIteratorImpl::isBeginWord( const OUString& Text, sal_Int32 nPos,
 189         const Locale& rLocale, sal_Int16 rWordType ) throw(RuntimeException)
 190 {
 191         sal_Int32 len = Text.getLength();
 192
 193         if (nPos < 0 || nPos >= len) return sal_False;
 194
 195         sal_Int32 tmp = skipSpace(Text, nPos, len, rWordType, sal_True);
 196
 197         if (tmp != nPos) return sal_False;
 198
 199         result = getWordBoundary(Text, nPos, rLocale, rWordType, sal_True);
 200
 201         return result.startPos == nPos;
 202 }
 203
 204 sal_Bool SAL_CALL BreakIteratorImpl::isEndWord( const OUString& Text, sal_Int32 nPos,
 205         const Locale& rLocale, sal_Int16 rWordType ) throw(RuntimeException)
 206 {
 207         sal_Int32 len = Text.getLength();
 208
 209         if (nPos <= 0 || nPos > len) return sal_False;
 210
 211         sal_Int32 tmp = skipSpace(Text, nPos, len, rWordType, sal_False);
 212
 213         if (tmp != nPos) return sal_False;
 214
 215         result = getWordBoundary(Text, nPos, rLocale, rWordType, sal_False);
 216
 217         return result.endPos == nPos;
 218 }
 219
 220 sal_Int32 SAL_CALL BreakIteratorImpl::beginOfSentence( const OUString& Text, sal_Int32 nStartPos,
 221         const Locale &rLocale ) throw(RuntimeException)
 222 {
 223         if (nStartPos < 0 || nStartPos > Text.getLength())
 224             return -1;
 225         if (Text.isEmpty()) return 0;
 226         return LBI->beginOfSentence(Text, nStartPos, rLocale);
 227 }
 228
 229 sal_Int32 SAL_CALL BreakIteratorImpl::endOfSentence( const OUString& Text, sal_Int32 nStartPos,
 230         const Locale &rLocale ) throw(RuntimeException)
 231 {
 232         if (nStartPos < 0 || nStartPos > Text.getLength())
 233             return -1;
 234         if (Text.isEmpty()) return 0;
 235         return LBI->endOfSentence(Text, nStartPos, rLocale);
 236 }
 237
 238 LineBreakResults SAL_CALL BreakIteratorImpl::getLineBreak( const OUString& Text, sal_Int32 nStartPos,
 239         const Locale& rLocale, sal_Int32 nMinBreakPos, const LineBreakHyphenationOptions& hOptions,
 240         const LineBreakUserOptions& bOptions ) throw(RuntimeException)
 241 {
 242         return LBI->getLineBreak(Text, nStartPos, rLocale, nMinBreakPos, hOptions, bOptions);
 243 }
 244
 245 sal_Int16 SAL_CALL BreakIteratorImpl::getScriptType( const OUString& Text, sal_Int32 nPos )
 246         throw(RuntimeException)
 247 {
 248         return (nPos < 0 || nPos >= Text.getLength()) ? ScriptType::WEAK :
 249                             getScriptClass(Text.iterateCodePoints(&nPos, 0));
 250 }
 251
 252
 253 /** Increments/decrements position first, then obtains character.
 254     @return current position, may be -1 or text length if string was consumed.
 255  */
 256 static sal_Int32 SAL_CALL iterateCodePoints(const OUString& Text, sal_Int32 &nStartPos, sal_Int32 inc, sal_uInt32& ch) {
 257         sal_Int32 nLen = Text.getLength();
 258         if (nStartPos + inc < 0 || nStartPos + inc >= nLen) {
 259             ch = 0;
 260             nStartPos = nStartPos + inc < 0 ? -1 : nLen;
 261         } else {
 262             ch = Text.iterateCodePoints(&nStartPos, inc);
 263             // Fix for #i80436#.
 264             // erAck: 2009-06-30T21:52+0200  This logic looks somewhat
 265             // suspicious as if it cures a symptom.. anyway, had to add
 266             // nStartPos < Text.getLength() to silence the (correct) assertion
 267             // in rtl_uString_iterateCodePoints() if Text was one character
 268             // (codepoint) only, made up of a surrogate pair.
 269             //if (inc > 0 && nStartPos < Text.getLength())
 270             //    ch = Text.iterateCodePoints(&nStartPos, 0);
 271             // With surrogates, nStartPos may actually point behind string
 272             // now, even if inc is only +1
 273             if (inc > 0)
 274                 ch = (nStartPos < nLen ? Text.iterateCodePoints(&nStartPos, 0) : 0);
 275         }
 276         return nStartPos;
 277 }
 278
 279
 280 sal_Int32 SAL_CALL BreakIteratorImpl::beginOfScript( const OUString& Text,
 281         sal_Int32 nStartPos, sal_Int16 ScriptType ) throw(RuntimeException)
 282 {
 283         if (nStartPos < 0 || nStartPos >= Text.getLength())
 284             return -1;
 285
 286         if(ScriptType != getScriptClass(Text.iterateCodePoints(&nStartPos, 0)))
 287             return -1;
 288
 289         if (nStartPos == 0) return 0;
 290         sal_uInt32 ch=0;
 291         while (iterateCodePoints(Text, nStartPos, -1, ch) >= 0 && ScriptType == getScriptClass(ch)) {
 292             if (nStartPos == 0) return 0;
 293         }
 294
 295         return  iterateCodePoints(Text, nStartPos, 1, ch);
 296 }
 297
 298 sal_Int32 SAL_CALL BreakIteratorImpl::endOfScript( const OUString& Text,
 299         sal_Int32 nStartPos, sal_Int16 ScriptType ) throw(RuntimeException)
 300 {
 301         if (nStartPos < 0 || nStartPos >= Text.getLength())
 302             return -1;
 303
 304         if(ScriptType != getScriptClass(Text.iterateCodePoints(&nStartPos, 0)))
 305             return -1;
 306
 307         sal_Int32 strLen = Text.getLength();
 308         sal_uInt32 ch=0;
 309         while(iterateCodePoints(Text, nStartPos, 1, ch) < strLen ) {
 310             sal_Int16 currentCharScriptType = getScriptClass(ch);
 311             if(ScriptType != currentCharScriptType && currentCharScriptType != ScriptType::WEAK)
 312                 break;
 313         }
 314         return  nStartPos;
 315 }
 316
 317 sal_Int32  SAL_CALL BreakIteratorImpl::previousScript( const OUString& Text,
 318         sal_Int32 nStartPos, sal_Int16 ScriptType ) throw(RuntimeException)
 319 {
 320         if (nStartPos < 0)
 321             return -1;
 322         if (nStartPos > Text.getLength())
 323             nStartPos = Text.getLength();
 324
 325         sal_Int16 numberOfChange = (ScriptType == getScriptClass(Text.iterateCodePoints(&nStartPos, 0))) ? 3 : 2;
 326
 327         sal_uInt32 ch=0;
 328         while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, -1, ch) >= 0) {
 329             if ((((numberOfChange % 2) == 0) ^ (ScriptType != getScriptClass(ch))))
 330                 numberOfChange--;
 331             else if (nStartPos == 0) {
 332                 if (numberOfChange > 0)
 333                     numberOfChange--;
 334                 if (nStartPos > 0)
 335                     Text.iterateCodePoints(&nStartPos, -1);
 336                 else
 337                     return -1;
 338             }
 339         }
 340         return numberOfChange == 0 ? iterateCodePoints(Text, nStartPos, 1, ch) : -1;
 341 }
 342
 343 sal_Int32 SAL_CALL BreakIteratorImpl::nextScript( const OUString& Text, sal_Int32 nStartPos,
 344         sal_Int16 ScriptType ) throw(RuntimeException)
 345
 346 {
 347         if (nStartPos < 0)
 348             nStartPos = 0;
 349         sal_Int32 strLen = Text.getLength();
 350         if (nStartPos > strLen)
 351             return -1;
 352
 353         sal_Int16 numberOfChange = (ScriptType == getScriptClass(Text.iterateCodePoints(&nStartPos, 0))) ? 2 : 1;
 354
 355         sal_uInt32 ch=0;
 356         while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, 1, ch) < strLen) {
 357             sal_Int16 currentCharScriptType = getScriptClass(ch);
 358             if ((numberOfChange == 1) ? (ScriptType == currentCharScriptType) :
 359                     (ScriptType != currentCharScriptType && currentCharScriptType != ScriptType::WEAK))
 360                 numberOfChange--;
 361         }
 362         return numberOfChange == 0 ? nStartPos : -1;
 363 }
 364
 365 sal_Int32 SAL_CALL BreakIteratorImpl::beginOfCharBlock( const OUString& Text, sal_Int32 nStartPos,
 366         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 367 {
 368         if (CharType == CharType::ANY_CHAR) return 0;
 369         if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
 370         if (CharType != (sal_Int16)u_charType( Text.iterateCodePoints(&nStartPos, 0))) return -1;
 371
 372         sal_Int32 nPos=nStartPos;
 373         while(nStartPos > 0 && CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nPos, -1))) { nStartPos=nPos; }
 374         return nStartPos; // begin of char block is inclusive
 375 }
 376
 377 sal_Int32 SAL_CALL BreakIteratorImpl::endOfCharBlock( const OUString& Text, sal_Int32 nStartPos,
 378         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 379 {
 380         sal_Int32 strLen = Text.getLength();
 381
 382         if (CharType == CharType::ANY_CHAR) return strLen; // end of char block is exclusive
 383         if (nStartPos < 0 || nStartPos >= strLen) return -1;
 384         if (CharType != (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) return -1;
 385
 386         sal_uInt32 ch=0;
 387         while(iterateCodePoints(Text, nStartPos, 1, ch) < strLen && CharType == (sal_Int16)u_charType(ch)) {}
 388         return nStartPos; // end of char block is exclusive
 389 }
 390
 391 sal_Int32 SAL_CALL BreakIteratorImpl::nextCharBlock( const OUString& Text, sal_Int32 nStartPos,
 392         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 393 {
 394         if (CharType == CharType::ANY_CHAR) return -1;
 395         if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
 396
 397         sal_Int16 numberOfChange = (CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) ? 2 : 1;
 398         sal_Int32 strLen = Text.getLength();
 399
 400     sal_uInt32 ch=0;
 401     while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, 1, ch) < strLen) {
 402         if ((CharType != (sal_Int16)u_charType(ch)) ^ (numberOfChange == 1))
 403             numberOfChange--;
 404     }
 405     return numberOfChange == 0 ? nStartPos : -1;
 406 }
 407
 408 sal_Int32 SAL_CALL BreakIteratorImpl::previousCharBlock( const OUString& Text, sal_Int32 nStartPos,
 409         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 410 {
 411         if(CharType == CharType::ANY_CHAR) return -1;
 412         if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
 413
 414         sal_Int16 numberOfChange = (CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) ? 3 : 2;
 415
 416         sal_uInt32 ch=0;
 417         while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, -1, ch) >= 0) {
 418             if (((numberOfChange % 2) == 0) ^ (CharType != (sal_Int16)u_charType(ch)))
 419                 numberOfChange--;
 420             if (nStartPos == 0 && numberOfChange > 0) {
 421                 numberOfChange--;
 422                 if (numberOfChange == 0) return nStartPos;
 423             }
 424         }
 425         return numberOfChange == 0 ? iterateCodePoints(Text, nStartPos, 1, ch) : -1;
 426 }
 427
 428
 429
 430 sal_Int16 SAL_CALL BreakIteratorImpl::getWordType( const OUString& /*Text*/,
 431         sal_Int32 /*nPos*/, const Locale& /*rLocale*/ ) throw(RuntimeException)
 432 {
 433         return 0;
 434 }
 435
 436 namespace
 437 {
 438     sal_Int16 getScriptClassByUAX24Script(sal_uInt32 currentChar)
 439     {
 440         int32_t script = u_getIntPropertyValue(currentChar, UCHAR_SCRIPT);
 441         return unicode::getScriptClassFromUScriptCode(static_cast<UScriptCode>(script));
 442     }
 443
 444     struct UBlock2Script
 445     {
 446         UBlockCode from;
 447         UBlockCode to;
 448         sal_Int16 script;
 449     };
 450
 451     static UBlock2Script scriptList[] =
 452     {
 453         {UBLOCK_NO_BLOCK, UBLOCK_NO_BLOCK, ScriptType::WEAK},
 454         {UBLOCK_BASIC_LATIN, UBLOCK_ARMENIAN, ScriptType::LATIN},
 455         {UBLOCK_HEBREW, UBLOCK_MYANMAR, ScriptType::COMPLEX},
 456         {UBLOCK_GEORGIAN, UBLOCK_GEORGIAN, ScriptType::LATIN},
 457         {UBLOCK_HANGUL_JAMO, UBLOCK_HANGUL_JAMO, ScriptType::ASIAN},
 458         {UBLOCK_ETHIOPIC, UBLOCK_ETHIOPIC, ScriptType::COMPLEX},
 459         {UBLOCK_CHEROKEE, UBLOCK_RUNIC, ScriptType::LATIN},
 460         {UBLOCK_KHMER, UBLOCK_MONGOLIAN, ScriptType::COMPLEX},
 461         {UBLOCK_LATIN_EXTENDED_ADDITIONAL, UBLOCK_GREEK_EXTENDED, ScriptType::LATIN},
 462         {UBLOCK_NUMBER_FORMS, UBLOCK_NUMBER_FORMS, ScriptType::WEAK},
 463         {UBLOCK_CJK_RADICALS_SUPPLEMENT, UBLOCK_HANGUL_SYLLABLES, ScriptType::ASIAN},
 464         {UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS, UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS, ScriptType::ASIAN},
 465         {UBLOCK_ARABIC_PRESENTATION_FORMS_A, UBLOCK_ARABIC_PRESENTATION_FORMS_A, ScriptType::COMPLEX},
 466         {UBLOCK_CJK_COMPATIBILITY_FORMS, UBLOCK_CJK_COMPATIBILITY_FORMS, ScriptType::ASIAN},
 467         {UBLOCK_ARABIC_PRESENTATION_FORMS_B, UBLOCK_ARABIC_PRESENTATION_FORMS_B, ScriptType::COMPLEX},
 468         {UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS, UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS, ScriptType::ASIAN},
 469         {UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, ScriptType::ASIAN},
 470         {UBLOCK_CJK_STROKES, UBLOCK_CJK_STROKES, ScriptType::ASIAN},
 471         {UBLOCK_LATIN_EXTENDED_C, UBLOCK_LATIN_EXTENDED_D, ScriptType::LATIN}
 472     };
 473
 474     #define scriptListCount SAL_N_ELEMENTS(scriptList)
 475
 476     //always sets rScriptType
 477     //
 478     //returns true for characters historically explicitly assigned to
 479     //latin/weak/asian
 480     //
 481     //returns false for characters that historically implicitly assigned to
 482     //weak as unknown
 483     bool getCompatibilityScriptClassByBlock(sal_uInt32 currentChar, sal_Int16 &rScriptType)
 484     {
 485         bool bKnown = true;
 486         //handle specific characters always as weak:
 487         //  0x01 - this breaks a word
 488         //  0x02 - this can be inside a word
 489         //  0x20 & 0xA0 - Bug 102975, declare western space and non-break space as WEAK char.
 490         if( 0x01 == currentChar || 0x02 == currentChar || 0x20 == currentChar || 0xA0 == currentChar)
 491             rScriptType = ScriptType::WEAK;
 492         // workaround for Coptic
 493         else if ( 0x2C80 <= currentChar && 0x2CE3 >= currentChar)
 494             rScriptType = ScriptType::LATIN;
 495         else
 496         {
 497             UBlockCode block=ublock_getCode(currentChar);
 498             size_t i = 0;
 499             while (i < scriptListCount)
 500             {
 501                 if (block <= scriptList[i].to)
 502                     break;
 503                 ++i;
 504             }
 505             if (i < scriptListCount && block >= scriptList[i].from)
 506                 rScriptType = scriptList[i].script;
 507             else
 508             {
 509                 rScriptType = ScriptType::WEAK;
 510                 bKnown = false;
 511             }
 512         }
 513         return bKnown;
 514     }
 515 }
 516
 517 sal_Int16  BreakIteratorImpl::getScriptClass(sal_uInt32 currentChar)
 518 {
 519     static sal_uInt32 lastChar = 0;
 520     static sal_Int16 nRet = 0;
 521
 522     if (currentChar != lastChar)
 523     {
 524         lastChar = currentChar;
 525
 526         if (!getCompatibilityScriptClassByBlock(currentChar, nRet))
 527             nRet = getScriptClassByUAX24Script(currentChar);
 528     }
 529
 530     return nRet;
 531 }
 532
 533 static inline sal_Bool operator == (const Locale& l1, const Locale& l2) {
 534         return l1.Language == l2.Language && l1.Country == l2.Country && l1.Variant == l2.Variant;
 535 }
 536
 537 sal_Bool SAL_CALL BreakIteratorImpl::createLocaleSpecificBreakIterator(const OUString& aLocaleName) throw( RuntimeException )
 538 {
 539         // to share service between same Language but different Country code, like zh_CN and zh_TW
 540         for (size_t l = 0; l < lookupTable.size(); l++) {
 541             lookupTableItem *listItem = lookupTable[l];
 542             if (aLocaleName == listItem->aLocale.Language) {
 543                 xBI = listItem->xBI;
 544                 return sal_True;
 545             }
 546         }
 547
 548         Reference < uno::XInterface > xI = m_xContext->getServiceManager()->createInstanceWithContext(
 549             OUString("com.sun.star.i18n.BreakIterator_") + aLocaleName, m_xContext);
 550
 551         if ( xI.is() ) {
 552             xI->queryInterface( getCppuType((const Reference< XBreakIterator>*)0) ) >>= xBI;
 553             if (xBI.is()) {
 554                 lookupTable.push_back(new lookupTableItem(Locale(aLocaleName, aLocaleName, aLocaleName), xBI));
 555                 return sal_True;
 556             }
 557         }
 558         return sal_False;
 559 }
 560
 561 Reference < XBreakIterator > SAL_CALL
 562 BreakIteratorImpl::getLocaleSpecificBreakIterator(const Locale& rLocale) throw (RuntimeException)
 563 {
 564         if (xBI.is() && rLocale == aLocale)
 565             return xBI;
 566         else if (m_xContext.is()) {
 567             aLocale = rLocale;
 568
 569             for (size_t i = 0; i < lookupTable.size(); i++) {
 570                 lookupTableItem *listItem = lookupTable[i];
 571                 if (rLocale == listItem->aLocale)
 572                     return xBI = listItem->xBI;
 573             }
 574
 575             sal_Unicode under = (sal_Unicode)'_';
 576
 577             sal_Int32 l = rLocale.Language.getLength();
 578             sal_Int32 c = rLocale.Country.getLength();
 579             sal_Int32 v = rLocale.Variant.getLength();
 580             OUStringBuffer aBuf(l+c+v+3);
 581
 582             if ((l > 0 && c > 0 && v > 0 &&
 583                     // load service with name <base>_<lang>_<country>_<varian>
 584                     createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).append(
 585                                     rLocale.Country).append(under).append(rLocale.Variant).makeStringAndClear())) ||
 586                 (l > 0 && c > 0 &&
 587                     // load service with name <base>_<lang>_<country>
 588                     createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).append(
 589                                     rLocale.Country).makeStringAndClear())) ||
 590                 (l > 0 && c > 0 && rLocale.Language.compareToAscii("zh") == 0 &&
 591                                     (rLocale.Country.compareToAscii("HK") == 0 ||
 592                                     rLocale.Country.compareToAscii("MO") == 0) &&
 593                     // if the country code is HK or MO, one more step to try TW.
 594                     createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).appendAscii(
 595                                     "TW").makeStringAndClear())) ||
 596                 (l > 0 &&
 597                     // load service with name <base>_<lang>
 598                     createLocaleSpecificBreakIterator(rLocale.Language)) ||
 599                     // load default service with name <base>_Unicode
 600                     createLocaleSpecificBreakIterator(OUString("Unicode"))) {
 601                 lookupTable.push_back( new lookupTableItem(aLocale, xBI) );
 602                 return xBI;
 603             }
 604         }
 605         throw RuntimeException();
 606 }
 607
 608 const sal_Char cBreakIterator[] = "com.sun.star.i18n.BreakIterator";
 609
 610 OUString SAL_CALL
 611 BreakIteratorImpl::getImplementationName(void) throw( RuntimeException )
 612 {
 613         return OUString::createFromAscii(cBreakIterator);
 614 }
 615
 616 sal_Bool SAL_CALL
 617 BreakIteratorImpl::supportsService(const OUString& rServiceName) throw( RuntimeException )
 618 {
 619         return !rServiceName.compareToAscii(cBreakIterator);
 620 }
 621
 622 Sequence< OUString > SAL_CALL
 623 BreakIteratorImpl::getSupportedServiceNames(void) throw( RuntimeException )
 624 {
 625         Sequence< OUString > aRet(1);
 626         aRet[0] = OUString::createFromAscii(cBreakIterator);
 627         return aRet;
 628 }
 629
 630 } } } }
 631
 632 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */