[apple/icu.git] / icuSources / common / loadednormalizer2impl.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2014, International Business Machines
* Corporation and others.  All Rights Reserved.
*******************************************************************************
* loadednormalizer2impl.cpp
*
* created on: 2014sep03
* created by: Markus W. Scherer
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_NORMALIZATION

#include "unicode/udata.h"
#include "unicode/localpointer.h"
#include "unicode/normalizer2.h"
#include "unicode/ucptrie.h"
#include "unicode/unistr.h"
#include "unicode/unorm.h"
#include "cstring.h"
#include "mutex.h"
#include "norm2allmodes.h"
#include "normalizer2impl.h"
#include "uassert.h"
#include "ucln_cmn.h"
#include "uhash.h"

U_NAMESPACE_BEGIN

class LoadedNormalizer2Impl : public Normalizer2Impl {
public:
    LoadedNormalizer2Impl() : memory(NULL), ownedTrie(NULL) {}
    virtual ~LoadedNormalizer2Impl();

    void load(const char *packageName, const char *name, UErrorCode &errorCode);

private:
    static UBool U_CALLCONV
    isAcceptable(void *context, const char *type, const char *name, const UDataInfo *pInfo);

    UDataMemory *memory;
    UCPTrie *ownedTrie;
};

LoadedNormalizer2Impl::~LoadedNormalizer2Impl() {
    udata_close(memory);
    ucptrie_close(ownedTrie);
}

UBool U_CALLCONV
LoadedNormalizer2Impl::isAcceptable(void * /*context*/,
                                    const char * /* type */, const char * /*name*/,
                                    const UDataInfo *pInfo) {
    if(
        pInfo->size>=20 &&
        pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
        pInfo->charsetFamily==U_CHARSET_FAMILY &&
        pInfo->dataFormat[0]==0x4e &&    /* dataFormat="Nrm2" */
        pInfo->dataFormat[1]==0x72 &&
        pInfo->dataFormat[2]==0x6d &&
        pInfo->dataFormat[3]==0x32 &&
        pInfo->formatVersion[0]==4
    ) {
        // Normalizer2Impl *me=(Normalizer2Impl *)context;
        // uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4);
        return TRUE;
    } else {
        return FALSE;
    }
}

void
LoadedNormalizer2Impl::load(const char *packageName, const char *name, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) {
        return;
    }
    memory=udata_openChoice(packageName, "nrm", name, isAcceptable, this, &errorCode);
    if(U_FAILURE(errorCode)) {
        return;
    }
    const uint8_t *inBytes=(const uint8_t *)udata_getMemory(memory);
    const int32_t *inIndexes=(const int32_t *)inBytes;
    int32_t indexesLength=inIndexes[IX_NORM_TRIE_OFFSET]/4;
    if(indexesLength<=IX_MIN_LCCC_CP) {
        errorCode=U_INVALID_FORMAT_ERROR;  // Not enough indexes.
        return;
    }

    int32_t offset=inIndexes[IX_NORM_TRIE_OFFSET];
    int32_t nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
    ownedTrie=ucptrie_openFromBinary(UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16,
                                     inBytes+offset, nextOffset-offset, NULL,
                                     &errorCode);
    if(U_FAILURE(errorCode)) {
        return;
    }

    offset=nextOffset;
    nextOffset=inIndexes[IX_SMALL_FCD_OFFSET];
    const uint16_t *inExtraData=(const uint16_t *)(inBytes+offset);

    // smallFCD: new in formatVersion 2
    offset=nextOffset;
    const uint8_t *inSmallFCD=inBytes+offset;

    init(inIndexes, ownedTrie, inExtraData, inSmallFCD);
}

// instance cache ---------------------------------------------------------- ***

