[apple/icu.git] / icuSources / test / perf / normperf / normperf.h

/*
**********************************************************************
* Copyright (c) 2002-2011, International Business Machines
* Corporation and others.  All Rights Reserved.
**********************************************************************
**********************************************************************
*/
#ifndef _NORMPERF_H
#define _NORMPERF_H

#include "unicode/unorm.h"
#include "unicode/ustring.h"

#include "unicode/uperf.h"
#include <stdlib.h>

//  Stubs for Windows API functions when building on UNIXes.
//
#if U_PLATFORM_USES_ONLY_WIN32_API
// do nothing
#else
#define _UNICODE
typedef int DWORD;
inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar* lpDestStr,int cchDest);
#endif

#define DEST_BUFFER_CAPACITY 6000
typedef int32_t (*NormFn)(const UChar* src,int32_t srcLen, UChar* dest,int32_t dstLen, int32_t options, UErrorCode* status);
typedef int32_t (*QuickCheckFn)(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status);

class QuickCheckPerfFunction : public UPerfFunction{
private:
    ULine* lines;
    int32_t numLines;
    QuickCheckFn fn;
    UNormalizationMode mode;
    int32_t retVal;
    UBool uselen;
    const UChar* src;
    int32_t srcLen;
    UBool line_mode;
    int32_t options;

public:
    virtual void call(UErrorCode* status){
        if(line_mode==TRUE){
            if(uselen){
                for(int32_t i = 0; i< numLines; i++){
                    retVal =  (*fn)(lines[i].name,lines[i].len,mode, options, status);
                }
            }else{
                for(int32_t i = 0; i< numLines; i++){
                    retVal =  (*fn)(lines[i].name,-1,mode, options, status);
                }
            }
        }else{
            if(uselen){

                retVal =  (*fn)(src,srcLen,mode, options, status);
            }else{
                retVal =  (*fn)(src,-1,mode, options, status);
            }
        }

    }
    virtual long getOperationsPerIteration(){
        if(line_mode==TRUE){
            int32_t totalChars=0;
            for(int32_t i =0; i< numLines; i++){
                totalChars+= lines[i].len;
            }
            return totalChars;
        }else{
            return srcLen;
        }
    }
    QuickCheckPerfFunction(QuickCheckFn func, ULine* srcLines,int32_t srcNumLines, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
        fn = func;
        lines = srcLines;
        numLines = srcNumLines;
        uselen = _uselen;
        mode = _mode;
        src = NULL;
        srcLen = 0;
        line_mode = TRUE;
    }
    QuickCheckPerfFunction(QuickCheckFn func, const UChar* source,int32_t sourceLen, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
        fn = func;
        lines = NULL;
        numLines = 0;
        uselen = _uselen;
        mode = _mode;
        src = source;
        srcLen = sourceLen;
        line_mode = FALSE;
    }
};


