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