X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/374ca955a76ecab1204ca8bfa63ff9238d998416..ef6cf650f4a75c3f97de06b51fa104f2069b9ea2:/icuSources/common/brkiter.cpp?ds=inline

diff --git a/icuSources/common/brkiter.cpp b/icuSources/common/brkiter.cpp
index 835711d4..065e6df9 100644
--- a/icuSources/common/brkiter.cpp
+++ b/icuSources/common/brkiter.cpp
@@ -1,10 +1,10 @@
 /*
 *******************************************************************************
-* Copyright (C) 1997-2004, International Business Machines Corporation and    *
-* others. All Rights Reserved.                                                *
+* Copyright (C) 1997-2016, International Business Machines Corporation and
+* others. All Rights Reserved.
 *******************************************************************************
 *
-* File TXTBDRY.CPP
+* File brkiter.cpp
 *
 * Modification History:
 *
@@ -22,16 +22,22 @@
 
 #if !UCONFIG_NO_BREAK_ITERATION
 
-#include "unicode/dbbi.h"
+#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 "mutex.h"
-#include "iculserv.h"
+#include "umutex.h"
+#include "servloc.h"
 #include "locbased.h"
 #include "uresimp.h"
+#include "uassert.h"
+#include "ubrkimpl.h"
+#include "charstr.h"
+#include "unicode/filteredbrk.h"
 
 // *****************************************************************************
 // class BreakIterator
@@ -42,21 +48,22 @@
 
 U_NAMESPACE_BEGIN
 
-const int32_t BreakIterator::DONE = (int32_t)-1;
-
 // -------------------------------------
 
 BreakIterator*
-BreakIterator::buildInstance(const Locale& loc, const char *type, UBool dict, UErrorCode &status)
+BreakIterator::buildInstance(const Locale& loc, const char *type, int32_t kind, UErrorCode &status)
 {
     char fnbuff[256];
-    char actualLocale[ULOC_FULLNAME_CAPACITY];
+    char ext[4]={'\0'};
+    CharString actualLocale;
     int32_t size;
     const UChar* brkfname = NULL;
-    UResourceBundle brkRulesStack, brkNameStack;
-    UResourceBundle *brkRules = &brkRulesStack, *brkName = &brkNameStack;
-    BreakIterator *result = NULL;
-    
+    UResourceBundle brkRulesStack;
+    UResourceBundle brkNameStack;
+    UResourceBundle *brkRules = &brkRulesStack;
+    UResourceBundle *brkName  = &brkNameStack;
+    RuleBasedBreakIterator *result = NULL;
+
     if (U_FAILURE(status))
         return NULL;
 
@@ -64,7 +71,7 @@ BreakIterator::buildInstance(const Locale& loc, const char *type, UBool dict, UE
     ures_initStackObject(brkName);
 
     // Get the locale
-    UResourceBundle *b = ures_open(NULL, loc.getName(), &status);
+    UResourceBundle *b = ures_openNoDefault(U_ICUDATA_BRKITR, loc.getName(), &status);
 
     // Get the "boundaries" array.
     if (U_SUCCESS(status)) {
@@ -73,61 +80,51 @@ BreakIterator::buildInstance(const Locale& loc, const char *type, UBool dict, UE
         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) {
-            uprv_strncpy(actualLocale,
-                ures_getLocale(brkName, &status),
-                sizeof(actualLocale)/sizeof(actualLocale[0]));
-            u_UCharsToChars(brkfname, fnbuff, size+1);
+            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(NULL, "brk", fnbuff, &status);
+
+    UDataMemory* file = udata_open(U_ICUDATA_BRKITR, ext, fnbuff, &status);
     if (U_FAILURE(status)) {
         ures_close(b);
         return NULL;
     }
 
-    // We found the break rules; now see if a dictionary is needed
-    if (dict)
-    {
-        UErrorCode localStatus = U_ZERO_ERROR;
-        brkName = &brkNameStack;
-        ures_initStackObject(brkName);
-        brkName = ures_getByKeyWithFallback(b, "BreakDictionaryData", brkName, &localStatus);
-#if 0
-        if (U_SUCCESS(localStatus)) {
-            brkfname = ures_getString(&brkname, &size, &localStatus);
-        }
-#endif
-        if (U_SUCCESS(localStatus)) {
-#if 0
-            u_UCharsToChars(brkfname, fnbuff, size);
-            fnbuff[size] = '\0';
-#endif
-            result = new DictionaryBasedBreakIterator(file, "thaidict.brk", status);
-        }
-        ures_close(brkName);
-    }
-    
-    // If there is still no result but we haven't had an error, no dictionary,
-    // so make a non-dictionary break iterator
-    if (U_SUCCESS(status) && result == NULL) {
-        result = new RuleBasedBreakIterator(file, status);
-    }
+    // Create a RuleBasedBreakIterator
+    result = new RuleBasedBreakIterator(file, status);
 
-    // If there is a result, set the valid locale and actual locale
+    // 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);
+        U_LOCALE_BASED(locBased, *(BreakIterator*)result);
+        locBased.setLocaleIDs(ures_getLocaleByType(b, ULOC_VALID_LOCALE, &status), 
+                              actualLocale.data());
+        result->setBreakType(kind);
     }
 
     ures_close(b);
-    
+
     if (U_FAILURE(status) && result != NULL) {  // Sometimes redundant check, but simple
         delete result;
         return NULL;
@@ -195,25 +192,6 @@ BreakIterator::getAvailableLocales(int32_t& count)
     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
@@ -221,8 +199,8 @@ BreakIterator::getDisplayName(const Locale& objectLocale,
 //-------------------------------------------
 
 BreakIterator::BreakIterator()
+: fKeepAll(FALSE)
 {
-    fBufferClone = FALSE;
     *validLocale = *actualLocale = 0;
 }
 
@@ -237,17 +215,19 @@ 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 {
@@ -258,11 +238,13 @@ public:
         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();
@@ -270,20 +252,26 @@ public:
         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 gInitOnce;
+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) {
@@ -292,61 +280,58 @@ static UBool U_CALLCONV breakiterator_cleanup(void) {
         delete gService;
         gService = NULL;
     }
+    gInitOnce.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(gInitOnce, &initService);
     return gService;
 }
 
+
 // -------------------------------------
 
-static UBool
-hasService(void) 
+static inline UBool
+hasService(void)
 {
-    Mutex mutex;
-    return gService != NULL;
+    return !gInitOnce.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;
 }
@@ -356,23 +341,26 @@ BreakIterator::unregister(URegistryKey key, UErrorCode& status)
 StringEnumeration* U_EXPORT2
 BreakIterator::getAvailableLocales(void)
 {
-  return getService()->getAvailableLocales();
+    ICULocaleService *service = getService();
+    if (service == NULL) {
+        return NULL;
+    }
+    return service->getAvailableLocales();
 }
 #endif /* UCONFIG_NO_SERVICE */
 
 // -------------------------------------
 
 BreakIterator*