class NormPerfFunction : public UPerfFunction{
private:
    ULine* lines;
    int32_t numLines;
    UChar dest[DEST_BUFFER_CAPACITY];
    UChar* pDest;
    int32_t destLen;
    NormFn fn;
    int32_t retVal;
    UBool uselen;
    const UChar* src;
    int32_t srcLen;
    UBool line_mode;
    int32_t options;

public:
    virtual void call(UErrorCode* status){
        if(line_mode==TRUE){
            if(uselen){
                for(int32_t i = 0; i< numLines; i++){
                    retVal =  (*fn)(lines[i].name,lines[i].len,pDest,destLen, options, status);
                }
            }else{
                for(int32_t i = 0; i< numLines; i++){
                    retVal =  (*fn)(lines[i].name,-1,pDest,destLen, options, status);
                }
            }
        }else{
            if(uselen){
                retVal =  (*fn)(src,srcLen,pDest,destLen, options, status);
            }else{
                retVal =  (*fn)(src,-1,pDest,destLen, options, status);
            }
        }
    }
    virtual long getOperationsPerIteration(){
        if(line_mode ==TRUE){
            int32_t totalChars=0;
            for(int32_t i =0; i< numLines; i++){
                totalChars+= lines[i].len;
            }
            return totalChars;
        }else{
            return srcLen;
        }
    }
    NormPerfFunction(NormFn func, int32_t opts, ULine* srcLines,int32_t srcNumLines,UBool _uselen) : options(opts) {
        fn = func;
        lines = srcLines;
        numLines = srcNumLines;
        uselen = _uselen;
        destLen = DEST_BUFFER_CAPACITY;
        pDest = dest;
        src = NULL;
        srcLen = 0;
        line_mode = TRUE;
    }
    NormPerfFunction(NormFn func, int32_t opts, const UChar* source,int32_t sourceLen,UBool _uselen) : options(opts) {
        fn = func;
        lines = NULL;
        numLines = 0;
        uselen = _uselen;
        destLen = sourceLen*3;
        pDest = (UChar*) malloc(destLen * U_SIZEOF_UCHAR);
        src = source;
        srcLen = sourceLen;
        line_mode = FALSE;
    }
    ~NormPerfFunction(){
        if(dest != pDest){
            free(pDest);
        }
    }
};


class  NormalizerPerformanceTest : public UPerfTest{
private:
    ULine* NFDFileLines;
    ULine* NFCFileLines;
    UChar* NFDBuffer;
    UChar* NFCBuffer;
    UChar* origBuffer;
    int32_t origBufferLen;
    int32_t NFDBufferLen;
    int32_t NFCBufferLen;
    int32_t options;

    void normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);
    UChar* normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);

public:

    NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status);
    ~NormalizerPerformanceTest();
    virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par = NULL);     
    /* NFC performance */
    UPerfFunction* TestICU_NFC_NFD_Text();
    UPerfFunction* TestICU_NFC_NFC_Text();
    UPerfFunction* TestICU_NFC_Orig_Text();
    
    /* NFD performance */
    UPerfFunction* TestICU_NFD_NFD_Text();
    UPerfFunction* TestICU_NFD_NFC_Text();
    UPerfFunction* TestICU_NFD_Orig_Text();

    /* FCD performance */
    UPerfFunction* TestICU_FCD_NFD_Text();
    UPerfFunction* TestICU_FCD_NFC_Text();
    UPerfFunction* TestICU_FCD_Orig_Text();
    
    /*Win NFC performance */
    UPerfFunction* TestWin_NFC_NFD_Text();
    UPerfFunction* TestWin_NFC_NFC_Text();
    UPerfFunction* TestWin_NFC_Orig_Text();
    
    /* Win NFD performance */
    UPerfFunction* TestWin_NFD_NFD_Text();
    UPerfFunction* TestWin_NFD_NFC_Text();
    UPerfFunction* TestWin_NFD_Orig_Text();
    
    /* Quick check performance */
    UPerfFunction* TestQC_NFC_NFD_Text();
    UPerfFunction* TestQC_NFC_NFC_Text();
    UPerfFunction* TestQC_NFC_Orig_Text();

    UPerfFunction* TestQC_NFD_NFD_Text();
    UPerfFunction* TestQC_NFD_NFC_Text();
    UPerfFunction* TestQC_NFD_Orig_Text();

    UPerfFunction* TestQC_FCD_NFD_Text();
    UPerfFunction* TestQC_FCD_NFC_Text();
    UPerfFunction* TestQC_FCD_Orig_Text();

    /* IsNormalized performnace */
    UPerfFunction* TestIsNormalized_NFC_NFD_Text();
    UPerfFunction* TestIsNormalized_NFC_NFC_Text();
    UPerfFunction* TestIsNormalized_NFC_Orig_Text();

    UPerfFunction* TestIsNormalized_NFD_NFD_Text();
    UPerfFunction* TestIsNormalized_NFD_NFC_Text();
    UPerfFunction* TestIsNormalized_NFD_Orig_Text();

    UPerfFunction* TestIsNormalized_FCD_NFD_Text();
    UPerfFunction* TestIsNormalized_FCD_NFC_Text();
    UPerfFunction* TestIsNormalized_FCD_Orig_Text();

};

