| /* |
| ******************************************************************************* |
| * Copyright (C) 1997-2009,2014 International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| * Date Name Description |
| * 06/21/00 aliu Creation. |
| ******************************************************************************* |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_TRANSLITERATION |
| |
| #include "unicode/utrans.h" |
| #include "unicode/putil.h" |
| #include "unicode/rep.h" |
| #include "unicode/translit.h" |
| #include "unicode/unifilt.h" |
| #include "unicode/uniset.h" |
| #include "unicode/ustring.h" |
| #include "unicode/uenum.h" |
| #include "unicode/uset.h" |
| #include "uenumimp.h" |
| #include "cpputils.h" |
| #include "rbt.h" |
| |
| // Following macro is to be followed by <return value>';' or just ';' |
| #define utrans_ENTRY(s) if ((s)==NULL || U_FAILURE(*(s))) return |
| |
| /******************************************************************** |
| * Replaceable-UReplaceableCallbacks glue |
| ********************************************************************/ |
| |
| /** |
| * Make a UReplaceable + UReplaceableCallbacks into a Replaceable object. |
| */ |
| U_NAMESPACE_BEGIN |
| class ReplaceableGlue : public Replaceable { |
| |
| UReplaceable *rep; |
| UReplaceableCallbacks *func; |
| |
| public: |
| |
| ReplaceableGlue(UReplaceable *replaceable, |
| UReplaceableCallbacks *funcCallback); |
| |
| virtual ~ReplaceableGlue(); |
| |
| virtual void handleReplaceBetween(int32_t start, |
| int32_t limit, |
| const UnicodeString& text); |
| |
| virtual void extractBetween(int32_t start, |
| int32_t limit, |
| UnicodeString& target) const; |
| |
| virtual void copy(int32_t start, int32_t limit, int32_t dest); |
| |
| // virtual Replaceable *clone() const { return NULL; } same as default |
| |
| /** |
| * ICU "poor man's RTTI", returns a UClassID for the actual class. |
| * |
| * @draft ICU 2.2 |
| */ |
| virtual UClassID getDynamicClassID() const; |
| |
| /** |
| * ICU "poor man's RTTI", returns a UClassID for this class. |
| * |
| * @draft ICU 2.2 |
| */ |
| static UClassID U_EXPORT2 getStaticClassID(); |
| |
| protected: |
| |
| virtual int32_t getLength() const; |
| |
| virtual UChar getCharAt(int32_t offset) const; |
| |
| virtual UChar32 getChar32At(int32_t offset) const; |
| }; |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ReplaceableGlue) |
| |
| ReplaceableGlue::ReplaceableGlue(UReplaceable *replaceable, |
| UReplaceableCallbacks *funcCallback) |
| : Replaceable() |
| { |
| this->rep = replaceable; |
| this->func = funcCallback; |
| } |
| |
| ReplaceableGlue::~ReplaceableGlue() {} |
| |
| int32_t ReplaceableGlue::getLength() const { |
| return (*func->length)(rep); |
| } |
| |
| UChar ReplaceableGlue::getCharAt(int32_t offset) const { |
| return (*func->charAt)(rep, offset); |
| } |
| |
| UChar32 ReplaceableGlue::getChar32At(int32_t offset) const { |
| return (*func->char32At)(rep, offset); |
| } |
| |
| void ReplaceableGlue::handleReplaceBetween(int32_t start, |
| int32_t limit, |
| const UnicodeString& text) { |
| (*func->replace)(rep, start, limit, text.getBuffer(), text.length()); |
| } |
| |
| void ReplaceableGlue::extractBetween(int32_t start, |
| int32_t limit, |
| UnicodeString& target) const { |
| (*func->extract)(rep, start, limit, target.getBuffer(limit-start)); |
| target.releaseBuffer(limit-start); |
| } |
| |
| void ReplaceableGlue::copy(int32_t start, int32_t limit, int32_t dest) { |
| (*func->copy)(rep, start, limit, dest); |
| } |
| U_NAMESPACE_END |
| /******************************************************************** |
| * General API |
| ********************************************************************/ |
| U_NAMESPACE_USE |
| |
| U_CAPI UTransliterator* U_EXPORT2 |
| utrans_openU(const UChar *id, |
| int32_t idLength, |
| UTransDirection dir, |
| const UChar *rules, |
| int32_t rulesLength, |
| UParseError *parseError, |
| UErrorCode *status) { |
| if(status==NULL || U_FAILURE(*status)) { |
| return NULL; |
| } |
| if (id == NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| UParseError temp; |
| |
| if(parseError == NULL){ |
| parseError = &temp; |
| } |
| |
| UnicodeString ID(idLength<0, id, idLength); // r-o alias |
| |
| if(rules==NULL){ |
| |
| Transliterator *trans = NULL; |
| |
| trans = Transliterator::createInstance(ID, dir, *parseError, *status); |
| |
| if(U_FAILURE(*status)){ |
| return NULL; |
| } |
| return (UTransliterator*) trans; |
| }else{ |
| UnicodeString ruleStr(rulesLength < 0, |
| rules, |
| rulesLength); // r-o alias |
| |
| Transliterator *trans = NULL; |
| trans = Transliterator::createFromRules(ID, ruleStr, dir, *parseError, *status); |
| if(U_FAILURE(*status)) { |
| return NULL; |
| } |
| |
| return (UTransliterator*) trans; |
| } |
| } |
| |
| U_CAPI UTransliterator* U_EXPORT2 |
| utrans_open(const char* id, |
| UTransDirection dir, |
| const UChar* rules, /* may be Null */ |
| int32_t rulesLength, /* -1 if null-terminated */ |
| UParseError* parseError, /* may be Null */ |
| UErrorCode* status) { |
| UnicodeString ID(id, -1, US_INV); // use invariant converter |
| return utrans_openU(ID.getBuffer(), ID.length(), dir, |
| rules, rulesLength, |
| parseError, status); |
| } |
| |
| U_CAPI UTransliterator* U_EXPORT2 |
| utrans_openInverse(const UTransliterator* trans, |
| UErrorCode* status) { |
| |
| utrans_ENTRY(status) NULL; |
| |
| UTransliterator* result = |
| (UTransliterator*) ((Transliterator*) trans)->createInverse(*status); |
| |
| return result; |
| } |
| |
| U_CAPI UTransliterator* U_EXPORT2 |
| utrans_clone(const UTransliterator* trans, |
| UErrorCode* status) { |
| |
| utrans_ENTRY(status) NULL; |
| |
| if (trans == NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| Transliterator *t = ((Transliterator*) trans)->clone(); |
| if (t == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| } |
| return (UTransliterator*) t; |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_close(UTransliterator* trans) { |
| delete (Transliterator*) trans; |
| } |
| |
| U_CAPI const UChar * U_EXPORT2 |
| utrans_getUnicodeID(const UTransliterator *trans, |
| int32_t *resultLength) { |
| // Transliterator keeps its ID NUL-terminated |
| const UnicodeString &ID=((Transliterator*) trans)->getID(); |
| if(resultLength!=NULL) { |
| *resultLength=ID.length(); |
| } |
| return ID.getBuffer(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| utrans_getID(const UTransliterator* trans, |
| char* buf, |
| int32_t bufCapacity) { |
| return ((Transliterator*) trans)->getID().extract(0, 0x7fffffff, buf, bufCapacity, US_INV); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_register(UTransliterator* adoptedTrans, |
| UErrorCode* status) { |
| utrans_ENTRY(status); |
| // status currently ignored; may remove later |
| Transliterator::registerInstance((Transliterator*) adoptedTrans); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_unregisterID(const UChar* id, int32_t idLength) { |
| UnicodeString ID(idLength<0, id, idLength); // r-o alias |
| Transliterator::unregister(ID); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_unregister(const char* id) { |
| UnicodeString ID(id, -1, US_INV); // use invariant converter |
| Transliterator::unregister(ID); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_setFilter(UTransliterator* trans, |
| const UChar* filterPattern, |
| int32_t filterPatternLen, |
| UErrorCode* status) { |
| |
| utrans_ENTRY(status); |
| UnicodeFilter* filter = NULL; |
| if (filterPattern != NULL && *filterPattern != 0) { |
| // Create read only alias of filterPattern: |
| UnicodeString pat(filterPatternLen < 0, filterPattern, filterPatternLen); |
| filter = new UnicodeSet(pat, *status); |
| /* test for NULL */ |
| if (filter == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| if (U_FAILURE(*status)) { |
| delete filter; |
| filter = NULL; |
| } |
| } |
| ((Transliterator*) trans)->adoptFilter(filter); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| utrans_countAvailableIDs(void) { |
| return Transliterator::countAvailableIDs(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| utrans_getAvailableID(int32_t index, |
| char* buf, // may be NULL |
| int32_t bufCapacity) { |
| return Transliterator::getAvailableID(index).extract(0, 0x7fffffff, buf, bufCapacity, US_INV); |
| } |
| |
| /* Transliterator UEnumeration ---------------------------------------------- */ |
| |
| typedef struct UTransEnumeration { |
| UEnumeration uenum; |
| int32_t index, count; |
| } UTransEnumeration; |
| |
| U_CDECL_BEGIN |
| static int32_t U_CALLCONV |
| utrans_enum_count(UEnumeration *uenum, UErrorCode *pErrorCode) { |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return 0; |
| } |
| return ((UTransEnumeration *)uenum)->count; |
| } |
| |
| static const UChar* U_CALLCONV |
| utrans_enum_unext(UEnumeration *uenum, |
| int32_t* resultLength, |
| UErrorCode *pErrorCode) { |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return 0; |
| } |
| |
| UTransEnumeration *ute=(UTransEnumeration *)uenum; |
| int32_t index=ute->index; |
| if(index<ute->count) { |
| const UnicodeString &ID=Transliterator::getAvailableID(index); |
| ute->index=index+1; |
| if(resultLength!=NULL) { |
| *resultLength=ID.length(); |
| } |
| // Transliterator keeps its ID NUL-terminated |
| return ID.getBuffer(); |
| } |
| |
| if(resultLength!=NULL) { |
| *resultLength=0; |
| } |
| return NULL; |
| } |
| |
| static void U_CALLCONV |
| utrans_enum_reset(UEnumeration *uenum, UErrorCode *pErrorCode) { |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return; |
| } |
| |
| UTransEnumeration *ute=(UTransEnumeration *)uenum; |
| ute->index=0; |
| ute->count=Transliterator::countAvailableIDs(); |
| } |
| |
| static void U_CALLCONV |
| utrans_enum_close(UEnumeration *uenum) { |
| uprv_free(uenum); |
| } |
| U_CDECL_END |
| |
| static const UEnumeration utransEnumeration={ |
| NULL, |
| NULL, |
| utrans_enum_close, |
| utrans_enum_count, |
| utrans_enum_unext, |
| uenum_nextDefault, |
| utrans_enum_reset |
| }; |
| |
| U_CAPI UEnumeration * U_EXPORT2 |
| utrans_openIDs(UErrorCode *pErrorCode) { |
| UTransEnumeration *ute; |
| |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return NULL; |
| } |
| |
| ute=(UTransEnumeration *)uprv_malloc(sizeof(UTransEnumeration)); |
| if(ute==NULL) { |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| ute->uenum=utransEnumeration; |
| ute->index=0; |
| ute->count=Transliterator::countAvailableIDs(); |
| return (UEnumeration *)ute; |
| } |
| |
| /******************************************************************** |
| * Transliteration API |
| ********************************************************************/ |
| |
| U_CAPI void U_EXPORT2 |
| utrans_trans(const UTransliterator* trans, |
| UReplaceable* rep, |
| UReplaceableCallbacks* repFunc, |
| int32_t start, |
| int32_t* limit, |
| UErrorCode* status) { |
| |
| utrans_ENTRY(status); |
| |
| if (trans == 0 || rep == 0 || repFunc == 0 || limit == 0) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| ReplaceableGlue r(rep, repFunc); |
| |
| *limit = ((Transliterator*) trans)->transliterate(r, start, *limit); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_transIncremental(const UTransliterator* trans, |
| UReplaceable* rep, |
| UReplaceableCallbacks* repFunc, |
| UTransPosition* pos, |
| UErrorCode* status) { |
| |
| utrans_ENTRY(status); |
| |
| if (trans == 0 || rep == 0 || repFunc == 0 || pos == 0) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| ReplaceableGlue r(rep, repFunc); |
| |
| ((Transliterator*) trans)->transliterate(r, *pos, *status); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_transUChars(const UTransliterator* trans, |
| UChar* text, |
| int32_t* textLength, |
| int32_t textCapacity, |
| int32_t start, |
| int32_t* limit, |
| UErrorCode* status) { |
| |
| utrans_ENTRY(status); |
| |
| if (trans == 0 || text == 0 || limit == 0) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| int32_t textLen = (textLength == NULL || *textLength < 0) |
| ? u_strlen(text) : *textLength; |
| // writeable alias: for this ct, len CANNOT be -1 (why?) |
| UnicodeString str(text, textLen, textCapacity); |
| |
| *limit = ((Transliterator*) trans)->transliterate(str, start, *limit); |
| |
| // Copy the string buffer back to text (only if necessary) |
| // and fill in *neededCapacity (if neededCapacity != NULL). |
| textLen = str.extract(text, textCapacity, *status); |
| if(textLength != NULL) { |
| *textLength = textLen; |
| } |
| } |
| |
| U_CAPI void U_EXPORT2 |
| utrans_transIncrementalUChars(const UTransliterator* trans, |
| UChar* text, |
| int32_t* textLength, |
| int32_t textCapacity, |
| UTransPosition* pos, |
| UErrorCode* status) { |
| |
| utrans_ENTRY(status); |
| |
| if (trans == 0 || text == 0 || pos == 0) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| int32_t textLen = (textLength == NULL || *textLength < 0) |
| ? u_strlen(text) : *textLength; |
| // writeable alias: for this ct, len CANNOT be -1 (why?) |
| UnicodeString str(text, textLen, textCapacity); |
| |
| ((Transliterator*) trans)->transliterate(str, *pos, *status); |
| |
| // Copy the string buffer back to text (only if necessary) |
| // and fill in *neededCapacity (if neededCapacity != NULL). |
| textLen = str.extract(text, textCapacity, *status); |
| if(textLength != NULL) { |
| *textLength = textLen; |
| } |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| utrans_toRules( const UTransliterator* trans, |
| UBool escapeUnprintable, |
| UChar* result, int32_t resultLength, |
| UErrorCode* status) { |
| utrans_ENTRY(status) 0; |
| if ( (result==NULL)? resultLength!=0: resultLength<0 ) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| UnicodeString res; |
| res.setTo(result, 0, resultLength); |
| ((Transliterator*) trans)->toRules(res, escapeUnprintable); |
| return res.extract(result, resultLength, *status); |
| } |
| |
| U_CAPI USet* U_EXPORT2 |
| utrans_getSourceSet(const UTransliterator* trans, |
| UBool ignoreFilter, |
| USet* fillIn, |
| UErrorCode* status) { |
| utrans_ENTRY(status) fillIn; |
| |
| if (fillIn == NULL) { |
| fillIn = uset_openEmpty(); |
| } |
| if (ignoreFilter) { |
| ((Transliterator*) trans)->handleGetSourceSet(*((UnicodeSet*)fillIn)); |
| } else { |
| ((Transliterator*) trans)->getSourceSet(*((UnicodeSet*)fillIn)); |
| } |
| return fillIn; |
| } |
| |
| #endif /* #if !UCONFIG_NO_TRANSLITERATION */ |