Norm2AllModes *
Norm2AllModes::createInstance(const char *packageName,
                              const char *name,
                              UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) {
        return NULL;
    }
    LoadedNormalizer2Impl *impl=new LoadedNormalizer2Impl;
    if(impl==NULL) {
        errorCode=U_MEMORY_ALLOCATION_ERROR;
        return NULL;
    }
    impl->load(packageName, name, errorCode);
    return createInstance(impl, errorCode);
}

U_CDECL_BEGIN
static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup();
U_CDECL_END

#if !NORM2_HARDCODE_NFC_DATA
static Norm2AllModes *nfcSingleton;
static icu::UInitOnce nfcInitOnce = U_INITONCE_INITIALIZER;
#endif

static Norm2AllModes *nfkcSingleton;
static icu::UInitOnce nfkcInitOnce = U_INITONCE_INITIALIZER;

static Norm2AllModes *nfkc_cfSingleton;
static icu::UInitOnce nfkc_cfInitOnce = U_INITONCE_INITIALIZER;

static UHashtable    *cache=NULL;

// UInitOnce singleton initialization function
static void U_CALLCONV initSingletons(const char *what, UErrorCode &errorCode) {
#if !NORM2_HARDCODE_NFC_DATA
    if (uprv_strcmp(what, "nfc") == 0) {
        nfcSingleton    = Norm2AllModes::createInstance(NULL, "nfc", errorCode);
    } else
#endif
    if (uprv_strcmp(what, "nfkc") == 0) {
        nfkcSingleton    = Norm2AllModes::createInstance(NULL, "nfkc", errorCode);
    } else if (uprv_strcmp(what, "nfkc_cf") == 0) {
        nfkc_cfSingleton = Norm2AllModes::createInstance(NULL, "nfkc_cf", errorCode);
    } else {
        UPRV_UNREACHABLE;   // Unknown singleton
    }
    ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
}

U_CDECL_BEGIN

static void U_CALLCONV deleteNorm2AllModes(void *allModes) {
    delete (Norm2AllModes *)allModes;
}

static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup() {
#if !NORM2_HARDCODE_NFC_DATA
    delete nfcSingleton;
    nfcSingleton = NULL;
    nfcInitOnce.reset();
#endif

    delete nfkcSingleton;
    nfkcSingleton = NULL;
    nfkcInitOnce.reset();

    delete nfkc_cfSingleton;
    nfkc_cfSingleton = NULL;
    nfkc_cfInitOnce.reset();

    uhash_close(cache);
    cache=NULL;
    return TRUE;
}

U_CDECL_END

#if !NORM2_HARDCODE_NFC_DATA
const Norm2AllModes *
Norm2AllModes::getNFCInstance(UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return NULL; }
    umtx_initOnce(nfcInitOnce, &initSingletons, "nfc", errorCode);
    return nfcSingleton;
}
#endif

const Norm2AllModes *
Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return NULL; }
    umtx_initOnce(nfkcInitOnce, &initSingletons, "nfkc", errorCode);
    return nfkcSingleton;
}

const Norm2AllModes *
Norm2AllModes::getNFKC_CFInstance(UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) { return NULL; }
    umtx_initOnce(nfkc_cfInitOnce, &initSingletons, "nfkc_cf", errorCode);
    return nfkc_cfSingleton;
}

#if !NORM2_HARDCODE_NFC_DATA
const Normalizer2 *
Normalizer2::getNFCInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
    return allModes!=NULL ? &allModes->comp : NULL;
}

const Normalizer2 *
Normalizer2::getNFDInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
    return allModes!=NULL ? &allModes->decomp : NULL;
}

const Normalizer2 *Normalizer2Factory::getFCDInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
    return allModes!=NULL ? &allModes->fcd : NULL;
}

const Normalizer2 *Normalizer2Factory::getFCCInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
    return allModes!=NULL ? &allModes->fcc : NULL;
}

const Normalizer2Impl *
Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
    return allModes!=NULL ? allModes->impl : NULL;
}
#endif

const Normalizer2 *
Normalizer2::getNFKCInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
    return allModes!=NULL ? &allModes->comp : NULL;
}