//---------------------------------------------------------------------------------------
// Platform / ICU version specific proto-types
//---------------------------------------------------------------------------------------


#if (U_ICU_VERSION_MAJOR_NUM > 1 ) || ((U_ICU_VERSION_MAJOR_NUM == 1 )&&(U_ICU_VERSION_MINOR_NUM > 8) && (U_ICU_VERSION_PATCHLEVEL_NUM >=1))

int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UNORM_NFD, options,dest,dstLen,status);
}

int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UNORM_NFC, options,dest,dstLen,status);
}

int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UNORM_NFKD, options,dest,dstLen,status);
}
int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UNORM_NFKC, options,dest,dstLen,status);
}

int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
}

int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
#if (U_ICU_VERSION_MAJOR_NUM > 2 ) || ((U_ICU_VERSION_MAJOR_NUM == 2 )&&(U_ICU_VERSION_MINOR_NUM >= 6))
    return unorm_quickCheckWithOptions(src,srcLen,mode, options, status);
#else
    return unorm_quickCheck(src,srcLen,mode,status);
#endif
}
int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
    return unorm_isNormalized(src,srcLen,mode,status);
}


#else

int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UCOL_DECOMP_CAN, options,dest,dstLen,status);
}

int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UCOL_COMPOSE_CAN, options,dest,dstLen,status);
}

int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UCOL_DECOMP_COMPAT, options,dest,dstLen,status);
}
int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UCOL_COMPOSE_COMPAT, options,dest,dstLen,status);
}

int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
}

int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
    return unorm_quickCheck(src,srcLen,mode,status);
}

int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
    return 0;
}
#endif

#if U_PLATFORM_HAS_WIN32_API

int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return FoldStringW(MAP_COMPOSITE,src,srcLen,dest,dstLen);
}

int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return FoldStringW(MAP_PRECOMPOSED,src,srcLen,dest,dstLen);
}

int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return FoldStringW(MAP_COMPOSITE+MAP_FOLDCZONE,src,srcLen,dest,dstLen);
}
int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return FoldStringW(MAP_FOLDCZONE,src,srcLen,dest,dstLen);
}
#else
int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return 0 ;
}

int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return 0;
}

int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return 0;
}
int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
    return 0;
}
#endif


#endif // NORMPERF_H
Commit	Line	Data
b75a7d8f A	1	/*
b75a7d8f A	2	**********************************************************************
4388f060	3	* Copyright (c) 2002-2011, International Business Machines
b75a7d8f A	4	* Corporation and others. All Rights Reserved.
	5	**********************************************************************
	6	**********************************************************************
	7	*/
	8	#ifndef _NORMPERF_H
	9	#define _NORMPERF_H
	10
b75a7d8f A	11	#include "unicode/unorm.h"
	12	#include "unicode/ustring.h"
	13
73c04bcf A	14	#include "unicode/uperf.h"
	15	#include <stdlib.h>
	16
