| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ******************************************************************************* | |
| * Copyright (C) 1997-2015, International Business Machines Corporation and | |
| * others. All Rights Reserved. | |
| ******************************************************************************* | |
| * | |
| * File brkiter.cpp | |
| * | |
| * Modification History: | |
| * | |
| * Date Name Description | |
| * 02/18/97 aliu Converted from OpenClass. Added DONE. | |
| * 01/13/2000 helena Added UErrorCode parameter to createXXXInstance methods. | |
| ***************************************************************************************** | |
| */ | |
| // ***************************************************************************** | |
| // This file was generated from the java source file BreakIterator.java | |
| // ***************************************************************************** | |
| #include "unicode/ptypes.h" | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_BREAK_ITERATION | |
| #if defined(STARBOARD) | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #endif // defined(STARBOARD) | |
| #include "unicode/rbbi.h" | |
| #include "unicode/brkiter.h" | |
| #include "unicode/udata.h" | |
| #include "unicode/ures.h" | |
| #include "unicode/ustring.h" | |
| #include "unicode/filteredbrk.h" | |
| #include "ucln_cmn.h" | |
| #include "cstring.h" | |
| #include "umutex.h" | |
| #include "servloc.h" | |
| #include "locbased.h" | |
| #include "uresimp.h" | |
| #include "uassert.h" | |
| #include "ubrkimpl.h" | |
| #include "utracimp.h" | |
| #include "charstr.h" | |
| // ***************************************************************************** | |
| // class BreakIterator | |
| // This class implements methods for finding the location of boundaries in text. | |
| // Instances of BreakIterator maintain a current position and scan over text | |
| // returning the index of characters where boundaries occur. | |
| // ***************************************************************************** | |
| U_NAMESPACE_BEGIN | |
| // ------------------------------------- | |
| BreakIterator* | |
| BreakIterator::buildInstance(const Locale& loc, const char *type, UErrorCode &status) | |
| { | |
| char fnbuff[256]; | |
| char ext[4]={'\0'}; | |
| CharString actualLocale; | |
| int32_t size; | |
| const UChar* brkfname = NULL; | |
| UResourceBundle brkRulesStack; | |
| UResourceBundle brkNameStack; | |
| UResourceBundle *brkRules = &brkRulesStack; | |
| UResourceBundle *brkName = &brkNameStack; | |
| RuleBasedBreakIterator *result = NULL; | |
| if (U_FAILURE(status)) | |
| return NULL; | |
| ures_initStackObject(brkRules); | |
| ures_initStackObject(brkName); | |
| // Get the locale | |
| UResourceBundle *b = ures_openNoDefault(U_ICUDATA_BRKITR, loc.getName(), &status); | |
| // Get the "boundaries" array. | |
| if (U_SUCCESS(status)) { | |
| brkRules = ures_getByKeyWithFallback(b, "boundaries", brkRules, &status); | |
| // Get the string object naming the rules file | |
| brkName = ures_getByKeyWithFallback(brkRules, type, brkName, &status); | |
| // Get the actual string | |
| brkfname = ures_getString(brkName, &size, &status); | |
| U_ASSERT((size_t)size<sizeof(fnbuff)); | |
| if ((size_t)size>=sizeof(fnbuff)) { | |
| size=0; | |
| if (U_SUCCESS(status)) { | |
| status = U_BUFFER_OVERFLOW_ERROR; | |
| } | |
| } | |
| // Use the string if we found it | |
| if (U_SUCCESS(status) && brkfname) { | |
| actualLocale.append(ures_getLocaleInternal(brkName, &status), -1, status); | |
| UChar* extStart=u_strchr(brkfname, 0x002e); | |
| int len = 0; | |
| if(extStart!=NULL){ | |
| len = (int)(extStart-brkfname); | |
| u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff | |
| u_UCharsToChars(brkfname, fnbuff, len); | |
| } | |
| fnbuff[len]=0; // nul terminate | |
| } | |
| } | |
| ures_close(brkRules); | |
| ures_close(brkName); | |
| UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status); | |
| if (U_FAILURE(status)) { | |
| ures_close(b); | |
| return NULL; | |
| } | |
| // Create a RuleBasedBreakIterator | |
| result = new RuleBasedBreakIterator(file, status); | |
| // If there is a result, set the valid locale and actual locale, and the kind | |
| if (U_SUCCESS(status) && result != NULL) { | |
| U_LOCALE_BASED(locBased, *(BreakIterator*)result); | |
| locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), | |
| actualLocale.data()); | |
| } | |
| ures_close(b); | |
| if (U_FAILURE(status) && result != NULL) { // Sometimes redundant check, but simple | |
| delete result; | |
| return NULL; | |
| } | |
| if (result == NULL) { | |
| udata_close(file); | |
| if (U_SUCCESS(status)) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| } | |
| return result; | |
| } | |
| // Creates a break iterator for word breaks. | |
| BreakIterator* U_EXPORT2 | |
| BreakIterator::createWordInstance(const Locale& key, UErrorCode& status) | |
| { | |
| return createInstance(key, UBRK_WORD, status); | |
| } | |
| // ------------------------------------- | |
| // Creates a break iterator for line breaks. | |
| BreakIterator* U_EXPORT2 | |
| BreakIterator::createLineInstance(const Locale& key, UErrorCode& status) | |
| { | |
| return createInstance(key, UBRK_LINE, status); | |
| } | |
| // ------------------------------------- | |
| // Creates a break iterator for character breaks. | |
| BreakIterator* U_EXPORT2 | |
| BreakIterator::createCharacterInstance(const Locale& key, UErrorCode& status) | |
| { | |
| return createInstance(key, UBRK_CHARACTER, status); | |
| } | |
| // ------------------------------------- | |
| // Creates a break iterator for sentence breaks. | |
| BreakIterator* U_EXPORT2 | |
| BreakIterator::createSentenceInstance(const Locale& key, UErrorCode& status) | |
| { | |
| return createInstance(key, UBRK_SENTENCE, status); | |
| } | |
| // ------------------------------------- | |
| // Creates a break iterator for title casing breaks. | |
| BreakIterator* U_EXPORT2 | |
| BreakIterator::createTitleInstance(const Locale& key, UErrorCode& status) | |
| { | |
| return createInstance(key, UBRK_TITLE, status); | |
| } | |
| // ------------------------------------- | |
| // Gets all the available locales that has localized text boundary data. | |
| const Locale* U_EXPORT2 | |
| BreakIterator::getAvailableLocales(int32_t& count) | |
| { | |
| return Locale::getAvailableLocales(count); | |
| } | |
| // ------------------------------------------ | |
| // | |
| // Constructors, destructor and assignment operator | |
| // | |
| //------------------------------------------- | |
| BreakIterator::BreakIterator() | |
| { | |
| *validLocale = *actualLocale = 0; | |
| } | |
| BreakIterator::BreakIterator(const BreakIterator &other) : UObject(other) { | |
| uprv_strncpy(actualLocale, other.actualLocale, sizeof(actualLocale)); | |
| uprv_strncpy(validLocale, other.validLocale, sizeof(validLocale)); | |
| } | |
| BreakIterator &BreakIterator::operator =(const BreakIterator &other) { | |
| if (this != &other) { | |
| uprv_strncpy(actualLocale, other.actualLocale, sizeof(actualLocale)); | |
| uprv_strncpy(validLocale, other.validLocale, sizeof(validLocale)); | |
| } | |
| return *this; | |
| } | |
| BreakIterator::~BreakIterator() | |
| { | |
| } | |
| // ------------------------------------------ | |
| // | |
| // Registration | |
| // | |
| //------------------------------------------- | |
| #if !UCONFIG_NO_SERVICE | |
| // ------------------------------------- | |
| class ICUBreakIteratorFactory : public ICUResourceBundleFactory { | |
| public: | |
| virtual ~ICUBreakIteratorFactory(); | |
| protected: | |
| virtual UObject* handleCreate(const Locale& loc, int32_t kind, const ICUService* /*service*/, UErrorCode& status) const { | |
| return BreakIterator::makeInstance(loc, kind, status); | |
| } | |
| }; | |
| ICUBreakIteratorFactory::~ICUBreakIteratorFactory() {} | |
| // ------------------------------------- | |
| class ICUBreakIteratorService : public ICULocaleService { | |
| public: | |
| ICUBreakIteratorService() | |
| : ICULocaleService(UNICODE_STRING("Break Iterator", 14)) | |
| { | |
| UErrorCode status = U_ZERO_ERROR; | |
| registerFactory(new ICUBreakIteratorFactory(), status); | |
| } | |
| virtual ~ICUBreakIteratorService(); | |
| virtual UObject* cloneInstance(UObject* instance) const { | |
| return ((BreakIterator*)instance)->clone(); | |
| } | |
| virtual UObject* handleDefault(const ICUServiceKey& key, UnicodeString* /*actualID*/, UErrorCode& status) const { | |
| LocaleKey& lkey = (LocaleKey&)key; | |
| int32_t kind = lkey.kind(); | |
| Locale loc; | |
| lkey.currentLocale(loc); | |
| return BreakIterator::makeInstance(loc, kind, status); | |
| } | |
| virtual UBool isDefault() const { | |
| return countFactories() == 1; | |
| } | |
| }; | |
| ICUBreakIteratorService::~ICUBreakIteratorService() {} | |
| // ------------------------------------- | |
| // defined in ucln_cmn.h | |
| U_NAMESPACE_END | |
| static icu::UInitOnce gInitOnceBrkiter = U_INITONCE_INITIALIZER; | |
| static icu::ICULocaleService* gService = NULL; | |
| /** | |
| * Release all static memory held by breakiterator. | |
| */ | |
| U_CDECL_BEGIN | |
| static UBool U_CALLCONV breakiterator_cleanup(void) { | |
| #if !UCONFIG_NO_SERVICE | |
| if (gService) { | |
| delete gService; | |
| gService = NULL; | |
| } | |
| gInitOnceBrkiter.reset(); | |
| #endif | |
| return TRUE; | |
| } | |
| U_CDECL_END | |
| U_NAMESPACE_BEGIN | |
| static void U_CALLCONV | |
| initService(void) { | |
| gService = new ICUBreakIteratorService(); | |
| ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup); | |
| } | |
| static ICULocaleService* | |
| getService(void) | |
| { | |
| umtx_initOnce(gInitOnceBrkiter, &initService); | |
| return gService; | |
| } | |
| // ------------------------------------- | |
| static inline UBool | |
| hasService(void) | |
| { | |
| return !gInitOnceBrkiter.isReset() && getService() != NULL; | |
| } | |
| // ------------------------------------- | |
| URegistryKey U_EXPORT2 | |
| BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status) | |
| { | |
| ICULocaleService *service = getService(); | |
| if (service == NULL) { | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| return NULL; | |
| } | |
| return service->registerInstance(toAdopt, locale, kind, status); | |
| } | |
| // ------------------------------------- | |
| UBool U_EXPORT2 | |
| BreakIterator::unregister(URegistryKey key, UErrorCode& status) | |
| { | |
| if (U_SUCCESS(status)) { | |
| if (hasService()) { | |
| return gService->unregister(key, status); | |
| } | |
| status = U_MEMORY_ALLOCATION_ERROR; | |
| } | |
| return FALSE; | |
| } | |
| // ------------------------------------- | |
| StringEnumeration* U_EXPORT2 | |
| BreakIterator::getAvailableLocales(void) | |
| { | |
| ICULocaleService *service = getService(); | |
| if (service == NULL) { | |
| return NULL; | |
| } | |
| return service->getAvailableLocales(); | |
| } | |
| #endif /* UCONFIG_NO_SERVICE */ | |
| // ------------------------------------- | |
| BreakIterator* | |
| BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status) | |
| { | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| #if !UCONFIG_NO_SERVICE | |
| if (hasService()) { | |
| Locale actualLoc(""); | |
| BreakIterator *result = (BreakIterator*)gService->get(loc, kind, &actualLoc, status); | |
| // TODO: The way the service code works in ICU 2.8 is that if | |
| // there is a real registered break iterator, the actualLoc | |
| // will be populated, but if the handleDefault path is taken | |
| // (because nothing is registered that can handle the | |
| // requested locale) then the actualLoc comes back empty. In | |
| // that case, the returned object already has its actual/valid | |
| // locale data populated (by makeInstance, which is what | |
| // handleDefault calls), so we don't touch it. YES, A COMMENT | |
| // THIS LONG is a sign of bad code -- so the action item is to | |
| // revisit this in ICU 3.0 and clean it up/fix it/remove it. | |
| if (U_SUCCESS(status) && (result != NULL) && *actualLoc.getName() != 0) { | |
| U_LOCALE_BASED(locBased, *result); | |
| locBased.setLocaleIDs(actualLoc.getName(), actualLoc.getName()); | |
| } | |
| return result; | |
| } | |
| else | |
| #endif | |
| { | |
| return makeInstance(loc, kind, status); | |
| } | |
| } | |
| // ------------------------------------- | |
| enum { kKeyValueLenMax = 32 }; | |
| BreakIterator* | |
| BreakIterator::makeInstance(const Locale& loc, int32_t kind, UErrorCode& status) | |
| { | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| char lbType[kKeyValueLenMax]; | |
| BreakIterator *result = NULL; | |
| switch (kind) { | |
| case UBRK_CHARACTER: | |
| { | |
| UTRACE_ENTRY(UTRACE_UBRK_CREATE_CHARACTER); | |
| result = BreakIterator::buildInstance(loc, "grapheme", status); | |
| UTRACE_EXIT_STATUS(status); | |
| } | |
| break; | |
| case UBRK_WORD: | |
| { | |
| UTRACE_ENTRY(UTRACE_UBRK_CREATE_WORD); | |
| result = BreakIterator::buildInstance(loc, "word", status); | |
| UTRACE_EXIT_STATUS(status); | |
| } | |
| break; | |
| case UBRK_LINE: | |
| { | |
| UTRACE_ENTRY(UTRACE_UBRK_CREATE_LINE); | |
| uprv_strcpy(lbType, "line"); | |
| char lbKeyValue[kKeyValueLenMax] = {0}; | |
| UErrorCode kvStatus = U_ZERO_ERROR; | |
| int32_t kLen = loc.getKeywordValue("lb", lbKeyValue, kKeyValueLenMax, kvStatus); | |
| if (U_SUCCESS(kvStatus) && kLen > 0 && (uprv_strcmp(lbKeyValue,"strict")==0 || uprv_strcmp(lbKeyValue,"normal")==0 || uprv_strcmp(lbKeyValue,"loose")==0)) { | |
| uprv_strcat(lbType, "_"); | |
| uprv_strcat(lbType, lbKeyValue); | |
| } | |
| result = BreakIterator::buildInstance(loc, lbType, status); | |
| UTRACE_DATA1(UTRACE_INFO, "lb=%s", lbKeyValue); | |
| UTRACE_EXIT_STATUS(status); | |
| } | |
| break; | |
| case UBRK_SENTENCE: | |
| { | |
| UTRACE_ENTRY(UTRACE_UBRK_CREATE_SENTENCE); | |
| result = BreakIterator::buildInstance(loc, "sentence", status); | |
| #if !UCONFIG_NO_FILTERED_BREAK_ITERATION | |
| char ssKeyValue[kKeyValueLenMax] = {0}; | |
| UErrorCode kvStatus = U_ZERO_ERROR; | |
| int32_t kLen = loc.getKeywordValue("ss", ssKeyValue, kKeyValueLenMax, kvStatus); | |
| if (U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(ssKeyValue,"standard")==0) { | |
| FilteredBreakIteratorBuilder* fbiBuilder = FilteredBreakIteratorBuilder::createInstance(loc, kvStatus); | |
| if (U_SUCCESS(kvStatus)) { | |
| result = fbiBuilder->build(result, status); | |
| delete fbiBuilder; | |
| } | |
| } | |
| #endif | |
| UTRACE_EXIT_STATUS(status); | |
| } | |
| break; | |
| case UBRK_TITLE: | |
| { | |
| UTRACE_ENTRY(UTRACE_UBRK_CREATE_TITLE); | |
| result = BreakIterator::buildInstance(loc, "title", status); | |
| UTRACE_EXIT_STATUS(status); | |
| } | |
| break; | |
| default: | |
| status = U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| if (U_FAILURE(status)) { | |
| return NULL; | |
| } | |
| return result; | |
| } | |
| Locale | |
| BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const { | |
| U_LOCALE_BASED(locBased, *this); | |
| return locBased.getLocale(type, status); | |
| } | |
| const char * | |
| BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const { | |
| U_LOCALE_BASED(locBased, *this); | |
| return locBased.getLocaleID(type, status); | |
| } | |
| // This implementation of getRuleStatus is a do-nothing stub, here to | |
| // provide a default implementation for any derived BreakIterator classes that | |
| // do not implement it themselves. | |
| int32_t BreakIterator::getRuleStatus() const { | |
| return 0; | |
| } | |
| // This implementation of getRuleStatusVec is a do-nothing stub, here to | |
| // provide a default implementation for any derived BreakIterator classes that | |
| // do not implement it themselves. | |
| int32_t BreakIterator::getRuleStatusVec(int32_t *fillInVec, int32_t capacity, UErrorCode &status) { | |
| if (U_FAILURE(status)) { | |
| return 0; | |
| } | |
| if (capacity < 1) { | |
| status = U_BUFFER_OVERFLOW_ERROR; | |
| return 1; | |
| } | |
| *fillInVec = 0; | |
| return 1; | |
| } | |
| BreakIterator::BreakIterator (const Locale& valid, const Locale& actual) { | |
| U_LOCALE_BASED(locBased, (*this)); | |
| locBased.setLocaleIDs(valid, actual); | |
| } | |
| U_NAMESPACE_END | |
| #endif /* #if !UCONFIG_NO_BREAK_ITERATION */ | |
| //eof |