const Normalizer2 *
Normalizer2::getNFKDInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
    return allModes!=NULL ? &allModes->decomp : NULL;
}

const Normalizer2 *
Normalizer2::getNFKCCasefoldInstance(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
    return allModes!=NULL ? &allModes->comp : NULL;
}

const Normalizer2 *
Normalizer2::getInstance(const char *packageName,
                         const char *name,
                         UNormalization2Mode mode,
                         UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) {
        return NULL;
    }
    if(name==NULL || *name==0) {
        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
        return NULL;
    }
    const Norm2AllModes *allModes=NULL;
    if(packageName==NULL) {
        if(0==uprv_strcmp(name, "nfc")) {
            allModes=Norm2AllModes::getNFCInstance(errorCode);
        } else if(0==uprv_strcmp(name, "nfkc")) {
            allModes=Norm2AllModes::getNFKCInstance(errorCode);
        } else if(0==uprv_strcmp(name, "nfkc_cf")) {
            allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
        }
    }
    if(allModes==NULL && U_SUCCESS(errorCode)) {
        {
            Mutex lock;
            if(cache!=NULL) {
                allModes=(Norm2AllModes *)uhash_get(cache, name);
            }
        }
        if(allModes==NULL) {
            ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
            LocalPointer<Norm2AllModes> localAllModes(
                Norm2AllModes::createInstance(packageName, name, errorCode));
            if(U_SUCCESS(errorCode)) {
                Mutex lock;
                if(cache==NULL) {
                    cache=uhash_open(uhash_hashChars, uhash_compareChars, NULL, &errorCode);
                    if(U_FAILURE(errorCode)) {
                        return NULL;
                    }
                    uhash_setKeyDeleter(cache, uprv_free);
                    uhash_setValueDeleter(cache, deleteNorm2AllModes);
                }
                void *temp=uhash_get(cache, name);
                if(temp==NULL) {
                    int32_t keyLength= static_cast<int32_t>(uprv_strlen(name)+1);
                    char *nameCopy=(char *)uprv_malloc(keyLength);
                    if(nameCopy==NULL) {
                        errorCode=U_MEMORY_ALLOCATION_ERROR;
                        return NULL;
                    }
                    uprv_memcpy(nameCopy, name, keyLength);
                    allModes=localAllModes.getAlias();
                    uhash_put(cache, nameCopy, localAllModes.orphan(), &errorCode);
                } else {
                    // race condition
                    allModes=(Norm2AllModes *)temp;
                }
            }
        }
    }
    if(allModes!=NULL && U_SUCCESS(errorCode)) {
        switch(mode) {
        case UNORM2_COMPOSE:
            return &allModes->comp;
        case UNORM2_DECOMPOSE:
            return &allModes->decomp;
        case UNORM2_FCD:
            return &allModes->fcd;
        case UNORM2_COMPOSE_CONTIGUOUS:
            return &allModes->fcc;
        default:
            break;  // do nothing
        }
    }
    return NULL;
}

const Normalizer2 *
Normalizer2Factory::getInstance(UNormalizationMode mode, UErrorCode &errorCode) {
    if(U_FAILURE(errorCode)) {
        return NULL;
    }
    switch(mode) {
    case UNORM_NFD:
        return Normalizer2::getNFDInstance(errorCode);
    case UNORM_NFKD:
        return Normalizer2::getNFKDInstance(errorCode);
    case UNORM_NFC:
        return Normalizer2::getNFCInstance(errorCode);
    case UNORM_NFKC:
        return Normalizer2::getNFKCInstance(errorCode);
    case UNORM_FCD:
        return getFCDInstance(errorCode);
    default:  // UNORM_NONE
        return getNoopInstance(errorCode);
    }
}

const Normalizer2Impl *
Normalizer2Factory::getNFKCImpl(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
    return allModes!=NULL ? allModes->impl : NULL;
}