b75a7d8f A	17	// Stubs for Windows API functions when building on UNIXes.
b75a7d8f A	18	//
4388f060	19	#if U_PLATFORM_USES_ONLY_WIN32_API
b75a7d8f A	20	// do nothing
	21	#else
	22	#define _UNICODE
	23	typedef int DWORD;
	24	inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar* lpDestStr,int cchDest);
	25	#endif
	26
	27	#define DEST_BUFFER_CAPACITY 6000
	28	typedef int32_t (NormFn)(const UChar src,int32_t srcLen, UChar* dest,int32_t dstLen, int32_t options, UErrorCode* status);
	29	typedef int32_t (QuickCheckFn)(const UChar src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status);
	30
	31	class QuickCheckPerfFunction : public UPerfFunction{
	32	private:
	33	ULine* lines;
	34	int32_t numLines;
	35	QuickCheckFn fn;
	36	UNormalizationMode mode;
	37	int32_t retVal;
	38	UBool uselen;
	39	const UChar* src;
	40	int32_t srcLen;
	41	UBool line_mode;
	42	int32_t options;
	43
	44	public:
	45	virtual void call(UErrorCode* status){
	46	if(line_mode==TRUE){
	47	if(uselen){
	48	for(int32_t i = 0; i< numLines; i++){
	49	retVal = (*fn)(lines[i].name,lines[i].len,mode, options, status);
	50	}
	51	}else{
	52	for(int32_t i = 0; i< numLines; i++){
	53	retVal = (*fn)(lines[i].name,-1,mode, options, status);
	54	}
	55	}
	56	}else{
	57	if(uselen){
	58
	59	retVal = (*fn)(src,srcLen,mode, options, status);
	60	}else{
	61	retVal = (*fn)(src,-1,mode, options, status);
	62	}
	63	}
	64
	65	}
	66	virtual long getOperationsPerIteration(){
	67	if(line_mode==TRUE){
	68	int32_t totalChars=0;
	69	for(int32_t i =0; i< numLines; i++){
	70	totalChars+= lines[i].len;
	71	}
	72	return totalChars;
	73	}else{
	74	return srcLen;
	75	}
	76	}
	77	QuickCheckPerfFunction(QuickCheckFn func, ULine* srcLines,int32_t srcNumLines, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
	78	fn = func;
	79	lines = srcLines;
	80	numLines = srcNumLines;
	81	uselen = _uselen;
	82	mode = _mode;
	83	src = NULL;
84	srcLen = 0;
85	line_mode = TRUE;
86	}
87	QuickCheckPerfFunction(QuickCheckFn func, const UChar* source,int32_t sourceLen, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
88	fn = func;
89	lines = NULL;
90	numLines = 0;
91	uselen = _uselen;
92	mode = _mode;
93	src = source;
94	srcLen = sourceLen;
95	line_mode = FALSE;
96	}
97	};
98
99
100	class NormPerfFunction : public UPerfFunction{
101	private:
102	ULine* lines;
103	int32_t numLines;
104	UChar dest[DEST_BUFFER_CAPACITY];
73c04bcf	105	UChar* pDest;
b75a7d8f A	106	int32_t destLen;
	107	NormFn fn;
	108	int32_t retVal;
	109	UBool uselen;
	110	const UChar* src;
	111	int32_t srcLen;
	112	UBool line_mode;
	113	int32_t options;
	114
	115	public:
	116	virtual void call(UErrorCode* status){
	117	if(line_mode==TRUE){
	118	if(uselen){
	119	for(int32_t i = 0; i< numLines; i++){
	120	retVal = (*fn)(lines[i].name,lines[i].len,pDest,destLen, options, status);
	121	}
	122	}else{
	123	for(int32_t i = 0; i< numLines; i++){
	124	retVal = (*fn)(lines[i].name,-1,pDest,destLen, options, status);
	125	}
	126	}
	127	}else{
	128	if(uselen){
	129	retVal = (*fn)(src,srcLen,pDest,destLen, options, status);
	130	}else{
	131	retVal = (*fn)(src,-1,pDest,destLen, options, status);
	132	}
	133	}
	134	}
	135	virtual long getOperationsPerIteration(){
	136	if(line_mode ==TRUE){
	137	int32_t totalChars=0;
	138	for(int32_t i =0; i< numLines; i++){
	139	totalChars+= lines[i].len;
	140	}
	141	return totalChars;
	142	}else{
	143	return srcLen;
	144	}
	145	}
	146	NormPerfFunction(NormFn func, int32_t opts, ULine* srcLines,int32_t srcNumLines,UBool _uselen) : options(opts) {
	147	fn = func;
	148	lines = srcLines;
	149	numLines = srcNumLines;
	150	uselen = _uselen;
	151	destLen = DEST_BUFFER_CAPACITY;
73c04bcf	152	pDest = dest;
b75a7d8f A	153	src = NULL;
	154	srcLen = 0;
	155	line_mode = TRUE;
	156	}
	157	NormPerfFunction(NormFn func, int32_t opts, const UChar* source,int32_t sourceLen,UBool _uselen) : options(opts) {
	158	fn = func;
	159	lines = NULL;
	160	numLines = 0;
	161	uselen = _uselen;
	162	destLen = sourceLen*3;
73c04bcf	163	pDest = (UChar) malloc(destLen U_SIZEOF_UCHAR);
b75a7d8f A	164	src = source;
	165	srcLen = sourceLen;
	166	line_mode = FALSE;
	167	}
73c04bcf A	168	~NormPerfFunction(){
	169	if(dest != pDest){
	170	free(pDest);
	171	}
	172	}
b75a7d8f A	173	};
	174
	175
	176
	177	class NormalizerPerformanceTest : public UPerfTest{
	178	private:
	179	ULine* NFDFileLines;
	180	ULine* NFCFileLines;
	181	UChar* NFDBuffer;
	182	UChar* NFCBuffer;
	183	UChar* origBuffer;
	184	int32_t origBufferLen;
	185	int32_t NFDBufferLen;
	186	int32_t NFCBufferLen;
	187	int32_t options;
	188
	189	void normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);
	190	UChar* normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);
	191
	192	public:
	193
	194	NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status);
	195	~NormalizerPerformanceTest();
	196	virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par = NULL);
	197	/* NFC performance */
	198	UPerfFunction* TestICU_NFC_NFD_Text();
	199	UPerfFunction* TestICU_NFC_NFC_Text();
	200	UPerfFunction* TestICU_NFC_Orig_Text();
	201
	202	/* NFD performance */
	203	UPerfFunction* TestICU_NFD_NFD_Text();
	204	UPerfFunction* TestICU_NFD_NFC_Text();
	205	UPerfFunction* TestICU_NFD_Orig_Text();
	206
	207	/* FCD performance */
	208	UPerfFunction* TestICU_FCD_NFD_Text();
	209	UPerfFunction* TestICU_FCD_NFC_Text();
	210	UPerfFunction* TestICU_FCD_Orig_Text();
	211
	212	/Win NFC performance /
	213	UPerfFunction* TestWin_NFC_NFD_Text();
	214	UPerfFunction* TestWin_NFC_NFC_Text();
	215	UPerfFunction* TestWin_NFC_Orig_Text();
	216
	217	/* Win NFD performance */
	218	UPerfFunction* TestWin_NFD_NFD_Text();
	219	UPerfFunction* TestWin_NFD_NFC_Text();
	220	UPerfFunction* TestWin_NFD_Orig_Text();
	221
	222	/* Quick check performance */
	223	UPerfFunction* TestQC_NFC_NFD_Text();
	224	UPerfFunction* TestQC_NFC_NFC_Text();
	225	UPerfFunction* TestQC_NFC_Orig_Text();
	226
	227	UPerfFunction* TestQC_NFD_NFD_Text();
	228	UPerfFunction* TestQC_NFD_NFC_Text();
	229	UPerfFunction* TestQC_NFD_Orig_Text();
	230
	231	UPerfFunction* TestQC_FCD_NFD_Text();
	232	UPerfFunction* TestQC_FCD_NFC_Text();
	233	UPerfFunction* TestQC_FCD_Orig_Text();
	234
	235	/* IsNormalized performnace */
	236	UPerfFunction* TestIsNormalized_NFC_NFD_Text();