-BreakIterator::createInstance(const Locale& loc, UBreakIteratorType kind, UErrorCode& status)
+BreakIterator::createInstance(const Locale& loc, int32_t kind, UErrorCode& status)
 {
     if (U_FAILURE(status)) {
         return NULL;
     }
-    
-    u_init(&status);
+
 #if !UCONFIG_NO_SERVICE
     if (hasService()) {
-        Locale actualLoc;
+        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
@@ -398,31 +386,61 @@ BreakIterator::createInstance(const Locale& loc, UBreakIteratorType kind, UError
 }
 
 // -------------------------------------
+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", FALSE, status);
+    case UBRK_CHARACTER:
+        result = BreakIterator::buildInstance(loc, "grapheme", kind, status);
         break;
     case UBRK_WORD:
-        result = BreakIterator::buildInstance(loc, "word", TRUE, status);
+        result = BreakIterator::buildInstance(loc, "word", kind, status);
         break;
     case UBRK_LINE:
-        result = BreakIterator::buildInstance(loc, "line", TRUE, 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, kind, 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);
+            result->setKeepAll(U_SUCCESS(kvStatus) && kLen > 0 && uprv_strcmp(lwKeyValue,"keepall")==0);
+        }
         break;
     case UBRK_SENTENCE:
-        result = BreakIterator::buildInstance(loc, "sentence", FALSE, status);
+        result = BreakIterator::buildInstance(loc, "sentence", kind, status);
+        {
+            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;
+                }
+            }
+        }
         break;
     case UBRK_TITLE:
-        result = BreakIterator::buildInstance(loc, "title", FALSE, status);
+        result = BreakIterator::buildInstance(loc, "title", kind, status);
         break;
     default:
         status = U_ILLEGAL_ARGUMENT_ERROR;
@@ -435,7 +453,7 @@ BreakIterator::makeInstance(const Locale& loc, int32_t kind, UErrorCode& status)
     return result;
 }
 
-Locale 
+Locale
 BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
     U_LOCALE_BASED(locBased, *this);
     return locBased.getLocale(type, status);
@@ -447,6 +465,34 @@ BreakIterator::getLocaleID(ULocDataLocaleType type, UErrorCode& status) const {
     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 */