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