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