+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
-* Copyright (C) 1997-2006, International Business Machines Corporation and *
-* others. All Rights Reserved. *
+* Copyright (C) 1997-2015, International Business Machines Corporation and
+* others. All Rights Reserved.
*******************************************************************************
*
-* File TXTBDRY.CPP
+* File brkiter.cpp
*
* Modification History:
*
#include "unicode/udata.h"
#include "unicode/ures.h"
#include "unicode/ustring.h"
+#include "unicode/filteredbrk.h"
#include "ucln_cmn.h"
#include "cstring.h"
-#include "mutex.h"
+#include "umutex.h"
#include "servloc.h"
#include "locbased.h"
#include "uresimp.h"
#include "uassert.h"
#include "ubrkimpl.h"
+#include "charstr.h"
// *****************************************************************************
// class BreakIterator
// -------------------------------------
BreakIterator*
-BreakIterator::buildInstance(const Locale& loc, const char *type, int32_t kind, UErrorCode &status)
+BreakIterator::buildInstance(const Locale& loc, const char *type, UErrorCode &status)
{
char fnbuff[256];
char ext[4]={'\0'};
- char actualLocale[ULOC_FULLNAME_CAPACITY];
+ CharString actualLocale;
int32_t size;
const UChar* brkfname = NULL;
UResourceBundle brkRulesStack;
UResourceBundle *brkRules = &brkRulesStack;
UResourceBundle *brkName = &brkNameStack;
RuleBasedBreakIterator *result = NULL;
-
+
if (U_FAILURE(status))
return NULL;
ures_initStackObject(brkName);
// Get the locale
- UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, loc.getName(), &status);
- /* this is a hack for now. Should be fixed when the data is fetched from
- brk_index.txt */
- if(status==U_USING_DEFAULT_WARNING){
- status=U_ZERO_ERROR;
- ures_openFillIn(b, U_ICUDATA_BRKITR, "", &status);
- }
+ UResourceBundle *b = ures_openNoDefault(U_ICUDATA_BRKITR, loc.getName(), &status);
// Get the "boundaries" array.
if (U_SUCCESS(status)) {
// Use the string if we found it
if (U_SUCCESS(status) && brkfname) {
- uprv_strncpy(actualLocale,
- ures_getLocale(brkName, &status),
- sizeof(actualLocale)/sizeof(actualLocale[0]));
-
+ actualLocale.append(ures_getLocaleInternal(brkName, &status), -1, status);
+
UChar* extStart=u_strchr(brkfname, 0x002e);
int len = 0;
if(extStart!=NULL){
- len = extStart-brkfname;
+ len = (int)(extStart-brkfname);
u_UCharsToChars(extStart+1, ext, sizeof(ext)); // nul terminates the buff
u_UCharsToChars(brkfname, fnbuff, len);
}
ures_close(brkRules);
ures_close(brkName);
-
+
UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status);
if (U_FAILURE(status)) {
ures_close(b);
// 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, *result);
- locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), actualLocale);
- result->setBreakType(kind);
+ 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;
return Locale::getAvailableLocales(count);
}
-// -------------------------------------
-// Gets the objectLocale display name in the default locale language.
-UnicodeString& U_EXPORT2
-BreakIterator::getDisplayName(const Locale& objectLocale,
- UnicodeString& name)
-{
- return objectLocale.getDisplayName(name);
-}
-
-// -------------------------------------
-// Gets the objectLocale display name in the displayLocale language.
-UnicodeString& U_EXPORT2
-BreakIterator::getDisplayName(const Locale& objectLocale,
- const Locale& displayLocale,
- UnicodeString& name)
-{
- return objectLocale.getDisplayName(displayLocale, name);
-}
-
// ------------------------------------------
//
-// Default constructor and destructor
+// Constructors, destructor and assignment operator
//
//-------------------------------------------
BreakIterator::BreakIterator()
+: fLineWordOpts(UBRK_LINEWORD_NORMAL)
{
- fBufferClone = FALSE;
*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()
{
}
//-------------------------------------------
#if !UCONFIG_NO_SERVICE
-static ICULocaleService* gService = NULL;
-
// -------------------------------------
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 {
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();
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
-// defined in ucln_cmn.h
+static icu::UInitOnce gInitOnceBrkiter = U_INITONCE_INITIALIZER;
+static icu::ICULocaleService* gService = NULL;
+
+
/**
- * Release all static memory held by breakiterator.
+ * Release all static memory held by breakiterator.
*/
U_CDECL_BEGIN
static UBool U_CALLCONV breakiterator_cleanup(void) {
delete gService;
gService = NULL;
}
+ gInitOnceBrkiter.reset();
#endif
return TRUE;
}
U_CDECL_END
U_NAMESPACE_BEGIN
-static ICULocaleService*
+static void U_CALLCONV
+initService(void) {
+ gService = new ICUBreakIteratorService();
+ ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);
+}
+
+static ICULocaleService*
getService(void)
{
- UBool needsInit;
- umtx_lock(NULL);
- needsInit = (UBool)(gService == NULL);
- umtx_unlock(NULL);
-
- if (needsInit) {
- ICULocaleService *tService = new ICUBreakIteratorService();
- umtx_lock(NULL);
- if (gService == NULL) {
- gService = tService;
- tService = NULL;
- ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);
- }
- umtx_unlock(NULL);
- delete tService;
- }
+ umtx_initOnce(gInitOnceBrkiter, &initService);
return gService;
}
+
// -------------------------------------
-static UBool
-hasService(void)
+static inline UBool
+hasService(void)
{
- Mutex mutex;
- return gService != NULL;
+ return !gInitOnceBrkiter.isReset() && getService() != NULL;
}
// -------------------------------------
URegistryKey U_EXPORT2
-BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status)
+BreakIterator::registerInstance(BreakIterator* toAdopt, const Locale& locale, UBreakIteratorType kind, UErrorCode& status)
{
- return getService()->registerInstance(toAdopt, locale, kind, 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)
+BreakIterator::unregister(URegistryKey key, UErrorCode& status)
{
if (U_SUCCESS(status)) {
if (hasService()) {
return gService->unregister(key, status);
}
- status = U_ILLEGAL_ARGUMENT_ERROR;
+ status = U_MEMORY_ALLOCATION_ERROR;
}
return FALSE;
}
StringEnumeration* U_EXPORT2
BreakIterator::getAvailableLocales(void)
{
- return getService()->getAvailableLocales();
+ ICULocaleService *service = getService();
+ if (service == NULL) {
+ return NULL;
+ }
+ return service->getAvailableLocales();
}
#endif /* UCONFIG_NO_SERVICE */
if (U_FAILURE(status)) {
return NULL;
}
-
- u_init(&status);
+
#if !UCONFIG_NO_SERVICE
if (hasService()) {
Locale actualLoc("");
}
// -------------------------------------
+enum { kKeyValueLenMax = 32 };
-BreakIterator*
+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:
- result = BreakIterator::buildInstance(loc, "grapheme", kind, status);
+ case UBRK_CHARACTER:
+ result = BreakIterator::buildInstance(loc, "grapheme", status);
break;
case UBRK_WORD:
- result = BreakIterator::buildInstance(loc, "word", kind, status);
+ result = BreakIterator::buildInstance(loc, "word", status);
break;
case UBRK_LINE:
- result = BreakIterator::buildInstance(loc, "line", kind, status);
+ 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);
+ if (U_SUCCESS(status) && result != NULL) {
+ char lwKeyValue[kKeyValueLenMax] = {0};
+ UErrorCode kvStatus = U_ZERO_ERROR;
+ int32_t kLen = loc.getKeywordValue("lw", lwKeyValue, kKeyValueLenMax, kvStatus);
+ ULineWordOptions lineWordOpts = UBRK_LINEWORD_NORMAL;
+ if (U_SUCCESS(kvStatus) && kLen > 0) {
+ if (uprv_strcmp(lwKeyValue,"keepall")==0 || uprv_strcmp(lwKeyValue,"keep-all")==0) {
+ lineWordOpts = UBRK_LINEWORD_KEEP_ALL;
+ } else if (uprv_strcmp(lwKeyValue,"keep-hangul")==0) {
+ lineWordOpts = UBRK_LINEWORD_KEEP_HANGUL;
+ }
+ }
+ result->setLineWordOpts(lineWordOpts);
+ ((RuleBasedBreakIterator *)result)->setCategoryOverrides(loc); // <rdar://problem/51193810>
+ }
break;
case UBRK_SENTENCE:
- result = BreakIterator::buildInstance(loc, "sentence", kind, status);
+ 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
break;
case UBRK_TITLE:
- result = BreakIterator::buildInstance(loc, "title", kind, status);
+ result = BreakIterator::buildInstance(loc, "title", status);
break;
default:
status = U_ILLEGAL_ARGUMENT_ERROR;
return result;
}
-Locale
+Locale
BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
U_LOCALE_BASED(locBased, *this);
return locBased.getLocale(type, status);
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 */
projects / apple / icu.git / blobdiff