237	UPerfFunction* TestIsNormalized_NFC_NFC_Text();
238	UPerfFunction* TestIsNormalized_NFC_Orig_Text();
239
240	UPerfFunction* TestIsNormalized_NFD_NFD_Text();
241	UPerfFunction* TestIsNormalized_NFD_NFC_Text();
242	UPerfFunction* TestIsNormalized_NFD_Orig_Text();
243
244	UPerfFunction* TestIsNormalized_FCD_NFD_Text();
245	UPerfFunction* TestIsNormalized_FCD_NFC_Text();
246	UPerfFunction* TestIsNormalized_FCD_Orig_Text();
247
248	};
249
250	//---------------------------------------------------------------------------------------
251	// Platform / ICU version specific proto-types
252	//---------------------------------------------------------------------------------------
253
254
255	#if (U_ICU_VERSION_MAJOR_NUM > 1 ) \|\| ((U_ICU_VERSION_MAJOR_NUM == 1 )&&(U_ICU_VERSION_MINOR_NUM > 8) && (U_ICU_VERSION_PATCHLEVEL_NUM >=1))
256
257	int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
258	return unorm_normalize(src,srcLen,UNORM_NFD, options,dest,dstLen,status);
259	}
260
261	int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
262	return unorm_normalize(src,srcLen,UNORM_NFC, options,dest,dstLen,status);
263	}
264
265	int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
266	return unorm_normalize(src,srcLen,UNORM_NFKD, options,dest,dstLen,status);
267	}
268	int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
269	return unorm_normalize(src,srcLen,UNORM_NFKC, options,dest,dstLen,status);
270	}
271
272	int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
273	return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
274	}
275
276	int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
277	#if (U_ICU_VERSION_MAJOR_NUM > 2 ) \|\| ((U_ICU_VERSION_MAJOR_NUM == 2 )&&(U_ICU_VERSION_MINOR_NUM >= 6))
278	return unorm_quickCheckWithOptions(src,srcLen,mode, options, status);
279	#else
280	return unorm_quickCheck(src,srcLen,mode,status);
281	#endif
282	}
283	int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
284	return unorm_isNormalized(src,srcLen,mode,status);
285	}
286
287
288	#else
289
290	int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
291	return unorm_normalize(src,srcLen,UCOL_DECOMP_CAN, options,dest,dstLen,status);
292	}
293
294	int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
295	return unorm_normalize(src,srcLen,UCOL_COMPOSE_CAN, options,dest,dstLen,status);
296	}
297
298	int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
299	return unorm_normalize(src,srcLen,UCOL_DECOMP_COMPAT, options,dest,dstLen,status);
300	}
301	int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
302	return unorm_normalize(src,srcLen,UCOL_COMPOSE_COMPAT, options,dest,dstLen,status);
303	}
304
305	int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
306	return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
307	}
308
309	int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
310	return unorm_quickCheck(src,srcLen,mode,status);
311	}
312
313	int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
314	return 0;
315	}
316	#endif
317
4388f060	318	#if U_PLATFORM_HAS_WIN32_API
b75a7d8f A	319
	320	int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	321	return FoldStringW(MAP_COMPOSITE,src,srcLen,dest,dstLen);
	322	}
	323
	324	int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	325	return FoldStringW(MAP_PRECOMPOSED,src,srcLen,dest,dstLen);
	326	}
	327
	328	int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	329	return FoldStringW(MAP_COMPOSITE+MAP_FOLDCZONE,src,srcLen,dest,dstLen);
	330	}
	331	int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	332	return FoldStringW(MAP_FOLDCZONE,src,srcLen,dest,dstLen);
	333	}
	334	#else
	335	int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	336	return 0 ;
	337	}
	338
	339	int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	340	return 0;
	341	}
	342
	343	int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	344	return 0;
	345	}
	346	int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
	347	return 0;
	348	}
	349	#endif
	350
	351
73c04bcf A	352	#endif // NORMPERF_H
73c04bcf A	353