You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

533 lines
15 KiB

// Copyright (C) 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* 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 */