const Normalizer2Impl *
Normalizer2Factory::getNFKC_CFImpl(UErrorCode &errorCode) {
    const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
    return allModes!=NULL ? allModes->impl : NULL;
}

U_NAMESPACE_END

// C API ------------------------------------------------------------------- ***

U_NAMESPACE_USE

U_CAPI const UNormalizer2 * U_EXPORT2
unorm2_getNFKCInstance(UErrorCode *pErrorCode) {
    return (const UNormalizer2 *)Normalizer2::getNFKCInstance(*pErrorCode);
}

U_CAPI const UNormalizer2 * U_EXPORT2
unorm2_getNFKDInstance(UErrorCode *pErrorCode) {
    return (const UNormalizer2 *)Normalizer2::getNFKDInstance(*pErrorCode);
}

U_CAPI const UNormalizer2 * U_EXPORT2
unorm2_getNFKCCasefoldInstance(UErrorCode *pErrorCode) {
    return (const UNormalizer2 *)Normalizer2::getNFKCCasefoldInstance(*pErrorCode);
}

U_CAPI const UNormalizer2 * U_EXPORT2
unorm2_getInstance(const char *packageName,
                   const char *name,
                   UNormalization2Mode mode,
                   UErrorCode *pErrorCode) {
    return (const UNormalizer2 *)Normalizer2::getInstance(packageName, name, mode, *pErrorCode);
}

U_CFUNC UNormalizationCheckResult
unorm_getQuickCheck(UChar32 c, UNormalizationMode mode) {
    if(mode<=UNORM_NONE || UNORM_FCD<=mode) {
        return UNORM_YES;
    }
    UErrorCode errorCode=U_ZERO_ERROR;
    const Normalizer2 *norm2=Normalizer2Factory::getInstance(mode, errorCode);
    if(U_SUCCESS(errorCode)) {
        return ((const Normalizer2WithImpl *)norm2)->getQuickCheck(c);
    } else {
        return UNORM_MAYBE;
    }
}

#endif  // !UCONFIG_NO_NORMALIZATION
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
b331163b A	3	/*
	4	*******************************************************************************
	5	* Copyright (C) 2014, International Business Machines
	6	* Corporation and others. All Rights Reserved.
	7	*******************************************************************************
	8	* loadednormalizer2impl.cpp
	9	*
	10	* created on: 2014sep03
	11	* created by: Markus W. Scherer
	12	*/
	13
	14	#include "unicode/utypes.h"
	15
	16	#if !UCONFIG_NO_NORMALIZATION
	17
	18	#include "unicode/udata.h"
	19	#include "unicode/localpointer.h"
	20	#include "unicode/normalizer2.h"
