diff options
Diffstat (limited to 'Build/source/libs/icu/icu-49.1/tools/dumpce')
4 files changed, 1805 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-49.1/tools/dumpce/Makefile.in b/Build/source/libs/icu/icu-49.1/tools/dumpce/Makefile.in new file mode 100644 index 00000000000..81f6808b047 --- /dev/null +++ b/Build/source/libs/icu/icu-49.1/tools/dumpce/Makefile.in @@ -0,0 +1,76 @@ +## Makefile.in for ICU - tools/dumpce +## Copyright (c) 2001, International Business Machines Corporation and +## others. All Rights Reserved. + +## Source directory information +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ + +top_builddir = ../.. + +include $(top_builddir)/icudefs.mk + +## Build directory information +subdir = tools/dumpce + +## Extra files to remove for 'make clean' +CLEANFILES = *~ $(DEPS) + +## Target information +TARGET = dumpce + +CPPFLAGS += -I$(top_srcdir)/common -I$(top_srcdir)/i18n -I$(top_srcdir)/tools/toolutil +LIBS = $(LIBICUI18N) $(LIBICUUC) $(LIBICUTOOLUTIL) $(DEFAULT_LIBS) $(LIB_M) + +OBJECTS = dumpce.o + +DEPS = $(OBJECTS:.o=.d) + +## List of phony targets +.PHONY : all all-local install install-local clean clean-local \ +distclean distclean-local dist dist-local check check-local + +## Clear suffix list +.SUFFIXES : + +## List of standard targets +all: all-local +install: install-local +clean: clean-local +distclean : distclean-local +dist: dist-local +check: all check-local + +all-local: $(TARGET) + +install-local: + +dist-local: + +clean-local: + test -z "$(CLEANFILES)" || $(RMV) $(CLEANFILES) + $(RMV) $(OBJECTS) $(TARGET) + +distclean-local: clean-local + $(RMV) Makefile + +check-local: all-local + +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + cd $(top_builddir) \ + && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status + +$(TARGET) : $(OBJECTS) + $(LINK.cc) -o $@ $^ $(LIBS) + $(POST_BUILD_STEP) + +invoke: + ICU_DATA=$${ICU_DATA:-$(top_builddir)/data/} TZ=PST8PDT $(INVOKE) $(INVOCATION) + +ifeq (,$(MAKECMDGOALS)) +-include $(DEPS) +else +ifneq ($(patsubst %clean,,$(MAKECMDGOALS)),) +-include $(DEPS) +endif +endif diff --git a/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.cpp b/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.cpp new file mode 100644 index 00000000000..0917ce7970d --- /dev/null +++ b/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.cpp @@ -0,0 +1,1597 @@ +/******************************************************************** + * COPYRIGHT: + * Copyright (C) 2001-2011 IBM, Inc. All Rights Reserved. + * + ********************************************************************/ +/******************************************************************************** +* +* File dumpce.cpp +* +* Modification History: +* Name Date Description +* synwee May 31 2001 Creation +* +********************************************************************************* +*/ + +/** +* This program outputs the collation elements used for a requested tailoring. +* +* Usage: +* dumpce options... please check main function. +*/ +#include <unicode/utypes.h> +#include <unicode/ucol.h> +#include <unicode/uloc.h> +#include <unicode/ucoleitr.h> +#include <unicode/uchar.h> +#include <unicode/uscript.h> +#include <unicode/utf16.h> +#include <unicode/putil.h> +#include <unicode/ustring.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include "ucol_tok.h" +#include "cstring.h" +#include "uoptions.h" +#include "ucol_imp.h" +#include <unicode/ures.h> +#include <unicode/uniset.h> +#include <unicode/usetiter.h> + +/** +* Command line option variables. +* These global variables are set according to the options specified on the +* command line by the user. +*/ +static UOption options[]={ + /* 00 */ UOPTION_HELP_H, + /* 01 */ UOPTION_HELP_QUESTION_MARK, + /* 02 */ {"locale", NULL, NULL, NULL, 'l', UOPT_REQUIRES_ARG, 0}, + /* 03 */ {"serialize", NULL, NULL, NULL, 'z', UOPT_NO_ARG, 0}, + /* 04 */ UOPTION_DESTDIR, + /* 05 */ UOPTION_SOURCEDIR, + /* 06 */ {"attribute", NULL, NULL, NULL, 'a', UOPT_REQUIRES_ARG, 0}, + /* 07 */ {"rule", NULL, NULL, NULL, 'r', UOPT_REQUIRES_ARG, 0}, + /* 08 */ {"normalization", NULL, NULL, NULL, 'n', UOPT_REQUIRES_ARG, 0}, + /* 09 */ {"scripts", NULL, NULL, NULL, 't', UOPT_NO_ARG, 0}, + /* 10 */ {"reducehan", NULL, NULL, NULL, 'e', UOPT_NO_ARG, 0}, + /* 11 */ UOPTION_VERBOSE, + /* 12 */ {"wholescripts", NULL, NULL, NULL, 'W', UOPT_NO_ARG, 0} +}; + +/** +* Collator used in this program +*/ +static UCollator *COLLATOR_; +/** +* Output strea, used in this program +*/ +static FILE *OUTPUT_; + +static UColAttributeValue ATTRIBUTE_[UCOL_ATTRIBUTE_COUNT] = { + UCOL_DEFAULT, UCOL_DEFAULT, UCOL_DEFAULT, UCOL_DEFAULT, UCOL_DEFAULT, + UCOL_DEFAULT, UCOL_DEFAULT, UCOL_DEFAULT, +}; + +typedef struct { + int value; + char *name; +} EnumNameValuePair; + +static const EnumNameValuePair ATTRIBUTE_NAME_[] = { + {UCOL_FRENCH_COLLATION, "UCOL_FRENCH_COLLATION"}, + {UCOL_ALTERNATE_HANDLING, "UCOL_ALTERNATE_HANDLING"}, + {UCOL_CASE_FIRST, "UCOL_CASE_FIRST"}, + {UCOL_CASE_LEVEL, "UCOL_CASE_LEVEL"}, + {UCOL_NORMALIZATION_MODE, + "UCOL_NORMALIZATION_MODE|UCOL_DECOMPOSITION_MODE"}, + {UCOL_STRENGTH, "UCOL_STRENGTH"}, + {UCOL_HIRAGANA_QUATERNARY_MODE, "UCOL_HIRAGANA_QUATERNARY_MODE"}, + {UCOL_NUMERIC_COLLATION, "UCOL_NUMERIC_COLLATION"}, + NULL +}; + +static const EnumNameValuePair ATTRIBUTE_VALUE_[] = { + {UCOL_PRIMARY, "UCOL_PRIMARY"}, + {UCOL_SECONDARY, "UCOL_SECONDARY"}, + {UCOL_TERTIARY, "UCOL_TERTIARY|UCOL_DEFAULT_STRENGTH"}, + {UCOL_QUATERNARY, "UCOL_QUATERNARY"}, + {UCOL_IDENTICAL, "UCOL_IDENTICAL"}, + {UCOL_OFF, "UCOL_OFF"}, + {UCOL_ON, "UCOL_ON"}, + {UCOL_SHIFTED, "UCOL_SHIFTED"}, + {UCOL_NON_IGNORABLE, "UCOL_NON_IGNORABLE"}, + {UCOL_LOWER_FIRST, "UCOL_LOWER_FIRST"}, + {UCOL_UPPER_FIRST, "UCOL_UPPER_FIRST"}, + NULL +}; + +typedef struct { + UChar ch[32]; + int count; // number of codepoint + UBool tailored; +} ScriptElement; + +/** +* Writes the hexadecimal of a null-terminated array of codepoints into a +* file +* @param f UFILE instance to store +* @param c codepoints array +*/ +void serialize(FILE *f, const UChar *c) +{ + UChar cp = *(c ++); + + fprintf(f, " %04x", cp); + + while (*c != 0) { + cp = *(c ++); + fprintf(f, " %04x", cp); + } +} + +/** +* Writes the hexadecimal of a non-null-terminated array of codepoints into a +* file +* @param f UFILE instance to store +* @param c codepoints array +* @param l codepoints array length +*/ +void serialize(FILE *f, const UChar *c, int l) +{ + int count = 1; + UChar cp = *(c ++); + + fprintf(f, " %04x", cp); + + while (count < l) { + cp = *(c ++); + fprintf(f, " %04x", cp); + count ++; + } +} + +/** +* Sets the iterator to the argument string and outputs the collation elements. +* @param f file output stream +* @param iter collation element iterator +*/ +void serialize(FILE *f, UCollationElements *iter) { + const UChar *codepoint = iter->iteratordata_.string; + // unlikely that sortkeys will be over this size + uint8_t sortkey[64]; + uint8_t *psortkey = sortkey; + int sortkeylength = 0; + + if (iter->iteratordata_.flags & UCOL_ITER_HASLEN) { + serialize(f, codepoint, iter->iteratordata_.endp - codepoint); + sortkeylength = ucol_getSortKey(iter->iteratordata_.coll, codepoint, + iter->iteratordata_.endp - codepoint, sortkey, 64); + } + else { + serialize(f, codepoint); + sortkeylength = ucol_getSortKey(iter->iteratordata_.coll, codepoint, + -1, sortkey, 64); + } + if (options[11].doesOccur) { + serialize(stdout, codepoint); + fprintf(stdout, "\n"); + } + + fprintf(f, "; "); + + UErrorCode error = U_ZERO_ERROR; + uint32_t ce = ucol_next(iter, &error); + if (U_FAILURE(error)) { + fprintf(f, "Error retrieving collation elements\n"); + return; + } + + while (TRUE) { + fprintf(f, "["); + if (UCOL_PRIMARYORDER(ce) != 0) { + fprintf(f, "%04x", UCOL_PRIMARYORDER(ce)); + } + fprintf(f, ","); + if (UCOL_SECONDARYORDER(ce) != 0) { + fprintf(f, " %02x", UCOL_SECONDARYORDER(ce)); + } + fprintf(f, ","); + if (UCOL_TERTIARYORDER(ce) != 0) { + fprintf(f, " %02x", UCOL_TERTIARYORDER(ce)); + } + fprintf(f, "] "); + + ce = ucol_next(iter, &error); + if (ce == UCOL_NULLORDER) { + break; + } + if (U_FAILURE(error)) { + fprintf(stdout, "Error retrieving collation elements"); + return; + } + } + + if (sortkeylength > 64) { + fprintf(f, "Sortkey exceeds pre-allocated size"); + } + + fprintf(f, "["); + while (TRUE) { + fprintf(f, "%02x", *psortkey); + psortkey ++; + if ((*psortkey) == 0) { + break; + } + fprintf(f, " "); + } + fprintf(f, "]\n"); +} + +/** +* Serializes the contraction within the given argument rule +* @param f file output stream +* @param r rule +* @param rlen rule length +* @param contractionsonly flag to indicate if only contractions are to be +* output or all collation elements +* @param iter iterator to iterate over collation elements +*/ +void serialize(FILE *f, UChar *rule, int rlen, UBool contractiononly, + UCollationElements *iter) { + const UChar *current = NULL; + uint32_t strength = 0; + uint32_t chOffset = 0; + uint32_t chLen = 0; + uint32_t exOffset = 0; + uint32_t exLen = 0; + uint32_t prefixOffset = 0; + uint32_t prefixLen = 0; + uint8_t specs = 0; + UBool rstart = TRUE; + UColTokenParser src; + UColOptionSet opts; + UParseError parseError; + UErrorCode error = U_ZERO_ERROR; + + src.opts = &opts; + + src.source = rule; + src.current = rule; + src.end = rule + rlen; + src.extraCurrent = src.end; + src.extraEnd = src.end + UCOL_TOK_EXTRA_RULE_SPACE_SIZE; + + + while ((current = ucol_tok_parseNextToken(&src, rstart, &parseError, + &error)) != NULL) { + chOffset = src.parsedToken.charsOffset; + chLen = src.parsedToken.charsLen; + // contractions handled here + if (!contractiononly || chLen > 1) { + ucol_setText(iter, rule + chOffset, chLen, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error setting text in iterator\n"); + return; + } + serialize(f, iter); + } + rstart = FALSE; + } +} + +/** +* Prints the attribute values in the argument collator into the output stream +* @param collator +*/ +void outputAttribute(UCollator *collator, UErrorCode *error) +{ + UColAttribute attribute = UCOL_FRENCH_COLLATION; + while (attribute < UCOL_ATTRIBUTE_COUNT) { + int count = 0; + while (TRUE) { + // getting attribute name + if (ATTRIBUTE_NAME_[count].value == attribute) { + fprintf(OUTPUT_, "%s = ", ATTRIBUTE_NAME_[count].name); + break; + } + count ++; + } + count = 0; + int attributeval = ucol_getAttribute(collator, attribute, error); + if (U_FAILURE(*error)) { + fprintf(stdout, "Failure in reading collator attribute\n"); + return; + } + while (TRUE) { + // getting attribute value + if (ATTRIBUTE_VALUE_[count].value == attributeval) { + fprintf(OUTPUT_, "%s\n", ATTRIBUTE_VALUE_[count].name); + break; + } + count ++; + } + attribute = (UColAttribute)(attribute + 1); + } +} + +/** +* Prints the normalization mode in the argument collator into the output stream +* @param collator +*/ +void outputNormalization(UCollator *collator) +{ + UErrorCode status = U_ZERO_ERROR; + int normmode = ucol_getAttribute(collator, UCOL_NORMALIZATION_MODE, &status); + int count = 0; + while (TRUE) { + // getting attribute name + if (ATTRIBUTE_VALUE_[count].value == normmode) { + break; + } + count ++; + } + fprintf(OUTPUT_, "NORMALIZATION MODE = %s\n", + ATTRIBUTE_VALUE_[count].name); +} + +/** +* Output the collation element belonging to the locale into a file +* @param locale string +* @param fullrules flag to indicate if only tailored collation elements are to +* be output or all collation elements +*/ +void serialize(const char *locale, UBool tailoredonly) { + UErrorCode error = U_ZERO_ERROR; + UChar str[128]; + int strlen = 0; + + fprintf(OUTPUT_, "# This file contains the serialized collation elements\n"); + fprintf(OUTPUT_, "# as of the collation version indicated below.\n"); + fprintf(OUTPUT_, "# Data format: xxxx xxxx..; [yyyy, yy, yy] [yyyy, yy, yy] ... [yyyy, yy, yy] [zz zz..\n"); + fprintf(OUTPUT_, "# where xxxx are codepoints in hexadecimals,\n"); + fprintf(OUTPUT_, "# yyyyyyyy are the corresponding\n"); + fprintf(OUTPUT_, "# collation elements in hexadecimals\n"); + fprintf(OUTPUT_, "# and zz are the sortkey values in hexadecimals\n"); + + fprintf(OUTPUT_, "\n# Collator information\n"); + + fprintf(OUTPUT_, "\nLocale: %s\n", locale); + fprintf(stdout, "Locale: %s\n", locale); + UVersionInfo version; + ucol_getVersion(COLLATOR_, version); + fprintf(OUTPUT_, "Version number: %d.%d.%d.%d\n", + version[0], version[1], version[2], version[3]); + outputAttribute(COLLATOR_, &error); + outputNormalization(COLLATOR_); + + UCollationElements *iter = ucol_openElements(COLLATOR_, str, strlen, + &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error creating iterator\n"); + return; + } + + if (!tailoredonly) { + fprintf(OUTPUT_, "\n# Range of unicode characters\n\n"); + UChar32 codepoint = 0; + while (codepoint <= UCHAR_MAX_VALUE) { + if (u_isdefined(codepoint)) { + strlen = 0; + UTF16_APPEND_CHAR_UNSAFE(str, strlen, codepoint); + str[strlen] = 0; + ucol_setText(iter, str, strlen, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error setting text in iterator\n"); + return; + } + serialize(OUTPUT_, iter); + } + codepoint ++; + } + } + + UChar ucarules[0x10000]; + UChar *rules; + int32_t rulelength = 0; + rules = ucarules; + + if (tailoredonly) { + int32_t rulelength = 0; + const UChar *temp = ucol_getRules(COLLATOR_, &rulelength); + if (rulelength + UCOL_TOK_EXTRA_RULE_SPACE_SIZE > 0x10000) { + rules = (UChar *)malloc(sizeof(UChar) * + (rulelength + UCOL_TOK_EXTRA_RULE_SPACE_SIZE)); + } + memcpy(rules, temp, rulelength * sizeof(UChar)); + rules[rulelength] = 0; + fprintf(OUTPUT_, "\n# Tailorings\n\n"); + serialize(OUTPUT_, rules, rulelength, FALSE, iter); + if (rules != ucarules) { + free(rules); + } + } + else { + rulelength = ucol_getRulesEx(COLLATOR_, UCOL_FULL_RULES, ucarules, + 0x10000); + if (rulelength + UCOL_TOK_EXTRA_RULE_SPACE_SIZE > 0x10000) { + rules = (UChar *)malloc(sizeof(UChar) * + (rulelength + UCOL_TOK_EXTRA_RULE_SPACE_SIZE)); + rulelength = ucol_getRulesEx(COLLATOR_, UCOL_FULL_RULES, rules, + rulelength); + } + fprintf(OUTPUT_, "\n# Contractions\n\n"); + serialize(OUTPUT_, rules, rulelength, TRUE, iter); + if (rules != ucarules) { + free(rules); + } + } + + ucol_closeElements(iter); +} + +/** +* Sets the collator with the attribute values +* @param collator +* @param error status +*/ +void setAttributes(UCollator *collator, UErrorCode *error) +{ + int count = 0; + while (count < UCOL_ATTRIBUTE_COUNT) { + if (ATTRIBUTE_[count] != UCOL_DEFAULT) { + ucol_setAttribute(collator, (UColAttribute)count, + ATTRIBUTE_[count], error); + if (U_FAILURE(*error)) { + return; + } + } + count ++; + } +} + +/** +* Appends directory path with an ending seperator if necessary. +* @param path with enough space to append one seperator +* @return new directory path length +*/ +int appendDirSeparator(char *dir) +{ + int dirlength = strlen(dir); + char dirending = dir[dirlength - 1]; + if (dirending != U_FILE_SEP_CHAR) { + dir[dirlength] = U_FILE_SEP_CHAR; + dir[dirlength + 1] = 0; + return dirlength + 1; + } + return dirlength; +} + +/** +* Output the collation element into a file +*/ +void serialize() { + char filename[128]; + int dirlength = 0; + + if (options[4].doesOccur) { + strcpy(filename, options[4].value); + dirlength = appendDirSeparator(filename); + } + + if (options[2].doesOccur) { + const char *locale = (char *)options[2].value; + int32_t localeindex = 0; + + if (strcmp(locale, "all") == 0) { + if (options[4].doesOccur) { + strcat(filename, "UCA.txt"); + OUTPUT_ = fopen(filename, "w"); + if (OUTPUT_ == NULL) { + fprintf(stdout, "Cannot open file:%s\n", filename); + return; + } + } + fprintf(stdout, "UCA\n"); + UErrorCode error = U_ZERO_ERROR; + COLLATOR_ = ucol_open("en_US", &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator creation failed:"); + fprintf(stdout, u_errorName(error)); + goto CLOSEUCA; + return; + } + setAttributes(COLLATOR_, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator attribute setting failed:"); + fprintf(stdout, u_errorName(error)); + goto CLOSEUCA; + return; + } + + serialize("UCA", FALSE); +CLOSEUCA : + if (options[4].doesOccur) { + filename[dirlength] = 0; + fclose(OUTPUT_); + } + ucol_close(COLLATOR_); + localeindex = ucol_countAvailable() - 1; + fprintf(stdout, "Number of locales: %d\n", localeindex + 1); + locale = ucol_getAvailable(localeindex); + } + + while (TRUE) { + UErrorCode error = U_ZERO_ERROR; + COLLATOR_ = ucol_open(locale, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator creation failed:"); + fprintf(stdout, u_errorName(error)); + goto CLOSETAILOR; + return; + } + setAttributes(COLLATOR_, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator attribute setting failed:"); + fprintf(stdout, u_errorName(error)); + goto CLOSETAILOR; + return; + } + + if (options[4].doesOccur) { + strcat(filename, locale); + strcat(filename, ".txt"); + OUTPUT_ = fopen(filename, "w"); + if (OUTPUT_ == NULL) { + fprintf(stdout, "Cannot open file:%s\n", filename); + return; + } + } + + if (options[3].doesOccur) { + serialize(locale, TRUE); + } + + ucol_close(COLLATOR_); + +CLOSETAILOR : + if (options[4].doesOccur) { + filename[dirlength] = 0; + fclose(OUTPUT_); + } + + localeindex --; + if (localeindex < 0) { + break; + } + locale = ucol_getAvailable(localeindex); + } + } + + if (options[7].doesOccur) { + char inputfilename[128] = ""; + // rules are to be used + if (options[5].doesOccur) { + strcpy(inputfilename, options[5].value); + appendDirSeparator(inputfilename); + } + strcat(inputfilename, options[7].value); + FILE *input = fopen(inputfilename, "r"); + if (input == NULL) { + fprintf(stdout, "Cannot open file:%s\n", filename); + return; + } + + char s[1024]; + UChar rule[1024]; + UChar *prule = rule; + int size = 1024; + // synwee TODO: make this part dynamic + while (fscanf(input, "%[^\n]s", s) != EOF) { + size -= u_unescape(s, prule, size); + prule = prule + u_strlen(prule); + } + fclose(input); + + if (options[4].doesOccur) { + strcat(filename, "Rules.txt"); + OUTPUT_ = fopen(filename, "w"); + if (OUTPUT_ == NULL) { + fprintf(stdout, "Cannot open file:%s\n", filename); + return; + } + } + + fprintf(stdout, "Rules\n"); + UErrorCode error = U_ZERO_ERROR; + UParseError parseError; + COLLATOR_ = ucol_openRules(rule, u_strlen(rule), UCOL_DEFAULT, + UCOL_DEFAULT_STRENGTH, &parseError, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator creation failed:"); + fprintf(stdout, u_errorName(error)); + goto CLOSERULES; + return; + } + setAttributes(COLLATOR_, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator attribute setting failed:"); + fprintf(stdout, u_errorName(error)); + goto CLOSERULES; + return; + } + + serialize("Rule-based", TRUE); + ucol_close(COLLATOR_); + +CLOSERULES : + if (options[4].doesOccur) { + filename[dirlength] = 0; + fclose(OUTPUT_); + } + } +} + +/** +* Parse for enum values. +* Note this only works for positive enum values. +* @param enumarray array containing names of the enum values in string and +* their corresponding value. +* declared enum value. +* @param str string to be parsed +* @return corresponding integer enum value or -1 if value is not found. +*/ +int parseEnums(const EnumNameValuePair enumarray[], const char *str) +{ + const char *enumname = enumarray[0].name; + int result = atoi(str); + if (result == 0 && str[0] != '0') { + while (strcmp(enumname, str) != 0) { + // checking for multiple enum names sharing the same values + enumname = strstr(enumname, str); + if (enumname != NULL) { + int size = strchr(enumname, '|') - enumname; + if (size < 0) { + size = strlen(enumname); + } + if (size == (int)strlen(str)) { + return enumarray[result].value; + } + } + result ++; + if (&(enumarray[result]) == NULL) { + return -1; + } + enumname = enumarray[result].name; + } + } + return -1; +} + +/** +* Parser for attribute name value pair +*/ +void parseAttributes() { + char str[32]; + const char *pname = options[6].value; + const char *pend = options[6].value + strlen(options[6].value); + const char *pvalue; + + while (pname < pend) { + pvalue = strchr(pname, '='); + if (pvalue == NULL) { + fprintf(stdout, + "No matching value found for attribute argument %s\n", + pname); + return; + } + int count = pvalue - pname; + strncpy(str, pname, count); + str[count] = 0; + + int name = parseEnums(ATTRIBUTE_NAME_, str); + if (name == -1) { + fprintf(stdout, "Attribute name not found: %s\n", str); + return; + } + + pvalue ++; + // getting corresponding enum value + pname = strchr(pvalue, ','); + if (pname == NULL) { + pname = pend; + } + count = pname - pvalue; + strncpy(str, pvalue, count); + str[count] = 0; + int value = parseEnums(ATTRIBUTE_VALUE_, str); + if (value == -1) { + fprintf(stdout, "Attribute value not found: %s\n", str); + return; + } + ATTRIBUTE_[name] = (UColAttributeValue)value; + pname ++; + } +} + +/** +* Checks if the locale argument is a base language +* @param locale to be checked +* @return TRUE if it is a base language +*/ +inline UBool checkLocaleForLanguage(const char *locale) +{ + return strlen(locale) <= 2; +} + +/** +* Converts a UChar array into its string form "xxxx xxxx" +* @param ch array of UChar characters +* @param count number of UChar characters +*/ +void outputUChar(UChar ch[], int count) +{ + for (int i = 0; i < count; i ++) { + fprintf(OUTPUT_, "%04X ", ch[i]); + } +} + +/** +* If it is a primary difference returns -1 or 1. +* If it is a secondary difference returns -2 or 2. +* If it is a tertiary difference returns -3 or 3. +* If equals returns 0. +*/ +int compareSortKey(const void *elem1, const void *elem2) +{ + // compare the 2 script element sort key + UChar *ch1 = ((ScriptElement *)elem1)->ch; + UChar *ch2 = ((ScriptElement *)elem2)->ch; + int size1 = ((ScriptElement *)elem1)->count; + int size2 = ((ScriptElement *)elem2)->count; + UErrorCode error = U_ZERO_ERROR; + + ucol_setStrength(COLLATOR_, UCOL_PRIMARY); + int result = ucol_strcoll(COLLATOR_, ch1, size1, ch2, size2); + if (result == 0) { + ucol_setStrength(COLLATOR_, UCOL_SECONDARY); + result = ucol_strcoll(COLLATOR_, ch1, size1, ch2, size2); + if (result == 0) { + ucol_setStrength(COLLATOR_, UCOL_TERTIARY); + result = ucol_strcoll(COLLATOR_, ch1, size1, ch2, size2); + if (result < 0) { + return -3; + } + if (result > 0) { + return 3; + } + } + if (result < 0) { + return -2; + } + if (result > 0) { + return 2; + } + } + return result; +} + +/** +* Output serialized script elements +* @param element the element to output +* @param compare the comparison with the previous element +* @param expansion flags TRUE if element has an expansion +*/ +void outputScriptElem(ScriptElement &element, int compare, UBool expansion) +{ + switch (compare) { + case 0: + if (expansion) { + fprintf(OUTPUT_, "<tr><td class='eq' title='["); + } + else { + fprintf(OUTPUT_, "<tr><td class='q' title='["); + } + break; + case -1: + if (expansion) { + fprintf(OUTPUT_, "<tr><td class='ep' title='["); + } + else { + fprintf(OUTPUT_, "<tr><td class='p' title='["); + } + break; + case -2: + if (expansion) { + fprintf(OUTPUT_, "<tr><td class='es' title='["); + } + else { + fprintf(OUTPUT_, "<tr><td class='s' title='["); + } + break; + default: + if (expansion) { + fprintf(OUTPUT_, "<tr><td class='et' title='["); + } + else { + fprintf(OUTPUT_, "<tr><td class='t' title='["); + } + } + + uint8_t sortkey[32]; + ucol_setStrength(COLLATOR_, UCOL_TERTIARY); + ucol_getSortKey(COLLATOR_, element.ch, element.count, sortkey, 32); + int i = 0; + while (sortkey[i] != 0) { + if (sortkey[i] == 1) { + fprintf(OUTPUT_, " | "); + } + else { + fprintf(OUTPUT_, "%02x", sortkey[i]); + } + + i ++; + } + + fprintf(OUTPUT_, "]'>"); + + UErrorCode error = U_ZERO_ERROR; + char utf8[64]; + UChar nfc[32]; + int32_t length = unorm_normalize(element.ch, element.count, UNORM_NFC, 0, nfc, + 32, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error normalizing contractions to NFC\n"); + } + u_strToUTF8(utf8, 64, &length, nfc, length, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error converting UChar to utf8\n"); + return; + } + + fprintf(OUTPUT_, "%s<br>", utf8); + fprintf(OUTPUT_, "<tt>"); + outputUChar(element.ch, element.count); + + if (compare == 0) { + fprintf(OUTPUT_, "</tt></td><td> </td><td> </td><td> </td><td>Q</td><td>"); + } + else if (compare == -1) { + fprintf(OUTPUT_, "</tt></td><td>P</td><td> </td><td> </td><td> </td><td>"); + } + else if (compare == -2) { + fprintf(OUTPUT_, "</tt></td><td> </td><td>S</td><td> </td><td> </td><td>"); + } + else if (compare == -3) { + fprintf(OUTPUT_, "</tt></td><td> </td><td> </td><td>T</td><td> </td><td>"); + } + + i = 0; + while (i < element.count) { + char str[128]; + UChar32 codepoint; + U16_NEXT(element.ch, i, element.count, codepoint); + int32_t temp = u_charName(codepoint, U_UNICODE_CHAR_NAME, str, 128, + &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error getting character name\n"); + return; + } + if (element.tailored) { + fprintf(OUTPUT_, "<b>"); + } + fprintf(OUTPUT_, "%s", str); + if (element.tailored) { + fprintf(OUTPUT_, " *</b>"); + } + if (i < element.count) { + fprintf(OUTPUT_, "<br>\n"); + } + } + + fprintf(OUTPUT_, "</td></tr>\n"); +} + +/** +* Checks if codepoint belongs to scripts +* @param script list +* @param scriptcount number of scripts +* @param codepoint to test +* @return TRUE if codepoint belongs to scripts +*/ +UBool checkInScripts(UScriptCode script[], int scriptcount, + UChar32 codepoint) +{ + UErrorCode error = U_ZERO_ERROR; + for (int i = 0; i < scriptcount; i ++) { + if (script[i] == USCRIPT_HAN && options[10].doesOccur) { + if ((codepoint >= 0x2E80 && codepoint <= 0x2EE4) || + (codepoint >= 0x2A672 && codepoint <= 0x2A6D6)) { + // reduce han + return TRUE; + } + } + else if (uscript_getScript(codepoint, &error) == script[i]) { + return TRUE; + } + if (U_FAILURE(error)) { + fprintf(stdout, "Error checking character in scripts\n"); + return FALSE; + } + } + return FALSE; +} + +/** +* Checks if the set of codepoints belongs to the script +* @param script list +* @param scriptcount number of scripts +* @param scriptelem +* @return TRUE if all codepoints belongs to the script +*/ +inline UBool checkInScripts(UScriptCode script[], int scriptcount, + ScriptElement scriptelem) +{ + int i = 0; + while (i < scriptelem.count) { + UChar32 codepoint; + U16_NEXT(scriptelem.ch, i, scriptelem.count, codepoint); + UErrorCode error = U_ZERO_ERROR; + if (checkInScripts(script, scriptcount, codepoint)) { + return TRUE; + } + } + return FALSE; +} + +/** +* Gets the script elements and contractions belonging to the script +* @param elems output list +* @param locale locale +* @return number of script elements +* Add by Richard +*/ +int getScriptElementsFromExemplars(ScriptElement scriptelem[], const char* locale) { + UErrorCode error = U_ZERO_ERROR; + UChar32 codepoint = 0; + + UResourceBundle* ures = ures_open(NULL, locale, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Can not find resource bundle for locale: %s\n", locale); + return -1; + } + int32_t length; + const UChar* exemplarChars = ures_getStringByKey(ures, "ExemplarCharacters", &length, &error); + + if (U_FAILURE(error)) { + fprintf(stdout, "Can not find ExemplarCharacters in resource bundle\n"); + return -1; + } + + UChar* upperChars = new UChar[length * 2]; + if (upperChars == 0) { + fprintf(stdout, "Memory error\n"); + return -1; + } + + int32_t destLength = u_strToUpper(upperChars, length * 2, exemplarChars, -1, locale, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error when u_strToUpper() \n"); + return -1; + } + + UChar* pattern = new UChar[length + destLength + 10]; + UChar left[2] = {0x005b, 0x0}; + UChar right[2] = {0x005d, 0x0}; + pattern = u_strcpy(pattern, left); + pattern = u_strcat(pattern, exemplarChars); + pattern = u_strcat(pattern, upperChars); + pattern = u_strcat(pattern, right); + + UnicodeSet * uniset = new UnicodeSet(UnicodeString(pattern), error); + if (U_FAILURE(error)) { + fprintf(stdout, "Can not open USet \n"); + return -1; + } + + UnicodeSetIterator* usetiter = new UnicodeSetIterator(*uniset); + + int32_t count = 0; + + while (usetiter -> next()) { + if (usetiter -> isString()) { + UnicodeString strItem = usetiter -> getString(); + + scriptelem[count].count = 0; + for (int i = 0; i < strItem.length(); i++) { + codepoint = strItem.char32At(i); + UTF16_APPEND_CHAR_UNSAFE(scriptelem[count].ch, scriptelem[count].count, codepoint); + scriptelem[count].tailored = FALSE; + } + } else { + codepoint = usetiter -> getCodepoint(); + scriptelem[count].count = 0; + UTF16_APPEND_CHAR_UNSAFE(scriptelem[count].ch, scriptelem[count].count, codepoint); + scriptelem[count].tailored = FALSE; + } + + count++; + } + delete []pattern; + + return count; +} + +/** +* Gets the script elements and contractions belonging to the script +* @param script list +* @param scriptcount number of scripts +* @param elems output list +* @return number of script elements +*/ +int getScriptElements(UScriptCode script[], int scriptcount, + ScriptElement scriptelem[]) +{ + UErrorCode error = U_ZERO_ERROR; + UChar32 codepoint = 0; + int count = 0; + while (codepoint <= UCHAR_MAX_VALUE) { + if (checkInScripts(script, scriptcount, codepoint)) { + scriptelem[count].count = 0; + UTF16_APPEND_CHAR_UNSAFE(scriptelem[count].ch, + scriptelem[count].count, codepoint); + scriptelem[count].tailored = FALSE; + count ++; + } + if (U_FAILURE(error)) { + fprintf(stdout, "Error determining codepoint in script\n"); + return -1; + } + codepoint ++; + } + + const UChar *current = NULL; + uint32_t strength = 0; + uint32_t chOffset = 0; + uint32_t chLen = 0; + uint32_t exOffset = 0; + uint32_t exLen = 0; + uint32_t prefixOffset = 0; + uint32_t prefixLen = 0; + uint8_t specs = 0; + UBool rstart = TRUE; + UColTokenParser src; + UColOptionSet opts; + UParseError parseError; + + int32_t rulelength = ucol_getRulesEx(COLLATOR_, UCOL_FULL_RULES, NULL, 0); + src.source = (UChar *)malloc(sizeof(UChar) * + (rulelength + UCOL_TOK_EXTRA_RULE_SPACE_SIZE)); + rulelength = ucol_getRulesEx(COLLATOR_, UCOL_FULL_RULES, src.source, + rulelength); + src.current = src.source; + src.end = src.source + rulelength; + src.extraCurrent = src.end; + src.extraEnd = src.end + UCOL_TOK_EXTRA_RULE_SPACE_SIZE; + src.opts = &opts; + + /* + ucol_tok_parseNextToken(&src, &strength, &chOffset, + &chLen, &exOffset, &exLen, + &prefixOffset, &prefixLen, + &specs, rstart, &parseError, + &error) + */ + while ((current = ucol_tok_parseNextToken(&src, rstart, &parseError, + &error)) != NULL) { + // contractions handled here + if (chLen > 1) { + u_strncpy(scriptelem[count].ch, src.source + chOffset, chLen); + scriptelem[count].count = chLen; + if (checkInScripts(script, scriptcount, scriptelem[count])) { + scriptelem[count].tailored = FALSE; + count ++; + } + } + rstart = FALSE; + } + if (U_FAILURE(error)) { + fprintf(stdout, "Error parsing rules: %s\n", u_errorName(error)); + } + // rule might have been reallocated, so delete this instead + free(src.source); + return count; +} + +int compareCodepoints(const void *elem1, const void *elem2) +{ + UChar *ch1 = ((ScriptElement *)elem1)->ch; // key + UChar *ch2 = ((ScriptElement *)elem2)->ch; + ch1[((ScriptElement *)elem1)->count] = 0; + ch2[((ScriptElement *)elem2)->count] = 0; + + // compare the 2 codepoints + return u_strcmp(ch1, ch2); +} + +UBool hasSubNFD(ScriptElement &se, ScriptElement &key) +{ + UChar *ch1 = se.ch; + UChar *ch2 = key.ch; // key + ch1[se.count] = 0; + ch2[key.count] = 0; + + // compare the 2 codepoints + if (u_strstr(ch1, ch2) != NULL) { + return TRUE; + } + + // check the decomposition + UChar norm[32]; + UErrorCode error = U_ZERO_ERROR; + int size = unorm_normalize(ch1, se.count, UNORM_NFD, 0, norm, 32, + &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error normalizing\n"); + } + if (u_strstr(norm, ch2) != NULL) { + return TRUE; + } + return FALSE; +} + +/** +* Marks tailored elements +* @param script list +* @param scriptcount number of scripts +* @param scriptelem script element list +* @param scriptelemlength size of the script element list +*/ +void markTailored(UScriptCode script[], int scriptcount, + ScriptElement scriptelem[], int scriptelemlength) +{ + int32_t rulelength; + const UChar *rule = ucol_getRules(COLLATOR_, &rulelength); + + const UChar *current = NULL; + uint32_t strength = 0; + uint32_t chOffset = 0; + uint32_t chLen = 0; + uint32_t exOffset = 0; + uint32_t exLen = 0; + uint32_t prefixOffset = 0; + uint32_t prefixLen = 0; + uint8_t specs = 0; + UBool rstart = TRUE; + UColTokenParser src; + UColOptionSet opts; + UParseError parseError; + + src.opts = &opts; + src.source = (UChar *)malloc( + (rulelength + UCOL_TOK_EXTRA_RULE_SPACE_SIZE) * sizeof(UChar)); + memcpy(src.source, rule, rulelength * sizeof(UChar)); + src.current = src.source; + src.end = (UChar *)src.source + rulelength; + src.extraCurrent = src.end; + src.extraEnd = src.end + UCOL_TOK_EXTRA_RULE_SPACE_SIZE; + + UErrorCode error = U_ZERO_ERROR; + + while ((current = ucol_tok_parseNextToken(&src, rstart, &parseError, + &error)) != NULL) { + if (chLen >= 1 && strength != UCOL_TOK_RESET) { + // skipping the reset characters and non useful stuff. + ScriptElement se; + u_strncpy(se.ch, src.source + chOffset, chLen); + se.count = chLen; + + if (checkInScripts(script, scriptcount, se)) { + /* + ScriptElement *tse = (ScriptElement *)bsearch(&se, scriptelem, + scriptelemlength, + sizeof(ScriptElement), + compareCodepoints); + */ + for (int i = 0; i < scriptelemlength; i ++) { + if (!scriptelem[i].tailored && + hasSubNFD(scriptelem[i], se)) { + scriptelem[i].tailored = TRUE; + } + } + } + } + rstart = FALSE; + } + free(src.source); + if (U_FAILURE(error)) { + fprintf(stdout, "Error parsing rules\n"); + } +} + +/** +* Checks if the collation iterator has more than 1 collation element +* @parem coleiter collation element iterator +* @return TRUE if collation iterator has more than 1 collation element +*/ +UBool hasExpansions(UCollationElements *coleiter) +{ + UErrorCode error = U_ZERO_ERROR; + int32_t ce = ucol_next(coleiter, &error); + int count = 0; + + if (U_FAILURE(error)) { + fprintf(stdout, "Error getting next collation element\n"); + } + while (ce != UCOL_NULLORDER) { + if ((UCOL_PRIMARYORDER(ce) != 0) && !isContinuation(ce)) { + count ++; + if (count == 2) { + return TRUE; + } + } + ce = ucol_next(coleiter, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error getting next collation element\n"); + } + } + return FALSE; +} + +/** +* Prints the footer for index.html +* @param file output file +*/ +void outputHTMLFooter() +{ + fprintf(OUTPUT_, "</table>\n"); + fprintf(OUTPUT_, "</body>\n"); + fprintf(OUTPUT_, "</html>\n"); +} + +/** +* Serialize the codepoints from start to end into an html file. +* Arranging them into ascending collation order. +* @param script code list +* @param scriptcount number of scripts +*/ +//void serializeScripts(UScriptCode script[], int scriptcount) +//Richard +void serializeScripts(UScriptCode script[], int scriptcount, const char* locale = NULL) +{ + UErrorCode error = U_ZERO_ERROR; + + ScriptElement *scriptelem = + (ScriptElement *)malloc(sizeof(ScriptElement) * 0x20000); + if (scriptelem == NULL) { + fprintf(stdout, "Memory error\n"); + return; + } + int count = 0; + if(locale) { + count = getScriptElementsFromExemplars(scriptelem, locale); + } else { + count = getScriptElements(script, scriptcount, scriptelem); + } + + // Sort script elements using Quicksort algorithm: + qsort(scriptelem, count, sizeof(ScriptElement), compareCodepoints); + markTailored(script, scriptcount, scriptelem, count); + // Sort script elements using Quicksort algorithm: + qsort(scriptelem, count, sizeof(ScriptElement), compareSortKey); + + UCollationElements* coleiter = ucol_openElements(COLLATOR_, + scriptelem[0].ch, + scriptelem[0].count, + &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error creating collation element iterator\n"); + return; + } + + outputScriptElem(scriptelem[0], -1, hasExpansions(coleiter)); + for (int i = 0; i < count - 1; i ++) { + ucol_setText(coleiter, scriptelem[i + 1].ch, scriptelem[i + 1].count, + &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error setting text in collation element iterator\n"); + return; + } + outputScriptElem(scriptelem[i + 1], + compareSortKey(scriptelem + i, scriptelem + i + 1), + hasExpansions(coleiter)); + } + free(scriptelem); + outputHTMLFooter(); +} + +/** +* Prints the header for the html +* @param locale name +* @param script +* @param scriptcount number of scripts +*/ +void outputHTMLHeader(const char *locale, UScriptCode script[], + int scriptcount) +{ + fprintf(OUTPUT_, "<html>\n"); + fprintf(OUTPUT_, "<head>\n"); + fprintf(OUTPUT_, "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n"); + fprintf(OUTPUT_, "<meta http-equiv=\"Content-Language\" content=\"en-us\">\n"); + fprintf(OUTPUT_, "<link rel=\"stylesheet\" href=\"charts.css\" type=\"text/css\">\n"); + fprintf(OUTPUT_, "<title>ICU Collation charts</title>\n"); + fprintf(OUTPUT_, "<base target=\"main\">\n"); + fprintf(OUTPUT_, "</head>\n"); + + fprintf(OUTPUT_, "<body bgcolor=#FFFFFF>\n"); + fprintf(OUTPUT_, "<!--\n"); + fprintf(OUTPUT_, "This file contains sorted characters in ascending order according to the locale stated\n"); + fprintf(OUTPUT_, "If the character is in red, it is tailored in the collation rules.\n"); + fprintf(OUTPUT_, "Background colours have certain meanings:\n"); + fprintf(OUTPUT_, "White - equals the previous character\n"); + fprintf(OUTPUT_, "dark blue - primary greater than the previous character\n"); + fprintf(OUTPUT_, "blue - secondary greater than the previous character\n"); + fprintf(OUTPUT_, "light blue - tertiary greater than the previous character\n"); + fprintf(OUTPUT_, "--!>\n"); + + fprintf(OUTPUT_, "<table border=0>\n"); + UChar displayname[64]; + UErrorCode error = U_ZERO_ERROR; + int32_t size = uloc_getDisplayName(locale, "en_US", displayname, 64, &error); + char utf8displayname[128]; + if (U_FAILURE(error)) { + utf8displayname[0] = 0; + } + else { + int32_t utf8size = 0; + u_strToUTF8(utf8displayname, 128, &utf8size, displayname, size, &error); + } + + fprintf(OUTPUT_, "<tr><th>Locale</th><td class='noborder'>%s</td></tr>\n", utf8displayname); + fprintf(OUTPUT_, "<tr><th>Script(s)</th>"); + fprintf(OUTPUT_, "<td class='noborder'>"); + for (int i = 0; i < scriptcount; i ++) { + fprintf(OUTPUT_, "%s", uscript_getName(script[i])); + if (i + 1 != scriptcount) { + fprintf(OUTPUT_, ", "); + } + } + fprintf(OUTPUT_, "</td></tr>\n"); + + fprintf(OUTPUT_, "<tr><th>Rules</th><td class='noborder'><a href=\"http://dev.icu-project.org/cgi-bin/viewcvs.cgi/*checkout*/icu/source/data/coll/%s.txt\">%s.txt</a></td></tr>\n", locale, locale); + + UVersionInfo version; + ucol_getVersion(COLLATOR_, version); + fprintf(OUTPUT_, "<tr><th>Collator version</th><td class='noborder'>%d.%d.%d.%d</td></tr>\n", + version[0], version[1], version[2], version[3]); + + UColAttribute attr = UCOL_FRENCH_COLLATION; + while (attr < UCOL_ATTRIBUTE_COUNT) { + UColAttributeValue value = ucol_getAttribute(COLLATOR_, attr, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error getting attribute\n"); + return; + } + if (value != UCOL_DEFAULT) { + if (attr == UCOL_FRENCH_COLLATION && value != UCOL_OFF) { + fprintf(OUTPUT_, "<tr><th>French Collation</th><td class='noborder'>on, code %d</td></tr>\n", value); + } + if (attr == UCOL_ALTERNATE_HANDLING && value != UCOL_NON_IGNORABLE) { + fprintf(OUTPUT_, "<tr><th>Alternate Handling</th><td class='noborder'>shifted, code%d</td></tr>\n", value); + } + if (attr == UCOL_CASE_FIRST && value != UCOL_OFF) { + fprintf(OUTPUT_, "<tr><th>Case First</th><td class='noborder'>on, code %d</td></tr>\n", value); + } + if (attr == UCOL_CASE_LEVEL && value != UCOL_OFF) { + fprintf(OUTPUT_, "<tr><th>Case Level</th><td class='noborder'>on, code %d</td></tr>\n", value); + } + if (attr == UCOL_NORMALIZATION_MODE && value != UCOL_OFF) { + fprintf(OUTPUT_, "<tr><th>Normalization</th><td class='noborder'>on, code %d</td></tr>\n", value); + } + if (attr == UCOL_STRENGTH && value != UCOL_TERTIARY) { + fprintf(OUTPUT_, "<tr><th>Strength</th><td class='noborder'>code %d</td></tr>\n", value); + } + if (attr == UCOL_HIRAGANA_QUATERNARY_MODE && value != UCOL_OFF) { + fprintf(OUTPUT_, "<tr><th>Hiragana Quaternary</th><td class='noborder'>on, code %d</td></tr>\n", value); + } + } + attr = (UColAttribute)(attr + 1); + } + + // Get UNIX-style time and display as number and string. + time_t ltime; + time( <ime ); + fprintf(OUTPUT_, "<tr><th>Date Generated</th><td class='noborder'>%s</td></tr>", ctime(<ime)); + + fprintf(OUTPUT_, "</table>\n"); + + fprintf(OUTPUT_, "<p><a href=help.html>How to read the table</a><br>\n"); + fprintf(OUTPUT_, "<a href=http://www.jtcsv.com/cgi-bin/icu-bugs/ target=new>Submit a bug</a></p>\n"); + fprintf(OUTPUT_, "\n<table>\n"); + fprintf(OUTPUT_, "\n<tr><th>Codepoint</th><th>P</th><th>S</th><th>T</th><th>Q</th><th>Name</th></tr>\n"); +} + +/** +* Prints the header for index.html +* @param file output file +*/ +void outputListHTMLHeader(FILE *file) +{ + fprintf(file, "<html>\n"); + fprintf(file, "<head>\n"); + fprintf(file, "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n"); + fprintf(file, "<meta http-equiv=\"Content-Language\" content=\"en-us\">\n"); + fprintf(file, "<title>ICU Collation Charts</title>\n"); + fprintf(file, "<base target=\"main\">\n"); + fprintf(file, "</head>\n"); + fprintf(file, "<body bgcolor=#FFFFFF>\n"); + fprintf(file, "<h2 align=center>ICU Collation Charts</h2>\n"); + fprintf(file, "<p align=center>\n"); + fprintf(file, "<a href=http://www.unicode.org/charts/collation/ target=new>UCA Charts</a><br>"); +} + +/** +* Prints the footer for index.html +* @param file output file +*/ +void outputListHTMLFooter(FILE *file) +{ + fprintf(file, "</p>\n"); + //fprintf(file, "<center><image src=http://oss.software.ibm.com/icu/images/w24.gif></center>\n"); + fprintf(file, "</body>\n"); + fprintf(file, "</html>\n"); +} + +/** +* Gets all scripts and serialize their codepoints into an html file. +*/ +void serializeScripts() { + char filename[128]; + int dirlength = 0; + + if (options[4].doesOccur) { + strcpy(filename, options[4].value); + dirlength = appendDirSeparator(filename); + } else { + filename[0] = 0; + } + + const char *locale; + int32_t localelist = 0; + int32_t localesize; + + localesize = ucol_countAvailable(); + locale = ucol_getAvailable(localelist); + + strcat(filename, "list.html"); + FILE *list = fopen(filename, "w"); + filename[dirlength] = 0; + if (list == NULL) { + fprintf(stdout, "Cannot open file: %s\n", filename); + return; + } + + outputListHTMLHeader(list); + fprintf(list, "<blockquote>\n"); + while (TRUE) { + UErrorCode error = U_ZERO_ERROR; + COLLATOR_ = ucol_open(locale, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator creation failed:"); + fprintf(stdout, u_errorName(error)); + break; + } + if ((error != U_USING_FALLBACK_WARNING && // not tailored + error != U_USING_DEFAULT_WARNING) || + checkLocaleForLanguage(locale)) { + fprintf(list, "<a href=%s.html>%s</a> ", locale, locale); + setAttributes(COLLATOR_, &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Collator attribute setting failed:"); + fprintf(stdout, u_errorName(error)); + break; + } + + UScriptCode scriptcode[32]; + uint32_t scriptcount = uscript_getCode(locale, scriptcode, 32, + &error); + if (U_FAILURE(error)) { + fprintf(stdout, "Error getting lcale scripts\n"); + break; + } + + strcat(filename, locale); + strcat(filename, ".html"); + OUTPUT_ = fopen(filename, "w"); + if (OUTPUT_ == NULL) { + fprintf(stdout, "Cannot open file:%s\n", filename); + break; + } + outputHTMLHeader(locale, scriptcode, scriptcount); + fprintf(stdout, "%s\n", locale); + + if(options[12].doesOccur) { + // use whole scripts + serializeScripts(scriptcode, scriptcount); + } else { + // use exemplar chars + serializeScripts(scriptcode, scriptcount, locale); + } + fclose(OUTPUT_); + } + ucol_close(COLLATOR_); + + filename[dirlength] = 0; + localelist ++; + if (localelist == localesize) { + break; + } + locale = ucol_getAvailable(localelist); + } + fprintf(list, "<br><a href=help.html>help</a><br>"); + fprintf(list, "</blockquote>\n"); + outputListHTMLFooter(list); + fclose(list); +} + +/** +* Main -- process command line, read in and pre-process the test file, +* call other functions to do the actual tests. +*/ +int main(int argc, char *argv[]) { + + argc = u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), + options); + + // error handling, printing usage message + if (argc < 0) { + fprintf(stdout, "error in command line argument: "); + fprintf(stdout, argv[-argc]); + fprintf(stdout, "\n"); + } + if (argc < 0 || options[0].doesOccur || options[1].doesOccur) { + fprintf(stdout, "Usage: dumpce options...\n" + "--help\n" + " Display this message.\n" + "--locale name|all\n" + " ICU locale to use. Default is en_US\n" + "--serialize\n" + " Serializes the collation elements in -locale or all locales available and outputs them into --outputdir/locale_ce.txt\n" + "--destdir dir_name\n" + " Path for outputing the serialized collation elements. Defaults to stdout if no defined\n" + "--sourcedir dir_name\n" + " Path for the input rule file for collation\n" + "--attribute name=value,name=value...\n" + " Pairs of attribute names and values for setting\n" + "--rule filename\n" + " Name of file containing the collation rules.\n" + "--normalizaton mode\n" + " UNormalizationMode mode to be used.\n" + "--scripts\n" + " Codepoints from all scripts are sorted and serialized.\n" + "--reducehan\n" + " Only 200 Han script characters will be displayed with the use of --scripts.\n" + "--wholescripts\n" + " Show collation order for whole scripts instead of just for exemplar characters of a locale\n\n"); + + fprintf(stdout, "Example to generate *.txt files : dumpce --serialize --locale af --destdir /temp --attribute UCOL_STRENGTH=UCOL_DEFAULT_STRENGTH,4=17\n\n"); + fprintf(stdout, "Example to generate *.html files for oss web display: dumpce --scripts --destdir /temp --reducehan\n"); + return argc < 0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR; + } + + OUTPUT_ = stdout; + if (options[6].doesOccur) { + fprintf(stdout, "attributes %s\n", options[6].value); + parseAttributes(); + } + if (options[3].doesOccur) { + serialize(); + } + if (options[9].doesOccur) { + serializeScripts(); + } + return 0; +} diff --git a/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.dsp b/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.dsp new file mode 100644 index 00000000000..d19f6537460 --- /dev/null +++ b/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.dsp @@ -0,0 +1,103 @@ +# Microsoft Developer Studio Project File - Name="dumpce" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=dumpce - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "dumpce.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "dumpce.mak" CFG="dumpce - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "dumpce - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "dumpce - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "dumpce - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /G6 /MD /W3 /GX /O2 /Ob2 /I "..\..\..\include" /I "..\..\common" /I "..\..\i18n" /I "..\..\tools\toolutil" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 icuuc.lib icuin.lib icutu.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\lib\\" + +!ELSEIF "$(CFG)" == "dumpce - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /G6 /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\include" /I "..\..\common" /I "..\..\i18n" /I "..\..\tools\toolutil" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 icuucd.lib icuind.lib icutud.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\lib\\" + +!ENDIF + +# Begin Target + +# Name "dumpce - Win32 Release" +# Name "dumpce - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\dumpce.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project diff --git a/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.dsw b/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.dsw new file mode 100644 index 00000000000..f0741494630 --- /dev/null +++ b/Build/source/libs/icu/icu-49.1/tools/dumpce/dumpce.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "dumpce"=.\dumpce.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + |