1 /*
2 ********************************************************************************
3 * Copyright (C) 1996-2008, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 ********************************************************************************
6 */
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_BREAK_ITERATION
11
12 #include "unicode/ubrk.h"
13
14 #include "unicode/brkiter.h"
15 #include "unicode/uloc.h"
16 #include "unicode/ustring.h"
17 #include "unicode/uchriter.h"
18 #include "unicode/rbbi.h"
19 #include "rbbirb.h"
20 #include "uassert.h"
21
22 U_NAMESPACE_USE
23
24 //------------------------------------------------------------------------------
25 //
26 // ubrk_open Create a canned type of break iterator based on type (word, line, etc.)
27 // and locale.
28 //
29 //------------------------------------------------------------------------------
30 U_CAPI UBreakIterator* U_EXPORT2
ubrk_open(UBreakIteratorType type,const char * locale,const UChar * text,int32_t textLength,UErrorCode * status)31 ubrk_open(UBreakIteratorType type,
32 const char *locale,
33 const UChar *text,
34 int32_t textLength,
35 UErrorCode *status)
36 {
37
38 if(U_FAILURE(*status)) return 0;
39
40 BreakIterator *result = 0;
41
42 switch(type) {
43
44 case UBRK_CHARACTER:
45 result = BreakIterator::createCharacterInstance(Locale(locale), *status);
46 break;
47
48 case UBRK_WORD:
49 result = BreakIterator::createWordInstance(Locale(locale), *status);
50 break;
51
52 case UBRK_LINE:
53 result = BreakIterator::createLineInstance(Locale(locale), *status);
54 break;
55
56 case UBRK_SENTENCE:
57 result = BreakIterator::createSentenceInstance(Locale(locale), *status);
58 break;
59
60 case UBRK_TITLE:
61 result = BreakIterator::createTitleInstance(Locale(locale), *status);
62 break;
63
64 default:
65 *status = U_ILLEGAL_ARGUMENT_ERROR;
66 }
67
68 // check for allocation error
69 if (U_FAILURE(*status)) {
70 return 0;
71 }
72 if(result == 0) {
73 *status = U_MEMORY_ALLOCATION_ERROR;
74 return 0;
75 }
76
77
78 UBreakIterator *uBI = (UBreakIterator *)result;
79 if (text != NULL) {
80 ubrk_setText(uBI, text, textLength, status);
81 }
82 return uBI;
83 }
84
85
86
87 //------------------------------------------------------------------------------
88 //
89 // ubrk_openRules open a break iterator from a set of break rules.
90 // Invokes the rule builder.
91 //
92 //------------------------------------------------------------------------------
93 U_CAPI UBreakIterator* U_EXPORT2
ubrk_openRules(const UChar * rules,int32_t rulesLength,const UChar * text,int32_t textLength,UParseError * parseErr,UErrorCode * status)94 ubrk_openRules( const UChar *rules,
95 int32_t rulesLength,
96 const UChar *text,
97 int32_t textLength,
98 UParseError *parseErr,
99 UErrorCode *status) {
100
101 if (status == NULL || U_FAILURE(*status)){
102 return 0;
103 }
104
105 BreakIterator *result = 0;
106 UnicodeString ruleString(rules, rulesLength);
107 result = RBBIRuleBuilder::createRuleBasedBreakIterator(ruleString, parseErr, *status);
108 if(U_FAILURE(*status)) {
109 return 0;
110 }
111
112 UBreakIterator *uBI = (UBreakIterator *)result;
113 if (text != NULL) {
114 ubrk_setText(uBI, text, textLength, status);
115 }
116 return uBI;
117 }
118
119
120
121
122
123 U_CAPI UBreakIterator * U_EXPORT2
ubrk_safeClone(const UBreakIterator * bi,void * stackBuffer,int32_t * pBufferSize,UErrorCode * status)124 ubrk_safeClone(
125 const UBreakIterator *bi,
126 void *stackBuffer,
127 int32_t *pBufferSize,
128 UErrorCode *status)
129 {
130 if (status == NULL || U_FAILURE(*status)){
131 return 0;
132 }
133 if (!pBufferSize || !bi){
134 *status = U_ILLEGAL_ARGUMENT_ERROR;
135 return 0;
136 }
137 // Clear any incoming Safe Clone Allocated warning.
138 // Propagating this through to our return would really
139 // confuse our caller.
140 if (*status==U_SAFECLONE_ALLOCATED_WARNING) {
141 *status = U_ZERO_ERROR;
142 }
143 return (UBreakIterator *)(((BreakIterator*)bi)->
144 createBufferClone(stackBuffer, *pBufferSize, *status));
145 }
146
147
148
149 U_CAPI void U_EXPORT2
ubrk_close(UBreakIterator * bi)150 ubrk_close(UBreakIterator *bi)
151 {
152 BreakIterator *ubi = (BreakIterator*) bi;
153 if (ubi) {
154 if (ubi->isBufferClone()) {
155 ubi->~BreakIterator();
156 *(uint32_t *)ubi = 0xdeadbeef;
157 } else {
158 delete ubi;
159 }
160 }
161 }
162
163 U_CAPI void U_EXPORT2
ubrk_setText(UBreakIterator * bi,const UChar * text,int32_t textLength,UErrorCode * status)164 ubrk_setText(UBreakIterator* bi,
165 const UChar* text,
166 int32_t textLength,
167 UErrorCode* status)
168 {
169 if (bi == NULL) {
170 if (U_SUCCESS(*status)) {
171 *status = U_ILLEGAL_ARGUMENT_ERROR;
172 }
173 return;
174 }
175
176 BreakIterator *brit = (BreakIterator *)bi;
177 UText ut = UTEXT_INITIALIZER;
178 utext_openUChars(&ut, text, textLength, status);
179 brit->setText(&ut, *status);
180 // A stack allocated UText wrapping a UCHar * string
181 // can be dumped without explicitly closing it.
182 }
183
184
185
186 U_CAPI void U_EXPORT2
ubrk_setUText(UBreakIterator * bi,UText * text,UErrorCode * status)187 ubrk_setUText(UBreakIterator *bi,
188 UText *text,
189 UErrorCode *status)
190 {
191 if (bi == NULL) {
192 if (U_SUCCESS(*status)) {
193 *status = U_ILLEGAL_ARGUMENT_ERROR;
194 }
195 return;
196 }
197
198 RuleBasedBreakIterator *brit = (RuleBasedBreakIterator *)bi;
199 brit->RuleBasedBreakIterator::setText(text, *status);
200 }
201
202
203
204
205
206 U_CAPI int32_t U_EXPORT2
ubrk_current(const UBreakIterator * bi)207 ubrk_current(const UBreakIterator *bi)
208 {
209
210 return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::current();
211 }
212
213 U_CAPI int32_t U_EXPORT2
ubrk_next(UBreakIterator * bi)214 ubrk_next(UBreakIterator *bi)
215 {
216
217 return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::next();
218 }
219
220 U_CAPI int32_t U_EXPORT2
ubrk_previous(UBreakIterator * bi)221 ubrk_previous(UBreakIterator *bi)
222 {
223
224 return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::previous();
225 }
226
227 U_CAPI int32_t U_EXPORT2
ubrk_first(UBreakIterator * bi)228 ubrk_first(UBreakIterator *bi)
229 {
230
231 return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::first();
232 }
233
234 U_CAPI int32_t U_EXPORT2
ubrk_last(UBreakIterator * bi)235 ubrk_last(UBreakIterator *bi)
236 {
237
238 return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::last();
239 }
240
241 U_CAPI int32_t U_EXPORT2
ubrk_preceding(UBreakIterator * bi,int32_t offset)242 ubrk_preceding(UBreakIterator *bi,
243 int32_t offset)
244 {
245
246 return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::preceding(offset);
247 }
248
249 U_CAPI int32_t U_EXPORT2
ubrk_following(UBreakIterator * bi,int32_t offset)250 ubrk_following(UBreakIterator *bi,
251 int32_t offset)
252 {
253
254 return ((RuleBasedBreakIterator*)bi)->RuleBasedBreakIterator::following(offset);
255 }
256
257 U_CAPI const char* U_EXPORT2
ubrk_getAvailable(int32_t index)258 ubrk_getAvailable(int32_t index)
259 {
260
261 return uloc_getAvailable(index);
262 }
263
264 U_CAPI int32_t U_EXPORT2
ubrk_countAvailable()265 ubrk_countAvailable()
266 {
267
268 return uloc_countAvailable();
269 }
270
271
272 U_CAPI UBool U_EXPORT2
ubrk_isBoundary(UBreakIterator * bi,int32_t offset)273 ubrk_isBoundary(UBreakIterator *bi, int32_t offset)
274 {
275 return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::isBoundary(offset);
276 }
277
278
279 U_CAPI int32_t U_EXPORT2
ubrk_getRuleStatus(UBreakIterator * bi)280 ubrk_getRuleStatus(UBreakIterator *bi)
281 {
282 return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::getRuleStatus();
283 }
284
285 U_CAPI int32_t U_EXPORT2
ubrk_getRuleStatusVec(UBreakIterator * bi,int32_t * fillInVec,int32_t capacity,UErrorCode * status)286 ubrk_getRuleStatusVec(UBreakIterator *bi, int32_t *fillInVec, int32_t capacity, UErrorCode *status)
287 {
288 return ((RuleBasedBreakIterator *)bi)->RuleBasedBreakIterator::getRuleStatusVec(fillInVec, capacity, *status);
289 }
290
291
292 U_CAPI const char* U_EXPORT2
ubrk_getLocaleByType(const UBreakIterator * bi,ULocDataLocaleType type,UErrorCode * status)293 ubrk_getLocaleByType(const UBreakIterator *bi,
294 ULocDataLocaleType type,
295 UErrorCode* status)
296 {
297 if (bi == NULL) {
298 if (U_SUCCESS(*status)) {
299 *status = U_ILLEGAL_ARGUMENT_ERROR;
300 }
301 return NULL;
302 }
303 return ((BreakIterator*)bi)->getLocaleID(type, *status);
304 }
305
306
307 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */
308