3d1f044b	21	#include "unicode/ucptrie.h"
b331163b A	22	#include "unicode/unistr.h"
	23	#include "unicode/unorm.h"
	24	#include "cstring.h"
	25	#include "mutex.h"
	26	#include "norm2allmodes.h"
	27	#include "normalizer2impl.h"
	28	#include "uassert.h"
	29	#include "ucln_cmn.h"
	30	#include "uhash.h"
	31
	32	U_NAMESPACE_BEGIN
	33
	34	class LoadedNormalizer2Impl : public Normalizer2Impl {
	35	public:
	36	LoadedNormalizer2Impl() : memory(NULL), ownedTrie(NULL) {}
	37	virtual ~LoadedNormalizer2Impl();
	38
	39	void load(const char packageName, const char name, UErrorCode &errorCode);
	40
	41	private:
	42	static UBool U_CALLCONV
	43	isAcceptable(void context, const char type, const char name, const UDataInfo pInfo);
	44
	45	UDataMemory *memory;
3d1f044b	46	UCPTrie *ownedTrie;
b331163b A	47	};
	48
	49	LoadedNormalizer2Impl::~LoadedNormalizer2Impl() {
	50	udata_close(memory);
3d1f044b	51	ucptrie_close(ownedTrie);
b331163b A	52	}
	53
	54	UBool U_CALLCONV
	55	LoadedNormalizer2Impl::isAcceptable(void * /context/,
	56	const char * /* type /, const char /name/,
	57	const UDataInfo *pInfo) {
	58	if(
	59	pInfo->size>=20 &&
	60	pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
	61	pInfo->charsetFamily==U_CHARSET_FAMILY &&
	62	pInfo->dataFormat[0]==0x4e && /* dataFormat="Nrm2" */
	63	pInfo->dataFormat[1]==0x72 &&
	64	pInfo->dataFormat[2]==0x6d &&
	65	pInfo->dataFormat[3]==0x32 &&
3d1f044b	66	pInfo->formatVersion[0]==4
b331163b A	67	) {
	68	// Normalizer2Impl me=(Normalizer2Impl )context;
	69	// uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4);
	70	return TRUE;
	71	} else {
	72	return FALSE;
	73	}
	74	}
	75
	76	void
	77	LoadedNormalizer2Impl::load(const char packageName, const char name, UErrorCode &errorCode) {
	78	if(U_FAILURE(errorCode)) {
	79	return;
	80	}
	81	memory=udata_openChoice(packageName, "nrm", name, isAcceptable, this, &errorCode);
	82	if(U_FAILURE(errorCode)) {
	83	return;
	84	}
	85	const uint8_t inBytes=(const uint8_t )udata_getMemory(memory);
	86	const int32_t inIndexes=(const int32_t )inBytes;
	87	int32_t indexesLength=inIndexes[IX_NORM_TRIE_OFFSET]/4;
0f5d89e8	88	if(indexesLength<=IX_MIN_LCCC_CP) {
b331163b A	89	errorCode=U_INVALID_FORMAT_ERROR; // Not enough indexes.
	90	return;
	91	}
	92
	93	int32_t offset=inIndexes[IX_NORM_TRIE_OFFSET];
	94	int32_t nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
3d1f044b A	95	ownedTrie=ucptrie_openFromBinary(UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16,
	96	inBytes+offset, nextOffset-offset, NULL,
	97	&errorCode);
b331163b A	98	if(U_FAILURE(errorCode)) {
	99	return;
	100	}
	101
	102	offset=nextOffset;
	103	nextOffset=inIndexes[IX_SMALL_FCD_OFFSET];
	104	const uint16_t inExtraData=(const uint16_t )(inBytes+offset);
	105
	106	// smallFCD: new in formatVersion 2
	107	offset=nextOffset;
	108	const uint8_t *inSmallFCD=inBytes+offset;
	109
	110	init(inIndexes, ownedTrie, inExtraData, inSmallFCD);
	111	}
	112
	113	// instance cache ---------------------------------------------------------- ***
	114
	115	Norm2AllModes *
	116	Norm2AllModes::createInstance(const char *packageName,
	117	const char *name,
	118	UErrorCode &errorCode) {
	119	if(U_FAILURE(errorCode)) {
	120	return NULL;
	121	}
	122	LoadedNormalizer2Impl *impl=new LoadedNormalizer2Impl;
	123	if(impl==NULL) {
	124	errorCode=U_MEMORY_ALLOCATION_ERROR;
	125	return NULL;
	126	}
	127	impl->load(packageName, name, errorCode);
	128	return createInstance(impl, errorCode);
	129	}
	130
	131	U_CDECL_BEGIN
	132	static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup();
	133	U_CDECL_END
	134
3d1f044b A	135	#if !NORM2_HARDCODE_NFC_DATA
	136	static Norm2AllModes *nfcSingleton;
	137	static icu::UInitOnce nfcInitOnce = U_INITONCE_INITIALIZER;
	138	#endif
