icuSources/i18n/utrans.cpp

   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 */