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