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
51U_NAMESPACE_BEGIN
52
53// -------------------------------------
54
55BreakIterator*
56BreakIterator::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.
145BreakIterator* U_EXPORT2
146BreakIterator::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.
154BreakIterator* U_EXPORT2
155BreakIterator::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.
163BreakIterator* U_EXPORT2
164BreakIterator::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.
172BreakIterator* U_EXPORT2
173BreakIterator::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.
181BreakIterator* U_EXPORT2
182BreakIterator::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.
190const Locale* U_EXPORT2
191BreakIterator::getAvailableLocales(int32_t& count)
192{
193 return Locale::getAvailableLocales(count);
194}
195
196// ------------------------------------------
197//
198// Constructors, destructor and assignment operator
199//
200//-------------------------------------------
201
202BreakIterator::BreakIterator()
203{
204 *validLocale = *actualLocale = 0;
205}
206
207BreakIterator::BreakIterator(const BreakIterator &other) : UObject(other) {
208 uprv_strncpy(actualLocale, other.actualLocale, sizeof(actualLocale));
209 uprv_strncpy(validLocale, other.validLocale, sizeof(validLocale));
210}
211
212BreakIterator &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
220BreakIterator::~BreakIterator()
221{
222}
223
224// ------------------------------------------
225//
226// Registration
227//
228//-------------------------------------------
229#if !UCONFIG_NO_SERVICE
230
231// -------------------------------------
232
233class ICUBreakIteratorFactory : public ICUResourceBundleFactory {
234public:
235 virtual ~ICUBreakIteratorFactory();
236protected:
237 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
242ICUBreakIteratorFactory::~ICUBreakIteratorFactory() {}
243
244// -------------------------------------
245
246class ICUBreakIteratorService : public ICULocaleService {
247public:
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
257 virtual UObject* cloneInstance(UObject* instance) const {
258 return ((BreakIterator*)instance)->clone();
259 }
260
261 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
269 virtual UBool isDefault() const {
270 return countFactories() == 1;
271 }
272};
273
274ICUBreakIteratorService::~ICUBreakIteratorService() {}
275
276// -------------------------------------
277
278// defined in ucln_cmn.h
279U_NAMESPACE_END
280
281static icu::UInitOnce gInitOnceBrkiter = U_INITONCE_INITIALIZER;
282static icu::ICULocaleService* gService = NULL;
283
284
285
286/**
287 * Release all static memory held by breakiterator.
288 */
289U_CDECL_BEGIN
290static 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}
300U_CDECL_END
301U_NAMESPACE_BEGIN
302
303static void U_CALLCONV
304initService(void) {
305 gService = new ICUBreakIteratorService();
306 ucln_common_registerCleanup(UCLN_COMMON_BREAKITERATOR, breakiterator_cleanup);
307}
308
309static ICULocaleService*
310getService(void)
311{
312 umtx_initOnce(gInitOnceBrkiter, &initService);
313 return gService;
314}
315
316
317// -------------------------------------
318
319static inline UBool
320hasService(void)
321{
322 return !gInitOnceBrkiter.isReset() && getService() != NULL;
323}
324
325// -------------------------------------
326
327URegistryKey U_EXPORT2
328BreakIterator::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
340UBool U_EXPORT2
341BreakIterator::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
354StringEnumeration* U_EXPORT2
355BreakIterator::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
367BreakIterator*
368BreakIterator::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// -------------------------------------
402enum { kKeyValueLenMax = 32 };
403
404BreakIterator*
405BreakIterator::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
483Locale
484BreakIterator::getLocale(ULocDataLocaleType type, UErrorCode& status) const {
485 U_LOCALE_BASED(locBased, *this);
486 return locBased.getLocale(type, status);
487}
488
489const char *
490BreakIterator::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.
499int32_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.
506int32_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
518BreakIterator::BreakIterator (const Locale& valid, const Locale& actual) {
519 U_LOCALE_BASED(locBased, (*this));
520 locBased.setLocaleIDs(valid, actual);
521}
522
523U_NAMESPACE_END
524
525#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
526
527//eof
528