| /* |
| ******************************************************************************* |
| * Copyright (C) 1996-1999, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| */ |
| |
| #include "unicode/ucol.h" |
| |
| #include "unicode/uloc.h" |
| #include "unicode/coll.h" |
| #include "unicode/tblcoll.h" |
| #include "unicode/coleitr.h" |
| #include "unicode/ustring.h" |
| #include "unicode/normlzr.h" |
| #include "cpputils.h" |
| |
| |
| static uint8_t utf16fixup[32] = { |
| 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0x20, 0xf8, 0xf8, 0xf8, 0xf8 |
| }; |
| |
| |
| #include <stdio.h> |
| |
| #include "ucmp32.h" |
| #include "tcoldata.h" |
| #include "tables.h" |
| #define UCOL_MAX_BUFFER 1000 |
| #define UCOL_WRITABLE_BUFFER_SIZE 256 |
| |
| struct collIterate { |
| UChar *string; // Original string |
| UChar *len; // Original string length |
| UChar *pos; // This is position in the string |
| uint32_t *toReturn; // This is the CE from CEs buffer that should be returned |
| uint32_t *CEpos; // This is the position to which we have stored processed CEs |
| uint32_t CEs[UCOL_MAX_BUFFER]; // This is where we store CEs |
| UBool isThai; // Have we already encountered a Thai prevowel |
| UBool isWritable; // is the source buffer writable? |
| UChar stackWritableBuffer[UCOL_WRITABLE_BUFFER_SIZE]; // A writable buffer. |
| UChar *writableBuffer; |
| }; |
| |
| |
| #define UCOL_UNMAPPEDCHARVALUE 0x7fff0000 // from coleiterator |
| |
| #define UCOL_LEVELTERMINATOR 1 |
| #define UCOL_IGNORABLE 0x0000 |
| #define UCOL_CHARINDEX 0x70000000 // need look up in .commit() |
| #define UCOL_EXPANDCHARINDEX 0x7E000000 // Expand index follows |
| #define UCOL_CONTRACTCHARINDEX 0x7F000000 // contract indexes follows |
| #define UCOL_UNMAPPED 0xFFFFFFFF // unmapped character values |
| #define UCOL_PRIMARYORDERINCREMENT 0x00010000 // primary strength increment |
| #define UCOL_SECONDARYORDERINCREMENT 0x00000100 // secondary strength increment |
| #define UCOL_TERTIARYORDERINCREMENT 0x00000001 // tertiary strength increment |
| #define UCOL_MAXIGNORABLE 0x00010000 // maximum ignorable char order value |
| #define UCOL_PRIMARYORDERMASK 0xffff0000 // mask off anything but primary order |
| #define UCOL_SECONDARYORDERMASK 0x0000ff00 // mask off anything but secondary order |
| #define UCOL_TERTIARYORDERMASK 0x000000ff // mask off anything but tertiary order |
| #define UCOL_SECONDARYRESETMASK 0x0000ffff // mask off secondary and tertiary order |
| #define UCOL_IGNORABLEMASK 0x0000ffff // mask off ignorable char order |
| #define UCOL_PRIMARYDIFFERENCEONLY 0xffff0000 // use only the primary difference |
| #define UCOL_SECONDARYDIFFERENCEONLY 0xffffff00 // use only the primary and secondary difference |
| #define UCOL_PRIMARYORDERSHIFT 16 // primary order shift |
| #define UCOL_SECONDARYORDERSHIFT 8 // secondary order shift |
| #define UCOL_SORTKEYOFFSET 2 // minimum sort key offset |
| #define UCOL_CONTRACTCHAROVERFLOW 0x7FFFFFFF // Indicates the char is a contract char |
| |
| #define UCOL_PRIMARYORDER(order) (((order) & UCOL_PRIMARYORDERMASK)>> UCOL_PRIMARYORDERSHIFT) |
| #define UCOL_SECONDARYORDER(order) (((order) & UCOL_SECONDARYORDERMASK)>> UCOL_SECONDARYORDERSHIFT) |
| #define UCOL_TERTIARYORDER(order) ((order) & UCOL_TERTIARYORDERMASK) |
| |
| /** |
| * Determine if a character is a Thai vowel (which sorts after |
| * its base consonant). |
| */ |
| #define UCOL_ISTHAIPREVOWEL(ch) ((uint32_t)(ch) - 0xe40) <= (0xe44 - 0xe40) |
| |
| /** |
| * Determine if a character is a Thai base consonant |
| */ |
| #define UCOL_ISTHAIBASECONSONANT(ch) ((uint32_t)(ch) - 0xe01) <= (0xe2e - 0xe01) |
| |
| U_CAPI UCollator* |
| ucol_open( const char *loc, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return 0; |
| |
| Collator *col = 0; |
| |
| if(loc == 0) |
| col = Collator::createInstance(*status); |
| else |
| col = Collator::createInstance(Locale(loc), *status); |
| |
| if(col == 0) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return 0; |
| } |
| |
| return (UCollator*)col; |
| } |
| |
| U_CAPI UCollator* |
| ucol_openRules( const UChar *rules, |
| int32_t rulesLength, |
| UNormalizationMode mode, |
| UCollationStrength strength, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return 0; |
| |
| int32_t len = (rulesLength == -1 ? u_strlen(rules) : rulesLength); |
| const UnicodeString ruleString((UChar*)rules, len, len); |
| |
| Normalizer::EMode normMode; |
| switch(mode) { |
| case UCOL_NO_NORMALIZATION: |
| normMode = Normalizer::NO_OP; |
| break; |
| case UCOL_DECOMP_CAN: |
| normMode = Normalizer::DECOMP; |
| break; |
| case UCOL_DECOMP_COMPAT: |
| normMode = Normalizer::DECOMP_COMPAT; |
| break; |
| case UCOL_DECOMP_CAN_COMP_COMPAT: |
| normMode = Normalizer::COMPOSE; |
| break; |
| case UCOL_DECOMP_COMPAT_COMP_CAN: |
| normMode = Normalizer::COMPOSE_COMPAT; |
| break; |
| default: |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| RuleBasedCollator *col = 0; |
| col = new RuleBasedCollator(ruleString, |
| (Collator::ECollationStrength) strength, |
| normMode, |
| *status); |
| |
| if(col == 0) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return 0; |
| } |
| |
| return (UCollator*) col; |
| } |
| |
| U_CAPI void |
| ucol_close(UCollator *coll) |
| { |
| delete (Collator*)coll; |
| } |
| |
| U_CAPI UBool |
| 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); |
| } |
| |
| U_CAPI UBool |
| 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); |
| } |
| |
| U_CAPI UBool |
| 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 UCollationStrength |
| ucol_getStrength(const UCollator *coll) |
| { |
| return (UCollationStrength) ((Collator*)coll)->getStrength(); |
| } |
| |
| |
| U_CAPI void |
| ucol_setStrength( UCollator *coll, |
| UCollationStrength strength) |
| { |
| ((Collator*)coll)->setStrength((Collator::ECollationStrength)strength); |
| } |
| |
| U_CAPI UNormalizationMode |
| ucol_getNormalization(const UCollator* coll) |
| { |
| switch(((Collator*)coll)->getDecomposition()) { |
| case Normalizer::NO_OP: |
| return UCOL_NO_NORMALIZATION; |
| |
| case Normalizer::COMPOSE: |
| return UCOL_DECOMP_COMPAT_COMP_CAN; |
| |
| case Normalizer::COMPOSE_COMPAT: |
| return UCOL_DECOMP_CAN_COMP_COMPAT; |
| |
| case Normalizer::DECOMP: |
| return UCOL_DECOMP_CAN; |
| |
| case Normalizer::DECOMP_COMPAT: |
| return UCOL_DECOMP_COMPAT; |
| |
| } |
| return UCOL_NO_NORMALIZATION; |
| } |
| |
| U_CAPI void |
| ucol_setNormalization( UCollator *coll, |
| UNormalizationMode mode) |
| { |
| Normalizer::EMode normMode; |
| switch(mode) { |
| case UCOL_NO_NORMALIZATION: |
| normMode = Normalizer::NO_OP; |
| break; |
| case UCOL_DECOMP_CAN: |
| normMode = Normalizer::DECOMP; |
| break; |
| case UCOL_DECOMP_COMPAT: |
| normMode = Normalizer::DECOMP_COMPAT; |
| break; |
| case UCOL_DECOMP_COMPAT_COMP_CAN: |
| normMode = Normalizer::COMPOSE; |
| break; |
| case UCOL_DECOMP_CAN_COMP_COMPAT: |
| normMode = Normalizer::COMPOSE_COMPAT; |
| break; |
| default: |
| /* Shouldn't get here. */ |
| /* *status = U_ILLEGAL_ARGUMENT_ERROR; */ |
| return; |
| } |
| |
| ((Collator*)coll)->setDecomposition(normMode); |
| } |
| |
| U_CAPI int32_t |
| ucol_getDisplayName( const char *objLoc, |
| const char *dispLoc, |
| UChar *result, |
| int32_t resultLength, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return -1; |
| |
| UnicodeString dst(result, resultLength, resultLength); |
| Collator::getDisplayName(Locale(objLoc), Locale(dispLoc), dst); |
| int32_t actLen; |
| T_fillOutputParams(&dst, result, resultLength, &actLen, status); |
| return actLen; |
| } |
| |
| U_CAPI const char* |
| ucol_getAvailable(int32_t index) |
| { |
| return uloc_getAvailable(index); |
| } |
| |
| U_CAPI int32_t |
| ucol_countAvailable() |
| { |
| return uloc_countAvailable(); |
| } |
| |
| U_CAPI const UChar* |
| ucol_getRules( const UCollator *coll, |
| int32_t *length) |
| { |
| const UnicodeString& rules = ((RuleBasedCollator*)coll)->getRules(); |
| *length = rules.length(); |
| return rules.getUChars(); |
| } |
| |
| /* |
| void init_collIterate(const UChar *string, int32_t len, collIterate *s, UBool isWritable) { |
| s->string = s->pos = (UChar *)string; |
| s->len = (UChar *)string+len; |
| s->CEpos = s->toReturn = s->CEs; |
| s->isThai = TRUE; |
| s->isWritable = isWritable; |
| s->writableBuffer = s->stackWritableBuffer; |
| } |
| */ |
| #define init_collIterate(sourceString, sourceLen, s, isSourceWritable) { \ |
| (s)->string = (s)->pos = (UChar *)(sourceString); \ |
| (s)->len = (UChar *)(sourceString)+(sourceLen); \ |
| (s)->CEpos = (s)->toReturn = (s)->CEs; \ |
| (s)->isThai = TRUE; \ |
| (s)->isWritable = (isSourceWritable); \ |
| (s)->writableBuffer = (s)->stackWritableBuffer; \ |
| } |
| |
| /* |
| int32_t ucol_getNextCE(const UCollator *coll, collIterate *source, UErrorCode *status) { |
| |
| if (U_FAILURE(*status) || (source->pos>=source->len && source->CEpos <= source->toReturn)) { |
| return CollationElementIterator::NULLORDER; |
| } |
| |
| if (source->CEpos > source->toReturn) { |
| return(*(source->toReturn++)); |
| } |
| |
| source->CEpos = source->toReturn = source->CEs; |
| |
| *(source->CEpos) = ucmp32_get(((RuleBasedCollator *)coll)->data->mapping, *(source->pos)); |
| |
| // this should benefit from reordering of the clauses, so that the cleanest case is returned the first. |
| |
| if(*(source->CEpos) < UCOL_EXPANDCHARINDEX && !(isThaiPreVowel(*(source->pos)))) { |
| source->pos++; |
| return (*(source->CEpos)); |
| } |
| return getComplicatedCE(coll, source, status); |
| } |
| */ |
| |
| #define UCOL_GETNEXTCE(order, coll, collationSource, status) { \ |
| if (U_FAILURE((status)) || ((collationSource).pos>=(collationSource).len \ |
| && (collationSource).CEpos <= (collationSource).toReturn)) { \ |
| (order) = UCOL_NULLORDER; \ |
| } else if ((collationSource).CEpos > (collationSource).toReturn) { \ |
| (order) = *((collationSource).toReturn++); \ |
| } else {\ |
| (collationSource).CEpos = (collationSource).toReturn = (collationSource).CEs; \ |
| *((collationSource).CEpos) = ucmp32_get(((RuleBasedCollator *)(coll))->data->mapping, *((collationSource).pos)); \ |
| if(*((collationSource).CEpos) < UCOL_EXPANDCHARINDEX && !(UCOL_ISTHAIPREVOWEL(*((collationSource).pos)))) { \ |
| (collationSource).pos++; \ |
| (order)=(*((collationSource).CEpos)); \ |
| } else { \ |
| (order) = getComplicatedCE((coll), &(collationSource), &(status)); \ |
| } \ |
| } \ |
| } |
| |
| |
| |
| int32_t getComplicatedCE(const UCollator *coll, collIterate *source, UErrorCode *status) { |
| if (*(source->CEpos) == UCOL_UNMAPPED) { |
| // Returned an "unmapped" flag and save the character so it can be |
| // returned next time this method is called. |
| if (*(source->pos) == 0x0000) return *(source->pos++); // \u0000 is not valid in C++'s UnicodeString |
| *(source->CEpos++) = UCOL_UNMAPPEDCHARVALUE; |
| *(source->CEpos++) = *(source->pos)<<16; |
| } else { |
| // Contraction sequence start... |
| if (*(source->CEpos) >= UCOL_CONTRACTCHARINDEX) { |
| UChar key[1024]; |
| uint32_t posKey = 0; |
| |
| VectorOfPToContractElement* list = ((RuleBasedCollator *)coll)->data->contractTable->at(*(source->CEpos)-UCOL_CONTRACTCHARINDEX); |
| // The upper line obtained a list of contracting sequences. |
| if (list != NULL) { |
| EntryPair *pair = (EntryPair *)list->at(0); // Taking out the first one. |
| int32_t order = pair->value; // This got us mapping for just the first element - the one that signalled a contraction. |
| |
| key[posKey++] = *(source->pos++); |
| // This tries to find the longes common match for the data in contraction table... |
| // and needs to be rewritten, especially the test down there! |
| int32_t i; |
| int32_t listSize = list->size(); |
| UBool foundSmaller = TRUE; |
| while(source->pos<source->len && foundSmaller) { |
| key[posKey++] = *source->pos; |
| |
| foundSmaller = FALSE; |
| i = 0; |
| while(i<listSize && !foundSmaller) { |
| pair = list->at(i); |
| if ((pair != NULL) && (pair->fwd == TRUE /*fwd*/) && (pair->equalTo(key, posKey))) { |
| /* Found a matching contraction sequence */ |
| order = pair->value; /* change the CE value */ |
| source->pos++; /* consume another char from the source */ |
| foundSmaller = TRUE; |
| } |
| i++; |
| |
| } |
| } |
| source->pos--; /* spit back the last char - it wasn't part of the sequence */ |
| *(source->CEpos) = order; |
| } |
| } |
| // Expansion sequence start... |
| if (*(source->CEpos) >= UCOL_EXPANDCHARINDEX) { |
| VectorOfInt *v = ((RuleBasedCollator *)coll)->data->expandTable->at(*(source->CEpos)-UCOL_EXPANDCHARINDEX); |
| if(v != NULL) { |
| int32_t expandindex=0; |
| int32_t vSize = v->size(); |
| while(expandindex < vSize) { |
| *(source->CEpos++) = v->at(expandindex++); |
| } |
| } |
| } |
| |
| // Thai/Lao reordering |
| if (UCOL_ISTHAIPREVOWEL(*(source->pos)) && |
| UCOL_ISTHAIBASECONSONANT(*(source->pos+1))) { |
| if(source->isThai == TRUE) { |
| source->isThai = FALSE; |
| if((source->len - source->pos) > UCOL_WRITABLE_BUFFER_SIZE) { |
| // allocate a new buffer |
| } |
| UChar *sourceCopy = source->pos; |
| UChar *targetCopy = source->writableBuffer; |
| while(sourceCopy < source->len) { |
| if(UCOL_ISTHAIPREVOWEL(*(sourceCopy)) && |
| UCOL_ISTHAIBASECONSONANT(*(sourceCopy+1))) { |
| *(targetCopy) = *(sourceCopy+1); |
| *(targetCopy+1) = *(sourceCopy); |
| targetCopy+=2; |
| sourceCopy+=2; |
| } else { |
| *(targetCopy++) = *(sourceCopy++); |
| } |
| } |
| source->pos = source->writableBuffer; |
| source->len = targetCopy; |
| source->CEpos = source->toReturn = source->CEs; |
| return UCOL_IGNORABLE; |
| } |
| } |
| } |
| source->pos++; |
| return (*(source->toReturn++)); |
| } |
| |
| |
| /* This is the original function */ |
| U_CAPI UCollationResult |
| ucol_strcollEx( const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| const UChar *target, |
| int32_t targetLength) |
| { |
| if (coll == NULL) return UCOL_EQUAL; |
| if (sourceLength == -1) sourceLength = u_strlen(source); |
| if (targetLength == -1) targetLength = u_strlen(target); |
| return (UCollationResult) ((RuleBasedCollator*)coll)->compareEx(source,sourceLength,target,targetLength); |
| } |
| |
| struct incrementalContext { |
| UCharForwardIterator *source; |
| void *sourceContext; |
| UChar currentChar; |
| UChar lastChar; |
| UChar string[UCOL_MAX_BUFFER]; // Original string |
| UChar *len; // Original string length |
| UChar *pos; // This is position in the string |
| uint32_t *toReturn; // This is the CE from CEs buffer that should be returned |
| uint32_t *CEpos; // This is the position to which we have stored processed CEs |
| uint32_t CEs[UCOL_MAX_BUFFER]; // This is where we store CEs |
| UBool panic; // can't handle it any more - we have to call the cavalry |
| }; |
| |
| |
| void init_incrementalContext(UCharForwardIterator *source, void *sourceContext, incrementalContext *s) { |
| s->len = s->pos = s->string ; |
| s->CEpos = s->toReturn = s->CEs; |
| s->source = source; |
| s->sourceContext = sourceContext; |
| s->currentChar = 0xFFFF; |
| s->lastChar = 0xFFFF; |
| s->panic = FALSE; |
| } |
| |
| int32_t ucol_getIncrementalCE(const UCollator *coll, incrementalContext *ctx, UErrorCode *status) { |
| |
| uint32_t order; |
| |
| if (U_FAILURE(*status) /*|| (ctx->CEpos <= ctx->toReturn)*/) { |
| return UCOL_NULLORDER; |
| } |
| |
| if (ctx->CEpos > ctx->toReturn) { |
| return(*(ctx->toReturn++)); |
| } |
| |
| ctx->CEpos = ctx->toReturn = ctx->CEs; |
| |
| if(ctx->lastChar == 0xFFFF) { |
| ctx->currentChar = ctx->source(ctx->sourceContext); |
| *(ctx->len++) = ctx->currentChar; |
| if(ctx->currentChar == 0xFFFF) { |
| return UCOL_NULLORDER; |
| } |
| } else { |
| ctx->currentChar = ctx->lastChar; |
| ctx->lastChar = 0xFFFF; |
| } |
| |
| order = ucmp32_get(((RuleBasedCollator *)coll)->data->mapping, ctx->currentChar); |
| |
| // this should benefit from reordering of the clauses, so that the cleanest case is returned the first. |
| |
| if(order < UCOL_EXPANDCHARINDEX && !(UCOL_ISTHAIPREVOWEL(ctx->currentChar))) { |
| return (order); |
| } |
| if (order == UCOL_UNMAPPED) { |
| // Returned an "unmapped" flag and save the character so it can be |
| // returned next time this method is called. |
| if (ctx->currentChar == 0x0000) return ctx->currentChar; // \u0000 is not valid in C++'s UnicodeString |
| //*(ctx->CEpos++) = UCOL_UNMAPPEDCHARVALUE; |
| order = UCOL_UNMAPPEDCHARVALUE; |
| *(ctx->CEpos++) = ctx->currentChar<<16; |
| } else { |
| // Contraction sequence start... |
| if (order >= UCOL_CONTRACTCHARINDEX) { |
| UChar key[1024]; |
| uint32_t posKey = 0; |
| |
| VectorOfPToContractElement* list = ((RuleBasedCollator *)coll)->data->contractTable->at(order-UCOL_CONTRACTCHARINDEX); |
| // The upper line obtained a list of contracting sequences. |
| if (list != NULL) { |
| EntryPair *pair = (EntryPair *)list->at(0); // Taking out the first one. |
| order = pair->value; // This got us mapping for just the first element - the one that signalled a contraction. |
| |
| key[posKey++] = ctx->currentChar; |
| // This tries to find the longes common match for the data in contraction table... |
| // and needs to be rewritten, especially the test down there! |
| int32_t i; |
| int32_t listSize = list->size(); |
| UBool foundSmaller = TRUE; |
| UBool endOfString = FALSE; |
| *(ctx->len++) = ctx->lastChar; |
| while(!endOfString && foundSmaller) { |
| endOfString = ((ctx->lastChar = ctx->source(ctx->sourceContext)) == 0xFFFF); |
| key[posKey++] = ctx->lastChar; |
| |
| foundSmaller = FALSE; |
| i = 0; |
| while(i<listSize && !foundSmaller) { |
| pair = list->at(i); |
| if ((pair != NULL) && (pair->fwd == TRUE /*fwd*/) && (pair->equalTo(key, posKey))) { |
| order = pair->value; |
| *(ctx->len++) = ctx->lastChar; |
| foundSmaller = TRUE; |
| } |
| i++; |
| |
| } |
| } |
| } |
| } |
| // Expansion sequence start... |
| if (order >= UCOL_EXPANDCHARINDEX) { |
| VectorOfInt *v = ((RuleBasedCollator *)coll)->data->expandTable->at(order-UCOL_EXPANDCHARINDEX); |
| if(v != NULL) { |
| int32_t expandindex=0; |
| int32_t vSize = v->size(); |
| order = v->at(expandindex++); // first character.... |
| while(expandindex < vSize) { |
| *(ctx->CEpos++) = v->at(expandindex++); |
| } |
| } |
| } |
| |
| // Thai/Lao reordering |
| // This is gonna be way too goofy - so we're gonna bail out and let others do the work... |
| if (UCOL_ISTHAIPREVOWEL(ctx->currentChar)) { |
| ctx->panic = TRUE; |
| return UCOL_NULLORDER; |
| } |
| } |
| return order; |
| } |
| |
| UCollationResult alternateIncrementalProcessing(const UCollator *coll, incrementalContext *srcCtx, incrementalContext *trgCtx) { |
| if(srcCtx->pos == srcCtx->len || *(srcCtx->len-1) != 0xFFFF) { |
| while((*(srcCtx->len++) = srcCtx->source(srcCtx->sourceContext)) != 0xFFFF); |
| } |
| if(trgCtx->pos == trgCtx->len || *(trgCtx->len-1) != 0xFFFF) { |
| while((*(trgCtx->len++) = trgCtx->source(trgCtx->sourceContext)) != 0xFFFF); |
| } |
| |
| return ucol_strcoll(coll, srcCtx->pos, srcCtx->len-srcCtx->pos-1, trgCtx->pos, trgCtx->len-trgCtx->pos-1); |
| } |
| |
| /* This is the incremental function */ |
| U_CAPI UCollationResult ucol_strcollinc(const UCollator *coll, |
| UCharForwardIterator *source, void *sourceContext, |
| UCharForwardIterator *target, void *targetContext) |
| { |
| Collator *cppColl = (Collator*)coll; |
| |
| UCollationResult result = UCOL_EQUAL; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| incrementalContext sColl, tColl; |
| |
| init_incrementalContext(source, sourceContext, &sColl); |
| init_incrementalContext(target, targetContext, &tColl); |
| |
| if(cppColl->getDecomposition() != Normalizer::NO_OP) { // run away screaming!!!! |
| return alternateIncrementalProcessing(coll, &sColl, &tColl); |
| } |
| |
| if (U_FAILURE(status)) |
| { |
| return UCOL_EQUAL; |
| } |
| |
| UColAttributeValue strength = ucol_getAttribute(coll, UCOL_STRENGTH, &status); |
| uint32_t sOrder=UCOL_NULLORDER, tOrder=UCOL_NULLORDER; |
| uint32_t pSOrder, pTOrder; |
| UBool gets = TRUE, gett = TRUE; |
| UBool initialCheckSecTer = strength >= UCOL_SECONDARY; |
| UBool checkSecTer = initialCheckSecTer; |
| UBool checkTertiary = strength >= UCOL_TERTIARY; |
| UBool checkQuad = strength >= UCOL_QUATERNARY; |
| UBool isFrenchSec = (cppColl->getAttribute(UCOL_FRENCH_COLLATION, status) == UCOL_ON) && checkSecTer; |
| |
| if(!isFrenchSec) { |
| for(;;) |
| { |
| // Get the next collation element in each of the strings, unless |
| // we've been requested to skip it. |
| if (gets) |
| { |
| sOrder = ucol_getIncrementalCE(coll, &sColl, &status); |
| } |
| gets = TRUE; |
| |
| if (gett) |
| { |
| tOrder = ucol_getIncrementalCE(coll, &tColl, &status); |
| } |
| gett = TRUE; |
| |
| // If we've hit the end of one of the strings, jump out of the loop |
| if ((sOrder == UCOL_NULLORDER)|| |
| (tOrder == UCOL_NULLORDER)) { |
| if(sColl.panic == TRUE || tColl.panic == TRUE) { |
| return alternateIncrementalProcessing(coll, &sColl, &tColl); |
| } |
| break; |
| } |
| |
| // If there's no difference at this position, we can skip to the |
| // next one. |
| if (sOrder == tOrder) |
| { |
| continue; |
| } |
| |
| // Compare primary differences first. |
| pSOrder = UCOL_PRIMARYORDER(sOrder); |
| pTOrder = UCOL_PRIMARYORDER(tOrder); |
| if (pSOrder != pTOrder) |
| { |
| if (sOrder == 0) |
| { |
| // The entire source element is ignorable. |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| continue; |
| } |
| |
| if (tOrder == 0) |
| { |
| gets = FALSE; |
| continue; |
| } |
| |
| // The source and target elements aren't ignorable, but it's still possible |
| // for the primary component of one of the elements to be ignorable.... |
| if (pSOrder == 0) // primary order in source is ignorable |
| { |
| // The source's primary is ignorable, but the target's isn't. We treat ignorables |
| // as a secondary difference, so remember that we found one. |
| if (checkSecTer) |
| { |
| result = UCOL_GREATER; // (strength is SECONDARY) - still need to check for tertiary or quad |
| checkSecTer = FALSE; |
| } |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| } |
| else if (pTOrder == 0) |
| { |
| // record differences - see the comment above. |
| if (checkSecTer) |
| { |
| result = UCOL_LESS; // (strength is SECONDARY) - still need to check for tertiary or quad |
| checkSecTer = FALSE; |
| } |
| // Skip to the next target element, but don't fetch another source element. |
| gets = FALSE; |
| } |
| else |
| { |
| // Neither of the orders is ignorable, and we already know that the primary |
| // orders are different because of the (pSOrder != pTOrder) test above. |
| // Record the difference and stop the comparison. |
| if (pSOrder < pTOrder) |
| { |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| } |
| else |
| { // else of if ( pSOrder != pTOrder ) |
| // primary order is the same, but complete order is different. So there |
| // are no base elements at this point, only ignorables (Since the strings are |
| // normalized) |
| |
| if (checkSecTer) |
| { |
| // a secondary or tertiary difference may still matter |
| uint32_t secSOrder = UCOL_SECONDARYORDER(sOrder); |
| uint32_t secTOrder = UCOL_SECONDARYORDER(tOrder); |
| |
| if (secSOrder != secTOrder) |
| { |
| // there is a secondary difference |
| result = (secSOrder < secTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is SECONDARY) |
| checkSecTer = FALSE; |
| } |
| else |
| { |
| if (checkTertiary) |
| { |
| // a tertiary difference may still matter |
| uint32_t terSOrder = UCOL_TERTIARYORDER(sOrder); |
| uint32_t terTOrder = UCOL_TERTIARYORDER(tOrder); |
| |
| if (terSOrder != terTOrder) |
| { |
| // there is a tertiary difference |
| result = (terSOrder < terTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is TERTIARY) |
| checkTertiary = FALSE; |
| } |
| } |
| } |
| } // if (checkSecTer) |
| |
| } // if ( pSOrder != pTOrder ) |
| } // while() |
| |
| if (sOrder != UCOL_NULLORDER) |
| { |
| // (tOrder must be CollationElementIterator::NULLORDER, |
| // since this point is only reached when sOrder or tOrder is NULLORDER.) |
| // The source string has more elements, but the target string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(sOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the source string. |
| // This is a primary difference, so the source is greater |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(sOrder) != 0) |
| { |
| // Additional secondary elements mean the source string is greater |
| if (checkSecTer) |
| { |
| result = UCOL_GREATER; // (strength is SECONDARY) |
| checkSecTer = FALSE; |
| } |
| } |
| sOrder = ucol_getIncrementalCE(coll, &sColl, &status); |
| } |
| //while ((sOrder = ucol_getIncrementalCE(coll, &sColl, &status)) != CollationElementIterator::NULLORDER); |
| while (sOrder != UCOL_NULLORDER); |
| } |
| else if (tOrder != UCOL_NULLORDER) |
| { |
| // The target string has more elements, but the source string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(tOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the target string. |
| // This is a primary difference, so the source is less |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(tOrder) != 0) |
| { |
| // Additional secondary elements in the target mean the source string is less |
| if (checkSecTer) |
| { |
| result = UCOL_LESS; // (strength is SECONDARY) |
| checkSecTer = FALSE; |
| } |
| } |
| tOrder = ucol_getIncrementalCE(coll, &tColl, &status); |
| } |
| while ( tOrder != UCOL_NULLORDER); |
| //while ((tOrder = ucol_getIncrementalCE(coll, &tColl, &status)) != CollationElementIterator::NULLORDER); |
| } |
| } else { //French |
| |
| // there is a bad situation with French when there is a different number of secondaries... |
| // If that situation arises (when one primary is ignorable with nonignorable secondary and the other primary is not |
| // ignorable |
| // TODO: if the buffer is not big enough, we should use sortkeys |
| UBool bufferFrenchSec = FALSE; |
| uint32_t sourceFrenchSec[UCOL_MAX_BUFFER], targetFrenchSec[UCOL_MAX_BUFFER]; |
| uint32_t *sFSBEnd = sourceFrenchSec+UCOL_MAX_BUFFER; |
| uint32_t *tFSBEnd = targetFrenchSec+UCOL_MAX_BUFFER; |
| |
| for(;;) |
| { |
| // Get the next collation element in each of the strings, unless |
| // we've been requested to skip it. |
| if (gets) |
| { |
| sOrder = ucol_getIncrementalCE(coll, &sColl, &status); |
| *(--sFSBEnd) = UCOL_SECONDARYORDER(sOrder); |
| } |
| |
| gets = TRUE; |
| |
| if (gett) |
| { |
| tOrder = ucol_getIncrementalCE(coll, &tColl, &status); |
| *(--tFSBEnd) = UCOL_SECONDARYORDER(tOrder); |
| } |
| |
| gett = TRUE; |
| |
| // If we've hit the end of one of the strings, jump out of the loop |
| if ((sOrder == UCOL_NULLORDER)|| |
| (tOrder == UCOL_NULLORDER)) { |
| break; |
| } |
| |
| // If there's no difference at this position, we can skip to the |
| // next one. |
| if (sOrder == tOrder) |
| { |
| continue; |
| } |
| |
| // Compare primary differences first. |
| pSOrder = UCOL_PRIMARYORDER(sOrder); |
| pTOrder = UCOL_PRIMARYORDER(tOrder); |
| if (pSOrder != pTOrder) |
| { |
| if (sOrder == 0) |
| { |
| // The entire source element is ignorable. |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| continue; |
| } |
| |
| if (tOrder == 0) |
| { |
| gets = FALSE; |
| continue; |
| } |
| |
| // The source and target elements aren't ignorable, but it's still possible |
| // for the primary component of one of the elements to be ignorable.... |
| if (pSOrder == 0) // primary order in source is ignorable |
| { |
| // The source's primary is ignorable, but the target's isn't. We treat ignorables |
| // as a secondary difference, so remember that we found one. |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| } |
| else if (pTOrder == 0) |
| { |
| // record differences - see the comment above. |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| // Skip to the next target element, but don't fetch another source element. |
| gets = FALSE; |
| } |
| else |
| { |
| // Neither of the orders is ignorable, and we already know that the primary |
| // orders are different because of the (pSOrder != pTOrder) test above. |
| // Record the difference and stop the comparison. |
| if (pSOrder < pTOrder) |
| { |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| } |
| else |
| { // else of if ( pSOrder != pTOrder ) |
| // primary order is the same, but complete order is different. So there |
| // are no base elements at this point, only ignorables (Since the strings are |
| // normalized) |
| |
| if (checkSecTer) |
| { |
| // a secondary or tertiary difference may still matter |
| uint32_t secSOrder = UCOL_SECONDARYORDER(sOrder); |
| uint32_t secTOrder = UCOL_SECONDARYORDER(tOrder); |
| |
| if (secSOrder != secTOrder) |
| { |
| // there is a secondary difference |
| result = (secSOrder < secTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is SECONDARY) |
| checkSecTer = isFrenchSec; // We still want to track the French secondaries |
| //checkSecTer = FALSE; |
| } |
| else |
| { |
| if (checkTertiary) |
| { |
| // a tertiary difference may still matter |
| uint32_t terSOrder = UCOL_TERTIARYORDER(sOrder); |
| uint32_t terTOrder = UCOL_TERTIARYORDER(tOrder); |
| |
| if (terSOrder != terTOrder) |
| { |
| // there is a tertiary difference |
| result = (terSOrder < terTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is TERTIARY) |
| checkTertiary = FALSE; |
| } |
| } |
| } |
| } // if (checkSecTer) |
| |
| } // if ( pSOrder != pTOrder ) |
| } // while() |
| |
| if (sOrder != UCOL_NULLORDER) |
| { |
| // (tOrder must be CollationElementIterator::NULLORDER, |
| // since this point is only reached when sOrder or tOrder is NULLORDER.) |
| // The source string has more elements, but the target string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(sOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the source string. |
| // This is a primary difference, so the source is greater |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(sOrder) != 0) |
| { |
| // Additional secondary elements mean the source string is greater |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| } |
| sOrder = ucol_getIncrementalCE(coll, &sColl, &status); |
| *(--sFSBEnd) = UCOL_SECONDARYORDER(sOrder); |
| } |
| //while ((sOrder = ucol_getIncrementalCE(coll, &sColl, &status)) != CollationElementIterator::NULLORDER); |
| while (sOrder != UCOL_NULLORDER); |
| } |
| else if (tOrder != UCOL_NULLORDER) |
| { |
| // The target string has more elements, but the source string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(tOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the target string. |
| // This is a primary difference, so the source is less |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(tOrder) != 0) |
| { |
| // Additional secondary elements in the target mean the source string is less |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| } |
| tOrder = ucol_getIncrementalCE(coll, &tColl, &status); |
| *(--tFSBEnd) = UCOL_SECONDARYORDER(tOrder); |
| } |
| while ( tOrder != UCOL_NULLORDER); |
| } |
| |
| if(bufferFrenchSec) { |
| while(sFSBEnd < sourceFrenchSec+UCOL_MAX_BUFFER && tFSBEnd < targetFrenchSec+UCOL_MAX_BUFFER) { |
| if(*sFSBEnd == *tFSBEnd) { |
| sFSBEnd++; |
| tFSBEnd++; |
| } else if(*sFSBEnd < *tFSBEnd) { |
| result = UCOL_LESS; |
| break; |
| } else { |
| result = UCOL_GREATER; |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| // For IDENTICAL comparisons, we use a bitwise character comparison |
| // as a tiebreaker if all else is equal |
| // NOTE: The java code compares result with 0, and |
| // puts the result of the string comparison directly into result |
| if (result == UCOL_EQUAL && strength == UCOL_IDENTICAL) |
| { |
| UnicodeString sourceDecomp, targetDecomp; |
| |
| int8_t comparison; |
| |
| Normalizer::normalize(UnicodeString(sColl.string, sColl.len-sColl.string-1), ((RuleBasedCollator *)coll)->getDecomposition(), |
| 0, sourceDecomp, status); |
| |
| Normalizer::normalize(UnicodeString(tColl.string, tColl.len-tColl.string-1), ((RuleBasedCollator *)coll)->getDecomposition(), |
| 0, targetDecomp, status); |
| |
| comparison = sourceDecomp.compare(targetDecomp); |
| |
| if (comparison < 0) |
| { |
| result = UCOL_LESS; |
| } |
| else if (comparison == 0) |
| { |
| result = UCOL_EQUAL; |
| } |
| else |
| { |
| result = UCOL_GREATER; |
| } |
| } |
| |
| return result; |
| } |
| |
| /* This is the new function */ |
| U_CAPI UCollationResult |
| ucol_strcoll( const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| const UChar *target, |
| int32_t targetLength) |
| { |
| Collator *cppColl = (Collator*)coll; |
| |
| // check if source and target are valid strings |
| if (((source == 0) && (target == 0)) || |
| ((sourceLength == 0) && (targetLength == 0))) |
| { |
| return UCOL_EQUAL; |
| } |
| |
| UCollationResult result = UCOL_EQUAL; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| UChar normSource[UCOL_MAX_BUFFER], normTarget[UCOL_MAX_BUFFER]; |
| uint32_t normSourceLength = UCOL_MAX_BUFFER, normTargetLength = UCOL_MAX_BUFFER; |
| |
| collIterate sColl, tColl; |
| |
| if(cppColl->getDecomposition() == Normalizer::NO_OP) { |
| init_collIterate(source, sourceLength, &sColl, FALSE); |
| init_collIterate(target, targetLength, &tColl, FALSE); |
| } else { |
| UNormalizationMode normMode = ucol_getNormalization(coll); |
| normSourceLength = u_normalize(source, sourceLength, normMode, 0, normSource, normSourceLength, &status); |
| normTargetLength = u_normalize(target, targetLength, normMode, 0, normTarget, normTargetLength, &status); |
| init_collIterate(normSource, normSourceLength, &sColl, TRUE); |
| init_collIterate(normTarget, normTargetLength, &tColl, TRUE); |
| } |
| |
| if (U_FAILURE(status)) |
| { |
| return UCOL_EQUAL; |
| } |
| |
| UColAttributeValue strength = ucol_getAttribute(coll, UCOL_STRENGTH, &status); |
| uint32_t sOrder=UCOL_NULLORDER, tOrder=UCOL_NULLORDER; |
| uint32_t pSOrder, pTOrder; |
| UBool gets = TRUE, gett = TRUE; |
| UBool initialCheckSecTer = strength >= UCOL_SECONDARY; |
| UBool checkSecTer = initialCheckSecTer; |
| UBool checkTertiary = strength >= UCOL_TERTIARY; |
| UBool checkQuad = strength >= UCOL_QUATERNARY; |
| UBool isFrenchSec = (cppColl->getAttribute(UCOL_FRENCH_COLLATION, status) == UCOL_ON) && checkSecTer; |
| |
| if(!isFrenchSec) { |
| for(;;) |
| { |
| // Get the next collation element in each of the strings, unless |
| // we've been requested to skip it. |
| if (gets) |
| { |
| UCOL_GETNEXTCE(sOrder, coll, sColl, status); |
| } |
| gets = TRUE; |
| |
| if (gett) |
| { |
| UCOL_GETNEXTCE(tOrder, coll, tColl, status); |
| } |
| gett = TRUE; |
| |
| // If we've hit the end of one of the strings, jump out of the loop |
| if ((sOrder == UCOL_NULLORDER)|| |
| (tOrder == UCOL_NULLORDER)) { |
| break; |
| } |
| |
| // If there's no difference at this position, we can skip to the |
| // next one. |
| if (sOrder == tOrder) |
| { |
| continue; |
| } |
| |
| // Compare primary differences first. |
| pSOrder = UCOL_PRIMARYORDER(sOrder); |
| pTOrder = UCOL_PRIMARYORDER(tOrder); |
| if (pSOrder != pTOrder) |
| { |
| if (sOrder == 0) |
| { |
| // The entire source element is ignorable. |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| continue; |
| } |
| |
| if (tOrder == 0) |
| { |
| gets = FALSE; |
| continue; |
| } |
| |
| // The source and target elements aren't ignorable, but it's still possible |
| // for the primary component of one of the elements to be ignorable.... |
| if (pSOrder == 0) // primary order in source is ignorable |
| { |
| // The source's primary is ignorable, but the target's isn't. We treat ignorables |
| // as a secondary difference, so remember that we found one. |
| if (checkSecTer) |
| { |
| result = UCOL_GREATER; // (strength is SECONDARY) - still need to check for tertiary or quad |
| checkSecTer = FALSE; |
| } |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| } |
| else if (pTOrder == 0) |
| { |
| // record differences - see the comment above. |
| if (checkSecTer) |
| { |
| result = UCOL_LESS; // (strength is SECONDARY) - still need to check for tertiary or quad |
| checkSecTer = FALSE; |
| } |
| // Skip to the next target element, but don't fetch another source element. |
| gets = FALSE; |
| } |
| else |
| { |
| // Neither of the orders is ignorable, and we already know that the primary |
| // orders are different because of the (pSOrder != pTOrder) test above. |
| // Record the difference and stop the comparison. |
| if (pSOrder < pTOrder) |
| { |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| } |
| else |
| { // else of if ( pSOrder != pTOrder ) |
| // primary order is the same, but complete order is different. So there |
| // are no base elements at this point, only ignorables (Since the strings are |
| // normalized) |
| |
| if (checkSecTer) |
| { |
| // a secondary or tertiary difference may still matter |
| uint32_t secSOrder = UCOL_SECONDARYORDER(sOrder); |
| uint32_t secTOrder = UCOL_SECONDARYORDER(tOrder); |
| |
| if (secSOrder != secTOrder) |
| { |
| // there is a secondary difference |
| result = (secSOrder < secTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is SECONDARY) |
| checkSecTer = FALSE; |
| } |
| else |
| { |
| if (checkTertiary) |
| { |
| // a tertiary difference may still matter |
| uint32_t terSOrder = UCOL_TERTIARYORDER(sOrder); |
| uint32_t terTOrder = UCOL_TERTIARYORDER(tOrder); |
| |
| if (terSOrder != terTOrder) |
| { |
| // there is a tertiary difference |
| result = (terSOrder < terTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is TERTIARY) |
| checkTertiary = FALSE; |
| } |
| } |
| } |
| } // if (checkSecTer) |
| |
| } // if ( pSOrder != pTOrder ) |
| } // while() |
| |
| if (sOrder != UCOL_NULLORDER) |
| { |
| // (tOrder must be CollationElementIterator::NULLORDER, |
| // since this point is only reached when sOrder or tOrder is NULLORDER.) |
| // The source string has more elements, but the target string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(sOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the source string. |
| // This is a primary difference, so the source is greater |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(sOrder) != 0) |
| { |
| // Additional secondary elements mean the source string is greater |
| if (checkSecTer) |
| { |
| result = UCOL_GREATER; // (strength is SECONDARY) |
| checkSecTer = FALSE; |
| } |
| } |
| UCOL_GETNEXTCE(sOrder, coll, sColl, status); |
| } |
| //while ((sOrder = ucol_getNextCE(coll, &sColl, &status)) != CollationElementIterator::NULLORDER); |
| while (sOrder != UCOL_NULLORDER); |
| } |
| else if (tOrder != UCOL_NULLORDER) |
| { |
| // The target string has more elements, but the source string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(tOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the target string. |
| // This is a primary difference, so the source is less |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(tOrder) != 0) |
| { |
| // Additional secondary elements in the target mean the source string is less |
| if (checkSecTer) |
| { |
| result = UCOL_LESS; // (strength is SECONDARY) |
| checkSecTer = FALSE; |
| } |
| } |
| UCOL_GETNEXTCE(tOrder, coll, tColl, status); |
| } |
| while ( tOrder != UCOL_NULLORDER); |
| //while ((tOrder = ucol_getNextCE(coll, &tColl, &status)) != CollationElementIterator::NULLORDER); |
| } |
| } else { //French |
| |
| // there is a bad situation with French when there is a different number of secondaries... |
| // If that situation arises (when one primary is ignorable with nonignorable secondary and the other primary is not |
| // ignorable |
| // TODO: if the buffer is not big enough, we should use sortkeys |
| UBool bufferFrenchSec = FALSE; |
| uint32_t sourceFrenchSec[UCOL_MAX_BUFFER], targetFrenchSec[UCOL_MAX_BUFFER]; |
| uint32_t *sFSBEnd = sourceFrenchSec+UCOL_MAX_BUFFER; |
| uint32_t *tFSBEnd = targetFrenchSec+UCOL_MAX_BUFFER; |
| |
| for(;;) |
| { |
| // Get the next collation element in each of the strings, unless |
| // we've been requested to skip it. |
| if (gets) |
| { |
| UCOL_GETNEXTCE(sOrder, coll, sColl, status); |
| *(--sFSBEnd) = UCOL_SECONDARYORDER(sOrder); |
| } |
| |
| gets = TRUE; |
| |
| if (gett) |
| { |
| UCOL_GETNEXTCE(tOrder, coll, tColl, status); |
| *(--tFSBEnd) = UCOL_SECONDARYORDER(tOrder); |
| } |
| |
| gett = TRUE; |
| |
| // If we've hit the end of one of the strings, jump out of the loop |
| if ((sOrder == UCOL_NULLORDER)|| |
| (tOrder == UCOL_NULLORDER)) { |
| break; |
| } |
| |
| // If there's no difference at this position, we can skip to the |
| // next one. |
| if (sOrder == tOrder) |
| { |
| continue; |
| } |
| |
| // Compare primary differences first. |
| pSOrder = UCOL_PRIMARYORDER(sOrder); |
| pTOrder = UCOL_PRIMARYORDER(tOrder); |
| if (pSOrder != pTOrder) |
| { |
| if (sOrder == 0) |
| { |
| // The entire source element is ignorable. |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| continue; |
| } |
| |
| if (tOrder == 0) |
| { |
| gets = FALSE; |
| continue; |
| } |
| |
| // The source and target elements aren't ignorable, but it's still possible |
| // for the primary component of one of the elements to be ignorable.... |
| if (pSOrder == 0) // primary order in source is ignorable |
| { |
| // The source's primary is ignorable, but the target's isn't. We treat ignorables |
| // as a secondary difference, so remember that we found one. |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| // Skip to the next source element, but don't fetch another target element. |
| gett = FALSE; |
| } |
| else if (pTOrder == 0) |
| { |
| // record differences - see the comment above. |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| // Skip to the next target element, but don't fetch another source element. |
| gets = FALSE; |
| } |
| else |
| { |
| // Neither of the orders is ignorable, and we already know that the primary |
| // orders are different because of the (pSOrder != pTOrder) test above. |
| // Record the difference and stop the comparison. |
| if (pSOrder < pTOrder) |
| { |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| } |
| else |
| { // else of if ( pSOrder != pTOrder ) |
| // primary order is the same, but complete order is different. So there |
| // are no base elements at this point, only ignorables (Since the strings are |
| // normalized) |
| |
| if (checkSecTer) |
| { |
| // a secondary or tertiary difference may still matter |
| uint32_t secSOrder = UCOL_SECONDARYORDER(sOrder); |
| uint32_t secTOrder = UCOL_SECONDARYORDER(tOrder); |
| |
| if (secSOrder != secTOrder) |
| { |
| // there is a secondary difference |
| result = (secSOrder < secTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is SECONDARY) |
| checkSecTer = isFrenchSec; // We still want to track the French secondaries |
| //checkSecTer = FALSE; |
| } |
| else |
| { |
| if (checkTertiary) |
| { |
| // a tertiary difference may still matter |
| uint32_t terSOrder = UCOL_TERTIARYORDER(sOrder); |
| uint32_t terTOrder = UCOL_TERTIARYORDER(tOrder); |
| |
| if (terSOrder != terTOrder) |
| { |
| // there is a tertiary difference |
| result = (terSOrder < terTOrder) ? UCOL_LESS : UCOL_GREATER; |
| // (strength is TERTIARY) |
| checkTertiary = FALSE; |
| } |
| } |
| } |
| } // if (checkSecTer) |
| |
| } // if ( pSOrder != pTOrder ) |
| } // while() |
| |
| if (sOrder != UCOL_NULLORDER) |
| { |
| // (tOrder must be CollationElementIterator::NULLORDER, |
| // since this point is only reached when sOrder or tOrder is NULLORDER.) |
| // The source string has more elements, but the target string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(sOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the source string. |
| // This is a primary difference, so the source is greater |
| return UCOL_GREATER; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(sOrder) != 0) |
| { |
| // Additional secondary elements mean the source string is greater |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| } |
| UCOL_GETNEXTCE(sOrder, coll, sColl, status); |
| *(--sFSBEnd) = UCOL_SECONDARYORDER(sOrder); |
| } |
| //while ((sOrder = ucol_getNextCE(coll, &sColl, &status)) != CollationElementIterator::NULLORDER); |
| while (sOrder != UCOL_NULLORDER); |
| } |
| else if (tOrder != UCOL_NULLORDER) |
| { |
| // The target string has more elements, but the source string hasn't. |
| do |
| { |
| if (UCOL_PRIMARYORDER(tOrder) != 0) |
| { |
| // We found an additional non-ignorable base character in the target string. |
| // This is a primary difference, so the source is less |
| return UCOL_LESS; // (strength is PRIMARY) |
| } |
| |
| if (UCOL_SECONDARYORDER(tOrder) != 0) |
| { |
| // Additional secondary elements in the target mean the source string is less |
| if (checkSecTer) |
| { |
| bufferFrenchSec = TRUE; |
| } |
| } |
| UCOL_GETNEXTCE(tOrder, coll, tColl, status); |
| *(--tFSBEnd) = UCOL_SECONDARYORDER(tOrder); |
| } |
| while ( tOrder != UCOL_NULLORDER); |
| } |
| |
| if(bufferFrenchSec) { |
| while(sFSBEnd < sourceFrenchSec+UCOL_MAX_BUFFER && tFSBEnd < targetFrenchSec+UCOL_MAX_BUFFER) { |
| if(*sFSBEnd == *tFSBEnd) { |
| sFSBEnd++; |
| tFSBEnd++; |
| } else if(*sFSBEnd < *tFSBEnd) { |
| result = UCOL_LESS; |
| break; |
| } else { |
| result = UCOL_GREATER; |
| break; |
| } |
| } |
| } |
| } |
| |
| |
| // For IDENTICAL comparisons, we use a bitwise character comparison |
| // as a tiebreaker if all else is equal |
| // NOTE: The java code compares result with 0, and |
| // puts the result of the string comparison directly into result |
| if (result == UCOL_EQUAL && strength == UCOL_IDENTICAL) |
| { |
| UnicodeString sourceDecomp, targetDecomp; |
| |
| int8_t comparison; |
| |
| Normalizer::normalize(UnicodeString(source, sourceLength), ((RuleBasedCollator *)coll)->getDecomposition(), |
| 0, sourceDecomp, status); |
| |
| Normalizer::normalize(UnicodeString(target, targetLength), ((RuleBasedCollator *)coll)->getDecomposition(), |
| 0, targetDecomp, status); |
| |
| comparison = sourceDecomp.compare(targetDecomp); |
| |
| if (comparison < 0) |
| { |
| result = UCOL_LESS; |
| } |
| else if (comparison == 0) |
| { |
| result = UCOL_EQUAL; |
| } |
| else |
| { |
| result = UCOL_GREATER; |
| } |
| } |
| |
| return result; |
| } |
| |
| /* This is the original sort key function */ |
| U_CAPI int32_t |
| ucol_getSortKeyEx(const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| uint8_t *result, |
| int32_t resultLength) |
| { |
| int32_t count; |
| const uint8_t* bytes = NULL; |
| CollationKey key; |
| int32_t copyLen; |
| int32_t len = (sourceLength == -1 ? u_strlen(source) |
| : sourceLength); |
| // UnicodeString string((UChar*)source, len, len); |
| UErrorCode status = U_ZERO_ERROR; |
| |
| ((RuleBasedCollator*)coll)->getCollationKeyEx(source, len, key, status); |
| if(U_FAILURE(status)) |
| return 0; |
| |
| bytes = key.getByteArray(count); |
| |
| copyLen = uprv_min(count, resultLength); |
| uprv_arrayCopy((const int8_t*)bytes, (int8_t*)result, copyLen); |
| |
| return count; |
| } |
| |
| U_CAPI int32_t |
| ucol_getSortKey(const UCollator *coll, |
| const UChar *source, |
| int32_t sourceLength, |
| uint8_t *result, |
| int32_t resultLength) |
| { |
| |
| uint32_t i = 0; // general purpose counter |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| uint8_t prim[2*UCOL_MAX_BUFFER], second[UCOL_MAX_BUFFER], tert[UCOL_MAX_BUFFER]; |
| |
| uint8_t *primaries = prim, *secondaries = second, *tertiaries = tert; |
| |
| UChar normBuffer[2*UCOL_MAX_BUFFER]; |
| UChar *normSource = normBuffer; |
| int32_t normSourceLen = 2048; |
| |
| for(i = 0; i<UCOL_MAX_BUFFER; i++) { |
| prim[i]=second[i]=tert[i]='\0'; |
| } |
| |
| for(i = UCOL_MAX_BUFFER; i<2*UCOL_MAX_BUFFER; i++) { |
| prim[i]=normBuffer[i]='\0'; |
| } |
| |
| |
| int32_t len = (sourceLength == -1 ? u_strlen(source) : sourceLength); |
| |
| UBool compareSec = (((RuleBasedCollator *)coll)->getStrength() >= Collator::SECONDARY); |
| UBool compareTer = (((RuleBasedCollator *)coll)->getStrength() >= Collator::TERTIARY); |
| UBool compareIdent = (((RuleBasedCollator *)coll)->getStrength() == Collator::IDENTICAL); |
| |
| if(len > UCOL_MAX_BUFFER) { |
| primaries = (uint8_t *)uprv_malloc(6*len*sizeof(uint8_t)); |
| if(compareSec) { |
| secondaries = (uint8_t *)uprv_malloc(2*len*sizeof(uint8_t)); |
| } |
| if(compareTer) { |
| tertiaries = (uint8_t *)uprv_malloc(2*len*sizeof(uint8_t)); |
| } |
| } |
| |
| uint8_t *primstart = primaries; |
| uint8_t *secstart = secondaries; |
| uint8_t *terstart = tertiaries; |
| |
| collIterate s; |
| init_collIterate((UChar *)source, len, &s, FALSE); |
| |
| // If we need to normalize, we'll do it all at once at the beggining! |
| if(((RuleBasedCollator *)coll)->getDecomposition() != Normalizer::NO_OP) { |
| UnicodeString normalized; |
| Normalizer::normalize(UnicodeString(source, sourceLength), ((RuleBasedCollator *)coll)->getDecomposition(), |
| 0, normalized, status); |
| normSourceLen = normalized.length(); |
| |
| if(normSourceLen > UCOL_MAX_BUFFER) { |
| normSource = (UChar *) uprv_malloc(normSourceLen*sizeof(UChar)); |
| } |
| normalized.extract(0, normSourceLen, normSource); |
| normSource[normSourceLen] = 0; |
| s.string = normSource; |
| s.pos = normSource; |
| s.len = normSource+normSourceLen; |
| } |
| |
| uint32_t order = 0; |
| |
| uint16_t primary = 0; |
| uint8_t secondary = 0; |
| uint8_t tertiary = 0; |
| |
| UCOL_GETNEXTCE(order, coll, s, status); |
| while(order != UCOL_NULLORDER) { |
| primary = ((order & UCOL_PRIMARYORDERMASK)>> UCOL_PRIMARYORDERSHIFT); |
| secondary = ((order & UCOL_SECONDARYORDERMASK)>> UCOL_SECONDARYORDERSHIFT); |
| tertiary = (order & UCOL_TERTIARYORDERMASK); |
| |
| if(primary != UCOL_IGNORABLE) { |
| *(primaries++) = (primary>>8)+UCOL_SORTKEYOFFSET; |
| *(primaries++) = (primary&0xFF)+UCOL_SORTKEYOFFSET; |
| if(compareSec) { |
| *(secondaries++) = secondary+UCOL_SORTKEYOFFSET; |
| } |
| if(compareTer) { |
| *(tertiaries++) = tertiary+UCOL_SORTKEYOFFSET; |
| } |
| } else { // original implementation offsets this with some extra... |
| if(compareSec && secondary != 0) { |
| *(secondaries++) = secondary+UCOL_SORTKEYOFFSET; |
| } |
| if(compareTer && tertiary != 0) { |
| *(tertiaries++) = tertiary+UCOL_SORTKEYOFFSET; |
| } |
| } |
| UCOL_GETNEXTCE(order, coll, s, status); |
| } |
| |
| |
| |
| if(compareSec) { |
| *(primaries++) = UCOL_LEVELTERMINATOR; |
| uint32_t secsize = secondaries-secstart; |
| if(ucol_getAttribute(coll, UCOL_FRENCH_COLLATION, &status) == UCOL_ON) { // do the reverse copy |
| for(i = 0; i<secsize; i++) { |
| *(primaries++) = *(secondaries-i-1); |
| } |
| } else { |
| uprv_memcpy(primaries, secstart, secsize); |
| primaries += secsize; |
| } |
| |
| } |
| |
| if(compareTer) { |
| *(primaries++) = UCOL_LEVELTERMINATOR; |
| uint32_t tersize = tertiaries - terstart; |
| uprv_memcpy(primaries, terstart, tersize); |
| primaries += tersize; |
| } |
| |
| |
| if(compareIdent) { |
| *(primaries++) = UCOL_LEVELTERMINATOR; |
| UChar *ident = s.string; |
| while(ident < s.len) { |
| *(primaries++) = (*(ident) >> 8) + utf16fixup[*(ident) >> 11]; |
| *(primaries++) = (*(ident) & 0xFF); |
| ident++; |
| } |
| } |
| |
| *(primaries++) = '\0'; |
| |
| uprv_memcpy(result, primstart, uprv_min(resultLength, (primaries-primstart))); |
| |
| if(terstart != tert) { |
| uprv_free(terstart); |
| } |
| if(secstart != second) { |
| uprv_free(secstart); |
| } |
| if(primstart != prim) { |
| uprv_free(primstart); |
| } |
| if(normSource != normBuffer) { |
| uprv_free(normSource); |
| } |
| |
| return primaries-primstart; |
| } |
| |
| U_CAPI int32_t |
| ucol_keyHashCode( const uint8_t* key, |
| int32_t length) |
| { |
| CollationKey newKey(key, length); |
| return newKey.hashCode(); |
| } |
| |
| UCollationElements* |
| ucol_openElements( const UCollator *coll, |
| const UChar *text, |
| int32_t textLength, |
| UErrorCode *status) |
| { |
| int32_t len = (textLength == -1 ? u_strlen(text) : textLength); |
| const UnicodeString src((UChar*)text, len, len); |
| |
| CollationElementIterator *iter = 0; |
| iter = ((RuleBasedCollator*)coll)->createCollationElementIterator(src); |
| if(iter == 0) { |
| *status = U_MEMORY_ALLOCATION_ERROR; |
| return 0; |
| } |
| |
| return (UCollationElements*) iter; |
| } |
| |
| U_CAPI void |
| ucol_closeElements(UCollationElements *elems) |
| { |
| delete (CollationElementIterator*)elems; |
| } |
| |
| U_CAPI void |
| ucol_reset(UCollationElements *elems) |
| { |
| ((CollationElementIterator*)elems)->reset(); |
| } |
| |
| U_CAPI int32_t |
| ucol_next( UCollationElements *elems, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return UCOL_NULLORDER; |
| |
| return ((CollationElementIterator*)elems)->next(*status); |
| } |
| |
| U_CAPI int32_t |
| ucol_previous( UCollationElements *elems, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return UCOL_NULLORDER; |
| |
| return ((CollationElementIterator*)elems)->previous(*status); |
| } |
| |
| U_CAPI int32_t |
| ucol_getMaxExpansion( const UCollationElements *elems, |
| int32_t order) |
| { |
| return ((CollationElementIterator*)elems)->getMaxExpansion(order); |
| } |
| |
| U_CAPI void |
| ucol_setText(UCollationElements *elems, |
| const UChar *text, |
| int32_t textLength, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return; |
| |
| int32_t len = (textLength == -1 ? u_strlen(text) : textLength); |
| const UnicodeString src((UChar*)text, len, len); |
| |
| ((CollationElementIterator*)elems)->setText(src, *status); |
| } |
| |
| U_CAPI UTextOffset |
| ucol_getOffset(const UCollationElements *elems) |
| { |
| return ((CollationElementIterator*)elems)->getOffset(); |
| } |
| |
| U_CAPI void |
| ucol_setOffset( UCollationElements *elems, |
| UTextOffset offset, |
| UErrorCode *status) |
| { |
| if(U_FAILURE(*status)) return; |
| |
| ((CollationElementIterator*)elems)->setOffset(offset, *status); |
| } |
| |
| U_CAPI void |
| ucol_getVersion(const UCollator* coll, |
| UVersionInfo versionInfo) |
| { |
| ((Collator*)coll)->getVersion(versionInfo); |
| } |
| |
| U_CAPI uint8_t * |
| ucol_cloneRuleData(UCollator *coll, int32_t *length, UErrorCode *status) |
| { |
| return ((RuleBasedCollator*)coll)->cloneRuleData(*length,*status); |
| } |
| |
| U_CAPI void ucol_setAttribute(UCollator *coll, UColAttribute attr, UColAttributeValue value, UErrorCode *status) { |
| ((RuleBasedCollator *)coll)->setAttribute(attr, value, *status); |
| } |
| |
| U_CAPI UColAttributeValue ucol_getAttribute(const UCollator *coll, UColAttribute attr, UErrorCode *status) { |
| return (((RuleBasedCollator *)coll)->getAttribute(attr, *status)); |
| } |
| |
| U_CAPI UCollator *ucol_safeClone(const UCollator *coll, void *stackBuffer, uint32_t bufferSize, UErrorCode *status) { |
| *status = U_UNSUPPORTED_ERROR; |
| return NULL; |
| } |
| |
| U_CAPI int32_t ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen) { |
| return 0; |
| } |