b331163b	139
3d1f044b	140	static Norm2AllModes *nfkcSingleton;
b331163b	141	static icu::UInitOnce nfkcInitOnce = U_INITONCE_INITIALIZER;
3d1f044b A	142
3d1f044b A	143	static Norm2AllModes *nfkc_cfSingleton;
b331163b A	144	static icu::UInitOnce nfkc_cfInitOnce = U_INITONCE_INITIALIZER;
b331163b A	145
3d1f044b A	146	static UHashtable *cache=NULL;
3d1f044b A	147
b331163b A	148	// UInitOnce singleton initialization function
b331163b A	149	static void U_CALLCONV initSingletons(const char *what, UErrorCode &errorCode) {
3d1f044b A	150	#if !NORM2_HARDCODE_NFC_DATA
	151	if (uprv_strcmp(what, "nfc") == 0) {
	152	nfcSingleton = Norm2AllModes::createInstance(NULL, "nfc", errorCode);
	153	} else
	154	#endif
b331163b A	155	if (uprv_strcmp(what, "nfkc") == 0) {
	156	nfkcSingleton = Norm2AllModes::createInstance(NULL, "nfkc", errorCode);
	157	} else if (uprv_strcmp(what, "nfkc_cf") == 0) {
	158	nfkc_cfSingleton = Norm2AllModes::createInstance(NULL, "nfkc_cf", errorCode);
	159	} else {
3d1f044b	160	UPRV_UNREACHABLE; // Unknown singleton
b331163b A	161	}
	162	ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
	163	}
	164
	165	U_CDECL_BEGIN
	166
	167	static void U_CALLCONV deleteNorm2AllModes(void *allModes) {
	168	delete (Norm2AllModes *)allModes;
	169	}
	170
	171	static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup() {
3d1f044b A	172	#if !NORM2_HARDCODE_NFC_DATA
	173	delete nfcSingleton;
	174	nfcSingleton = NULL;
	175	nfcInitOnce.reset();
	176	#endif
	177
b331163b A	178	delete nfkcSingleton;
b331163b A	179	nfkcSingleton = NULL;
3d1f044b A	180	nfkcInitOnce.reset();
3d1f044b A	181
b331163b A	182	delete nfkc_cfSingleton;
b331163b A	183	nfkc_cfSingleton = NULL;
3d1f044b A	184	nfkc_cfInitOnce.reset();
3d1f044b A	185
b331163b A	186	uhash_close(cache);
b331163b A	187	cache=NULL;
b331163b A	188	return TRUE;
	189	}
	190
	191	U_CDECL_END
	192
3d1f044b A	193	#if !NORM2_HARDCODE_NFC_DATA
	194	const Norm2AllModes *
	195	Norm2AllModes::getNFCInstance(UErrorCode &errorCode) {
	196	if(U_FAILURE(errorCode)) { return NULL; }
	197	umtx_initOnce(nfcInitOnce, &initSingletons, "nfc", errorCode);
	198	return nfcSingleton;
	199	}
	200	#endif
	201
b331163b A	202	const Norm2AllModes *
	203	Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) {
	204	if(U_FAILURE(errorCode)) { return NULL; }
	205	umtx_initOnce(nfkcInitOnce, &initSingletons, "nfkc", errorCode);
	206	return nfkcSingleton;
	207	}
	208
	209	const Norm2AllModes *
	210	Norm2AllModes::getNFKC_CFInstance(UErrorCode &errorCode) {
	211	if(U_FAILURE(errorCode)) { return NULL; }
	212	umtx_initOnce(nfkc_cfInitOnce, &initSingletons, "nfkc_cf", errorCode);
	213	return nfkc_cfSingleton;
	214	}
	215
