icuSources/common/brkiter.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 1997-2016, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 *
   7 * File brkiter.cpp
   8 *
   9 * Modification History:
  10 *
  11 *   Date        Name        Description
  12 *   02/18/97    aliu        Converted from OpenClass.  Added DONE.
  13 *   01/13/2000  helena      Added UErrorCode parameter to createXXXInstance methods.
  14 *****************************************************************************************
  15 */
  16
  17 // *****************************************************************************
  18 // This file was generated from the java source file BreakIterator.java
  19 // *****************************************************************************
  20
  21 #include "unicode/utypes.h"
  22
  23 #if !UCONFIG_NO_BREAK_ITERATION
  24
  25 #include "unicode/rbbi.h"
  26 #include "unicode/brkiter.h"
  27 #include "unicode/udata.h"
  28 #include "unicode/ures.h"
  29 #include "unicode/ustring.h"
  30 #include "unicode/filteredbrk.h"
  31 #include "ucln_cmn.h"
  32 #include "cstring.h"
  33 #include "umutex.h"
  34 #include "servloc.h"
  35 #include "locbased.h"
  36 #include "uresimp.h"
  37 #include "uassert.h"
  38 #include "ubrkimpl.h"
  39 #include "charstr.h"
  40 #include "unicode/filteredbrk.h"
  41
  42 // *****************************************************************************
  43 // class BreakIterator
  44 // This class implements methods for finding the location of boundaries in text.
  45 // Instances of BreakIterator maintain a current position and scan over text
  46 // returning the index of characters where boundaries occur.
  47 // *****************************************************************************
  48
  49 U_NAMESPACE_BEGIN
  50
  51 // -------------------------------------
  52
  53 BreakIterator*
  54 BreakIterator::buildInstance(const Locale& loc, const char *type, int32_t kind, UErrorCode &status)
  55 {
  56     char fnbuff[256];
  57     char ext[4]={'\0'};
  58     CharString actualLocale;
  59     int32_t size;
  60     const UChar* brkfname = NULL;
  61     UResourceBundle brkRulesStack;
  62     UResourceBundle brkNameStack;
  63     UResourceBundle *brkRules = &brkRulesStack;
  64     UResourceBundle *brkName  = &brkNameStack;
  65     RuleBasedBreakIterator *result = NULL;
  66
  67     if (U_FAILURE(status))
  68         return NULL;
  69
  70     ures_initStackObject(brkRules);
  71     ures_initStackObject(brkName);
  72
  73     // Get the locale
  74     UResourceBundle *b = ures_openNoDefault(U_ICUDATA_BRKITR, loc.getName(), &status);
  75
  76     // Get the "boundaries" array.
  77     if (U_SUCCESS(status)) {
  78         brkRules = ures_getByKeyWithFallback(b, "boundaries", brkRules, &status);
  79         // Get the string object naming the rules file
  80         brkName = ures_getByKeyWithFallback(brkRules, type, brkName, &status);
  81         // Get the actual string
  82         brkfname = ures_getString(brkName, &size, &status);
  83         U_ASSERT((size_t)size<sizeof(fnbuff));
  84         if ((size_t)size>=sizeof(fnbuff)) {
  85             size=0;
  86             if (U_SUCCESS(status)) {
  87                 status = U_BUFFER_OVERFLOW_ERROR;
  88             }
  89         }
  90
  91         // Use the string if we found it
  92         if (U_SUCCESS(status) && brkfname) {
  93             actualLocale.append(ures_getLocaleInternal(brkName, &status), -1, status);
  94
  95             UChar* extStart=u_strchr(brkfname, 0x002e);
  96             int len = 0;
  97             if(extStart!=NULL){
  98                 len = (int)(extStart-brkfname);
  99                 u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff
 100                 u_UCharsToChars(brkfname, fnbuff, len);
 101             }
 102             fnbuff[len]=0; // nul terminate
 103         }
 104     }
 105
 106     ures_close(brkRules);
 107     ures_close(brkName);
 108
 109     UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status);
 110     if (U_FAILURE(status)) {
 111         ures_close(b);
 112         return NULL;
 113     }
 114
 115     // Create a RuleBasedBreakIterator
 116     result = new RuleBasedBreakIterator(file, status);
 117
 118     // If there is a result, set the valid locale and actual locale, and the kind
 119     if (U_SUCCESS(status) && result != NULL) {
 120         U_LOCALE_BASED(locBased, *(BreakIterator*)result);
 121         locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status),
 122                               actualLocale.data());
 123         result->setBreakType(kind);
 124     }
 125
 126     ures_close(b);
 127
 128     if (U_FAILURE(status) && result != NULL) {  // Sometimes redundant check, but simple
 129         delete result;
 130         return NULL;
 131     }
 132
 133     if (result == NULL) {
 134         udata_close(file);
 135         if (U_SUCCESS(status)) {
 136             status = U_MEMORY_ALLOCATION_ERROR;
 137         }
 138     }
 139
 140     return result;
 141 }
 142
 143 // Creates a break iterator for word breaks.
 144 BreakIterator* U_EXPORT2
 145 BreakIterator::createWordInstance(const Locale& key, UErrorCode& status)
 146 {
 147     return createInstance(key, UBRK_WORD, status);
 148 }
 149
 150 // -------------------------------------
 151
 152 // Creates a break iterator  for line breaks.
 153 BreakIterator* U_EXPORT2
 154 BreakIterator::createLineInstance(const Locale& key, UErrorCode& status)
 155 {
 156     return createInstance(key, UBRK_LINE, status);
 157 }
 158
 159 // -------------------------------------
 160
 161 // Creates a break iterator  for character breaks.
 162 BreakIterator* U_EXPORT2
 163 BreakIterator::createCharacterInstance(const Locale& key, UErrorCode& status)
 164 {
 165     return createInstance(key, UBRK_CHARACTER, status);
 166 }
 167
 168 // -------------------------------------
 169
 170 // Creates a break iterator  for sentence breaks.
 171 BreakIterator* U_EXPORT2
 172 BreakIterator::createSentenceInstance(const Locale& key, UErrorCode& status)
 173 {
 174     return createInstance(key, UBRK_SENTENCE, status);
 175 }
 176
 177 // -------------------------------------
 178
 179 // Creates a break iterator for title casing breaks.
 180 BreakIterator* U_EXPORT2
 181 BreakIterator::createTitleInstance(const Locale& key, UErrorCode& status)
 182 {
 183     return createInstance(key, UBRK_TITLE, status);
 184 }
 185
 186 // -------------------------------------
 187
 188 // Gets all the available locales that has localized text boundary data.
 189 const Locale* U_EXPORT2
 190 BreakIterator::getAvailableLocales(int32_t& count)
 191 {
 192     return Locale::getAvailableLocales(count);
 193 }
 194
 195 // ------------------------------------------
 196 //
 197 // Default constructor and destructor
 198 //
 199 //-------------------------------------------
 200
 201 BreakIterator::BreakIterator()
 202 : fKeepAll(FALSE)
 203 {
 204     *validLocale = *actualLocale = 0;
 205 }
 206
 207 BreakIterator::~BreakIterator()
 208 {
 209 }
 210
 211 // ------------------------------------------
 212 //
 213 // Registration
 214 //
 215 //-------------------------------------------
 216 #if !UCONFIG_NO_SERVICE
 217
 218 // -------------------------------------
 219
 220 class ICUBreakIteratorFactory : public ICUResourceBundleFactory {
 221 public:
 222     virtual ~ICUBreakIteratorFactory();
 223 protected:
 224     virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const {
 225         return BreakIterator::makeInstance(loc, kind, status);
 226     }
 227 };
 228
 229 ICUBreakIteratorFactory::~ICUBreakIteratorFactory() {}
 230
 231 // -------------------------------------
 232
 233 class ICUBreakIteratorService : public ICULocaleService {
 234 public:
 235     ICUBreakIteratorService()
 236         : ICULocaleService(UNICODE_STRING("Break Iterator", 14))
 237     {
 238         UErrorCode status = U_ZERO_ERROR;
 239         registerFactory(new ICUBreakIteratorFactory(), status);
 240     }
 241
 242     virtual ~ICUBreakIteratorService();
 243
 244     virtual UObject* cloneInstance(UObject* instance) const {
 245         return ((BreakIterator*)instance)->clone();
 246     }
 247
 248     virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const {
 249         LocaleKey& lkey = (LocaleKey&)key;
 250         int32_t kind = lkey.kind();
 251         Locale loc;
 252         lkey.currentLocale(loc);
 253         return BreakIterator::makeInstance(loc, kind, status);
 254     }
 255
 256     virtual UBool isDefault() const {
 257         return countFactories() == 1;
 258     }
 259 };
 260
 261 ICUBreakIteratorService::~ICUBreakIteratorService() {}
 262
 263 // -------------------------------------
 264
 265 // defined in ucln_cmn.h
 266 U_NAMESPACE_END
 267
 268 static icu::UInitOnce gInitOnce;
 269 static icu::ICULocaleService* gService = NULL;
 270
 271
 272
 273 /**
 274  * Release all static memory held by breakiterator.
 275  */
 276 U_CDECL_BEGIN
 277 static UBool U_CALLCONV breakiterator_cleanup(void) {
 278 #if !UCONFIG_NO_SERVICE
 279     if (gService) {
 280         delete gService;
 281         gService = NULL;
 282     }
 283     gInitOnce.reset();
 284 #endif
 285     return TRUE;
 286 }
 287 U_CDECL_END
 288 U_NAMESPACE_BEGIN
 289
 290 static void U_CALLCONV
 291 initService(void) {
 292     gService = new ICUBreakIteratorService();
 293     ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);
 294 }
 295
 296 static ICULocaleService*
 297 getService(void)
 298 {
 299     umtx_initOnce(gInitOnce, &initService);
 300     return gService;
 301 }
 302
 303
 304 // -------------------------------------
 305
 306 static inline UBool
 307 hasService(void)
 308 {
 309     return !gInitOnce.isReset() && getService() != NULL;
 310 }
 311
 312 // -------------------------------------
 313
 314 URegistryKey U_EXPORT2
 315 BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status)
 316 {
 317     ICULocaleService *service = getService();
 318     if (service == NULL) {
 319         status = U_MEMORY_ALLOCATION_ERROR;
 320         return NULL;
 321     }
 322     return service->registerInstance(toAdopt, locale, kind, status);
 323 }
 324
 325 // -------------------------------------
 326
 327 UBool U_EXPORT2
 328 BreakIterator::unregister(URegistryKey key, UErrorCode& status)
 329 {
 330     if (U_SUCCESS(status)) {
 331         if (hasService()) {
 332             return gService->unregister(key, status);
 333         }
 334         status = U_MEMORY_ALLOCATION_ERROR;
 335     }
 336     return FALSE;
 337 }
 338
 339 // -------------------------------------
 340
 341 StringEnumeration* U_EXPORT2
 342 BreakIterator::getAvailableLocales(void)
 343 {
 344     ICULocaleService *service = getService();
 345     if (service == NULL) {
 346         return NULL;
 347     }
 348     return service->getAvailableLocales();
 349 }
 350 #endif /* UCONFIG_NO_SERVICE */
 351
 352 // -------------------------------------
 353
 354 BreakIterator*
 355 BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status)
 356 {
 357     if (U_FAILURE(status)) {
 358         return NULL;
 359     }
 360
 361 #if !UCONFIG_NO_SERVICE
 362     if (hasService()) {
 363         Locale actualLoc("");
 364         BreakIterator *result = (BreakIterator*)gService->get(loc, kind, &actualLoc, status);
 365         // TODO: The way the service code works in ICU 2.8 is that if
 366         // there is a real registered break iterator, the actualLoc
 367         // will be populated, but if the handleDefault path is taken
 368         // (because nothing is registered that can handle the
 369         // requested locale) then the actualLoc comes back empty.  In
 370         // that case, the returned object already has its actual/valid
 371         // locale data populated (by makeInstance, which is what
 372         // handleDefault calls), so we don't touch it.  YES, A COMMENT
 373         // THIS LONG is a sign of bad code -- so the action item is to
 374         // revisit this in ICU 3.0 and clean it up/fix it/remove it.
 375         if (U_SUCCESS(status) && (result != NULL) && *actualLoc.getName() != 0) {
 376             U_LOCALE_BASED(locBased, *result);
 377             locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName());
 378         }
 379         return result;
 380     }
 381     else
 382 #endif
 383     {
 384         return makeInstance(loc, kind, status);
 385     }
 386 }
 387
 388 // -------------------------------------
 389 enum { kKeyValueLenMax = 32 };
 390
 391 BreakIterator*
 392 BreakIterator::makeInstance(const Locale& loc, int32_t kind, UErrorCode& status)
 393 {
 394
 395     if (U_FAILURE(status)) {
 396         return NULL;
 397     }
 398     char lbType[kKeyValueLenMax];
 399
 400     BreakIterator *result = NULL;
 401     switch (kind) {
 402     case UBRK_CHARACTER:
 403         result = BreakIterator::buildInstance(loc, "grapheme", kind, status);
 404         break;
 405     case UBRK_WORD:
 406         result = BreakIterator::buildInstance(loc, "word", kind, status);
 407         break;
 408     case UBRK_LINE:
 409         uprv_strcpy(lbType, "line");
 410         {
 411             char lbKeyValue[kKeyValueLenMax] = {0};
 412             UErrorCode kvStatus = U_ZERO_ERROR;
 413             int32_t kLen = loc.getKeywordValue("lb", lbKeyValue, kKeyValueLenMax, kvStatus);
 414             if (U_SUCCESS(kvStatus) && kLen > 0 && (uprv_strcmp(lbKeyValue,"strict")==0 || uprv_strcmp(lbKeyValue,"normal")==0 || uprv_strcmp(lbKeyValue,"loose")==0)) {
 415                 uprv_strcat(lbType, "_");
 416                 uprv_strcat(lbType, lbKeyValue);
 417             }
 418         }
 419         result = BreakIterator::buildInstance(loc, lbType, kind, status);
 420         if (U_SUCCESS(status) && result != NULL) {
 421             char lwKeyValue[kKeyValueLenMax] = {0};
 422             UErrorCode kvStatus = U_ZERO_ERROR;
 423             int32_t kLen = loc.getKeywordValue("lw", lwKeyValue, kKeyValueLenMax, kvStatus);
 424             result->setKeepAll(U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(lwKeyValue,"keepall")==0);
 425         }
 426         break;
 427     case UBRK_SENTENCE:
 428         result = BreakIterator::buildInstance(loc, "sentence", kind, status);
 429         {
 430             char ssKeyValue[kKeyValueLenMax] = {0};
 431             UErrorCode kvStatus = U_ZERO_ERROR;
 432             int32_t kLen = loc.getKeywordValue("ss", ssKeyValue, kKeyValueLenMax, kvStatus);
 433             if (U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(ssKeyValue,"standard")==0) {
 434                 FilteredBreakIteratorBuilder* fbiBuilder = FilteredBreakIteratorBuilder::createInstance(loc, kvStatus);
 435                 if (U_SUCCESS(kvStatus)) {
 436                     result = fbiBuilder->build(result, status);
 437                     delete fbiBuilder;
 438                 }
 439             }
 440         }
 441         break;
 442     case UBRK_TITLE:
 443         result = BreakIterator::buildInstance(loc, "title", kind, status);
 444         break;
 445     default:
 446         status = U_ILLEGAL_ARGUMENT_ERROR;
 447     }
 448
 449     if (U_FAILURE(status)) {
 450         return NULL;
 451     }
 452
 453     return result;
 454 }
 455
 456 Locale
 457 BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
 458     U_LOCALE_BASED(locBased, *this);
 459     return locBased.getLocale(type, status);
 460 }
 461
 462 const char *
 463 BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
 464     U_LOCALE_BASED(locBased, *this);
 465     return locBased.getLocaleID(type, status);
 466 }
 467
 468
 469 // This implementation of getRuleStatus is a do-nothing stub, here to
 470 // provide a default implementation for any derived BreakIterator classes that
 471 // do not implement it themselves.
 472 int32_t BreakIterator::getRuleStatus() const {
 473     return 0;
 474 }
 475
 476 // This implementation of getRuleStatusVec is a do-nothing stub, here to
 477 // provide a default implementation for any derived BreakIterator classes that
 478 // do not implement it themselves.
 479 int32_t BreakIterator::getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status) {
 480     if (U_FAILURE(status)) {
 481         return 0;
 482     }
 483     if (capacity < 1) {
 484         status = U_BUFFER_OVERFLOW_ERROR;
 485         return 1;
 486     }
 487     *fillInVec = 0;
 488     return 1;
 489 }
 490
 491 BreakIterator::BreakIterator (const Locale& valid, const Locale& actual) {
 492   U_LOCALE_BASED(locBased, (*this));
 493   locBased.setLocaleIDs(valid, actual);
 494 }
 495
 496 U_NAMESPACE_END
 497
 498 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */
 499
 500 //eof