| // © 2018 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| // characterproperties.cpp | |
| // created: 2018sep03 Markus W. Scherer | |
| #include "unicode/utypes.h" | |
| #include "unicode/localpointer.h" | |
| #include "unicode/uchar.h" | |
| #include "unicode/ucpmap.h" | |
| #include "unicode/ucptrie.h" | |
| #include "unicode/umutablecptrie.h" | |
| #include "unicode/uniset.h" | |
| #include "unicode/uscript.h" | |
| #include "unicode/uset.h" | |
| #include "cmemory.h" | |
| #include "mutex.h" | |
| #include "normalizer2impl.h" | |
| #include "uassert.h" | |
| #include "ubidi_props.h" | |
| #include "ucase.h" | |
| #include "ucln_cmn.h" | |
| #include "umutex.h" | |
| #include "uprops.h" | |
| using icu::LocalPointer; | |
| #if !UCONFIG_NO_NORMALIZATION | |
| using icu::Normalizer2Factory; | |
| using icu::Normalizer2Impl; | |
| #endif | |
| using icu::UInitOnce; | |
| using icu::UnicodeSet; | |
| namespace { | |
| UBool U_CALLCONV characterproperties_cleanup(); | |
| constexpr int32_t NUM_INCLUSIONS = UPROPS_SRC_COUNT + UCHAR_INT_LIMIT - UCHAR_INT_START; | |
| struct Inclusion { | |
| UnicodeSet *fSet = nullptr; | |
| UInitOnce fInitOnce = U_INITONCE_INITIALIZER; | |
| }; | |
| Inclusion gInclusions[NUM_INCLUSIONS]; // cached getInclusions() | |
| UnicodeSet *sets[UCHAR_BINARY_LIMIT] = {}; | |
| UCPMap *maps[UCHAR_INT_LIMIT - UCHAR_INT_START] = {}; | |
| icu::UMutex cpMutex; | |
| //---------------------------------------------------------------- | |
| // Inclusions list | |
| //---------------------------------------------------------------- | |
| // USetAdder implementation | |
| // Does not use uset.h to reduce code dependencies | |
| void U_CALLCONV | |
| _set_add(USet *set, UChar32 c) { | |
| ((UnicodeSet *)set)->add(c); | |
| } | |
| void U_CALLCONV | |
| _set_addRange(USet *set, UChar32 start, UChar32 end) { | |
| ((UnicodeSet *)set)->add(start, end); | |
| } | |
| void U_CALLCONV | |
| _set_addString(USet *set, const UChar *str, int32_t length) { | |
| ((UnicodeSet *)set)->add(icu::UnicodeString((UBool)(length<0), str, length)); | |
| } | |
| UBool U_CALLCONV characterproperties_cleanup() { | |
| for (Inclusion &in: gInclusions) { | |
| delete in.fSet; | |
| in.fSet = nullptr; | |
| in.fInitOnce.reset(); | |
| } | |
| for (int32_t i = 0; i < UPRV_LENGTHOF(sets); ++i) { | |
| delete sets[i]; | |
| sets[i] = nullptr; | |
| } | |
| for (int32_t i = 0; i < UPRV_LENGTHOF(maps); ++i) { | |
| ucptrie_close(reinterpret_cast<UCPTrie *>(maps[i])); | |
| maps[i] = nullptr; | |
| } | |
| return TRUE; | |
| } | |
| void U_CALLCONV initInclusion(UPropertySource src, UErrorCode &errorCode) { | |
| // This function is invoked only via umtx_initOnce(). | |
| U_ASSERT(0 <= src && src < UPROPS_SRC_COUNT); | |
| if (src == UPROPS_SRC_NONE) { | |
| errorCode = U_INTERNAL_PROGRAM_ERROR; | |
| return; | |
| } | |
| U_ASSERT(gInclusions[src].fSet == nullptr); | |
| LocalPointer<UnicodeSet> incl(new UnicodeSet()); | |
| if (incl.isNull()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| USetAdder sa = { | |
| (USet *)incl.getAlias(), | |
| _set_add, | |
| _set_addRange, | |
| _set_addString, | |
| nullptr, // don't need remove() | |
| nullptr // don't need removeRange() | |
| }; | |
| switch(src) { | |
| case UPROPS_SRC_CHAR: | |
| uchar_addPropertyStarts(&sa, &errorCode); | |
| break; | |
| case UPROPS_SRC_PROPSVEC: | |
| upropsvec_addPropertyStarts(&sa, &errorCode); | |
| break; | |
| case UPROPS_SRC_CHAR_AND_PROPSVEC: | |
| uchar_addPropertyStarts(&sa, &errorCode); | |
| upropsvec_addPropertyStarts(&sa, &errorCode); | |
| break; | |
| #if !UCONFIG_NO_NORMALIZATION | |
| case UPROPS_SRC_CASE_AND_NORM: { | |
| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); | |
| if(U_SUCCESS(errorCode)) { | |
| impl->addPropertyStarts(&sa, errorCode); | |
| } | |
| ucase_addPropertyStarts(&sa, &errorCode); | |
| break; | |
| } | |
| case UPROPS_SRC_NFC: { | |
| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); | |
| if(U_SUCCESS(errorCode)) { | |
| impl->addPropertyStarts(&sa, errorCode); | |
| } | |
| break; | |
| } | |
| case UPROPS_SRC_NFKC: { | |
| const Normalizer2Impl *impl=Normalizer2Factory::getNFKCImpl(errorCode); | |
| if(U_SUCCESS(errorCode)) { | |
| impl->addPropertyStarts(&sa, errorCode); | |
| } | |
| break; | |
| } | |
| case UPROPS_SRC_NFKC_CF: { | |
| const Normalizer2Impl *impl=Normalizer2Factory::getNFKC_CFImpl(errorCode); | |
| if(U_SUCCESS(errorCode)) { | |
| impl->addPropertyStarts(&sa, errorCode); | |
| } | |
| break; | |
| } | |
| case UPROPS_SRC_NFC_CANON_ITER: { | |
| const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); | |
| if(U_SUCCESS(errorCode)) { | |
| impl->addCanonIterPropertyStarts(&sa, errorCode); | |
| } | |
| break; | |
| } | |
| #endif | |
| case UPROPS_SRC_CASE: | |
| ucase_addPropertyStarts(&sa, &errorCode); | |
| break; | |
| case UPROPS_SRC_BIDI: | |
| ubidi_addPropertyStarts(&sa, &errorCode); | |
| break; | |
| case UPROPS_SRC_INPC: | |
| case UPROPS_SRC_INSC: | |
| case UPROPS_SRC_VO: | |
| uprops_addPropertyStarts((UPropertySource)src, &sa, &errorCode); | |
| break; | |
| default: | |
| errorCode = U_INTERNAL_PROGRAM_ERROR; | |
| break; | |
| } | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| if (incl->isBogus()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| // Compact for caching. | |
| incl->compact(); | |
| gInclusions[src].fSet = incl.orphan(); | |
| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); | |
| } | |
| const UnicodeSet *getInclusionsForSource(UPropertySource src, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode)) { return nullptr; } | |
| if (src < 0 || UPROPS_SRC_COUNT <= src) { | |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| return nullptr; | |
| } | |
| Inclusion &i = gInclusions[src]; | |
| umtx_initOnce(i.fInitOnce, &initInclusion, src, errorCode); | |
| return i.fSet; | |
| } | |
| void U_CALLCONV initIntPropInclusion(UProperty prop, UErrorCode &errorCode) { | |
| // This function is invoked only via umtx_initOnce(). | |
| U_ASSERT(UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT); | |
| int32_t inclIndex = UPROPS_SRC_COUNT + prop - UCHAR_INT_START; | |
| U_ASSERT(gInclusions[inclIndex].fSet == nullptr); | |
| UPropertySource src = uprops_getSource(prop); | |
| const UnicodeSet *incl = getInclusionsForSource(src, errorCode); | |
| if (U_FAILURE(errorCode)) { | |
| return; | |
| } | |
| LocalPointer<UnicodeSet> intPropIncl(new UnicodeSet(0, 0)); | |
| if (intPropIncl.isNull()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| int32_t numRanges = incl->getRangeCount(); | |
| int32_t prevValue = 0; | |
| for (int32_t i = 0; i < numRanges; ++i) { | |
| UChar32 rangeEnd = incl->getRangeEnd(i); | |
| for (UChar32 c = incl->getRangeStart(i); c <= rangeEnd; ++c) { | |
| // TODO: Get a UCharacterProperty.IntProperty to avoid the property dispatch. | |
| int32_t value = u_getIntPropertyValue(c, prop); | |
| if (value != prevValue) { | |
| intPropIncl->add(c); | |
| prevValue = value; | |
| } | |
| } | |
| } | |
| if (intPropIncl->isBogus()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return; | |
| } | |
| // Compact for caching. | |
| intPropIncl->compact(); | |
| gInclusions[inclIndex].fSet = intPropIncl.orphan(); | |
| ucln_common_registerCleanup(UCLN_COMMON_CHARACTERPROPERTIES, characterproperties_cleanup); | |
| } | |
| } // namespace | |
| U_NAMESPACE_BEGIN | |
| const UnicodeSet *CharacterProperties::getInclusionsForProperty( | |
| UProperty prop, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode)) { return nullptr; } | |
| if (UCHAR_INT_START <= prop && prop < UCHAR_INT_LIMIT) { | |
| int32_t inclIndex = UPROPS_SRC_COUNT + prop - UCHAR_INT_START; | |
| Inclusion &i = gInclusions[inclIndex]; | |
| umtx_initOnce(i.fInitOnce, &initIntPropInclusion, prop, errorCode); | |
| return i.fSet; | |
| } else { | |
| UPropertySource src = uprops_getSource(prop); | |
| return getInclusionsForSource(src, errorCode); | |
| } | |
| } | |
| U_NAMESPACE_END | |
| namespace { | |
| UnicodeSet *makeSet(UProperty property, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode)) { return nullptr; } | |
| LocalPointer<UnicodeSet> set(new UnicodeSet()); | |
| if (set.isNull()) { | |
| errorCode = U_MEMORY_ALLOCATION_ERROR; | |
| return nullptr; | |
| } | |
| const UnicodeSet *inclusions = | |
| icu::CharacterProperties::getInclusionsForProperty(property, errorCode); | |
| if (U_FAILURE(errorCode)) { return nullptr; } | |
| int32_t numRanges = inclusions->getRangeCount(); | |
| UChar32 startHasProperty = -1; | |
| for (int32_t i = 0; i < numRanges; ++i) { | |
| UChar32 rangeEnd = inclusions->getRangeEnd(i); | |
| for (UChar32 c = inclusions->getRangeStart(i); c <= rangeEnd; ++c) { | |
| // TODO: Get a UCharacterProperty.BinaryProperty to avoid the property dispatch. | |
| if (u_hasBinaryProperty(c, property)) { | |
| if (startHasProperty < 0) { | |
| // Transition from false to true. | |
| startHasProperty = c; | |
| } | |
| } else if (startHasProperty >= 0) { | |
| // Transition from true to false. | |
| set->add(startHasProperty, c - 1); | |
| startHasProperty = -1; | |
| } | |
| } | |
| } | |
| if (startHasProperty >= 0) { | |
| set->add(startHasProperty, 0x10FFFF); | |
| } | |
| set->freeze(); | |
| return set.orphan(); | |
| } | |
| UCPMap *makeMap(UProperty property, UErrorCode &errorCode) { | |
| if (U_FAILURE(errorCode)) { return nullptr; } | |
| uint32_t nullValue = property == UCHAR_SCRIPT ? USCRIPT_UNKNOWN : 0; | |
| icu::LocalUMutableCPTriePointer mutableTrie( | |
| umutablecptrie_open(nullValue, nullValue, &errorCode)); | |
| const UnicodeSet *inclusions = | |
| icu::CharacterProperties::getInclusionsForProperty(property, errorCode); | |
| if (U_FAILURE(errorCode)) { return nullptr; } | |
| int32_t numRanges = inclusions->getRangeCount(); | |
| UChar32 start = 0; | |
| uint32_t value = nullValue; | |
| for (int32_t i = 0; i < numRanges; ++i) { | |
| UChar32 rangeEnd = inclusions->getRangeEnd(i); | |
| for (UChar32 c = inclusions->getRangeStart(i); c <= rangeEnd; ++c) { | |
| // TODO: Get a UCharacterProperty.IntProperty to avoid the property dispatch. | |
| uint32_t nextValue = u_getIntPropertyValue(c, property); | |
| if (value != nextValue) { | |
| if (value != nullValue) { | |
| umutablecptrie_setRange(mutableTrie.getAlias(), start, c - 1, value, &errorCode); | |
| } | |
| start = c; | |
| value = nextValue; | |
| } | |
| } | |
| } | |
| if (value != 0) { | |
| umutablecptrie_setRange(mutableTrie.getAlias(), start, 0x10FFFF, value, &errorCode); | |
| } | |
| UCPTrieType type; | |
| if (property == UCHAR_BIDI_CLASS || property == UCHAR_GENERAL_CATEGORY) { | |
| type = UCPTRIE_TYPE_FAST; | |
| } else { | |
| type = UCPTRIE_TYPE_SMALL; | |
| } | |
| UCPTrieValueWidth valueWidth; | |
| // TODO: UCharacterProperty.IntProperty | |
| int32_t max = u_getIntPropertyMaxValue(property); | |
| if (max <= 0xff) { | |
| valueWidth = UCPTRIE_VALUE_BITS_8; | |
| } else if (max <= 0xffff) { | |
| valueWidth = UCPTRIE_VALUE_BITS_16; | |
| } else { | |
| valueWidth = UCPTRIE_VALUE_BITS_32; | |
| } | |
| return reinterpret_cast<UCPMap *>( | |
| umutablecptrie_buildImmutable(mutableTrie.getAlias(), type, valueWidth, &errorCode)); | |
| } | |
| } // namespace | |
| U_NAMESPACE_USE | |
| U_CAPI const USet * U_EXPORT2 | |
| u_getBinaryPropertySet(UProperty property, UErrorCode *pErrorCode) { | |
| if (U_FAILURE(*pErrorCode)) { return nullptr; } | |
| if (property < 0 || UCHAR_BINARY_LIMIT <= property) { | |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| return nullptr; | |
| } | |
| Mutex m(&cpMutex); | |
| UnicodeSet *set = sets[property]; | |
| if (set == nullptr) { | |
| sets[property] = set = makeSet(property, *pErrorCode); | |
| } | |
| if (U_FAILURE(*pErrorCode)) { return nullptr; } | |
| return set->toUSet(); | |
| } | |
| U_CAPI const UCPMap * U_EXPORT2 | |
| u_getIntPropertyMap(UProperty property, UErrorCode *pErrorCode) { | |
| if (U_FAILURE(*pErrorCode)) { return nullptr; } | |
| if (property < UCHAR_INT_START || UCHAR_INT_LIMIT <= property) { | |
| *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; | |
| return nullptr; | |
| } | |
| Mutex m(&cpMutex); | |
| UCPMap *map = maps[property - UCHAR_INT_START]; | |
| if (map == nullptr) { | |
| maps[property - UCHAR_INT_START] = map = makeMap(property, *pErrorCode); | |
| } | |
| return map; | |
| } |