The Tor Browser / file comparison

comparison: intl/icu/source/i18n/utrans.cpp

intl/icu/source/i18n/utrans.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:0a765bd6176b
1 /*
2 *******************************************************************************
3 * Copyright (C) 1997-2009, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 *******************************************************************************
6 * Date Name Description
7 * 06/21/00 aliu Creation.
8 *******************************************************************************
9 */
10
11 #include "unicode/utypes.h"
12
13 #if !UCONFIG_NO_TRANSLITERATION
14
15 #include "unicode/utrans.h"
16 #include "unicode/putil.h"
17 #include "unicode/rep.h"
18 #include "unicode/translit.h"
19 #include "unicode/unifilt.h"
20 #include "unicode/uniset.h"
21 #include "unicode/ustring.h"
22 #include "unicode/uenum.h"
23 #include "uenumimp.h"
24 #include "cpputils.h"
25 #include "rbt.h"
26
27 // Following macro is to be followed by <return value>';' or just ';'
28 #define utrans_ENTRY(s) if ((s)==NULL || U_FAILURE(*(s))) return
29
30 /********************************************************************
31 * Replaceable-UReplaceableCallbacks glue
32 ********************************************************************/
33
34 /**
35 * Make a UReplaceable + UReplaceableCallbacks into a Replaceable object.
36 */
37 U_NAMESPACE_BEGIN
38 class ReplaceableGlue : public Replaceable {
39
40 UReplaceable *rep;
41 UReplaceableCallbacks *func;
42
43 public:
44
45 ReplaceableGlue(UReplaceable *replaceable,
46 UReplaceableCallbacks *funcCallback);
47
48 virtual ~ReplaceableGlue();
49
50 virtual void handleReplaceBetween(int32_t start,
51 int32_t limit,
52 const UnicodeString& text);
53
54 virtual void extractBetween(int32_t start,
55 int32_t limit,
56 UnicodeString& target) const;
57
58 virtual void copy(int32_t start, int32_t limit, int32_t dest);
59
60 // virtual Replaceable *clone() const { return NULL; } same as default
61
62 /**
63 * ICU "poor man's RTTI", returns a UClassID for the actual class.
64 *
65 * @draft ICU 2.2
66 */
67 virtual UClassID getDynamicClassID() const;
68
69 /**
70 * ICU "poor man's RTTI", returns a UClassID for this class.
71 *
72 * @draft ICU 2.2
73 */
74 static UClassID U_EXPORT2 getStaticClassID();
75
76 protected:
77
78 virtual int32_t getLength() const;
79
80 virtual UChar getCharAt(int32_t offset) const;
81
82 virtual UChar32 getChar32At(int32_t offset) const;
83 };
84
85 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ReplaceableGlue)
86
87 ReplaceableGlue::ReplaceableGlue(UReplaceable *replaceable,
88 UReplaceableCallbacks *funcCallback)
89 : Replaceable()
90 {
91 this->rep = replaceable;
92 this->func = funcCallback;
93 }
94
95 ReplaceableGlue::~ReplaceableGlue() {}
96
97 int32_t ReplaceableGlue::getLength() const {
98 return (*func->length)(rep);
99 }
100
101 UChar ReplaceableGlue::getCharAt(int32_t offset) const {
102 return (*func->charAt)(rep, offset);
103 }
104
105 UChar32 ReplaceableGlue::getChar32At(int32_t offset) const {
106 return (*func->char32At)(rep, offset);
107 }
108
109 void ReplaceableGlue::handleReplaceBetween(int32_t start,
110 int32_t limit,
111 const UnicodeString& text) {
112 (*func->replace)(rep, start, limit, text.getBuffer(), text.length());
113 }
114
115 void ReplaceableGlue::extractBetween(int32_t start,
116 int32_t limit,
117 UnicodeString& target) const {
118 (*func->extract)(rep, start, limit, target.getBuffer(limit-start));
119 target.releaseBuffer(limit-start);
120 }
121
122 void ReplaceableGlue::copy(int32_t start, int32_t limit, int32_t dest) {
123 (*func->copy)(rep, start, limit, dest);
124 }
125 U_NAMESPACE_END
126 /********************************************************************
127 * General API
128 ********************************************************************/
129 U_NAMESPACE_USE
130
131 U_CAPI UTransliterator* U_EXPORT2
132 utrans_openU(const UChar *id,
133 int32_t idLength,
134 UTransDirection dir,
135 const UChar *rules,
136 int32_t rulesLength,
137 UParseError *parseError,
138 UErrorCode *status) {
139 if(status==NULL || U_FAILURE(*status)) {
140 return NULL;
141 }
142 if (id == NULL) {
143 *status = U_ILLEGAL_ARGUMENT_ERROR;
144 return NULL;
145 }
146 UParseError temp;
147
148 if(parseError == NULL){
149 parseError = &temp;
150 }
151
152 UnicodeString ID(idLength<0, id, idLength); // r-o alias
153
154 if(rules==NULL){
155
156 Transliterator *trans = NULL;
157
158 trans = Transliterator::createInstance(ID, dir, *parseError, *status);
159
160 if(U_FAILURE(*status)){
161 return NULL;
162 }
163 return (UTransliterator*) trans;
164 }else{
165 UnicodeString ruleStr(rulesLength < 0,
166 rules,
167 rulesLength); // r-o alias
168
169 Transliterator *trans = NULL;
170 trans = Transliterator::createFromRules(ID, ruleStr, dir, *parseError, *status);
171 if(U_FAILURE(*status)) {
172 return NULL;
173 }
174
175 return (UTransliterator*) trans;
176 }
177 }
178
179 U_CAPI UTransliterator* U_EXPORT2
180 utrans_open(const char* id,
181 UTransDirection dir,
182 const UChar* rules, /* may be Null */
183 int32_t rulesLength, /* -1 if null-terminated */
184 UParseError* parseError, /* may be Null */
185 UErrorCode* status) {
186 UnicodeString ID(id, -1, US_INV); // use invariant converter
187 return utrans_openU(ID.getBuffer(), ID.length(), dir,
188 rules, rulesLength,
189 parseError, status);
190 }
191
192 U_CAPI UTransliterator* U_EXPORT2
193 utrans_openInverse(const UTransliterator* trans,
194 UErrorCode* status) {
195
196 utrans_ENTRY(status) NULL;
197
198 UTransliterator* result =
199 (UTransliterator*) ((Transliterator*) trans)->createInverse(*status);
200
201 return result;
202 }
203
204 U_CAPI UTransliterator* U_EXPORT2
205 utrans_clone(const UTransliterator* trans,
206 UErrorCode* status) {
207
208 utrans_ENTRY(status) NULL;
209
210 if (trans == NULL) {
211 *status = U_ILLEGAL_ARGUMENT_ERROR;
212 return NULL;
213 }
214
215 Transliterator *t = ((Transliterator*) trans)->clone();
216 if (t == NULL) {
217 *status = U_MEMORY_ALLOCATION_ERROR;
218 }
219 return (UTransliterator*) t;
220 }
221
222 U_CAPI void U_EXPORT2
223 utrans_close(UTransliterator* trans) {
224 delete (Transliterator*) trans;
225 }
226
227 U_CAPI const UChar * U_EXPORT2
228 utrans_getUnicodeID(const UTransliterator *trans,
229 int32_t *resultLength) {
230 // Transliterator keeps its ID NUL-terminated
231 const UnicodeString &ID=((Transliterator*) trans)->getID();
232 if(resultLength!=NULL) {
233 *resultLength=ID.length();
234 }
235 return ID.getBuffer();
236 }
237
238 U_CAPI int32_t U_EXPORT2
239 utrans_getID(const UTransliterator* trans,
240 char* buf,
241 int32_t bufCapacity) {
242 return ((Transliterator*) trans)->getID().extract(0, 0x7fffffff, buf, bufCapacity, US_INV);
243 }
244
245 U_CAPI void U_EXPORT2
246 utrans_register(UTransliterator* adoptedTrans,
247 UErrorCode* status) {
248 utrans_ENTRY(status);
249 // status currently ignored; may remove later
250 Transliterator::registerInstance((Transliterator*) adoptedTrans);
251 }
252
253 U_CAPI void U_EXPORT2
254 utrans_unregisterID(const UChar* id, int32_t idLength) {
255 UnicodeString ID(idLength<0, id, idLength); // r-o alias
256 Transliterator::unregister(ID);
257 }
258
259 U_CAPI void U_EXPORT2
260 utrans_unregister(const char* id) {
261 UnicodeString ID(id, -1, US_INV); // use invariant converter
262 Transliterator::unregister(ID);
263 }
264
265 U_CAPI void U_EXPORT2
266 utrans_setFilter(UTransliterator* trans,
267 const UChar* filterPattern,
268 int32_t filterPatternLen,
269 UErrorCode* status) {
270
271 utrans_ENTRY(status);
272 UnicodeFilter* filter = NULL;
273 if (filterPattern != NULL && *filterPattern != 0) {
274 // Create read only alias of filterPattern:
275 UnicodeString pat(filterPatternLen < 0, filterPattern, filterPatternLen);
276 filter = new UnicodeSet(pat, *status);
277 /* test for NULL */
278 if (filter == NULL) {
279 *status = U_MEMORY_ALLOCATION_ERROR;
280 return;
281 }
282 if (U_FAILURE(*status)) {
283 delete filter;
284 filter = NULL;
285 }
286 }
287 ((Transliterator*) trans)->adoptFilter(filter);
288 }
289
290 U_CAPI int32_t U_EXPORT2
291 utrans_countAvailableIDs(void) {
292 return Transliterator::countAvailableIDs();
293 }
294
295 U_CAPI int32_t U_EXPORT2
296 utrans_getAvailableID(int32_t index,
297 char* buf, // may be NULL
298 int32_t bufCapacity) {
299 return Transliterator::getAvailableID(index).extract(0, 0x7fffffff, buf, bufCapacity, US_INV);
300 }
301
302 /* Transliterator UEnumeration ---------------------------------------------- */
303
304 typedef struct UTransEnumeration {
305 UEnumeration uenum;
306 int32_t index, count;
307 } UTransEnumeration;
308
309 U_CDECL_BEGIN
310 static int32_t U_CALLCONV
311 utrans_enum_count(UEnumeration *uenum, UErrorCode *pErrorCode) {
312 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
313 return 0;
314 }
315 return ((UTransEnumeration *)uenum)->count;
316 }
317
318 static const UChar* U_CALLCONV
319 utrans_enum_unext(UEnumeration *uenum,
320 int32_t* resultLength,
321 UErrorCode *pErrorCode) {
322 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
323 return 0;
324 }
325
326 UTransEnumeration *ute=(UTransEnumeration *)uenum;
327 int32_t index=ute->index;
328 if(index<ute->count) {
329 const UnicodeString &ID=Transliterator::getAvailableID(index);
330 ute->index=index+1;
331 if(resultLength!=NULL) {
332 *resultLength=ID.length();
333 }
334 // Transliterator keeps its ID NUL-terminated
335 return ID.getBuffer();
336 }
337
338 if(resultLength!=NULL) {
339 *resultLength=0;
340 }
341 return NULL;
342 }
343
344 static void U_CALLCONV
345 utrans_enum_reset(UEnumeration *uenum, UErrorCode *pErrorCode) {
346 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
347 return;
348 }
349
350 UTransEnumeration *ute=(UTransEnumeration *)uenum;
351 ute->index=0;
352 ute->count=Transliterator::countAvailableIDs();
353 }
354
355 static void U_CALLCONV
356 utrans_enum_close(UEnumeration *uenum) {
357 uprv_free(uenum);
358 }
359 U_CDECL_END
360
361 static const UEnumeration utransEnumeration={
362 NULL,
363 NULL,
364 utrans_enum_close,
365 utrans_enum_count,
366 utrans_enum_unext,
367 uenum_nextDefault,
368 utrans_enum_reset
369 };
370
371 U_CAPI UEnumeration * U_EXPORT2
372 utrans_openIDs(UErrorCode *pErrorCode) {
373 UTransEnumeration *ute;
374
375 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
376 return NULL;
377 }
378
379 ute=(UTransEnumeration *)uprv_malloc(sizeof(UTransEnumeration));
380 if(ute==NULL) {
381 *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
382 return NULL;
383 }
384
385 ute->uenum=utransEnumeration;
386 ute->index=0;
387 ute->count=Transliterator::countAvailableIDs();
388 return (UEnumeration *)ute;
389 }
390
391 /********************************************************************
392 * Transliteration API
393 ********************************************************************/
394
395 U_CAPI void U_EXPORT2
396 utrans_trans(const UTransliterator* trans,
397 UReplaceable* rep,
398 UReplaceableCallbacks* repFunc,
399 int32_t start,
400 int32_t* limit,
401 UErrorCode* status) {
402
403 utrans_ENTRY(status);
404
405 if (trans == 0 || rep == 0 || repFunc == 0 || limit == 0) {
406 *status = U_ILLEGAL_ARGUMENT_ERROR;
407 return;
408 }
409
410 ReplaceableGlue r(rep, repFunc);
411
412 *limit = ((Transliterator*) trans)->transliterate(r, start, *limit);
413 }
414
415 U_CAPI void U_EXPORT2
416 utrans_transIncremental(const UTransliterator* trans,
417 UReplaceable* rep,
418 UReplaceableCallbacks* repFunc,
419 UTransPosition* pos,
420 UErrorCode* status) {
421
422 utrans_ENTRY(status);
423
424 if (trans == 0 || rep == 0 || repFunc == 0 || pos == 0) {
425 *status = U_ILLEGAL_ARGUMENT_ERROR;
426 return;
427 }
428
429 ReplaceableGlue r(rep, repFunc);
430
431 ((Transliterator*) trans)->transliterate(r, *pos, *status);
432 }
433
434 U_CAPI void U_EXPORT2
435 utrans_transUChars(const UTransliterator* trans,
436 UChar* text,
437 int32_t* textLength,
438 int32_t textCapacity,
439 int32_t start,
440 int32_t* limit,
441 UErrorCode* status) {
442
443 utrans_ENTRY(status);
444
445 if (trans == 0 || text == 0 || limit == 0) {
446 *status = U_ILLEGAL_ARGUMENT_ERROR;
447 return;
448 }
449
450 int32_t textLen = (textLength == NULL || *textLength < 0)
451 ? u_strlen(text) : *textLength;
452 // writeable alias: for this ct, len CANNOT be -1 (why?)
453 UnicodeString str(text, textLen, textCapacity);
454
455 *limit = ((Transliterator*) trans)->transliterate(str, start, *limit);
456
457 // Copy the string buffer back to text (only if necessary)
458 // and fill in *neededCapacity (if neededCapacity != NULL).
459 textLen = str.extract(text, textCapacity, *status);
460 if(textLength != NULL) {
461 *textLength = textLen;
462 }
463 }
464
465 U_CAPI void U_EXPORT2
466 utrans_transIncrementalUChars(const UTransliterator* trans,
467 UChar* text,
468 int32_t* textLength,
469 int32_t textCapacity,
470 UTransPosition* pos,
471 UErrorCode* status) {
472
473 utrans_ENTRY(status);
474
475 if (trans == 0 || text == 0 || pos == 0) {
476 *status = U_ILLEGAL_ARGUMENT_ERROR;
477 return;
478 }
479
480 int32_t textLen = (textLength == NULL || *textLength < 0)
481 ? u_strlen(text) : *textLength;
482 // writeable alias: for this ct, len CANNOT be -1 (why?)
483 UnicodeString str(text, textLen, textCapacity);
484
485 ((Transliterator*) trans)->transliterate(str, *pos, *status);
486
487 // Copy the string buffer back to text (only if necessary)
488 // and fill in *neededCapacity (if neededCapacity != NULL).
489 textLen = str.extract(text, textCapacity, *status);
490 if(textLength != NULL) {
491 *textLength = textLen;
492 }
493 }
494
495 #endif /* #if !UCONFIG_NO_TRANSLITERATION */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial