Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(440)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: icu46/source/i18n/ucol_res.cpp

Issue 5516007: Check in the pristine copy of ICU 4.6... (Closed) Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/
Patch Set: Created 10 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « icu46/source/i18n/ucol_imp.h ('k') | icu46/source/i18n/ucol_sit.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: icu46/source/i18n/ucol_res.cpp
===================================================================
--- icu46/source/i18n/ucol_res.cpp (revision 0)
+++ icu46/source/i18n/ucol_res.cpp (revision 0)
@@ -0,0 +1,1295 @@
+/*
+*******************************************************************************
+* Copyright (C) 1996-2010, International Business Machines
+* Corporation and others. All Rights Reserved.
+*******************************************************************************
+* file name: ucol_res.cpp
+* encoding: US-ASCII
+* tab size: 8 (not used)
+* indentation:4
+*
+* Description:
+* This file contains dependencies that the collation run-time doesn't normally
+* need. This mainly contains resource bundle usage and collation meta information
+*
+* 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
+* 12/08/2004 grhoten Split part of ucol.cpp into ucol_res.cpp
+*/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_COLLATION
+#include "unicode/uloc.h"
+#include "unicode/coll.h"
+#include "unicode/tblcoll.h"
+#include "unicode/caniter.h"
+#include "unicode/uscript.h"
+#include "unicode/ustring.h"
+
+#include "ucol_bld.h"
+#include "ucol_imp.h"
+#include "ucol_tok.h"
+#include "ucol_elm.h"
+#include "uresimp.h"
+#include "ustr_imp.h"
+#include "cstring.h"
+#include "umutex.h"
+#include "ucln_in.h"
+#include "ustrenum.h"
+#include "putilimp.h"
+#include "utracimp.h"
+#include "cmemory.h"
+#include "uenumimp.h"
+#include "ulist.h"
+
+U_NAMESPACE_USE
+
+static void ucol_setReorderCodesFromParser(UCollator *coll, UColTokenParser *parser, UErrorCode *status);
+
+// static UCA. There is only one. Collators don't use it.
+// It is referenced only in ucol_initUCA and ucol_cleanup
+static UCollator* _staticUCA = NULL;
+// static pointer to udata memory. Inited in ucol_initUCA
+// used for cleanup in ucol_cleanup
+static UDataMemory* UCA_DATA_MEM = NULL;
+
+U_CDECL_BEGIN
+static UBool U_CALLCONV
+ucol_res_cleanup(void)
+{
+ if (UCA_DATA_MEM) {
+ udata_close(UCA_DATA_MEM);
+ UCA_DATA_MEM = NULL;
+ }
+ if (_staticUCA) {
+ ucol_close(_staticUCA);
+ _staticUCA = NULL;
+ }
+ return TRUE;
+}
+
+static UBool U_CALLCONV
+isAcceptableUCA(void * /*context*/,
+ const char * /*type*/, const char * /*name*/,
+ const UDataInfo *pInfo){
+ /* context, type & name are intentionally not used */
+ if( pInfo->size>=20 &&
+ pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
+ pInfo->charsetFamily==U_CHARSET_FAMILY &&
+ pInfo->dataFormat[0]==UCA_DATA_FORMAT_0 && /* dataFormat="UCol" */
+ pInfo->dataFormat[1]==UCA_DATA_FORMAT_1 &&
+ pInfo->dataFormat[2]==UCA_DATA_FORMAT_2 &&
+ pInfo->dataFormat[3]==UCA_DATA_FORMAT_3 &&
+ pInfo->formatVersion[0]==UCA_FORMAT_VERSION_0 &&
+ pInfo->formatVersion[1]>=UCA_FORMAT_VERSION_1// &&
+ //pInfo->formatVersion[1]==UCA_FORMAT_VERSION_1 &&
+ //pInfo->formatVersion[2]==UCA_FORMAT_VERSION_2 && // Too harsh
+ //pInfo->formatVersion[3]==UCA_FORMAT_VERSION_3 && // Too harsh
+ ) {
+ UVersionInfo UCDVersion;
+ u_getUnicodeVersion(UCDVersion);
+ return (UBool)(pInfo->dataVersion[0]==UCDVersion[0]
+ && pInfo->dataVersion[1]==UCDVersion[1]);
+ //&& pInfo->dataVersion[2]==ucaDataInfo.dataVersion[2]
+ //&& pInfo->dataVersion[3]==ucaDataInfo.dataVersion[3]);
+ } else {
+ return FALSE;
+ }
+}
+U_CDECL_END
+
+/* do not close UCA returned by ucol_initUCA! */
+UCollator *
+ucol_initUCA(UErrorCode *status) {
+ if(U_FAILURE(*status)) {
+ return NULL;
+ }
+ UBool needsInit;
+ UMTX_CHECK(NULL, (_staticUCA == NULL), needsInit);
+
+ if(needsInit) {
+ UDataMemory *result = udata_openChoice(U_ICUDATA_COLL, UCA_DATA_TYPE, UCA_DATA_NAME, isAcceptableUCA, NULL, status);
+
+ if(U_SUCCESS(*status)){
+ UCollator *newUCA = ucol_initCollator((const UCATableHeader *)udata_getMemory(result), NULL, NULL, status);
+ if(U_SUCCESS(*status)){
+ // Initalize variables for implicit generation
+ uprv_uca_initImplicitConstants(status);
+
+ umtx_lock(NULL);
+ if(_staticUCA == NULL) {
+ UCA_DATA_MEM = result;
+ _staticUCA = newUCA;
+ newUCA = NULL;
+ result = NULL;
+ }
+ umtx_unlock(NULL);
+
+ ucln_i18n_registerCleanup(UCLN_I18N_UCOL_RES, ucol_res_cleanup);
+ if(newUCA != NULL) {
+ ucol_close(newUCA);
+ udata_close(result);
+ }
+ }else{
+ ucol_close(newUCA);
+ udata_close(result);
+ }
+ }
+ else {
+ udata_close(result);
+ }
+ }
+ return _staticUCA;
+}
+
+U_CAPI void U_EXPORT2
+ucol_forgetUCA(void)
+{
+ _staticUCA = NULL;
+ UCA_DATA_MEM = NULL;
+}
+
+/****************************************************************************/
+/* Following are the open/close functions */
+/* */
+/****************************************************************************/
+static UCollator*
+tryOpeningFromRules(UResourceBundle *collElem, UErrorCode *status) {
+ int32_t rulesLen = 0;
+ const UChar *rules = ures_getStringByKey(collElem, "Sequence", &rulesLen, status);
+ return ucol_openRules(rules, rulesLen, UCOL_DEFAULT, UCOL_DEFAULT, NULL, status);
+}
+
+
+// API in ucol_imp.h
+
+U_CFUNC UCollator*
+ucol_open_internal(const char *loc,
+ UErrorCode *status)
+{
+ UErrorCode intStatus = U_ZERO_ERROR;
+ const UCollator* UCA = ucol_initUCA(status);
+
+ /* New version */
+ if(U_FAILURE(*status)) return 0;
+
+
+
+ UCollator *result = NULL;
+ UResourceBundle *b = ures_open(U_ICUDATA_COLL, loc, status);
+
+ /* we try to find stuff from keyword */
+ UResourceBundle *collations = ures_getByKey(b, "collations", NULL, status);
+ UResourceBundle *collElem = NULL;
+ char keyBuffer[256];
+ // if there is a keyword, we pick it up and try to get elements
+ if(!uloc_getKeywordValue(loc, "collation", keyBuffer, 256, status) ||
+ !uprv_strcmp(keyBuffer,"default")) { /* Treat 'zz@collation=default' as 'zz'. */
+ // no keyword. we try to find the default setting, which will give us the keyword value
+ intStatus = U_ZERO_ERROR;
+ // finding default value does not affect collation fallback status
+ UResourceBundle *defaultColl = ures_getByKeyWithFallback(collations, "default", NULL, &intStatus);
+ if(U_SUCCESS(intStatus)) {
+ int32_t defaultKeyLen = 0;
+ const UChar *defaultKey = ures_getString(defaultColl, &defaultKeyLen, &intStatus);
+ u_UCharsToChars(defaultKey, keyBuffer, defaultKeyLen);
+ keyBuffer[defaultKeyLen] = 0;
+ } else {
+ *status = U_INTERNAL_PROGRAM_ERROR;
+ return NULL;
+ }
+ ures_close(defaultColl);
+ }
+ collElem = ures_getByKeyWithFallback(collations, keyBuffer, collations, status);
+ collations = NULL; // We just reused the collations object as collElem.
+
+ UResourceBundle *binary = NULL;
+ UResourceBundle *reorderRes = NULL;
+
+ if(*status == U_MISSING_RESOURCE_ERROR) { /* We didn't find the tailoring data, we fallback to the UCA */
+ *status = U_USING_DEFAULT_WARNING;
+ result = ucol_initCollator(UCA->image, result, UCA, status);
+ if (U_FAILURE(*status)) {
+ goto clean;
+ }
+ // if we use UCA, real locale is root
+ ures_close(b);
+ b = ures_open(U_ICUDATA_COLL, "", status);
+ ures_close(collElem);
+ collElem = ures_open(U_ICUDATA_COLL, "", status);
+ if(U_FAILURE(*status)) {
+ goto clean;
+ }
+ result->hasRealData = FALSE;
+ } else if(U_SUCCESS(*status)) {
+ intStatus = U_ZERO_ERROR;
+
+ binary = ures_getByKey(collElem, "%%CollationBin", NULL, &intStatus);
+
+ if(intStatus == U_MISSING_RESOURCE_ERROR) { /* we didn't find the binary image, we should use the rules */
+ binary = NULL;
+ result = tryOpeningFromRules(collElem, status);
+ if(U_FAILURE(*status)) {
+ goto clean;
+ }
+ } else if(U_SUCCESS(intStatus)) { /* otherwise, we'll pick a collation data that exists */
+ int32_t len = 0;
+ const uint8_t *inData = ures_getBinary(binary, &len, status);
+ if(U_FAILURE(*status)) {
+ goto clean;
+ }
+ UCATableHeader *colData = (UCATableHeader *)inData;
+ if(uprv_memcmp(colData->UCAVersion, UCA->image->UCAVersion, sizeof(UVersionInfo)) != 0 ||
+ uprv_memcmp(colData->UCDVersion, UCA->image->UCDVersion, sizeof(UVersionInfo)) != 0 ||
+ colData->version[0] != UCOL_BUILDER_VERSION)
+ {
+ *status = U_DIFFERENT_UCA_VERSION;
+ result = tryOpeningFromRules(collElem, status);
+ } else {
+ if(U_FAILURE(*status)){
+ goto clean;
+ }
+ if((uint32_t)len > (paddedsize(sizeof(UCATableHeader)) + paddedsize(sizeof(UColOptionSet)))) {
+ result = ucol_initCollator((const UCATableHeader *)inData, result, UCA, status);
+ if(U_FAILURE(*status)){
+ goto clean;
+ }
+ result->hasRealData = TRUE;
+ } else {
+ result = ucol_initCollator(UCA->image, result, UCA, status);
+ ucol_setOptionsFromHeader(result, (UColOptionSet *)(inData+((const UCATableHeader *)inData)->options), status);
+ if(U_FAILURE(*status)){
+ goto clean;
+ }
+ result->hasRealData = FALSE;
+ }
+ result->freeImageOnClose = FALSE;
+
+ reorderRes = ures_getByKey(collElem, "%%ReorderCodes", NULL, &intStatus);
+ if (U_SUCCESS(intStatus)) {
+ int32_t reorderCodesLen = 0;
+ const int32_t* reorderCodes = ures_getIntVector(reorderRes, &reorderCodesLen, status);
+ ucol_setReorderCodes(result, reorderCodes, reorderCodesLen, status);
+ if (U_FAILURE(*status)) {
+ goto clean;
+ }
+ }
+ }
+
+ } else { // !U_SUCCESS(binaryStatus)
+ if(U_SUCCESS(*status)) {
+ *status = intStatus; // propagate underlying error
+ }
+ goto clean;
+ }
+ intStatus = U_ZERO_ERROR;
+ result->rules = ures_getStringByKey(collElem, "Sequence", &result->rulesLength, &intStatus);
+ result->freeRulesOnClose = FALSE;
+ } else { /* There is another error, and we're just gonna clean up */
+ goto clean;
+ }
+
+ intStatus = U_ZERO_ERROR;
+ result->ucaRules = ures_getStringByKey(b,"UCARules",NULL,&intStatus);
+
+ if(loc == NULL) {
+ loc = ures_getLocaleByType(b, ULOC_ACTUAL_LOCALE, status);
+ }
+ result->requestedLocale = uprv_strdup(loc);
+ /* test for NULL */
+ if (result->requestedLocale == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ goto clean;
+ }
+ loc = ures_getLocaleByType(collElem, ULOC_ACTUAL_LOCALE, status);
+ result->actualLocale = uprv_strdup(loc);
+ /* test for NULL */
+ if (result->actualLocale == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ goto clean;
+ }
+ loc = ures_getLocaleByType(b, ULOC_ACTUAL_LOCALE, status);
+ result->validLocale = uprv_strdup(loc);
+ /* test for NULL */
+ if (result->validLocale == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ goto clean;
+ }
+
+ ures_close(b);
+ ures_close(collElem);
+ ures_close(binary);
+ ures_close(reorderRes);
+ return result;
+
+clean:
+ ures_close(b);
+ ures_close(collElem);
+ ures_close(binary);
+ ures_close(reorderRes);
+ ucol_close(result);
+ return NULL;
+}
+
+U_CAPI UCollator*
+ucol_open(const char *loc,
+ UErrorCode *status)
+{
+ U_NAMESPACE_USE
+
+ UTRACE_ENTRY_OC(UTRACE_UCOL_OPEN);
+ UTRACE_DATA1(UTRACE_INFO, "locale = \"%s\"", loc);
+ UCollator *result = NULL;
+
+#if !UCONFIG_NO_SERVICE
+ result = Collator::createUCollator(loc, status);
+ if (result == NULL)
+#endif
+ {
+ result = ucol_open_internal(loc, status);
+ }
+ UTRACE_EXIT_PTR_STATUS(result, *status);
+ return result;
+}
+
+
+UCollator*
+ucol_openRulesForImport( const UChar *rules,
+ int32_t rulesLength,
+ UColAttributeValue normalizationMode,
+ UCollationStrength strength,
+ UParseError *parseError,
+ GetCollationRulesFunction importFunc,
+ void* context,
+ UErrorCode *status)
+{
+ UColTokenParser src;
+ UColAttributeValue norm;
+ UParseError tErr;
+
+ if(status == NULL || U_FAILURE(*status)){
+ return 0;
+ }
+
+ if(rules == NULL || rulesLength < -1) {
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ if(rulesLength == -1) {
+ rulesLength = u_strlen(rules);
+ }
+
+ if(parseError == NULL){
+ parseError = &tErr;
+ }
+
+ switch(normalizationMode) {
+ case UCOL_OFF:
+ case UCOL_ON:
+ case UCOL_DEFAULT:
+ norm = normalizationMode;
+ break;
+ default:
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ UCollator *result = NULL;
+ UCATableHeader *table = NULL;
+ UCollator *UCA = ucol_initUCA(status);
+
+ if(U_FAILURE(*status)){
+ return NULL;
+ }
+
+ ucol_tok_initTokenList(&src, rules, rulesLength, UCA, importFunc, context, status);
+ ucol_tok_assembleTokenList(&src,parseError, status);
+
+ if(U_FAILURE(*status)) {
+ /* if status is U_ILLEGAL_ARGUMENT_ERROR, src->current points at the offending option */
+ /* if status is U_INVALID_FORMAT_ERROR, src->current points after the problematic part of the rules */
+ /* so something might be done here... or on lower level */
+#ifdef UCOL_DEBUG
+ if(*status == U_ILLEGAL_ARGUMENT_ERROR) {
+ fprintf(stderr, "bad option starting at offset %i\n", (int)(src.current-src.source));
+ } else {
+ fprintf(stderr, "invalid rule just before offset %i\n", (int)(src.current-src.source));
+ }
+#endif
+ goto cleanup;
+ }
+
+ if(src.resultLen > 0 || src.removeSet != NULL) { /* we have a set of rules, let's make something of it */
+ /* also, if we wanted to remove some contractions, we should make a tailoring */
+ table = ucol_assembleTailoringTable(&src, status);
+ if(U_SUCCESS(*status)) {
+ // builder version
+ table->version[0] = UCOL_BUILDER_VERSION;
+ // no tailoring information on this level
+ table->version[1] = table->version[2] = table->version[3] = 0;
+ // set UCD version
+ u_getUnicodeVersion(table->UCDVersion);
+ // set UCA version
+ uprv_memcpy(table->UCAVersion, UCA->image->UCAVersion, sizeof(UVersionInfo));
+ result = ucol_initCollator(table, 0, UCA, status);
+ if (U_FAILURE(*status)) {
+ goto cleanup;
+ }
+ result->hasRealData = TRUE;
+ result->freeImageOnClose = TRUE;
+ }
+ } else { /* no rules, but no error either */
+ // must be only options
+ // We will init the collator from UCA
+ result = ucol_initCollator(UCA->image, 0, UCA, status);
+ // Check for null result
+ if (U_FAILURE(*status)) {
+ goto cleanup;
+ }
+ // And set only the options
+ UColOptionSet *opts = (UColOptionSet *)uprv_malloc(sizeof(UColOptionSet));
+ /* test for NULL */
+ if (opts == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ goto cleanup;
+ }
+ uprv_memcpy(opts, src.opts, sizeof(UColOptionSet));
+ ucol_setOptionsFromHeader(result, opts, status);
+ ucol_setReorderCodesFromParser(result, &src, status);
+ result->freeOptionsOnClose = TRUE;
+ result->hasRealData = FALSE;
+ result->freeImageOnClose = FALSE;
+ }
+
+ if(U_SUCCESS(*status)) {
+ UChar *newRules;
+ result->dataVersion[0] = UCOL_BUILDER_VERSION;
+ if(rulesLength > 0) {
+ newRules = (UChar *)uprv_malloc((rulesLength+1)*U_SIZEOF_UCHAR);
+ /* test for NULL */
+ if (newRules == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ goto cleanup;
+ }
+ uprv_memcpy(newRules, rules, rulesLength*U_SIZEOF_UCHAR);
+ newRules[rulesLength]=0;
+ result->rules = newRules;
+ result->rulesLength = rulesLength;
+ result->freeRulesOnClose = TRUE;
+ }
+ result->ucaRules = NULL;
+ result->actualLocale = NULL;
+ result->validLocale = NULL;
+ result->requestedLocale = NULL;
+ ucol_buildPermutationTable(result, status);
+ ucol_setAttribute(result, UCOL_STRENGTH, strength, status);
+ ucol_setAttribute(result, UCOL_NORMALIZATION_MODE, norm, status);
+ } else {
+cleanup:
+ if(result != NULL) {
+ ucol_close(result);
+ } else {
+ if(table != NULL) {
+ uprv_free(table);
+ }
+ }
+ result = NULL;
+ }
+
+ ucol_tok_closeTokenList(&src);
+
+ return result;
+}
+
+U_CAPI UCollator* U_EXPORT2
+ucol_openRules( const UChar *rules,
+ int32_t rulesLength,
+ UColAttributeValue normalizationMode,
+ UCollationStrength strength,
+ UParseError *parseError,
+ UErrorCode *status)
+{
+ return ucol_openRulesForImport(rules,
+ rulesLength,
+ normalizationMode,
+ strength,
+ parseError,
+ ucol_tok_getRulesFromBundle,
+ NULL,
+ status);
+}
+
+U_CAPI int32_t U_EXPORT2
+ucol_getRulesEx(const UCollator *coll, UColRuleOption delta, UChar *buffer, int32_t bufferLen) {
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t len = 0;
+ int32_t UCAlen = 0;
+ const UChar* ucaRules = 0;
+ const UChar *rules = ucol_getRules(coll, &len);
+ if(delta == UCOL_FULL_RULES) {
+ /* take the UCA rules and append real rules at the end */
+ /* UCA rules will be probably coming from the root RB */
+ ucaRules = coll->ucaRules;
+ if (ucaRules) {
+ UCAlen = u_strlen(ucaRules);
+ }
+ /*
+ ucaRules = ures_getStringByKey(coll->rb,"UCARules",&UCAlen,&status);
+ UResourceBundle* cresb = ures_getByKeyWithFallback(coll->rb, "collations", NULL, &status);
+ UResourceBundle* uca = ures_getByKeyWithFallback(cresb, "UCA", NULL, &status);
+ ucaRules = ures_getStringByKey(uca,"Sequence",&UCAlen,&status);
+ ures_close(uca);
+ ures_close(cresb);
+ */
+ }
+ if(U_FAILURE(status)) {
+ return 0;
+ }
+ if(buffer!=0 && bufferLen>0){
+ *buffer=0;
+ if(UCAlen > 0) {
+ u_memcpy(buffer, ucaRules, uprv_min(UCAlen, bufferLen));
+ }
+ if(len > 0 && bufferLen > UCAlen) {
+ u_memcpy(buffer+UCAlen, rules, uprv_min(len, bufferLen-UCAlen));
+ }
+ }
+ return u_terminateUChars(buffer, bufferLen, len+UCAlen, &status);
+}
+
+static const UChar _NUL = 0;
+
+U_CAPI const UChar* U_EXPORT2
+ucol_getRules( const UCollator *coll,
+ int32_t *length)
+{
+ if(coll->rules != NULL) {
+ *length = coll->rulesLength;
+ return coll->rules;
+ }
+ else {
+ *length = 0;
+ return &_NUL;
+ }
+}
+
+U_CAPI UBool U_EXPORT2
+ucol_equals(const UCollator *source, const UCollator *target) {
+ UErrorCode status = U_ZERO_ERROR;
+ // if pointers are equal, collators are equal
+ if(source == target) {
+ return TRUE;
+ }
+ int32_t i = 0, j = 0;
+ // if any of attributes are different, collators are not equal
+ for(i = 0; i < UCOL_ATTRIBUTE_COUNT; i++) {
+ if(ucol_getAttribute(source, (UColAttribute)i, &status) != ucol_getAttribute(target, (UColAttribute)i, &status) || U_FAILURE(status)) {
+ return FALSE;
+ }
+ }
+ if (source->reorderCodesLength != target->reorderCodesLength){
+ return FALSE;
+ }
+ for (i = 0; i < source->reorderCodesLength; i++) {
+ if(source->reorderCodes[i] != target->reorderCodes[i]) {
+ return FALSE;
+ }
+ }
+
+ int32_t sourceRulesLen = 0, targetRulesLen = 0;
+ const UChar *sourceRules = ucol_getRules(source, &sourceRulesLen);
+ const UChar *targetRules = ucol_getRules(target, &targetRulesLen);
+
+ if(sourceRulesLen == targetRulesLen && u_strncmp(sourceRules, targetRules, sourceRulesLen) == 0) {
+ // all the attributes are equal and the rules are equal - collators are equal
+ return(TRUE);
+ }
+ // hard part, need to construct tree from rules and see if they yield the same tailoring
+ UBool result = TRUE;
+ UParseError parseError;
+ UColTokenParser sourceParser, targetParser;
+ int32_t sourceListLen = 0, targetListLen = 0;
+ ucol_tok_initTokenList(&sourceParser, sourceRules, sourceRulesLen, source->UCA, ucol_tok_getRulesFromBundle, NULL, &status);
+ ucol_tok_initTokenList(&targetParser, targetRules, targetRulesLen, target->UCA, ucol_tok_getRulesFromBundle, NULL, &status);
+ sourceListLen = ucol_tok_assembleTokenList(&sourceParser, &parseError, &status);
+ targetListLen = ucol_tok_assembleTokenList(&targetParser, &parseError, &status);
+
+ if(sourceListLen != targetListLen) {
+ // different number of resets
+ result = FALSE;
+ } else {
+ UColToken *sourceReset = NULL, *targetReset = NULL;
+ UChar *sourceResetString = NULL, *targetResetString = NULL;
+ int32_t sourceStringLen = 0, targetStringLen = 0;
+ for(i = 0; i < sourceListLen; i++) {
+ sourceReset = sourceParser.lh[i].reset;
+ sourceResetString = sourceParser.source+(sourceReset->source & 0xFFFFFF);
+ sourceStringLen = sourceReset->source >> 24;
+ for(j = 0; j < sourceListLen; j++) {
+ targetReset = targetParser.lh[j].reset;
+ targetResetString = targetParser.source+(targetReset->source & 0xFFFFFF);
+ targetStringLen = targetReset->source >> 24;
+ if(sourceStringLen == targetStringLen && (u_strncmp(sourceResetString, targetResetString, sourceStringLen) == 0)) {
+ sourceReset = sourceParser.lh[i].first;
+ targetReset = targetParser.lh[j].first;
+ while(sourceReset != NULL && targetReset != NULL) {
+ sourceResetString = sourceParser.source+(sourceReset->source & 0xFFFFFF);
+ sourceStringLen = sourceReset->source >> 24;
+ targetResetString = targetParser.source+(targetReset->source & 0xFFFFFF);
+ targetStringLen = targetReset->source >> 24;
+ if(sourceStringLen != targetStringLen || (u_strncmp(sourceResetString, targetResetString, sourceStringLen) != 0)) {
+ result = FALSE;
+ goto returnResult;
+ }
+ // probably also need to check the expansions
+ if(sourceReset->expansion) {
+ if(!targetReset->expansion) {
+ result = FALSE;
+ goto returnResult;
+ } else {
+ // compare expansions
+ sourceResetString = sourceParser.source+(sourceReset->expansion& 0xFFFFFF);
+ sourceStringLen = sourceReset->expansion >> 24;
+ targetResetString = targetParser.source+(targetReset->expansion & 0xFFFFFF);
+ targetStringLen = targetReset->expansion >> 24;
+ if(sourceStringLen != targetStringLen || (u_strncmp(sourceResetString, targetResetString, sourceStringLen) != 0)) {
+ result = FALSE;
+ goto returnResult;
+ }
+ }
+ } else {
+ if(targetReset->expansion) {
+ result = FALSE;
+ goto returnResult;
+ }
+ }
+ sourceReset = sourceReset->next;
+ targetReset = targetReset->next;
+ }
+ if(sourceReset != targetReset) { // at least one is not NULL
+ // there are more tailored elements in one list
+ result = FALSE;
+ goto returnResult;
+ }
+
+
+ break;
+ }
+ }
+ // couldn't find the reset anchor, so the collators are not equal
+ if(j == sourceListLen) {
+ result = FALSE;
+ goto returnResult;
+ }
+ }
+ }
+
+returnResult:
+ ucol_tok_closeTokenList(&sourceParser);
+ ucol_tok_closeTokenList(&targetParser);
+ return result;
+
+}
+
+U_CAPI int32_t U_EXPORT2
+ucol_getDisplayName( const char *objLoc,
+ const char *dispLoc,
+ UChar *result,
+ int32_t resultLength,
+ UErrorCode *status)
+{
+ U_NAMESPACE_USE
+
+ if(U_FAILURE(*status)) return -1;
+ UnicodeString dst;
+ if(!(result==NULL && resultLength==0)) {
+ // NULL destination for pure preflighting: empty dummy string
+ // otherwise, alias the destination buffer
+ dst.setTo(result, 0, resultLength);
+ }
+ Collator::getDisplayName(Locale(objLoc), Locale(dispLoc), dst);
+ return dst.extract(result, resultLength, *status);
+}
+
+U_CAPI const char* U_EXPORT2
+ucol_getAvailable(int32_t index)
+{
+ int32_t count = 0;
+ const Locale *loc = Collator::getAvailableLocales(count);
+ if (loc != NULL && index < count) {
+ return loc[index].getName();
+ }
+ return NULL;
+}
+
+U_CAPI int32_t U_EXPORT2
+ucol_countAvailable()
+{
+ int32_t count = 0;
+ Collator::getAvailableLocales(count);
+ return count;
+}
+
+#if !UCONFIG_NO_SERVICE
+U_CAPI UEnumeration* U_EXPORT2
+ucol_openAvailableLocales(UErrorCode *status) {
+ U_NAMESPACE_USE
+
+ // This is a wrapper over Collator::getAvailableLocales()
+ if (U_FAILURE(*status)) {
+ return NULL;
+ }
+ StringEnumeration *s = Collator::getAvailableLocales();
+ if (s == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ return NULL;
+ }
+ return uenum_openFromStringEnumeration(s, status);
+}
+#endif
+
+// Note: KEYWORDS[0] != RESOURCE_NAME - alan
+
+static const char RESOURCE_NAME[] = "collations";
+
+static const char* const KEYWORDS[] = { "collation" };
+
+#define KEYWORD_COUNT (sizeof(KEYWORDS)/sizeof(KEYWORDS[0]))
+
+U_CAPI UEnumeration* U_EXPORT2
+ucol_getKeywords(UErrorCode *status) {
+ UEnumeration *result = NULL;
+ if (U_SUCCESS(*status)) {
+ return uenum_openCharStringsEnumeration(KEYWORDS, KEYWORD_COUNT, status);
+ }
+ return result;
+}
+
+U_CAPI UEnumeration* U_EXPORT2
+ucol_getKeywordValues(const char *keyword, UErrorCode *status) {
+ if (U_FAILURE(*status)) {
+ return NULL;
+ }
+ // hard-coded to accept exactly one collation keyword
+ // modify if additional collation keyword is added later
+ if (keyword==NULL || uprv_strcmp(keyword, KEYWORDS[0])!=0)
+ {
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ return NULL;
+ }
+ return ures_getKeywordValues(U_ICUDATA_COLL, RESOURCE_NAME, status);
+}
+
+static const UEnumeration defaultKeywordValues = {
+ NULL,
+ NULL,
+ ulist_close_keyword_values_iterator,
+ ulist_count_keyword_values,
+ uenum_unextDefault,
+ ulist_next_keyword_value,
+ ulist_reset_keyword_values_iterator
+};
+
+#include <stdio.h>
+
+U_CAPI UEnumeration* U_EXPORT2
+ucol_getKeywordValuesForLocale(const char* /*key*/, const char* locale,
+ UBool /*commonlyUsed*/, UErrorCode* status) {
+ /* Get the locale base name. */
+ char localeBuffer[ULOC_FULLNAME_CAPACITY] = "";
+ uloc_getBaseName(locale, localeBuffer, sizeof(localeBuffer), status);
+
+ /* Create the 2 lists
+ * -values is the temp location for the keyword values
+ * -results hold the actual list used by the UEnumeration object
+ */
+ UList *values = ulist_createEmptyList(status);
+ UList *results = ulist_createEmptyList(status);
+ UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration));
+ if (U_FAILURE(*status) || en == NULL) {
+ if (en == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ } else {
+ uprv_free(en);
+ }
+ ulist_deleteList(values);
+ ulist_deleteList(results);
+ return NULL;
+ }
+
+ memcpy(en, &defaultKeywordValues, sizeof(UEnumeration));
+ en->context = results;
+
+ /* Open the resource bundle for collation with the given locale. */
+ UResourceBundle bundle, collations, collres, defres;
+ ures_initStackObject(&bundle);
+ ures_initStackObject(&collations);
+ ures_initStackObject(&collres);
+ ures_initStackObject(&defres);
+
+ ures_openFillIn(&bundle, U_ICUDATA_COLL, localeBuffer, status);
+
+ while (U_SUCCESS(*status)) {
+ ures_getByKey(&bundle, RESOURCE_NAME, &collations, status);
+ ures_resetIterator(&collations);
+ while (U_SUCCESS(*status) && ures_hasNext(&collations)) {
+ ures_getNextResource(&collations, &collres, status);
+ const char *key = ures_getKey(&collres);
+ /* If the key is default, get the string and store it in results list only
+ * if results list is empty.
+ */
+ if (uprv_strcmp(key, "default") == 0) {
+ if (ulist_getListSize(results) == 0) {
+ char *defcoll = (char *)uprv_malloc(sizeof(char) * ULOC_KEYWORDS_CAPACITY);
+ int32_t defcollLength = ULOC_KEYWORDS_CAPACITY;
+
+ ures_getNextResource(&collres, &defres, status);
+#if U_CHARSET_FAMILY==U_ASCII_FAMILY
+ /* optimize - use the utf-8 string */
+ ures_getUTF8String(&defres, defcoll, &defcollLength, TRUE, status);
+#else
+ {
+ const UChar* defString = ures_getString(&defres, &defcollLength, status);
+ if(U_SUCCESS(*status)) {
+ if(defcollLength+1 > ULOC_KEYWORDS_CAPACITY) {
+ *status = U_BUFFER_OVERFLOW_ERROR;
+ } else {
+ u_UCharsToChars(defString, defcoll, defcollLength+1);
+ }
+ }
+ }
+#endif
+
+ ulist_addItemBeginList(results, defcoll, TRUE, status);
+ }
+ } else {
+ ulist_addItemEndList(values, key, FALSE, status);
+ }
+ }
+
+ /* If the locale is "" this is root so exit. */
+ if (uprv_strlen(localeBuffer) == 0) {
+ break;
+ }
+ /* Get the parent locale and open a new resource bundle. */
+ uloc_getParent(localeBuffer, localeBuffer, sizeof(localeBuffer), status);
+ ures_openFillIn(&bundle, U_ICUDATA_COLL, localeBuffer, status);
+ }
+
+ ures_close(&defres);
+ ures_close(&collres);
+ ures_close(&collations);
+ ures_close(&bundle);
+
+ if (U_SUCCESS(*status)) {
+ char *value = NULL;
+ ulist_resetList(values);
+ while ((value = (char *)ulist_getNext(values)) != NULL) {
+ if (!ulist_containsString(results, value, (int32_t)uprv_strlen(value))) {
+ ulist_addItemEndList(results, value, FALSE, status);
+ if (U_FAILURE(*status)) {
+ break;
+ }
+ }
+ }
+ }
+
+ ulist_deleteList(values);
+
+ if (U_FAILURE(*status)){
+ uenum_close(en);
+ en = NULL;
+ } else {
+ ulist_resetList(results);
+ }
+
+ return en;
+}
+
+U_CAPI int32_t U_EXPORT2
+ucol_getFunctionalEquivalent(char* result, int32_t resultCapacity,
+ const char* keyword, const char* locale,
+ UBool* isAvailable, UErrorCode* status)
+{
+ // N.B.: Resource name is "collations" but keyword is "collation"
+ return ures_getFunctionalEquivalent(result, resultCapacity, U_ICUDATA_COLL,
+ "collations", keyword, locale,
+ isAvailable, TRUE, status);
+}
+
+/* returns the locale name the collation data comes from */
+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) {
+ const char *result = NULL;
+ if(status == NULL || U_FAILURE(*status)) {
+ return NULL;
+ }
+ UTRACE_ENTRY(UTRACE_UCOL_GETLOCALE);
+ UTRACE_DATA1(UTRACE_INFO, "coll=%p", coll);
+
+ switch(type) {
+ case ULOC_ACTUAL_LOCALE:
+ result = coll->actualLocale;
+ break;
+ case ULOC_VALID_LOCALE:
+ result = coll->validLocale;
+ break;
+ case ULOC_REQUESTED_LOCALE:
+ result = coll->requestedLocale;
+ break;
+ default:
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ }
+ UTRACE_DATA1(UTRACE_INFO, "result = %s", result);
+ UTRACE_EXIT_STATUS(*status);
+ return result;
+}
+
+U_CFUNC void U_EXPORT2
+ucol_setReqValidLocales(UCollator *coll, char *requestedLocaleToAdopt, char *validLocaleToAdopt, char *actualLocaleToAdopt)
+{
+ if (coll) {
+ if (coll->validLocale) {
+ uprv_free(coll->validLocale);
+ }
+ coll->validLocale = validLocaleToAdopt;
+ if (coll->requestedLocale) { // should always have
+ uprv_free(coll->requestedLocale);
+ }
+ coll->requestedLocale = requestedLocaleToAdopt;
+ if (coll->actualLocale) {
+ uprv_free(coll->actualLocale);
+ }
+ coll->actualLocale = actualLocaleToAdopt;
+ }
+}
+
+U_CAPI USet * U_EXPORT2
+ucol_getTailoredSet(const UCollator *coll, UErrorCode *status)
+{
+ U_NAMESPACE_USE
+
+ if(status == NULL || U_FAILURE(*status)) {
+ return NULL;
+ }
+ if(coll == NULL || coll->UCA == NULL) {
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ return NULL;
+ }
+ UParseError parseError;
+ UColTokenParser src;
+ int32_t rulesLen = 0;
+ const UChar *rules = ucol_getRules(coll, &rulesLen);
+ UBool startOfRules = TRUE;
+ // we internally use the C++ class, for the following reasons:
+ // 1. we need to utilize canonical iterator, which is a C++ only class
+ // 2. canonical iterator returns UnicodeStrings - USet cannot take them
+ // 3. USet is internally really UnicodeSet, C is just a wrapper
+ UnicodeSet *tailored = new UnicodeSet();
+ UnicodeString pattern;
+ UnicodeString empty;
+ CanonicalIterator it(empty, *status);
+
+
+ // The idea is to tokenize the rule set. For each non-reset token,
+ // we add all the canonicaly equivalent FCD sequences
+ ucol_tok_initTokenList(&src, rules, rulesLen, coll->UCA, ucol_tok_getRulesFromBundle, NULL, status);
+ while (ucol_tok_parseNextToken(&src, startOfRules, &parseError, status) != NULL) {
+ startOfRules = FALSE;
+ if(src.parsedToken.strength != UCOL_TOK_RESET) {
+ const UChar *stuff = src.source+(src.parsedToken.charsOffset);
+ it.setSource(UnicodeString(stuff, src.parsedToken.charsLen), *status);
+ pattern = it.next();
+ while(!pattern.isBogus()) {
+ if(Normalizer::quickCheck(pattern, UNORM_FCD, *status) != UNORM_NO) {
+ tailored->add(pattern);
+ }
+ pattern = it.next();
+ }
+ }
+ }
+ ucol_tok_closeTokenList(&src);
+ return (USet *)tailored;
+}
+
+/*
+ * Collation Reordering
+ */
+
+static void ucol_setReorderCodesFromParser(UCollator *coll, UColTokenParser *parser, UErrorCode *status) {
+ if (U_FAILURE(*status)) {
+ return;
+ }
+
+ coll->reorderCodesLength = 0;
+ if (coll->reorderCodes != NULL) {
+ uprv_free(coll->reorderCodes);
+ }
+
+ if (parser->reorderCodesLength == 0 || parser->reorderCodes == NULL) {
+ return;
+ }
+
+ coll->reorderCodesLength = parser->reorderCodesLength;
+ coll->reorderCodes = (int32_t*) uprv_malloc(coll->reorderCodesLength * sizeof(int32_t));
+ uprv_memcpy(coll->reorderCodes, parser->reorderCodes, coll->reorderCodesLength * sizeof(int32_t));
+}
+
+static int ucol_getLeadBytesForReorderCode(UCollator *coll, int reorderCode, uint16_t* returnLeadBytes, int returnCapacity) {
+ uint16_t reorderCodeIndexLength = *((uint16_t*) ((uint8_t *)coll->UCA->image + coll->UCA->image->scriptToLeadByte));
+ uint16_t* reorderCodeIndex = (uint16_t*) ((uint8_t *)coll->UCA->image + coll->UCA->image->scriptToLeadByte + 2 *sizeof(uint16_t));
+
+ // TODO - replace with a binary search
+ // reorder code index is 2 uint16_t's - reorder code + offset
+ for (int i = 0; i < reorderCodeIndexLength; i++) {
+ if (reorderCode == reorderCodeIndex[i*2]) {
+ uint16_t dataOffset = reorderCodeIndex[(i*2) + 1];
+ if ((dataOffset & 0x8000) == 0x8000) {
+ // offset isn't offset but instead is a single data element
+ if (returnCapacity >= 1) {
+ returnLeadBytes[0] = dataOffset & ~0x8000;
+ return 1;
+ }
+ return 0;
+ }
+ uint16_t* dataOffsetBase = (uint16_t*) ((uint8_t *)reorderCodeIndex + reorderCodeIndexLength * (2 * sizeof(uint16_t)));
+ uint16_t leadByteCount = *(dataOffsetBase + dataOffset);
+ leadByteCount = leadByteCount > returnCapacity ? returnCapacity : leadByteCount;
+ uprv_memcpy(returnLeadBytes, dataOffsetBase + dataOffset + 1, leadByteCount * sizeof(uint16_t));
+ return leadByteCount;
+ }
+ }
+ return 0;
+}
+
+static int ucol_getReorderCodesForLeadByte(UCollator *coll, int leadByte, int16_t* returnReorderCodes, int returnCapacity) {
+ int leadByteIndexLength = *((uint16_t*) ((uint8_t *)coll->UCA->image + coll->UCA->image->leadByteToScript));
+ uint16_t* leadByteIndex = (uint16_t*) ((uint8_t *)coll->UCA->image + coll->UCA->image->leadByteToScript + 2 *sizeof(uint16_t));
+ if (leadByte >= leadByteIndexLength) {
+ return 0;
+ }
+
+ if ((leadByteIndex[leadByte] & 0x8000) == 0x8000) {
+ // offset isn't offset but instead is a single data element
+ if (returnCapacity >= 1) {
+ returnReorderCodes[0] = leadByteIndex[leadByte] & ~0x8000;
+ return 1;
+ }
+ return 0;
+ }
+ uint16_t* dataOffsetBase = (uint16_t*) ((uint8_t *)leadByteIndex + leadByteIndexLength * (2 * sizeof(uint16_t)));
+ uint16_t reorderCodeCount = *(dataOffsetBase + leadByteIndex[leadByte]);
+ reorderCodeCount = reorderCodeCount > returnCapacity ? returnCapacity : reorderCodeCount;
+ uprv_memcpy(returnReorderCodes, dataOffsetBase + leadByteIndex[leadByte] + 1, reorderCodeCount * sizeof(uint16_t));
+ return reorderCodeCount;
+}
+
+// used to mark ignorable reorder code slots
+static const int32_t UCOL_REORDER_CODE_IGNORE = UCOL_REORDER_CODE_LIMIT + 1;
+
+void ucol_buildPermutationTable(UCollator *coll, UErrorCode *status) {
+ uint16_t leadBytesSize = 256;
+ uint16_t leadBytes[256];
+ int32_t internalReorderCodesLength = coll->reorderCodesLength + (UCOL_REORDER_CODE_LIMIT - UCOL_REORDER_CODE_FIRST);
+ int32_t* internalReorderCodes;
+
+ // The lowest byte that hasn't been assigned a mapping
+ int toBottom = 0x03;
+ // The highest byte that hasn't been assigned a mapping - don't include the special or trailing
+ int toTop = 0xe4;
+
+ // are we filling from the bottom?
+ bool fromTheBottom = true;
+
+ // lead bytes that have alread been assigned to the permutation table
+ bool newLeadByteUsed[256];
+ // permutation table slots that have already been filled
+ bool permutationSlotFilled[256];
+
+ // nothing to do
+ if(U_FAILURE(*status) || coll == NULL || coll->reorderCodesLength == 0) {
+ if (coll != NULL) {
+ if (coll->leadBytePermutationTable != NULL) {
+ uprv_free(coll->leadBytePermutationTable);
+ coll->leadBytePermutationTable = NULL;
+ }
+ coll->reorderCodesLength = 0;
+ }
+ return;
+ }
+
+ if (coll->leadBytePermutationTable == NULL) {
+ coll->leadBytePermutationTable = (uint8_t*)uprv_malloc(256*sizeof(uint8_t));
+ if (coll->leadBytePermutationTable == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ return;
+ }
+ }
+
+ // prefill the reordering codes with the leading entries
+ internalReorderCodes = (int32_t*)uprv_malloc(internalReorderCodesLength * sizeof(int32_t));
+ if (internalReorderCodes == NULL) {
+ *status = U_MEMORY_ALLOCATION_ERROR;
+ if (coll->leadBytePermutationTable != NULL) {
+ uprv_free(coll->leadBytePermutationTable);
+ coll->leadBytePermutationTable = NULL;
+ }
+ return;
+ }
+
+ for (uint32_t codeIndex = 0; codeIndex < (UCOL_REORDER_CODE_LIMIT - UCOL_REORDER_CODE_FIRST); codeIndex++) {
+ internalReorderCodes[codeIndex] = UCOL_REORDER_CODE_FIRST + codeIndex;
+ }
+ for (int32_t codeIndex = 0; codeIndex < coll->reorderCodesLength; codeIndex++) {
+ uint32_t reorderCodesCode = coll->reorderCodes[codeIndex];
+ internalReorderCodes[codeIndex + (UCOL_REORDER_CODE_LIMIT - UCOL_REORDER_CODE_FIRST)] = reorderCodesCode;
+ if (reorderCodesCode >= UCOL_REORDER_CODE_FIRST && reorderCodesCode < UCOL_REORDER_CODE_LIMIT) {
+ internalReorderCodes[reorderCodesCode - UCOL_REORDER_CODE_FIRST] = UCOL_REORDER_CODE_IGNORE;
+ }
+ }
+
+ for (int i = 0; i < 256; i++) {
+ if (i < toBottom || i > toTop) {
+ permutationSlotFilled[i] = true;
+ newLeadByteUsed[i] = true;
+ coll->leadBytePermutationTable[i] = i;
+ } else {
+ permutationSlotFilled[i] = false;
+ newLeadByteUsed[i] = false;
+ coll->leadBytePermutationTable[i] = 0;
+ }
+ }
+
+ /* Start from the front of the list and place each script we encounter at the
+ * earliest possible locatation in the permutation table. If we encounter
+ * UNKNOWN, start processing from the back, and place each script in the last
+ * possible location. At each step, we also need to make sure that any scripts
+ * that need to not be moved are copied to their same location in the final table.
+ */
+ for (int reorderCodesIndex = 0; reorderCodesIndex < internalReorderCodesLength; reorderCodesIndex++) {
+ int32_t next = internalReorderCodes[reorderCodesIndex];
+ if (next == UCOL_REORDER_CODE_IGNORE) {
+ continue;
+ }
+ if (next == USCRIPT_UNKNOWN) {
+ if (fromTheBottom == false) {
+ // double turnaround
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ if (coll->leadBytePermutationTable != NULL) {
+ uprv_free(coll->leadBytePermutationTable);
+ coll->leadBytePermutationTable = NULL;
+ }
+ coll->reorderCodesLength = 0;
+ if (internalReorderCodes != NULL) {
+ uprv_free(internalReorderCodes);
+ }
+ return;
+ }
+ fromTheBottom = false;
+ continue;
+ }
+
+ uint16_t leadByteCount = ucol_getLeadBytesForReorderCode(coll, next, leadBytes, leadBytesSize);
+ if (fromTheBottom) {
+ for (int leadByteIndex = 0; leadByteIndex < leadByteCount; leadByteIndex++) {
+ // don't place a lead byte twice in the permutation table
+ if (permutationSlotFilled[leadBytes[leadByteIndex]]) {
+ // lead byte already used
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ if (coll->leadBytePermutationTable != NULL) {
+ uprv_free(coll->leadBytePermutationTable);
+ coll->leadBytePermutationTable = NULL;
+ }
+ coll->reorderCodesLength = 0;
+ if (internalReorderCodes != NULL) {
+ uprv_free(internalReorderCodes);
+ }
+ return;
+ }
+
+ coll->leadBytePermutationTable[leadBytes[leadByteIndex]] = toBottom;
+ newLeadByteUsed[toBottom] = true;
+ permutationSlotFilled[leadBytes[leadByteIndex]] = true;
+ toBottom++;
+ }
+ } else {
+ for (int leadByteIndex = leadByteCount - 1; leadByteIndex >= 0; leadByteIndex--) {
+ // don't place a lead byte twice in the permutation table
+ if (permutationSlotFilled[leadBytes[leadByteIndex]]) {
+ // lead byte already used
+ *status = U_ILLEGAL_ARGUMENT_ERROR;
+ if (coll->leadBytePermutationTable != NULL) {
+ uprv_free(coll->leadBytePermutationTable);
+ coll->leadBytePermutationTable = NULL;
+ }
+ coll->reorderCodesLength = 0;
+ if (internalReorderCodes != NULL) {
+ uprv_free(internalReorderCodes);
+ }
+ return;
+ }
+
+ coll->leadBytePermutationTable[leadBytes[leadByteIndex]] = toTop;
+ newLeadByteUsed[toTop] = true;
+ permutationSlotFilled[leadBytes[leadByteIndex]] = true;
+ toTop--;
+ }
+ }
+ }
+
+#ifdef REORDER_DEBUG
+ fprintf(stdout, "\n@@@@ Partial Script Reordering Table\n");
+ for (int i = 0; i < 256; i++) {
+ fprintf(stdout, "\t%02x = %02x\n", i, coll->leadBytePermutationTable[i]);
+ }
+ fprintf(stdout, "\n@@@@ Lead Byte Used Table\n");
+ for (int i = 0; i < 256; i++) {
+ fprintf(stdout, "\t%02x = %02x\n", i, newLeadByteUsed[i]);
+ }
+ fprintf(stdout, "\n@@@@ Permutation Slot Filled Table\n");
+ for (int i = 0; i < 256; i++) {
+ fprintf(stdout, "\t%02x = %02x\n", i, permutationSlotFilled[i]);
+ }
+#endif
+
+ /* Copy everything that's left over */
+ int reorderCode = 0;
+ for (int i = 0; i < 256; i++) {
+ if (!permutationSlotFilled[i]) {
+ while (reorderCode < 256 && newLeadByteUsed[reorderCode]) {
+ reorderCode++;
+ }
+ coll->leadBytePermutationTable[i] = reorderCode;
+ permutationSlotFilled[i] = true;
+ newLeadByteUsed[reorderCode] = true;
+ }
+ }
+
+#ifdef REORDER_DEBUG
+ fprintf(stdout, "\n@@@@ Script Reordering Table\n");
+ for (int i = 0; i < 256; i++) {
+ fprintf(stdout, "\t%02x = %02x\n", i, coll->leadBytePermutationTable[i]);
+ }
+#endif
+
+ if (internalReorderCodes != NULL) {
+ uprv_free(internalReorderCodes);
+ }
+
+ // force a regen of the latin one table since it is affected by the script reordering
+ coll->latinOneRegenTable = TRUE;
+ ucol_updateInternalState(coll, status);
+}
+
+#endif /* #if !UCONFIG_NO_COLLATION */
Property changes on: icu46/source/i18n/ucol_res.cpp
___________________________________________________________________
Added: svn:eol-style
+ LF
« no previous file with comments | « icu46/source/i18n/ucol_imp.h ('k') | icu46/source/i18n/ucol_sit.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698