static UBool ucbuf_isCPKnown(const char* cp){ if(ucnv_compareNames("UTF-8",cp)==0){ return TRUE; } if(ucnv_compareNames("UTF-16BE",cp)==0){ return TRUE; } if(ucnv_compareNames("UTF-16LE",cp)==0){ return TRUE; } if(ucnv_compareNames("UTF-16",cp)==0){ return TRUE; } if(ucnv_compareNames("UTF-32",cp)==0){ return TRUE; } if(ucnv_compareNames("UTF-32BE",cp)==0){ return TRUE; } if(ucnv_compareNames("UTF-32LE",cp)==0){ return TRUE; } if(ucnv_compareNames("SCSU",cp)==0){ return TRUE; } if(ucnv_compareNames("BOCU-1",cp)==0){ return TRUE; } if(ucnv_compareNames("UTF-7",cp)==0){ return TRUE; } return FALSE; }
static int32_t findIndex(const char* converterName) { int32_t i; for (i = 0 ; i < gCountAvailable; i++) { if(ucnv_compareNames(gAvailableNames[i], converterName) == 0) { return i; } } return -1; }
static int compareAliases(const void *alias1, const void *alias2) { /* Names like IBM850 and ibm-850 need to be sorted together */ int result = ucnv_compareNames(GET_ALIAS_STR(*(uint16_t*)alias1), GET_ALIAS_STR(*(uint16_t*)alias2)); if (!result) { /* Sort the shortest first */ return (int)uprv_strlen(GET_ALIAS_STR(*(uint16_t*)alias1)) - (int)uprv_strlen(GET_ALIAS_STR(*(uint16_t*)alias2)); } return result; }
/* * Is this alias in this list? * alias and listOffset should be non-NULL. */ static U_INLINE UBool isAliasInList(const char* alias, uint32_t listOffset) { if (listOffset) { uint32_t currAlias; uint32_t listCount = gMainTable.taggedAliasLists[listOffset]; /* +1 to skip listCount */ const uint16_t* currList = gMainTable.taggedAliasLists + listOffset + 1; for (currAlias = 0; currAlias < listCount; currAlias++) { if (currList[currAlias] && ucnv_compareNames(alias, GET_STRING(currList[currAlias])) == 0) { return TRUE; } } } return FALSE; }
static uint16_t addConverter(const char *converter) { uint32_t idx; if(converterCount>=MAX_CONV_COUNT) { fprintf(stderr, "%s:%d: error: too many converters\n", path, lineNum); exit(U_BUFFER_OVERFLOW_ERROR); } for (idx = 0; idx < converterCount; idx++) { if (ucnv_compareNames(converter, GET_ALIAS_STR(converters[idx].converter)) == 0) { fprintf(stderr, "%s:%d: error: duplicate converter %s found!\n", path, lineNum, converter); exit(U_PARSE_ERROR); break; } } converters[converterCount].converter = GET_ALIAS_NUM(converter); converters[converterCount].totalAliasCount = 0; return converterCount++; }
bool qTextCodecNameMatch(const char *n, const char *h) { return ucnv_compareNames(n, h) == 0; }
/* * search for an alias * return the converter number index for gConverterList */ static inline uint32_t findConverter(const char *alias, UBool *containsOption, UErrorCode *pErrorCode) { uint32_t mid, start, limit; uint32_t lastMid; int result; int isUnnormalized = (gMainTable.optionTable->stringNormalizationType == UCNV_IO_UNNORMALIZED); char strippedName[UCNV_MAX_CONVERTER_NAME_LENGTH]; if (!isUnnormalized) { if (uprv_strlen(alias) >= UCNV_MAX_CONVERTER_NAME_LENGTH) { *pErrorCode = U_BUFFER_OVERFLOW_ERROR; return UINT32_MAX; } /* Lower case and remove ignoreable characters. */ ucnv_io_stripForCompare(strippedName, alias); alias = strippedName; } /* do a binary search for the alias */ start = 0; limit = gMainTable.untaggedConvArraySize; mid = limit; lastMid = UINT32_MAX; for (;;) { mid = (uint32_t)((start + limit) / 2); if (lastMid == mid) { /* Have we moved? */ break; /* We haven't moved, and it wasn't found. */ } lastMid = mid; if (isUnnormalized) { result = ucnv_compareNames(alias, GET_STRING(gMainTable.aliasList[mid])); } else { result = uprv_strcmp(alias, GET_NORMALIZED_STRING(gMainTable.aliasList[mid])); } if (result < 0) { limit = mid; } else if (result > 0) { start = mid; } else { /* Since the gencnval tool folds duplicates into one entry, * this alias in gAliasList is unique, but different standards * may map an alias to different converters. */ if (gMainTable.untaggedConvArray[mid] & UCNV_AMBIGUOUS_ALIAS_MAP_BIT) { *pErrorCode = U_AMBIGUOUS_ALIAS_WARNING; } /* State whether the canonical converter name contains an option. This information is contained in this list in order to maintain backward & forward compatibility. */ if (containsOption) { UBool containsCnvOptionInfo = (UBool)gMainTable.optionTable->containsCnvOptionInfo; *containsOption = (UBool)((containsCnvOptionInfo && ((gMainTable.untaggedConvArray[mid] & UCNV_CONTAINS_OPTION_BIT) != 0)) || !containsCnvOptionInfo); } return gMainTable.untaggedConvArray[mid] & UCNV_CONVERTER_INDEX_MASK; } } return UINT32_MAX; }
/* The knownAliases should be sorted before calling this function */ static uint32_t resolveAliases(uint16_t *uniqueAliasArr, uint16_t *uniqueAliasToConverterArr, uint16_t aliasOffset) { uint32_t uniqueAliasIdx = 0; uint32_t idx; uint16_t currTagNum, oldTagNum; uint16_t currConvNum, oldConvNum; const char *lastName; resolveAliasToConverter(knownAliases[0], &oldTagNum, &currConvNum); uniqueAliasToConverterArr[uniqueAliasIdx] = currConvNum; oldConvNum = currConvNum; uniqueAliasArr[uniqueAliasIdx] = knownAliases[0] + aliasOffset; uniqueAliasIdx++; lastName = GET_ALIAS_STR(knownAliases[0]); for (idx = 1; idx < knownAliasesCount; idx++) { resolveAliasToConverter(knownAliases[idx], &currTagNum, &currConvNum); if (ucnv_compareNames(lastName, GET_ALIAS_STR(knownAliases[idx])) == 0) { /* duplicate found */ if ((currTagNum < oldTagNum && currTagNum >= UCNV_NUM_RESERVED_TAGS) || oldTagNum == 0) { oldTagNum = currTagNum; uniqueAliasToConverterArr[uniqueAliasIdx - 1] = currConvNum; uniqueAliasArr[uniqueAliasIdx - 1] = knownAliases[idx] + aliasOffset; if (verbose) { printf("using %s instead of %s -> %s", GET_ALIAS_STR(knownAliases[idx]), lastName, GET_ALIAS_STR(converters[currConvNum].converter)); if (oldConvNum != currConvNum) { printf(" (alias conflict)"); } puts(""); } } else { /* else ignore it */ if (verbose) { printf("folding %s into %s -> %s", GET_ALIAS_STR(knownAliases[idx]), lastName, GET_ALIAS_STR(converters[oldConvNum].converter)); if (oldConvNum != currConvNum) { printf(" (alias conflict)"); } puts(""); } } if (oldConvNum != currConvNum) { uniqueAliasToConverterArr[uniqueAliasIdx - 1] |= UCNV_AMBIGUOUS_ALIAS_MAP_BIT; } } else { uniqueAliasToConverterArr[uniqueAliasIdx] = currConvNum; oldConvNum = currConvNum; uniqueAliasArr[uniqueAliasIdx] = knownAliases[idx] + aliasOffset; uniqueAliasIdx++; lastName = GET_ALIAS_STR(knownAliases[idx]); oldTagNum = currTagNum; /*printf("%s -> %s\n", GET_ALIAS_STR(knownAliases[idx]), GET_ALIAS_STR(converters[currConvNum].converter));*/ } if (uprv_strchr(GET_ALIAS_STR(converters[currConvNum].converter), UCNV_OPTION_SEP_CHAR) != NULL) { uniqueAliasToConverterArr[uniqueAliasIdx-1] |= UCNV_CONTAINS_OPTION_BIT; } } return uniqueAliasIdx; }
/* @param standard When standard is 0, then it's the "empty" tag. */ static uint16_t addAlias(const char *alias, uint16_t standard, uint16_t converter, UBool defaultName) { uint32_t idx, idx2; UBool startEmptyWithoutDefault = FALSE; AliasList *aliasList; if(standard>=MAX_TAG_COUNT) { fprintf(stderr, "%s:%d: error: too many standard tags\n", path, lineNum); exit(U_BUFFER_OVERFLOW_ERROR); } if(converter>=MAX_CONV_COUNT) { fprintf(stderr, "%s:%d: error: too many converter names\n", path, lineNum); exit(U_BUFFER_OVERFLOW_ERROR); } aliasList = &tags[standard].aliasList[converter]; if (strchr(alias, '}')) { fprintf(stderr, "%s:%d: error: unmatched } found\n", path, lineNum); } if(aliasList->aliasCount + 1 >= MAX_TC_ALIAS_COUNT) { fprintf(stderr, "%s:%d: error: too many aliases for alias %s and converter %s\n", path, lineNum, alias, GET_ALIAS_STR(converters[converter].converter)); exit(U_BUFFER_OVERFLOW_ERROR); } /* Show this warning only once. All aliases are added to the "ALL" tag. */ if (standard == ALL_TAG_NUM && GET_ALIAS_STR(converters[converter].converter) != alias) { /* Normally these option values are parsed at runtime, and they can be discarded when the alias is a default converter. Options should only be on a converter and not an alias. */ if (uprv_strchr(alias, UCNV_OPTION_SEP_CHAR) != 0) { fprintf(stderr, "warning(line %d): alias %s contains a \""UCNV_OPTION_SEP_STRING"\". Options are parsed at run-time and do not need to be in the alias table.\n", lineNum, alias); } if (uprv_strchr(alias, UCNV_VALUE_SEP_CHAR) != 0) { fprintf(stderr, "warning(line %d): alias %s contains an \""UCNV_VALUE_SEP_STRING"\". Options are parsed at run-time and do not need to be in the alias table.\n", lineNum, alias); } } if (standard != ALL_TAG_NUM) { /* Check for duplicate aliases for this tag on all converters */ for (idx = 0; idx < converterCount; idx++) { for (idx2 = 0; idx2 < tags[standard].aliasList[idx].aliasCount; idx2++) { uint16_t aliasNum = tags[standard].aliasList[idx].aliases[idx2]; if (aliasNum && ucnv_compareNames(alias, GET_ALIAS_STR(aliasNum)) == 0) { if (idx == converter) { /* * (alias, standard) duplicates are harmless if they map to the same converter. * Only print a warning in verbose mode, or if the alias is a precise duplicate, * not just a lenient-match duplicate. */ if (verbose || 0 == uprv_strcmp(alias, GET_ALIAS_STR(aliasNum))) { fprintf(stderr, "%s:%d: warning: duplicate aliases %s and %s found for standard %s and converter %s\n", path, lineNum, alias, GET_ALIAS_STR(aliasNum), GET_TAG_STR(tags[standard].tag), GET_ALIAS_STR(converters[converter].converter)); } } else { fprintf(stderr, "%s:%d: warning: duplicate aliases %s and %s found for standard tag %s between converter %s and converter %s\n", path, lineNum, alias, GET_ALIAS_STR(aliasNum), GET_TAG_STR(tags[standard].tag), GET_ALIAS_STR(converters[converter].converter), GET_ALIAS_STR(converters[idx].converter)); } break; } } } /* Check for duplicate default aliases for this converter on all tags */ /* It's okay to have multiple standards prefer the same name */ /* if (verbose && !dupFound) { for (idx = 0; idx < tagCount; idx++) { if (tags[idx].aliasList[converter].aliases) { uint16_t aliasNum = tags[idx].aliasList[converter].aliases[0]; if (aliasNum && ucnv_compareNames(alias, GET_ALIAS_STR(aliasNum)) == 0) { fprintf(stderr, "%s:%d: warning: duplicate alias %s found for converter %s and standard tag %s\n", path, lineNum, alias, GET_ALIAS_STR(converters[converter].converter), GET_TAG_STR(tags[standard].tag)); break; } } } }*/ } if (aliasList->aliasCount <= 0) { aliasList->aliasCount++; startEmptyWithoutDefault = TRUE; } aliasList->aliases = (uint16_t *)uprv_realloc(aliasList->aliases, (aliasList->aliasCount + 1) * sizeof(aliasList->aliases[0])); if (startEmptyWithoutDefault) { aliasList->aliases[0] = 0; } if (defaultName) { if (aliasList->aliases[0] != 0) { fprintf(stderr, "%s:%d: error: Alias %s and %s cannot both be the default alias for standard tag %s and converter %s\n", path, lineNum, alias, GET_ALIAS_STR(aliasList->aliases[0]), GET_TAG_STR(tags[standard].tag), GET_ALIAS_STR(converters[converter].converter)); exit(U_PARSE_ERROR); } aliasList->aliases[0] = GET_ALIAS_NUM(alias); } else { aliasList->aliases[aliasList->aliasCount++] = GET_ALIAS_NUM(alias); } /* aliasList->converter = converter;*/ converters[converter].totalAliasCount++; /* One more to the column */ tags[standard].totalAliasCount++; /* One more to the row */ return aliasList->aliasCount; }
int __hs_ucnv_compareNames(const char *name1, const char *name2) { return ucnv_compareNames(name1, name2); }