3d1f044b A	216	#if !NORM2_HARDCODE_NFC_DATA
	217	const Normalizer2 *
	218	Normalizer2::getNFCInstance(UErrorCode &errorCode) {
	219	const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
	220	return allModes!=NULL ? &allModes->comp : NULL;
	221	}
	222
	223	const Normalizer2 *
	224	Normalizer2::getNFDInstance(UErrorCode &errorCode) {
	225	const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
	226	return allModes!=NULL ? &allModes->decomp : NULL;
	227	}
	228
	229	const Normalizer2 *Normalizer2Factory::getFCDInstance(UErrorCode &errorCode) {
	230	const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
	231	return allModes!=NULL ? &allModes->fcd : NULL;
	232	}
	233
	234	const Normalizer2 *Normalizer2Factory::getFCCInstance(UErrorCode &errorCode) {
	235	const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
	236	return allModes!=NULL ? &allModes->fcc : NULL;
	237	}
	238
	239	const Normalizer2Impl *
	240	Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) {
	241	const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
	242	return allModes!=NULL ? allModes->impl : NULL;
	243	}
	244	#endif
	245
b331163b A	246	const Normalizer2 *
	247	Normalizer2::getNFKCInstance(UErrorCode &errorCode) {
	248	const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
	249	return allModes!=NULL ? &allModes->comp : NULL;
	250	}
	251
	252	const Normalizer2 *
	253	Normalizer2::getNFKDInstance(UErrorCode &errorCode) {
	254	const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
	255	return allModes!=NULL ? &allModes->decomp : NULL;
	256	}
	257
	258	const Normalizer2 *
	259	Normalizer2::getNFKCCasefoldInstance(UErrorCode &errorCode) {
	260	const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
	261	return allModes!=NULL ? &allModes->comp : NULL;
	262	}
	263
	264	const Normalizer2 *
	265	Normalizer2::getInstance(const char *packageName,
	266	const char *name,
	267	UNormalization2Mode mode,
	268	UErrorCode &errorCode) {
	269	if(U_FAILURE(errorCode)) {
	270	return NULL;
	271	}
	272	if(name==NULL \|\| *name==0) {
	273	errorCode=U_ILLEGAL_ARGUMENT_ERROR;
	274	return NULL;
	275	}
	276	const Norm2AllModes *allModes=NULL;
	277	if(packageName==NULL) {
	278	if(0==uprv_strcmp(name, "nfc")) {
	279	allModes=Norm2AllModes::getNFCInstance(errorCode);
	280	} else if(0==uprv_strcmp(name, "nfkc")) {
	281	allModes=Norm2AllModes::getNFKCInstance(errorCode);
	282	} else if(0==uprv_strcmp(name, "nfkc_cf")) {
	283	allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
	284	}
	285	}
	286	if(allModes==NULL && U_SUCCESS(errorCode)) {
	287	{
	288	Mutex lock;
	289	if(cache!=NULL) {
	290	allModes=(Norm2AllModes *)uhash_get(cache, name);
	291	}
	292	}
	293	if(allModes==NULL) {
f3c0d7a5	294	ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
b331163b A	295	LocalPointer<Norm2AllModes> localAllModes(
	296	Norm2AllModes::createInstance(packageName, name, errorCode));
	297	if(U_SUCCESS(errorCode)) {
	298	Mutex lock;
	299	if(cache==NULL) {
	300	cache=uhash_open(uhash_hashChars, uhash_compareChars, NULL, &errorCode);
	301	if(U_FAILURE(errorCode)) {
	302	return NULL;
	303	}
	304	uhash_setKeyDeleter(cache, uprv_free);
	305	uhash_setValueDeleter(cache, deleteNorm2AllModes);
	306	}
	307	void *temp=uhash_get(cache, name);
	308	if(temp==NULL) {
3d1f044b	309	int32_t keyLength= static_cast<int32_t>(uprv_strlen(name)+1);
b331163b A	310	char nameCopy=(char )uprv_malloc(keyLength);
	311	if(nameCopy==NULL) {
	312	errorCode=U_MEMORY_ALLOCATION_ERROR;
	313	return NULL;
	314	}
	315	uprv_memcpy(nameCopy, name, keyLength);
	316	allModes=localAllModes.getAlias();
	317	uhash_put(cache, nameCopy, localAllModes.orphan(), &errorCode);
	318	} else {
	319	// race condition
	320	allModes=(Norm2AllModes *)temp;
	321	}
	322	}
	323	}
	324	}
	325	if(allModes!=NULL && U_SUCCESS(errorCode)) {
	326	switch(mode) {
	327	case UNORM2_COMPOSE:
	328	return &allModes->comp;
	329	case UNORM2_DECOMPOSE:
	330	return &allModes->decomp;
	331	case UNORM2_FCD:
	332	return &allModes->fcd;
	333	case UNORM2_COMPOSE_CONTIGUOUS:
	334	return &allModes->fcc;
	335	default:
	336	break; // do nothing
	337	}
	338	}
	339	return NULL;
	340	}
	341
	342	const Normalizer2 *
	343	Normalizer2Factory::getInstance(UNormalizationMode mode, UErrorCode &errorCode) {
	344	if(U_FAILURE(errorCode)) {
	345	return NULL;
	346	}
	347	switch(mode) {
	348	case UNORM_NFD:
	349	return Normalizer2::getNFDInstance(errorCode);
	350	case UNORM_NFKD:
	351	return Normalizer2::getNFKDInstance(errorCode);
	352	case UNORM_NFC:
	353	return Normalizer2::getNFCInstance(errorCode);
	354	case UNORM_NFKC:
	355	return Normalizer2::getNFKCInstance(errorCode);
	356	case UNORM_FCD:
	357	return getFCDInstance(errorCode);
	358	default: // UNORM_NONE
	359	return getNoopInstance(errorCode);
	360	}
	361	}
	362
	363	const Normalizer2Impl *
	364	Normalizer2Factory::getNFKCImpl(UErrorCode &errorCode) {
	365	const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
	366	return allModes!=NULL ? allModes->impl : NULL;
	367	}
	368
	369	const Normalizer2Impl *
	370	Normalizer2Factory::getNFKC_CFImpl(UErrorCode &errorCode) {
	371	const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
	372	return allModes!=NULL ? allModes->impl : NULL;
	373	}
