| /* |
| ******************************************************************************* |
| * Copyright (C) 1996-2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| * file name: ucol.cpp |
| * encoding: US-ASCII |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * Modification history |
| * Date Name Comments |
| * 1996-1999 various members of ICU team maintained C API for collation framework |
| * 02/16/2001 synwee Added internal method getPrevSpecialCE |
| * 03/01/2001 synwee Added maxexpansion functionality. |
| * 03/16/2001 weiv Collation framework is rewritten in C and made UCA compliant |
| * 2012-2014 markus Rewritten in C++ again. |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| #include "unicode/coll.h" |
| #include "unicode/tblcoll.h" |
| #include "unicode/bytestream.h" |
| #include "unicode/coleitr.h" |
| #include "unicode/ucoleitr.h" |
| #include "unicode/ustring.h" |
| #include "cmemory.h" |
| #include "collation.h" |
| #include "cstring.h" |
| #include "putilimp.h" |
| #include "uassert.h" |
| #include "utracimp.h" |
| |
| U_NAMESPACE_USE |
| |
| U_CAPI UCollator* U_EXPORT2 |
| ucol_openBinary(const uint8_t *bin, int32_t length, |
| const UCollator *base, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) { return NULL; } |
| RuleBasedCollator *coll = new RuleBasedCollator( |
| bin, length, |
| RuleBasedCollator::rbcFromUCollator(base), |
| *status); |
| if(coll == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| if(U_FAILURE(*status)) { |
| delete coll; |
| return NULL; |
| } |
| return coll->toUCollator(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_cloneBinary(const UCollator *coll, |
| uint8_t *buffer, int32_t capacity, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) { |
| return 0; |
| } |
| const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll); |
| if(rbc == NULL && coll != NULL) { |
| *status = U_UNSUPPORTED_ERROR; |
| return 0; |
| } |
| return rbc->cloneBinary(buffer, capacity, *status); |
| } |
| |
| U_CAPI UCollator* U_EXPORT2 |
| ucol_safeClone(const UCollator *coll, void * /*stackBuffer*/, int32_t * pBufferSize, UErrorCode *status) |
| { |
| if (status == NULL || U_FAILURE(*status)){ |
| return NULL; |
| } |
| if (coll == NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| if (pBufferSize != NULL) { |
| int32_t inputSize = *pBufferSize; |
| *pBufferSize = 1; |
| if (inputSize == 0) { |
| return NULL; // preflighting for deprecated functionality |
| } |
| } |
| Collator *newColl = Collator::fromUCollator(coll)->clone(); |
| if (newColl == NULL) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| } else { |
| *status = U_SAFECLONE_ALLOCATED_WARNING; |
| } |
| return newColl->toUCollator(); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_close(UCollator *coll) |
| { |
| UTRACE_ENTRY_OC(UTRACE_UCOL_CLOSE); |
| UTRACE_DATA1(UTRACE_INFO, "coll = %p", coll); |
| if(coll != NULL) { |
| delete Collator::fromUCollator(coll); |
| } |
| UTRACE_EXIT(); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_mergeSortkeys(const uint8_t *src1, int32_t src1Length, |
| const uint8_t *src2, int32_t src2Length, |
| uint8_t *dest, int32_t destCapacity) { |
| /* check arguments */ |
| if( src1==NULL || src1Length<-1 || src1Length==0 || (src1Length>0 && src1[src1Length-1]!=0) || |
| src2==NULL || src2Length<-1 || src2Length==0 || (src2Length>0 && src2[src2Length-1]!=0) || |
| destCapacity<0 || (destCapacity>0 && dest==NULL) |
| ) { |
| /* error, attempt to write a zero byte and return 0 */ |
| if(dest!=NULL && destCapacity>0) { |
| *dest=0; |
| } |
| return 0; |
| } |
| |
| /* check lengths and capacity */ |
| if(src1Length<0) { |
| src1Length=(int32_t)uprv_strlen((const char *)src1)+1; |
| } |
| if(src2Length<0) { |
| src2Length=(int32_t)uprv_strlen((const char *)src2)+1; |
| } |
| |
| int32_t destLength=src1Length+src2Length; |
| if(destLength>destCapacity) { |
| /* the merged sort key does not fit into the destination */ |
| return destLength; |
| } |
| |
| /* merge the sort keys with the same number of levels */ |
| uint8_t *p=dest; |
| for(;;) { |
| /* copy level from src1 not including 00 or 01 */ |
| uint8_t b; |
| while((b=*src1)>=2) { |
| ++src1; |
| *p++=b; |
| } |
| |
| /* add a 02 merge separator */ |
| *p++=2; |
| |
| /* copy level from src2 not including 00 or 01 */ |
| while((b=*src2)>=2) { |
| ++src2; |
| *p++=b; |
| } |
| |
| /* if both sort keys have another level, then add a 01 level separator and continue */ |
| if(*src1==1 && *src2==1) { |
| ++src1; |
| ++src2; |
| *p++=1; |
| } else { |
| break; |
| } |
| } |
| |
| /* |
| * here, at least one sort key is finished now, but the other one |
| * might have some contents left from containing more levels; |
| * that contents is just appended to the result |
| */ |
| if(*src1!=0) { |
| /* src1 is not finished, therefore *src2==0, and src1 is appended */ |
| src2=src1; |
| } |
| /* append src2, "the other, unfinished sort key" */ |
| while((*p++=*src2++)!=0) {} |
| |
| /* the actual length might be less than destLength if either sort key contained illegally embedded zero bytes */ |
| return (int32_t)(p-dest); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_getSortKey(const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| uint8_t *result, |
| int32_t resultLength) |
| { |
| UTRACE_ENTRY(UTRACE_UCOL_GET_SORTKEY); |
| if (UTRACE_LEVEL(UTRACE_VERBOSE)) { |
| UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source string = %vh ", coll, source, |
| ((sourceLength==-1 && source!=NULL) ? u_strlen(source) : sourceLength)); |
| } |
| |
| int32_t keySize = Collator::fromUCollator(coll)-> |
| getSortKey(source, sourceLength, result, resultLength); |
| |
| UTRACE_DATA2(UTRACE_VERBOSE, "Sort Key = %vb", result, keySize); |
| UTRACE_EXIT_VALUE(keySize); |
| return keySize; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_nextSortKeyPart(const UCollator *coll, |
| UCharIterator *iter, |
| uint32_t state[2], |
| uint8_t *dest, int32_t count, |
| UErrorCode *status) |
| { |
| /* error checking */ |
| if(status==NULL || U_FAILURE(*status)) { |
| return 0; |
| } |
| UTRACE_ENTRY(UTRACE_UCOL_NEXTSORTKEYPART); |
| UTRACE_DATA6(UTRACE_VERBOSE, "coll=%p, iter=%p, state=%d %d, dest=%p, count=%d", |
| coll, iter, state[0], state[1], dest, count); |
| |
| int32_t i = Collator::fromUCollator(coll)-> |
| internalNextSortKeyPart(iter, state, dest, count, *status); |
| |
| // Return number of meaningful sortkey bytes. |
| UTRACE_DATA4(UTRACE_VERBOSE, "dest = %vb, state=%d %d", |
| dest,i, state[0], state[1]); |
| UTRACE_EXIT_VALUE_STATUS(i, *status); |
| return i; |
| } |
| |
| /** |
| * Produce a bound for a given sortkey and a number of levels. |
| */ |
| U_CAPI int32_t U_EXPORT2 |
| ucol_getBound(const uint8_t *source, |
| int32_t sourceLength, |
| UColBoundMode boundType, |
| uint32_t noOfLevels, |
| uint8_t *result, |
| int32_t resultLength, |
| UErrorCode *status) |
| { |
| // consistency checks |
| if(status == NULL || U_FAILURE(*status)) { |
| return 0; |
| } |
| if(source == NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| int32_t sourceIndex = 0; |
| // Scan the string until we skip enough of the key OR reach the end of the key |
| do { |
| sourceIndex++; |
| if(source[sourceIndex] == Collation::LEVEL_SEPARATOR_BYTE) { |
| noOfLevels--; |
| } |
| } while (noOfLevels > 0 |
| && (source[sourceIndex] != 0 || sourceIndex < sourceLength)); |
| |
| if((source[sourceIndex] == 0 || sourceIndex == sourceLength) |
| && noOfLevels > 0) { |
| *status = U_SORT_KEY_TOO_SHORT_WARNING; |
| } |
| |
| |
| // READ ME: this code assumes that the values for boundType |
| // enum will not changes. They are set so that the enum value |
| // corresponds to the number of extra bytes each bound type |
| // needs. |
| if(result != NULL && resultLength >= sourceIndex+boundType) { |
| uprv_memcpy(result, source, sourceIndex); |
| switch(boundType) { |
| // Lower bound just gets terminated. No extra bytes |
| case UCOL_BOUND_LOWER: // = 0 |
| break; |
| // Upper bound needs one extra byte |
| case UCOL_BOUND_UPPER: // = 1 |
| result[sourceIndex++] = 2; |
| break; |
| // Upper long bound needs two extra bytes |
| case UCOL_BOUND_UPPER_LONG: // = 2 |
| result[sourceIndex++] = 0xFF; |
| result[sourceIndex++] = 0xFF; |
| break; |
| default: |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| result[sourceIndex++] = 0; |
| |
| return sourceIndex; |
| } else { |
| return sourceIndex+boundType+1; |
| } |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_setMaxVariable(UCollator *coll, UColReorderCode group, UErrorCode *pErrorCode) { |
| if(U_FAILURE(*pErrorCode)) { return; } |
| Collator::fromUCollator(coll)->setMaxVariable(group, *pErrorCode); |
| } |
| |
| U_CAPI UColReorderCode U_EXPORT2 |
| ucol_getMaxVariable(const UCollator *coll) { |
| return Collator::fromUCollator(coll)->getMaxVariable(); |
| } |
| |
| U_CAPI uint32_t U_EXPORT2 |
| ucol_setVariableTop(UCollator *coll, const UChar *varTop, int32_t len, UErrorCode *status) { |
| if(U_FAILURE(*status) || coll == NULL) { |
| return 0; |
| } |
| return Collator::fromUCollator(coll)->setVariableTop(varTop, len, *status); |
| } |
| |
| U_CAPI uint32_t U_EXPORT2 ucol_getVariableTop(const UCollator *coll, UErrorCode *status) { |
| if(U_FAILURE(*status) || coll == NULL) { |
| return 0; |
| } |
| return Collator::fromUCollator(coll)->getVariableTop(*status); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_restoreVariableTop(UCollator *coll, const uint32_t varTop, UErrorCode *status) { |
| if(U_FAILURE(*status) || coll == NULL) { |
| return; |
| } |
| Collator::fromUCollator(coll)->setVariableTop(varTop, *status); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status) { |
| if(U_FAILURE(*status) || coll == NULL) { |
| return; |
| } |
| |
| Collator::fromUCollator(coll)->setAttribute(attr, value, *status); |
| } |
| |
| U_CAPI UColAttributeValue U_EXPORT2 |
| ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status) { |
| if(U_FAILURE(*status) || coll == NULL) { |
| return UCOL_DEFAULT; |
| } |
| |
| return Collator::fromUCollator(coll)->getAttribute(attr, *status); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_setStrength( UCollator *coll, |
| UCollationStrength strength) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| ucol_setAttribute(coll, UCOL_STRENGTH, strength, &status); |
| } |
| |
| U_CAPI UCollationStrength U_EXPORT2 |
| ucol_getStrength(const UCollator *coll) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| return ucol_getAttribute(coll, UCOL_STRENGTH, &status); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_getReorderCodes(const UCollator *coll, |
| int32_t *dest, |
| int32_t destCapacity, |
| UErrorCode *status) { |
| if (U_FAILURE(*status)) { |
| return 0; |
| } |
| |
| return Collator::fromUCollator(coll)->getReorderCodes(dest, destCapacity, *status); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_setReorderCodes(UCollator* coll, |
| const int32_t* reorderCodes, |
| int32_t reorderCodesLength, |
| UErrorCode *status) { |
| if (U_FAILURE(*status)) { |
| return; |
| } |
| |
| Collator::fromUCollator(coll)->setReorderCodes(reorderCodes, reorderCodesLength, *status); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_getEquivalentReorderCodes(int32_t reorderCode, |
| int32_t* dest, |
| int32_t destCapacity, |
| UErrorCode *pErrorCode) { |
| return Collator::getEquivalentReorderCodes(reorderCode, dest, destCapacity, *pErrorCode); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_getVersion(const UCollator* coll, |
| UVersionInfo versionInfo) |
| { |
| Collator::fromUCollator(coll)->getVersion(versionInfo); |
| } |
| |
| U_CAPI UCollationResult U_EXPORT2 |
| ucol_strcollIter( const UCollator *coll, |
| UCharIterator *sIter, |
| UCharIterator *tIter, |
| UErrorCode *status) |
| { |
| if(!status || U_FAILURE(*status)) { |
| return UCOL_EQUAL; |
| } |
| |
| UTRACE_ENTRY(UTRACE_UCOL_STRCOLLITER); |
| UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, sIter=%p, tIter=%p", coll, sIter, tIter); |
| |
| if(sIter == NULL || tIter == NULL || coll == NULL) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| UTRACE_EXIT_VALUE_STATUS(UCOL_EQUAL, *status); |
| return UCOL_EQUAL; |
| } |
| |
| UCollationResult result = Collator::fromUCollator(coll)->compare(*sIter, *tIter, *status); |
| |
| UTRACE_EXIT_VALUE_STATUS(result, *status); |
| return result; |
| } |
| |
| |
| /* */ |
| /* ucol_strcoll Main public API string comparison function */ |
| /* */ |
| U_CAPI UCollationResult U_EXPORT2 |
| ucol_strcoll( const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| const UChar *target, |
| int32_t targetLength) |
| { |
| UTRACE_ENTRY(UTRACE_UCOL_STRCOLL); |
| if (UTRACE_LEVEL(UTRACE_VERBOSE)) { |
| UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source=%p, target=%p", coll, source, target); |
| UTRACE_DATA2(UTRACE_VERBOSE, "source string = %vh ", source, sourceLength); |
| UTRACE_DATA2(UTRACE_VERBOSE, "target string = %vh ", target, targetLength); |
| } |
| |
| UErrorCode status = U_ZERO_ERROR; |
| UCollationResult returnVal = Collator::fromUCollator(coll)-> |
| compare(source, sourceLength, target, targetLength, status); |
| UTRACE_EXIT_VALUE_STATUS(returnVal, status); |
| return returnVal; |
| } |
| |
| U_CAPI UCollationResult U_EXPORT2 |
| ucol_strcollUTF8( |
| const UCollator *coll, |
| const char *source, |
| int32_t sourceLength, |
| const char *target, |
| int32_t targetLength, |
| UErrorCode *status) |
| { |
| UTRACE_ENTRY(UTRACE_UCOL_STRCOLLUTF8); |
| if (UTRACE_LEVEL(UTRACE_VERBOSE)) { |
| UTRACE_DATA3(UTRACE_VERBOSE, "coll=%p, source=%p, target=%p", coll, source, target); |
| UTRACE_DATA2(UTRACE_VERBOSE, "source string = %vb ", source, sourceLength); |
| UTRACE_DATA2(UTRACE_VERBOSE, "target string = %vb ", target, targetLength); |
| } |
| |
| if (U_FAILURE(*status)) { |
| /* do nothing */ |
| UTRACE_EXIT_VALUE_STATUS(UCOL_EQUAL, *status); |
| return UCOL_EQUAL; |
| } |
| |
| UCollationResult returnVal = Collator::fromUCollator(coll)->internalCompareUTF8( |
| source, sourceLength, target, targetLength, *status); |
| UTRACE_EXIT_VALUE_STATUS(returnVal, *status); |
| return returnVal; |
| } |
| |
| |
| /* convenience function for comparing strings */ |
| U_CAPI UBool U_EXPORT2 |
| ucol_greater( const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| const UChar *target, |
| int32_t targetLength) |
| { |
| return (ucol_strcoll(coll, source, sourceLength, target, targetLength) |
| == UCOL_GREATER); |
| } |
| |
| /* convenience function for comparing strings */ |
| U_CAPI UBool U_EXPORT2 |
| ucol_greaterOrEqual( const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| const UChar *target, |
| int32_t targetLength) |
| { |
| return (ucol_strcoll(coll, source, sourceLength, target, targetLength) |
| != UCOL_LESS); |
| } |
| |
| /* convenience function for comparing strings */ |
| U_CAPI UBool U_EXPORT2 |
| ucol_equal( const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| const UChar *target, |
| int32_t targetLength) |
| { |
| return (ucol_strcoll(coll, source, sourceLength, target, targetLength) |
| == UCOL_EQUAL); |
| } |
| |
| U_CAPI void U_EXPORT2 |
| ucol_getUCAVersion(const UCollator* coll, UVersionInfo info) { |
| const Collator *c = Collator::fromUCollator(coll); |
| if(c != NULL) { |
| UVersionInfo v; |
| c->getVersion(v); |
| // Note: This is tied to how the current implementation encodes the UCA version |
| // in the overall getVersion(). |
| // Alternatively, we could load the root collator and get at lower-level data from there. |
| // Either way, it will reflect the input collator's UCA version only |
| // if it is a known implementation. |
| // It would be cleaner to make this a virtual Collator method. |
| info[0] = v[1] >> 3; |
| info[1] = v[1] & 7; |
| info[2] = v[2] >> 6; |
| info[3] = 0; |
| } |
| } |
| |
| U_CAPI const UChar * U_EXPORT2 |
| ucol_getRules(const UCollator *coll, int32_t *length) { |
| const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll); |
| // OK to crash if coll==NULL: We do not want to check "this" pointers. |
| if(rbc != NULL || coll == NULL) { |
| const UnicodeString &rules = rbc->getRules(); |
| U_ASSERT(rules.getBuffer()[rules.length()] == 0); |
| *length = rules.length(); |
| return rules.getBuffer(); |
| } |
| static const UChar _NUL = 0; |
| *length = 0; |
| return &_NUL; |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen) { |
| UnicodeString rules; |
| const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll); |
| if(rbc != NULL || coll == NULL) { |
| rbc->getRules(delta, rules); |
| } |
| if(buffer != NULL && bufferLen > 0) { |
| UErrorCode errorCode = U_ZERO_ERROR; |
| return rules.extract(buffer, bufferLen, errorCode); |
| } else { |
| return rules.length(); |
| } |
| } |
| |
| U_CAPI const char * U_EXPORT2 |
| ucol_getLocale(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status) { |
| return ucol_getLocaleByType(coll, type, status); |
| } |
| |
| U_CAPI const char * U_EXPORT2 |
| ucol_getLocaleByType(const UCollator *coll, ULocDataLocaleType type, UErrorCode *status) { |
| if(U_FAILURE(*status)) { |
| return NULL; |
| } |
| UTRACE_ENTRY(UTRACE_UCOL_GETLOCALE); |
| UTRACE_DATA1(UTRACE_INFO, "coll=%p", coll); |
| |
| const char *result; |
| const RuleBasedCollator *rbc = RuleBasedCollator::rbcFromUCollator(coll); |
| if(rbc == NULL && coll != NULL) { |
| *status = U_UNSUPPORTED_ERROR; |
| result = NULL; |
| } else { |
| result = rbc->internalGetLocaleID(type, *status); |
| } |
| |
| UTRACE_DATA1(UTRACE_INFO, "result = %s", result); |
| UTRACE_EXIT_STATUS(*status); |
| return result; |
| } |
| |
| U_CAPI USet * U_EXPORT2 |
| ucol_getTailoredSet(const UCollator *coll, UErrorCode *status) { |
| if(U_FAILURE(*status)) { |
| return NULL; |
| } |
| UnicodeSet *set = Collator::fromUCollator(coll)->getTailoredSet(*status); |
| if(U_FAILURE(*status)) { |
| delete set; |
| return NULL; |
| } |
| return set->toUSet(); |
| } |
| |
| U_CAPI UBool U_EXPORT2 |
| ucol_equals(const UCollator *source, const UCollator *target) { |
| return source == target || |
| (*Collator::fromUCollator(source)) == (*Collator::fromUCollator(target)); |
| } |
| |
| #endif /* #if !UCONFIG_NO_COLLATION */ |