374
375	U_NAMESPACE_END
376
377	// C API ------------------------------------------------------------------- ***
378
379	U_NAMESPACE_USE
380
381	U_CAPI const UNormalizer2 * U_EXPORT2
382	unorm2_getNFKCInstance(UErrorCode *pErrorCode) {
383	return (const UNormalizer2 )Normalizer2::getNFKCInstance(pErrorCode);
384	}
385
386	U_CAPI const UNormalizer2 * U_EXPORT2
387	unorm2_getNFKDInstance(UErrorCode *pErrorCode) {
388	return (const UNormalizer2 )Normalizer2::getNFKDInstance(pErrorCode);
389	}
390
391	U_CAPI const UNormalizer2 * U_EXPORT2
392	unorm2_getNFKCCasefoldInstance(UErrorCode *pErrorCode) {
393	return (const UNormalizer2 )Normalizer2::getNFKCCasefoldInstance(pErrorCode);
394	}
395
396	U_CAPI const UNormalizer2 * U_EXPORT2
397	unorm2_getInstance(const char *packageName,
398	const char *name,
399	UNormalization2Mode mode,
400	UErrorCode *pErrorCode) {
401	return (const UNormalizer2 )Normalizer2::getInstance(packageName, name, mode, pErrorCode);
402	}
403
404	U_CFUNC UNormalizationCheckResult
405	unorm_getQuickCheck(UChar32 c, UNormalizationMode mode) {
406	if(mode<=UNORM_NONE \|\| UNORM_FCD<=mode) {
407	return UNORM_YES;
408	}
409	UErrorCode errorCode=U_ZERO_ERROR;
410	const Normalizer2 *norm2=Normalizer2Factory::getInstance(mode, errorCode);
411	if(U_SUCCESS(errorCode)) {
412	return ((const Normalizer2WithImpl *)norm2)->getQuickCheck(c);
413	} else {
414	return UNORM_MAYBE;
415	}
416	}
417
418	#endif // !UCONFIG_NO_NORMALIZATION