/* Version information */
static void
version()
{
UErrorCode status = U_ZERO_ERROR;
const char *tzVer;
int len = 256;
UChar tzName[256];
printf("icudate version %s, created by Stephen F. Booth.\n",
DATE_VERSION);
puts(U_COPYRIGHT_STRING);
tzVer = ucal_getTZDataVersion(&status);
if(U_FAILURE(status)) {
tzVer = u_errorName(status);
}
printf("\n");
printf("ICU Version: %s\n", U_ICU_VERSION);
printf("ICU Data (major+min): %s\n", U_ICUDATA_NAME);
printf("Default Locale: %s\n", uloc_getDefault());
printf("Time Zone Data Version: %s\n", tzVer);
printf("Default Time Zone: ");
status = U_ZERO_ERROR;
u_init(&status);
len = ucal_getDefaultTimeZone(tzName, len, &status);
if(U_FAILURE(status)) {
printf(" ** Error getting default zone: %s\n", u_errorName(status));
}
uprint(tzName, stdout, &status);
printf("\n\n");
}
// ---------------------------------------------------------------------------
// ICUTransService: Constructors and Destructor
// ---------------------------------------------------------------------------
ICUTransService::ICUTransService()
{
#if (U_ICU_VERSION_MAJOR_NUM > 2 || (U_ICU_VERSION_MAJOR_NUM == 2 && U_ICU_VERSION_MINOR_NUM >= 6))
UErrorCode errorCode=U_ZERO_ERROR;
u_init(&errorCode);
if(U_FAILURE(errorCode)) {
XMLPlatformUtils::panic(PanicHandler::Panic_NoTransService);
}
#endif
#if !defined(XML_OS390) && !defined(XML_AS400) && !defined(XML_HPUX) && !defined(XML_PTX)
#if (U_ICU_VERSION_MAJOR_NUM < 2)
// Starting with ICU 2.0, ICU itself includes a static reference to the data
// entrypoint symbol.
//
// ICU 1.8 (and previous) did not include a static reference, but would
// dynamically load the data dll when it was first needed, however this dynamic
// loading proved unreliable in some of the odd environments that Xerces needed
// to run in. Hence, the static reference.
// Pass the location of the converter data to ICU. By doing so, we are
// forcing the load of ICU converter data DLL, after the Xerces-C DLL is
// loaded. This implies that Xerces-C, now has to explicitly link with the
// ICU converter dll. However, the advantage is that we no longer depend
// on the code which does demand dynamic loading of DLL's. The demand
// loading is highly system dependent and was a constant source of support
// calls.
UErrorCode uerr = U_ZERO_ERROR;
udata_setCommonData((void *) icudata_dat, &uerr);
#endif
#endif
}
void OsmAnd::ICU::initialize()
{
// Initialize ICU
UErrorCode icuError = U_ZERO_ERROR;
g_IcuData = qMove(std::unique_ptr<QByteArray>(new QByteArray(EmbeddedResources::decompressResource(QLatin1String("icu4c/icu-data-l.dat")))));
udata_setCommonData(g_IcuData->constData(), &icuError);
if (U_FAILURE(icuError))
{
LogPrintf(LogSeverityLevel::Error, "Failed to initialize ICU data: %d", icuError);
return;
}
u_init(&icuError);
if (U_FAILURE(icuError))
{
LogPrintf(LogSeverityLevel::Error, "Failed to initialize ICU: %d", icuError);
return;
}
// Allocate resources:
g_pIcuAnyToLatinTransliterator = Transliterator::createInstance(UnicodeString("Any-Latin/BGN"), UTRANS_FORWARD, icuError);
if (U_FAILURE(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU Any-to-Latin transliterator: %d", icuError);
icuError = U_ZERO_ERROR;
g_pIcuAccentsAndDiacriticsConverter = Transliterator::createInstance(UnicodeString("NFD; [:Mn:] Remove; NFC"), UTRANS_FORWARD, icuError);
if (U_FAILURE(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU accents&diacritics converter: %d", icuError);
icuError = U_ZERO_ERROR;
g_pIcuWordBreakIterator = BreakIterator::createWordInstance(Locale::getRoot(), icuError);
if (U_FAILURE(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU word break iterator: %d", icuError);
}
/**
* Set up ICU, print # of available collators
*/
void setup(UErrorCode &status) {
u_init(&status);
fprintf(stderr, "ICU %s init: %s\n", U_ICU_VERSION, u_errorName(status));
int32_t count;
StringEnumeration *se = Collator::getAvailableLocales();
count = se->count(status);
fprintf(stderr, "# Collators now available: %d,\t%s - %d providers expected.\n", count, u_errorName(status), (int32_t)PROVIDER_COUNT);
}
void register_libcore_icu_ICU(JNIEnv* env) {
std::string path;
path = u_getDataDirectory();
path += "/";
path += U_ICUDATA_NAME;
path += ".dat";
#define FAIL_WITH_STRERROR(s) \
ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
abort();
#define MAYBE_FAIL_WITH_ICU_ERROR(s) \
if (status != U_ZERO_ERROR) {\
ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
abort(); \
}
// Open the file and get its length.
ScopedFd fd(open(path.c_str(), O_RDONLY));
if (fd.get() == -1) {
FAIL_WITH_STRERROR("open");
}
struct stat sb;
if (fstat(fd.get(), &sb) == -1) {
FAIL_WITH_STRERROR("stat");
}
// Map it.
void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
if (data == MAP_FAILED) {
FAIL_WITH_STRERROR("mmap");
}
// Tell the kernel that accesses are likely to be random rather than sequential.
if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
}
// Tell ICU to use our memory-mapped data.
UErrorCode status = U_ZERO_ERROR;
udata_setCommonData(data, &status);
MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
// Tell ICU it can *only* use our memory-mapped data.
udata_setFileAccess(UDATA_NO_FILES, &status);
MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
// Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
// use, which can be anywhere. Force initialization up front so we can report a nice clear error
// and bail.
u_init(&status);
MAYBE_FAIL_WITH_ICU_ERROR("u_init");
jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
}
int
l_string_extract (lua_State *L)
{
/* Init */
char *fname = "extract";
u_init(L, state, fname, NULL);
#ifdef TIMING
/* Timestamp */
TTR_START();
#endif
/* Defines */
#ifdef LIBKIRK_DEBUG
char pause;
#endif
const char *string;
long pos_1, pos_2;
int len;
/* Catches */
if (lua_type(L, 1) == LUA_TSTRING)
string = lua_tostring(L, 1);
else
return u_abort(1, "Incorrect argument type at position 1.");
/* Get the first and last position to extract from. */
if (lua_type(L, 2) == LUA_TNUMBER)
pos_1 = lua_tonumber(L, 2);
else
return u_abort(1, "Incorrect argument type at position 2.");
if (lua_type(L, 3) == LUA_TNUMBER)
pos_2 = lua_tonumber(L, 3);
else
return u_abort(1, "Incorrect argument type at position 3.");
/* Pop all values */
lua_pop(L, 3);
#ifdef TIMING
/* Get time to serve and all */
TTR_END();
TTR_ELAPSED();
#endif
len = strlen(string);
char n_value[(const int)len];
/* Return results */
lua_pushstring(L, n_value);
return 1;
}
U_NAMESPACE_BEGIN
//--------------------------------------------------------------------------
//
// RegexPattern Default Constructor
//
//--------------------------------------------------------------------------
RegexPattern::RegexPattern() {
UErrorCode status = U_ZERO_ERROR;
u_init(&status);
// Init all of this instances data.
init();
}
void
newgame()
{
fobj = invent = level.buriedobjlist = migrating_objs = (struct obj *)0;
fmon = migrating_mons = (struct monst *)0;
ftrap = 0;
flags.ident = 1;
if(wiz1_level.dlevel == 0) init_dungeons();
init_objects(); /* must be before u_init() */
u_init();
init_artifacts(); /* must be after u_init() */
#ifndef NO_SIGNAL
(void) signal(SIGINT, (SIG_RET_TYPE) done1);
#endif
#ifdef NEWS
if(flags.news) display_file(NEWS, FALSE);
#endif
#ifdef MULDGN
load_qtlist(); /* load up the quest text info */
quest_init();
if(flags.legacy && moves == 1) com_pager(1);
#endif
mklev();
u_on_upstairs();
check_special_room(FALSE);
vision_reset(); /* set up internals for level (after mklev) */
flags.botlx = 1;
/* Move the monster from under you or else
* makedog() will fail when it calls makemon().
* - ucsfcgl!kneller
*/
if(MON_AT(u.ux, u.uy)) mnexto(m_at(u.ux, u.uy));
#ifdef CLIPPING
cliparound(u.ux, u.uy);
#endif
(void) makedog();
docrt();
#ifdef INSURANCE
save_currentstate();
#endif
return;
}
U_NAMESPACE_BEGIN
//--------------------------------------------------------------------------
//
// RegexPattern Default Constructor
//
//--------------------------------------------------------------------------
RegexPattern::RegexPattern() {
UErrorCode status = U_ZERO_ERROR;
u_init(&status);
// Init all of this instances data.
init();
// Lazy init of all shared global sets.
RegexStaticSets::initGlobals(&fDeferredStatus);
}
/**
* Library initialization.
*
* R calls this automatically on lib load/attach.
*/
extern "C" void R_init_stringi(DllInfo* dll)
{
#if STRI_ICU_FOUND == 0
stri_set_icu_data_directory((char*)*(char**)(dll) /* dll->path */);
#endif
/* BTW: u_init: It is OK to simply use ICU services and functions without
first having initialized ICU by calling u_init().
u_init() will attempt to load some part of ICU's data, and is useful
as a test for configuration or installation problems that leave
the ICU data inaccessible. A successful invocation of u_init() does not,
however, guarantee that all ICU data is accessible.
*/
UErrorCode status = U_ZERO_ERROR;
u_init(&status);
if (U_FAILURE(status))
Rf_error("ICU init failed: %s", u_errorName(status));
R_registerRoutines(dll, NULL, cCallMethods, NULL, NULL);
// R_useDynamicSymbols(dll, Rboolean(FALSE)); // slower
const R_CallMethodDef* methods = cCallMethods;
while (methods->name) {
R_RegisterCCallable("stringi", methods->name, methods->fun);
methods++;
}
if (!SUPPORT_UTF8) {
/* Rconfig.h states that all R platforms supports that */
Rf_error("R does not support UTF-8 encoding.");
}
#ifndef NDEBUG
// fprintf(stdout, "!NDEBUG: ************************************************\n");
// fprintf(stdout, "!NDEBUG: Dynamic library `stringi` loaded\n");
// fprintf(stdout, "!NDEBUG: Check out http://stringi.rexamine.com\n");
// fprintf(stdout, "!NDEBUG: \n");
// fprintf(stdout, "!NDEBUG: Please send bug reports to [email protected] \n");
// fprintf(stdout, "!NDEBUG: or at https://github.com/Rexamine/stringi/issues\n");
// fprintf(stdout, "!NDEBUG: \n");
// fprintf(stdout, "!NDEBUG: Have fun testing! :-)\n");
// fprintf(stdout, "!NDEBUG: ************************************************\n");
#endif
}
int main(int argc, char *argv[]) {
UErrorCode status = U_ZERO_ERROR;
u_init(&status);
if (U_FAILURE(status) && status != U_FILE_ACCESS_ERROR) {
// Note: u_init() will try to open ICU property data.
// failures here are expected when building ICU from scratch.
// ignore them.
fprintf(stderr, "genpname: can not initialize ICU. Status = %s\n",
u_errorName(status));
exit(1);
}
genpname app;
U_MAIN_INIT_ARGS(argc, argv);
int retVal = app.MMain(argc, argv);
u_cleanup();
return retVal;
}
UBool ctest_resetICU() {
UErrorCode status = U_ZERO_ERROR;
char *dataDir = safeGetICUDataDirectory();
u_cleanup();
if (!initArgs(gOrigArgc, gOrigArgv, NULL, NULL)) {
/* Error already displayed. */
return FALSE;
}
u_setDataDirectory(dataDir);
free(dataDir);
u_init(&status);
if (U_FAILURE(status)) {
log_err_status(status, "u_init failed with %s\n", u_errorName(status));
return FALSE;
}
return TRUE;
}
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;
u_init(status);
#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;
}
void OsmAnd::ICU::initialize()
{
// Initialize ICU
UErrorCode icuError = U_ZERO_ERROR;
g_IcuData = qMove(std::unique_ptr<QByteArray>(new QByteArray(EmbeddedResources::decompressResource(QLatin1String("icu4c/icu-data-l.xml")))));
udata_setCommonData(g_IcuData->constData(), &icuError);
if(!U_SUCCESS(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to initialize ICU data: %d", icuError);
u_init(&icuError);
if(!U_SUCCESS(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to initialize ICU: %d", icuError);
// Allocate resources
icuError = U_ZERO_ERROR;
g_pIcuTransliterator = Transliterator::createInstance(UnicodeString("Any-Latin/UNGEGN; NFD; [:M:] Remove; NFC"), UTRANS_FORWARD, icuError);
if(!U_SUCCESS(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU transliterator: %d", icuError);
icuError = U_ZERO_ERROR;
g_pIcuWordBreakIterator = BreakIterator::createWordInstance(Locale::getRoot(), icuError);
if(!U_SUCCESS(icuError))
LogPrintf(LogSeverityLevel::Error, "Failed to create global ICU word break iterator: %d", icuError);
}
static void do_init() {
if(!icuInitted) {
u_init(&initStatus);
icuInitted = TRUE;
}
}
PyMODINIT_FUNC
initicu(void)
{
PyObject* m;
UVersionInfo ver, uver;
UErrorCode status = U_ZERO_ERROR;
char version[U_MAX_VERSION_STRING_LENGTH+1] = {0}, uversion[U_MAX_VERSION_STRING_LENGTH+5] = {0};
if (sizeof(Py_UNICODE) != 2 && sizeof(Py_UNICODE) != 4) {
PyErr_SetString(PyExc_RuntimeError, "This module only works on python versions <= 3.2");
return;
}
u_init(&status);
if (U_FAILURE(status)) {
PyErr_SetString(PyExc_RuntimeError, u_errorName(status));
return;
}
u_getVersion(ver);
u_versionToString(ver, version);
u_getUnicodeVersion(uver);
u_versionToString(uver, uversion);
if (PyType_Ready(&icu_CollatorType) < 0)
return;
if (PyType_Ready(&icu_BreakIteratorType) < 0)
return;
m = Py_InitModule3("icu", icu_methods,
"Wrapper for the ICU internationalization library");
Py_INCREF(&icu_CollatorType); Py_INCREF(&icu_BreakIteratorType);
PyModule_AddObject(m, "Collator", (PyObject *)&icu_CollatorType);
PyModule_AddObject(m, "BreakIterator", (PyObject *)&icu_BreakIteratorType);
// uint8_t must be the same size as char
PyModule_AddIntConstant(m, "ok", (U_SUCCESS(status) && sizeof(uint8_t) == sizeof(char)) ? 1 : 0);
PyModule_AddStringConstant(m, "icu_version", version);
PyModule_AddStringConstant(m, "unicode_version", uversion);
ADDUCONST(USET_SPAN_NOT_CONTAINED);
ADDUCONST(USET_SPAN_CONTAINED);
ADDUCONST(USET_SPAN_SIMPLE);
ADDUCONST(UCOL_DEFAULT);
ADDUCONST(UCOL_PRIMARY);
ADDUCONST(UCOL_SECONDARY);
ADDUCONST(UCOL_TERTIARY);
ADDUCONST(UCOL_DEFAULT_STRENGTH);
ADDUCONST(UCOL_QUATERNARY);
ADDUCONST(UCOL_IDENTICAL);
ADDUCONST(UCOL_OFF);
ADDUCONST(UCOL_ON);
ADDUCONST(UCOL_SHIFTED);
ADDUCONST(UCOL_NON_IGNORABLE);
ADDUCONST(UCOL_LOWER_FIRST);
ADDUCONST(UCOL_UPPER_FIRST);
ADDUCONST(UNORM_NONE);
ADDUCONST(UNORM_NFD);
ADDUCONST(UNORM_NFKD);
ADDUCONST(UNORM_NFC);
ADDUCONST(UNORM_DEFAULT);
ADDUCONST(UNORM_NFKC);
ADDUCONST(UNORM_FCD);
ADDUCONST(UPPER_CASE);
ADDUCONST(LOWER_CASE);
ADDUCONST(TITLE_CASE);
ADDUCONST(UBRK_CHARACTER);
ADDUCONST(UBRK_WORD);
ADDUCONST(UBRK_LINE);
ADDUCONST(UBRK_SENTENCE);
}
//----------------------------------------------------------------------------
//
// main for genctd
//
//----------------------------------------------------------------------------
int main(int argc, char **argv) {
UErrorCode status = U_ZERO_ERROR;
const char *wordFileName;
const char *outFileName;
const char *outDir = NULL;
const char *copyright = NULL;
//
// Pick up and check the command line arguments,
// using the standard ICU tool utils option handling.
//
U_MAIN_INIT_ARGS(argc, argv);
progName = argv[0];
argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);
if(argc<0) {
// Unrecognized option
fprintf(stderr, "error in command line argument \"%s\"\n", argv[-argc]);
usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
}
if(options[0].doesOccur || options[1].doesOccur) {
// -? or -h for help.
usageAndDie(0);
}
if (!options[3].doesOccur || argc < 2) {
fprintf(stderr, "input and output file must both be specified.\n");
usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
}
outFileName = options[3].value;
wordFileName = argv[1];
if (options[4].doesOccur) {
u_setDataDirectory(options[4].value);
}
status = U_ZERO_ERROR;
/* Combine the directory with the file name */
if(options[5].doesOccur) {
outDir = options[5].value;
}
if (options[6].doesOccur) {
copyright = U_COPYRIGHT_STRING;
}
#if UCONFIG_NO_BREAK_ITERATION || UCONFIG_NO_FILE_IO
UNewDataMemory *pData;
char msg[1024];
/* write message with just the name */
sprintf(msg, "genctd writes dummy %s because of UCONFIG_NO_BREAK_ITERATION and/or UCONFIG_NO_FILE_IO, see uconfig.h", outFileName);
fprintf(stderr, "%s\n", msg);
/* write the dummy data file */
pData = udata_create(outDir, NULL, outFileName, &dummyDataInfo, NULL, &status);
udata_writeBlock(pData, msg, strlen(msg));
udata_finish(pData, &status);
return (int)status;
#else
/* Initialize ICU */
u_init(&status);
if (U_FAILURE(status)) {
fprintf(stderr, "%s: can not initialize ICU. status = %s\n",
argv[0], u_errorName(status));
exit(1);
}
status = U_ZERO_ERROR;
//
// Read in the dictionary source file
//
long result;
long wordFileSize;
FILE *file;
char *wordBufferC;
MutableTrieDictionary *mtd = NULL;
file = fopen(wordFileName, "rb");
if( file == 0 ) { //cannot find file
//create 1-line dummy file: ie 1 char, 1 value
UNewDataMemory *pData;
char msg[1024];
/* write message with just the name */
sprintf(msg, "%s not found, genctd writes dummy %s", wordFileName, outFileName);
fprintf(stderr, "%s\n", msg);
UChar c = 0x0020;
mtd = new MutableTrieDictionary(c, status, TRUE);
mtd->addWord(&c, 1, status, 1);
} else { //read words in from input file
fseek(file, 0, SEEK_END);
wordFileSize = ftell(file);
fseek(file, 0, SEEK_SET);
wordBufferC = new char[wordFileSize+10];
result = (long)fread(wordBufferC, 1, wordFileSize, file);
if (result != wordFileSize) {
fprintf(stderr, "Error reading file \"%s\"\n", wordFileName);
exit (-1);
}
wordBufferC[wordFileSize]=0;
fclose(file);
//
// Look for a Unicode Signature (BOM) on the word file
//
int32_t signatureLength;
const char * wordSourceC = wordBufferC;
const char* encoding = ucnv_detectUnicodeSignature(
wordSourceC, wordFileSize, &signatureLength, &status);
if (U_FAILURE(status)) {
exit(status);
}
if(encoding!=NULL ){
wordSourceC += signatureLength;
wordFileSize -= signatureLength;
}
//
// Open a converter to take the rule file to UTF-16
//
UConverter* conv;
conv = ucnv_open(encoding, &status);
if (U_FAILURE(status)) {
fprintf(stderr, "ucnv_open: ICU Error \"%s\"\n", u_errorName(status));
exit(status);
}
//
// Convert the words to UChar.
// Preflight first to determine required buffer size.
//
uint32_t destCap = ucnv_toUChars(conv,
NULL, // dest,
0, // destCapacity,
wordSourceC,
wordFileSize,
&status);
if (status != U_BUFFER_OVERFLOW_ERROR) {
fprintf(stderr, "ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status));
exit(status);
};
status = U_ZERO_ERROR;
UChar *wordSourceU = new UChar[destCap+1];
ucnv_toUChars(conv,
wordSourceU, // dest,
destCap+1,
wordSourceC,
wordFileSize,
&status);
if (U_FAILURE(status)) {
fprintf(stderr, "ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status));
exit(status);
};
ucnv_close(conv);
// Get rid of the original file buffer
delete[] wordBufferC;
// Create a MutableTrieDictionary, and loop through all the lines, inserting
// words.
// First, pick a median character.
UChar *current = wordSourceU + (destCap/2);
UChar uc = *current++;
UnicodeSet breaks;
breaks.add(0x000A); // Line Feed
breaks.add(0x000D); // Carriage Return
breaks.add(0x2028); // Line Separator
breaks.add(0x2029); // Paragraph Separator
do {
// Look for line break
while (uc && !breaks.contains(uc)) {
uc = *current++;
}
// Now skip to first non-line-break
while (uc && breaks.contains(uc)) {
uc = *current++;
}
}
while (uc && (breaks.contains(uc) || u_isspace(uc)));
mtd = new MutableTrieDictionary(uc, status);
if (U_FAILURE(status)) {
fprintf(stderr, "new MutableTrieDictionary: ICU Error \"%s\"\n", u_errorName(status));
exit(status);
}
// Now add the words. Words are non-space characters at the beginning of
// lines, and must be at least one UChar. If a word has an associated value,
// the value should follow the word on the same line after a tab character.
current = wordSourceU;
UChar *candidate = current;
uc = *current++;
int32_t length = 0;
int count = 0;
while (uc) {
while (uc && !u_isspace(uc)) {
++length;
uc = *current++;
}
UnicodeString valueString;
UChar candidateValue;
if(uc == 0x0009){ //separator is a tab char, read in number after space
while (uc && u_isspace(uc)) {
uc = *current++;
}
while (uc && !u_isspace(uc)) {
valueString.append(uc);
uc = *current++;
}
}
if (length > 0) {
count++;
if(valueString.length() > 0){
mtd->setValued(TRUE);
uint32_t value = 0;
char* s = new char[valueString.length()];
valueString.extract(0,valueString.length(), s, valueString.length());
int n = sscanf(s, "%ud", &value);
U_ASSERT(n == 1);
U_ASSERT(value >= 0);
mtd->addWord(candidate, length, status, (uint16_t)value);
delete[] s;
} else {
mtd->addWord(candidate, length, status);
}
if (U_FAILURE(status)) {
fprintf(stderr, "MutableTrieDictionary::addWord: ICU Error \"%s\" at line %d in input file\n",
u_errorName(status), count);
exit(status);
}
}
// Find beginning of next line
while (uc && !breaks.contains(uc)) {
uc = *current++;
}
// Find next non-line-breaking character
while (uc && breaks.contains(uc)) {
uc = *current++;
}
candidate = current-1;
length = 0;
}
// Get rid of the Unicode text buffer
delete[] wordSourceU;
}
// Now, create a CompactTrieDictionary from the mutable dictionary
CompactTrieDictionary *ctd = new CompactTrieDictionary(*mtd, status);
if (U_FAILURE(status)) {
fprintf(stderr, "new CompactTrieDictionary: ICU Error \"%s\"\n", u_errorName(status));
exit(status);
}
// Get rid of the MutableTrieDictionary
delete mtd;
//
// Get the binary data from the dictionary.
//
uint32_t outDataSize = ctd->dataSize();
const uint8_t *outData = (const uint8_t *)ctd->data();
//
// Create the output file
//
size_t bytesWritten;
UNewDataMemory *pData;
pData = udata_create(outDir, NULL, outFileName, &(dh.info), copyright, &status);
if(U_FAILURE(status)) {
fprintf(stderr, "genctd: Could not open output file \"%s\", \"%s\"\n",
outFileName, u_errorName(status));
exit(status);
}
// Write the data itself.
udata_writeBlock(pData, outData, outDataSize);
// finish up
bytesWritten = udata_finish(pData, &status);
if(U_FAILURE(status)) {
fprintf(stderr, "genctd: error \"%s\" writing the output file\n", u_errorName(status));
exit(status);
}
if (bytesWritten != outDataSize) {
fprintf(stderr, "Error writing to output file \"%s\"\n", outFileName);
exit(-1);
}
// Get rid of the CompactTrieDictionary
delete ctd;
u_cleanup();
printf("genctd: tool completed successfully.\n");
return 0;
#endif /* #if !UCONFIG_NO_BREAK_ITERATION */
}
/* A folder could be remote (IMAP), or local(a spool directory) like $HOME/Mail
etc .. We maintain a list of known folders to avoid creating multiple
folders for the same URL. So, when mu_folder_create is called we check if
we already have a folder for that URL and return it, otherwise we create a
new one. Downsides: the scheme to detect the same URL is very weak, and
there could be cases where you'll want a different folder for the same URL,
there is not easy way to do this. */
int
mu_folder_create_from_record (mu_folder_t *pfolder, mu_url_t url,
mu_record_t record)
{
if (!pfolder)
return MU_ERR_OUT_PTR_NULL;
if (record ||
/* Look in the registrar list(iterator), for a possible concrete mailbox
implementation that could match the URL. */
mu_registrar_lookup_url (url, MU_FOLDER_ATTRIBUTE_DIRECTORY, &record,
NULL) == 0)
{
int (*f_init) (mu_folder_t) = NULL;
mu_record_get_folder (record, &f_init);
if (f_init)
{
int status, mask;
mu_folder_t folder;
int (*u_init) (mu_url_t) = NULL;
status = mu_record_check_url (record, url, &mask);
if (status)
/* FIXME: mask would provide more info */
return status;
mu_record_get_url (record, &u_init);
if (u_init)
{
status = u_init (url);
if (status)
return status;
}
mu_monitor_wrlock (&folder_lock);
/* Check if we already have the same URL folder. */
if (is_known_folder (url, &folder))
{
folder->ref++;
*pfolder = folder;
mu_url_destroy (&url); /* FIXME: Hmm */
mu_monitor_unlock (&folder_lock);
return 0;
}
else
mu_monitor_unlock (&folder_lock);
/* Create a new folder. */
/* Allocate memory for the folder. */
folder = calloc (1, sizeof (*folder));
if (folder != NULL)
{
folder->url = url;
/* Initialize the internal foilder lock, now so the
concrete folder could use it. */
status = mu_monitor_create (&folder->monitor, 0, folder);
if (status == 0)
{
/* Create the concrete folder type. */
status = f_init (folder);
if (status == 0)
{
if (!folder->_match)
folder->_match = mu_folder_imap_match;
*pfolder = folder;
folder->ref++;
/* Put on the internal list of known folders. */
if (known_folder_list == NULL)
mu_list_create (&known_folder_list);
mu_list_append (known_folder_list, folder);
}
}
/* Something went wrong, destroy the object. */
if (status)
{
if (folder->monitor)
mu_monitor_destroy (&folder->monitor, folder);
free (folder);
}
}
return status;
}
}
return MU_ERR_NOENT;
}
void
newgame()
{
int i;
#ifdef MFLOPPY
gameDiskPrompt();
#endif
flags.ident = 1;
for (i = 0; i < NUMMONS; i++)
mvitals[i].mvflags = mons[i].geno & G_NOCORPSE;
init_objects(); /* must be before u_init() */
flags.pantheon = -1; /* role_init() will reset this */
role_init(); /* must be before init_dungeons(), u_init(),
* and init_artifacts() */
init_dungeons(); /* must be before u_init() to avoid rndmonst()
* creating odd monsters for any tins and eggs
* in hero's initial inventory */
init_artifacts(); /* before u_init() in case $WIZKIT specifies
* any artifacts */
u_init();
#ifndef NO_SIGNAL
(void) signal(SIGINT, (SIG_RET_TYPE) done1);
#endif
#ifdef NEWS
if(iflags.news) display_file(NEWS, FALSE);
#endif
load_qtlist(); /* load up the quest text info */
/* quest_init();*/ /* Now part of role_init() */
mklev();
u_on_upstairs();
vision_reset(); /* set up internals for level (after mklev) */
check_special_room(FALSE);
flags.botlx = 1;
/* Move the monster from under you or else
* makedog() will fail when it calls makemon().
* - ucsfcgl!kneller
*/
if(MON_AT(u.ux, u.uy)) mnexto(m_at(u.ux, u.uy));
(void) makedog();
docrt();
if (flags.legacy) {
flush_screen(1);
com_pager(1);
}
#ifdef INSURANCE
save_currentstate();
#endif
program_state.something_worth_saving++; /* useful data now exists */
#if defined(RECORD_REALTIME) || defined(REALTIME_ON_BOTL)
/* Start the timer here */
realtime_data.realtime = (time_t)0L;
#if defined(BSD) && !defined(POSIX_TYPES)
(void) time((long *)&realtime_data.restoretime);
#else
(void) time(&realtime_data.restoretime);
#endif
#endif /* RECORD_REALTIME || REALTIME_ON_BOTL */
/* Success! */
welcome(TRUE);
return;
}
U_CDECL_END
int main(int argc, char* argv[])
{
int32_t nerrors = 0;
TestNode *root = NULL;
UErrorCode errorCode = U_ZERO_ERROR;
UDate startTime, endTime;
int32_t diffTime;
startTime = uprv_getRawUTCtime();
/* Check whether ICU will initialize without forcing the build data directory into
* the ICU_DATA path. Success here means either the data dll contains data, or that
* this test program was run with ICU_DATA set externally. Failure of this check
* is normal when ICU data is not packaged into a shared library.
*
* Whether or not this test succeeds, we want to cleanup and reinitialize
* with a data path so that data loading from individual files can be tested.
*/
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### Note: ICU Init without build-specific setDataDirectory() failed.\n");
}
u_cleanup();
errorCode = U_ZERO_ERROR;
if (!initArgs(argc, argv, argHandler, (void *) &STANDARD_TEST_FILE)) {
/* Error already displayed. */
return -1;
}
/* Initialize ICU */
ctest_setICU_DATA(); /* u_setDataDirectory() must happen Before u_init() */
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### ERROR! %s: u_init() failed with status = \"%s\".\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", argv[0], u_errorName(errorCode));
return 1;
}
fprintf(stdout, "Default charset for this run is %s\n", ucnv_getDefaultName());
addAllTests(&root);
nerrors = runTestRequest(root, argc, argv);
#if 1
{
FILE* fileToRemove = fopen(STANDARD_TEST_FILE, "r");
/* This should delete any temporary files. */
if (fileToRemove) {
fclose(fileToRemove);
log_verbose("Deleting: %s\n", STANDARD_TEST_FILE);
if (remove(STANDARD_TEST_FILE) != 0) {
/* Maybe someone didn't close the file correctly. */
fprintf(stderr, "FAIL: Could not delete %s\n", STANDARD_TEST_FILE);
nerrors += 1;
}
}
}
#endif
cleanUpTestTree(root);
DataDrivenLogger::cleanUp();
u_cleanup();
endTime = uprv_getRawUTCtime();
diffTime = (int32_t)(endTime - startTime);
printf("Elapsed Time: %02d:%02d:%02d.%03d\n",
(int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR),
(int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE),
(int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND),
(int)(diffTime%U_MILLIS_PER_SECOND));
return nerrors;
}
U_CAPI UCollator* U_EXPORT2
ucol_openRules( const UChar *rules,
int32_t rulesLength,
UColAttributeValue normalizationMode,
UCollationStrength strength,
UParseError *parseError,
UErrorCode *status)
{
UColTokenParser src;
UColAttributeValue norm;
UParseError tErr;
if(status == NULL || U_FAILURE(*status)){
return 0;
}
u_init(status);
if (U_FAILURE(*status)) {
return NULL;
}
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 *UCA = ucol_initUCA(status);
if(U_FAILURE(*status)){
return NULL;
}
ucol_tok_initTokenList(&src, rules, rulesLength, UCA, 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", src.current-src.source);
} else {
fprintf(stderr, "invalid rule just before offset %i\n", src.current-src.source);
}
#endif
ucol_tok_closeTokenList(&src);
return NULL;
}
UCollator *result = NULL;
UCATableHeader *table = NULL;
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);
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);
// 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);
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->rb = NULL;
result->elements = NULL;
result->validLocale = NULL;
result->requestedLocale = NULL;
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;
}
int
main(int argc,
char* argv[])
{
UErrorCode status = U_ZERO_ERROR;
const char *arg = NULL;
const char *outputDir = NULL; /* NULL = no output directory, use current */
const char *inputDir = NULL;
const char *encoding = "";
int i;
U_MAIN_INIT_ARGS(argc, argv);
argc = u_parseArgs(argc, argv, (int32_t)(sizeof(options)/sizeof(options[0])), options);
/* error handling, printing usage message */
if(argc<0) {
fprintf(stderr, "%s: error in command line argument \"%s\"\n", argv[0], argv[-argc]);
} else if(argc<2) {
argc = -1;
}
if(options[WRITE_POOL_BUNDLE].doesOccur && options[USE_POOL_BUNDLE].doesOccur) {
fprintf(stderr, "%s: cannot combine --writePoolBundle and --usePoolBundle\n", argv[0]);
argc = -1;
}
if(options[FORMAT_VERSION].doesOccur) {
const char *s = options[FORMAT_VERSION].value;
if(uprv_strlen(s) != 1 || (s[0] != '1' && s[0] != '2')) {
fprintf(stderr, "%s: unsupported --formatVersion %s\n", argv[0], s);
argc = -1;
} else if(s[0] == '1' &&
(options[WRITE_POOL_BUNDLE].doesOccur || options[USE_POOL_BUNDLE].doesOccur)
) {
fprintf(stderr, "%s: cannot combine --formatVersion 1 with --writePoolBundle or --usePoolBundle\n", argv[0]);
argc = -1;
} else {
setFormatVersion(s[0] - '0');
}
}
if(options[VERSION].doesOccur) {
fprintf(stderr,
"%s version %s (ICU version %s).\n"
"%s\n",
argv[0], GENRB_VERSION, U_ICU_VERSION, U_COPYRIGHT_STRING);
return U_ZERO_ERROR;
}
if(argc<0 || options[HELP1].doesOccur || options[HELP2].doesOccur) {
/*
* Broken into chunks because the C89 standard says the minimum
* required supported string length is 509 bytes.
*/
fprintf(stderr,
"Usage: %s [OPTIONS] [FILES]\n"
"\tReads the list of resource bundle source files and creates\n"
"\tbinary version of reosurce bundles (.res files)\n",
argv[0]);
fprintf(stderr,
"Options:\n"
"\t-h or -? or --help this usage text\n"
"\t-q or --quiet do not display warnings\n"
"\t-v or --verbose print extra information when processing files\n"
"\t-V or --version prints out version number and exits\n"
"\t-c or --copyright include copyright notice\n");
fprintf(stderr,
"\t-e or --encoding encoding of source files\n"
"\t-d of --destdir destination directory, followed by the path, defaults to %s\n"
"\t-s or --sourcedir source directory for files followed by path, defaults to %s\n"
"\t-i or --icudatadir directory for locating any needed intermediate data files,\n"
"\t followed by path, defaults to %s\n",
u_getDataDirectory(), u_getDataDirectory(), u_getDataDirectory());
fprintf(stderr,
"\t-j or --write-java write a Java ListResourceBundle for ICU4J, followed by optional encoding\n"
"\t defaults to ASCII and \\uXXXX format.\n");
/* This option is deprecated and should not be used ever.
"\t-p or --package-name For ICU4J: package name for writing the ListResourceBundle for ICU4J,\n"
"\t defaults to com.ibm.icu.impl.data\n"); */
fprintf(stderr,
"\t-b or --bundle-name bundle name for writing the ListResourceBundle for ICU4J,\n"
"\t defaults to LocaleElements\n"
"\t-x or --write-xliff write an XLIFF file for the resource bundle. Followed by\n"
"\t an optional output file name.\n"
"\t-k or --strict use pedantic parsing of syntax\n"
/*added by Jing*/
"\t-l or --language for XLIFF: language code compliant with BCP 47.\n");
fprintf(stderr,
"\t-C or --noBinaryCollation do not generate binary collation image;\n"
"\t makes .res file smaller but collator instantiation much slower;\n"
"\t maintains ability to get tailoring rules\n"
"\t-R or --omitCollationRules do not include collation (tailoring) rules;\n"
"\t makes .res file smaller and maintains collator instantiation speed\n"
"\t but tailoring rules will not be available (they are rarely used)\n");
fprintf(stderr,
"\t --formatVersion write a .res file compatible with the requested formatVersion (single digit);\n"
"\t for example, --formatVersion 1\n");
fprintf(stderr,
"\t --writePoolBundle write a pool.res file with all of the keys of all input bundles\n"
"\t --usePoolBundle [path-to-pool.res] point to keys from the pool.res keys pool bundle if they are available there;\n"
"\t makes .res files smaller but dependent on the pool bundle\n"
"\t (--writePoolBundle and --usePoolBundle cannot be combined)\n");
return argc < 0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
}
if(options[VERBOSE].doesOccur) {
setVerbose(TRUE);
}
if(options[QUIET].doesOccur) {
setShowWarning(FALSE);
}
if(options[STRICT].doesOccur) {
setStrict(TRUE);
}
if(options[COPYRIGHT].doesOccur){
setIncludeCopyright(TRUE);
}
if(options[SOURCEDIR].doesOccur) {
inputDir = options[SOURCEDIR].value;
}
if(options[DESTDIR].doesOccur) {
outputDir = options[DESTDIR].value;
}
/* This option is deprecated and should never be used.
if(options[PACKAGE_NAME].doesOccur) {
gPackageName = options[PACKAGE_NAME].value;
if(!strcmp(gPackageName, "ICUDATA"))
{
gPackageName = U_ICUDATA_NAME;
}
if(gPackageName[0] == 0)
{
gPackageName = NULL;
}
}*/
if(options[ENCODING].doesOccur) {
encoding = options[ENCODING].value;
}
if(options[ICUDATADIR].doesOccur) {
u_setDataDirectory(options[ICUDATADIR].value);
}
/* Initialize ICU */
u_init(&status);
if (U_FAILURE(status) && status != U_FILE_ACCESS_ERROR) {
/* Note: u_init() will try to open ICU property data.
* failures here are expected when building ICU from scratch.
* ignore them.
*/
fprintf(stderr, "%s: can not initialize ICU. status = %s\n",
argv[0], u_errorName(status));
exit(1);
}
status = U_ZERO_ERROR;
if(options[WRITE_JAVA].doesOccur) {
write_java = TRUE;
outputEnc = options[WRITE_JAVA].value;
}
if(options[BUNDLE_NAME].doesOccur) {
bundleName = options[BUNDLE_NAME].value;
}
if(options[WRITE_XLIFF].doesOccur) {
write_xliff = TRUE;
if(options[WRITE_XLIFF].value != NULL){
xliffOutputFileName = options[WRITE_XLIFF].value;
}
}
initParser(options[NO_BINARY_COLLATION].doesOccur, options[NO_COLLATION_RULES].doesOccur);
/*added by Jing*/
if(options[LANGUAGE].doesOccur) {
language = options[LANGUAGE].value;
}
if(options[WRITE_POOL_BUNDLE].doesOccur) {
newPoolBundle = bundle_open(NULL, TRUE, &status);
if(U_FAILURE(status)) {
fprintf(stderr, "unable to create an empty bundle for the pool keys: %s\n", u_errorName(status));
return status;
} else {
const char *poolResName = "pool.res";
char *nameWithoutSuffix = uprv_malloc(uprv_strlen(poolResName) + 1);
if (nameWithoutSuffix == NULL) {
fprintf(stderr, "out of memory error\n");
return U_MEMORY_ALLOCATION_ERROR;
}
uprv_strcpy(nameWithoutSuffix, poolResName);
*uprv_strrchr(nameWithoutSuffix, '.') = 0;
newPoolBundle->fLocale = nameWithoutSuffix;
}
}
if(options[USE_POOL_BUNDLE].doesOccur) {
const char *poolResName = "pool.res";
FileStream *poolFile;
int32_t poolFileSize;
int32_t indexLength;
/*
* TODO: Consolidate inputDir/filename handling from main() and processFile()
* into a common function, and use it here as well.
* Try to create toolutil functions for dealing with dir/filenames and
* loading ICU data files without udata_open().
* Share code with icupkg?
* Also, make_res_filename() seems to be unused. Review and remove.
*/
if (options[USE_POOL_BUNDLE].value!=NULL) {
uprv_strcpy(theCurrentFileName, options[USE_POOL_BUNDLE].value);
uprv_strcat(theCurrentFileName, U_FILE_SEP_STRING);
} else if (inputDir) {
uprv_strcpy(theCurrentFileName, inputDir);
uprv_strcat(theCurrentFileName, U_FILE_SEP_STRING);
} else {
*theCurrentFileName = 0;
}
uprv_strcat(theCurrentFileName, poolResName);
poolFile = T_FileStream_open(theCurrentFileName, "rb");
if (poolFile == NULL) {
fprintf(stderr, "unable to open pool bundle file %s\n", theCurrentFileName);
return 1;
}
poolFileSize = T_FileStream_size(poolFile);
if (poolFileSize < 32) {
fprintf(stderr, "the pool bundle file %s is too small\n", theCurrentFileName);
return 1;
}
poolBundle.fBytes = (uint8_t *)uprv_malloc((poolFileSize + 15) & ~15);
if (poolFileSize > 0 && poolBundle.fBytes == NULL) {
fprintf(stderr, "unable to allocate memory for the pool bundle file %s\n", theCurrentFileName);
return U_MEMORY_ALLOCATION_ERROR;
} else {
UDataSwapper *ds;
const DataHeader *header;
int32_t bytesRead = T_FileStream_read(poolFile, poolBundle.fBytes, poolFileSize);
int32_t keysBottom;
if (bytesRead != poolFileSize) {
fprintf(stderr, "unable to read the pool bundle file %s\n", theCurrentFileName);
return 1;
}
/*
* Swap the pool bundle so that a single checked-in file can be used.
* The swapper functions also test that the data looks like
* a well-formed .res file.
*/
ds = udata_openSwapperForInputData(poolBundle.fBytes, bytesRead,
U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &status);
if (U_FAILURE(status)) {
fprintf(stderr, "udata_openSwapperForInputData(pool bundle %s) failed: %s\n",
theCurrentFileName, u_errorName(status));
return status;
}
ures_swap(ds, poolBundle.fBytes, bytesRead, poolBundle.fBytes, &status);
udata_closeSwapper(ds);
if (U_FAILURE(status)) {
fprintf(stderr, "ures_swap(pool bundle %s) failed: %s\n",
theCurrentFileName, u_errorName(status));
return status;
}
header = (const DataHeader *)poolBundle.fBytes;
if (header->info.formatVersion[0]!=2) {
fprintf(stderr, "invalid format of pool bundle file %s\n", theCurrentFileName);
return U_INVALID_FORMAT_ERROR;
}
poolBundle.fKeys = (const char *)header + header->dataHeader.headerSize;
poolBundle.fIndexes = (const int32_t *)poolBundle.fKeys + 1;
indexLength = poolBundle.fIndexes[URES_INDEX_LENGTH] & 0xff;
if (indexLength <= URES_INDEX_POOL_CHECKSUM) {
fprintf(stderr, "insufficient indexes[] in pool bundle file %s\n", theCurrentFileName);
return U_INVALID_FORMAT_ERROR;
}
keysBottom = (1 + indexLength) * 4;
poolBundle.fKeys += keysBottom;
poolBundle.fKeysLength = (poolBundle.fIndexes[URES_INDEX_KEYS_TOP] * 4) - keysBottom;
poolBundle.fChecksum = poolBundle.fIndexes[URES_INDEX_POOL_CHECKSUM];
}
for (i = 0; i < poolBundle.fKeysLength; ++i) {
if (poolBundle.fKeys[i] == 0) {
++poolBundle.fKeysCount;
}
}
T_FileStream_close(poolFile);
setUsePoolBundle(TRUE);
}
if(options[INCLUDE_UNIHAN_COLL].doesOccur) {
gIncludeUnihanColl = TRUE;
}
if((argc-1)!=1) {
printf("genrb number of files: %d\n", argc - 1);
}
/* generate the binary files */
for(i = 1; i < argc; ++i) {
status = U_ZERO_ERROR;
arg = getLongPathname(argv[i]);
if (inputDir) {
uprv_strcpy(theCurrentFileName, inputDir);
uprv_strcat(theCurrentFileName, U_FILE_SEP_STRING);
} else {
*theCurrentFileName = 0;
}
uprv_strcat(theCurrentFileName, arg);
if (isVerbose()) {
printf("Processing file \"%s\"\n", theCurrentFileName);
}
processFile(arg, encoding, inputDir, outputDir, gPackageName, &status);
}
uprv_free(poolBundle.fBytes);
if(options[WRITE_POOL_BUNDLE].doesOccur) {
char outputFileName[256];
bundle_write(newPoolBundle, outputDir, NULL, outputFileName, sizeof(outputFileName), &status);
bundle_close(newPoolBundle, &status);
if(U_FAILURE(status)) {
fprintf(stderr, "unable to write the pool bundle: %s\n", u_errorName(status));
}
}
/* Dont return warnings as a failure */
if (U_SUCCESS(status)) {
return 0;
}
return status;
}
int register_libcore_icu_ICU(JNIEnv* env) {
std::string path;
#define FAIL_WITH_STRERROR(s) \
ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
abort();
#define MAYBE_FAIL_WITH_ICU_ERROR(s) \
if (status != U_ZERO_ERROR) {\
ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
abort(); \
}
// RoboVM note: Start change. Look for custom ICU data and fall back to builtin minimal data if not found.
if (!findCustomICUData(path)) {
ALOGI("Using builtin minimal ICU data");
void* data = malloc(out_icudt51l_dat_len);
if (!data) {
ALOGE("Failed to allocate %d bytes for builtin ICU data", out_icudt51l_dat_len);
abort();
}
int ret = inflate(out_icudt51l_dat_gz, out_icudt51l_dat_gz_len, data, out_icudt51l_dat_len);
if (ret != out_icudt51l_dat_len) {
ALOGE("Failed to inflate %d->%d bytes of builtin ICU data: %d",
out_icudt51l_dat_gz_len, out_icudt51l_dat_len, ret);
abort();
}
UErrorCode status = U_ZERO_ERROR;
udata_setCommonData(data, &status);
MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
// Tell ICU it can *only* use our data.
udata_setFileAccess(UDATA_NO_FILES, &status);
MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
// Force initialization up front so we can report a nice clear error and bail.
u_init(&status);
MAYBE_FAIL_WITH_ICU_ERROR("u_init");
return 0;
}
ALOGI("Using custom ICU data file: '%s'", path.c_str());
// RoboVM note: End change.
// Open the file and get its length.
ScopedFd fd(open(path.c_str(), O_RDONLY));
if (fd.get() == -1) {
FAIL_WITH_STRERROR("open");
}
struct stat sb;
if (fstat(fd.get(), &sb) == -1) {
FAIL_WITH_STRERROR("stat");
}
// Map it.
void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
if (data == MAP_FAILED) {
FAIL_WITH_STRERROR("mmap");
}
// Tell the kernel that accesses are likely to be random rather than sequential.
if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
}
// Tell ICU to use our memory-mapped data.
UErrorCode status = U_ZERO_ERROR;
udata_setCommonData(data, &status);
MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
// Tell ICU it can *only* use our memory-mapped data.
udata_setFileAccess(UDATA_NO_FILES, &status);
MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
// Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
// use, which can be anywhere. Force initialization up front so we can report a nice clear error
// and bail.
u_init(&status);
MAYBE_FAIL_WITH_ICU_ERROR("u_init");
return 0;
}
int
main(int argc,
char* argv[])
{
UErrorCode status = U_ZERO_ERROR;
const char *arg = NULL;
const char *outputDir = NULL; /* NULL = no output directory, use current */
const char *inputDir = NULL;
const char *encoding = "";
int i;
UBool illegalArg = FALSE;
U_MAIN_INIT_ARGS(argc, argv);
options[JAVA_PACKAGE].value = "com.ibm.icu.impl.data";
options[BUNDLE_NAME].value = "LocaleElements";
argc = u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options);
/* error handling, printing usage message */
if(argc<0) {
fprintf(stderr, "%s: error in command line argument \"%s\"\n", argv[0], argv[-argc]);
illegalArg = TRUE;
} else if(argc<2) {
illegalArg = TRUE;
}
if(options[WRITE_POOL_BUNDLE].doesOccur && options[USE_POOL_BUNDLE].doesOccur) {
fprintf(stderr, "%s: cannot combine --writePoolBundle and --usePoolBundle\n", argv[0]);
illegalArg = TRUE;
}
if(options[FORMAT_VERSION].doesOccur) {
const char *s = options[FORMAT_VERSION].value;
if(uprv_strlen(s) != 1 || (s[0] < '1' && '3' < s[0])) {
fprintf(stderr, "%s: unsupported --formatVersion %s\n", argv[0], s);
illegalArg = TRUE;
} else if(s[0] == '1' &&
(options[WRITE_POOL_BUNDLE].doesOccur || options[USE_POOL_BUNDLE].doesOccur)
) {
fprintf(stderr, "%s: cannot combine --formatVersion 1 with --writePoolBundle or --usePoolBundle\n", argv[0]);
illegalArg = TRUE;
} else {
setFormatVersion(s[0] - '0');
}
}
if((options[JAVA_PACKAGE].doesOccur || options[BUNDLE_NAME].doesOccur) &&
!options[WRITE_JAVA].doesOccur) {
fprintf(stderr,
"%s error: command line argument --java-package or --bundle-name "
"without --write-java\n",
argv[0]);
illegalArg = TRUE;
}
if(options[VERSION].doesOccur) {
fprintf(stderr,
"%s version %s (ICU version %s).\n"
"%s\n",
argv[0], GENRB_VERSION, U_ICU_VERSION, U_COPYRIGHT_STRING);
if(!illegalArg) {
return U_ZERO_ERROR;
}
}
if(illegalArg || options[HELP1].doesOccur || options[HELP2].doesOccur) {
/*
* Broken into chunks because the C89 standard says the minimum
* required supported string length is 509 bytes.
*/
fprintf(stderr,
"Usage: %s [OPTIONS] [FILES]\n"
"\tReads the list of resource bundle source files and creates\n"
"\tbinary version of resource bundles (.res files)\n",
argv[0]);
fprintf(stderr,
"Options:\n"
"\t-h or -? or --help this usage text\n"
"\t-q or --quiet do not display warnings\n"
"\t-v or --verbose print extra information when processing files\n"
"\t-V or --version prints out version number and exits\n"
"\t-c or --copyright include copyright notice\n");
fprintf(stderr,
"\t-e or --encoding encoding of source files\n"
"\t-d of --destdir destination directory, followed by the path, defaults to %s\n"
"\t-s or --sourcedir source directory for files followed by path, defaults to %s\n"
"\t-i or --icudatadir directory for locating any needed intermediate data files,\n"
"\t followed by path, defaults to %s\n",
u_getDataDirectory(), u_getDataDirectory(), u_getDataDirectory());
fprintf(stderr,
"\t-j or --write-java write a Java ListResourceBundle for ICU4J, followed by optional encoding\n"
"\t defaults to ASCII and \\uXXXX format.\n"
"\t --java-package For --write-java: package name for writing the ListResourceBundle,\n"
"\t defaults to com.ibm.icu.impl.data\n");
fprintf(stderr,
"\t-b or --bundle-name For --write-java: root resource bundle name for writing the ListResourceBundle,\n"
"\t defaults to LocaleElements\n"
"\t-x or --write-xliff write an XLIFF file for the resource bundle. Followed by\n"
"\t an optional output file name.\n"
"\t-k or --strict use pedantic parsing of syntax\n"
/*added by Jing*/
"\t-l or --language for XLIFF: language code compliant with BCP 47.\n");
fprintf(stderr,
"\t-C or --noBinaryCollation do not generate binary collation image;\n"
"\t makes .res file smaller but collator instantiation much slower;\n"
"\t maintains ability to get tailoring rules\n"
"\t-R or --omitCollationRules do not include collation (tailoring) rules;\n"
"\t makes .res file smaller and maintains collator instantiation speed\n"
"\t but tailoring rules will not be available (they are rarely used)\n");
fprintf(stderr,
"\t --formatVersion write a .res file compatible with the requested formatVersion (single digit);\n"
"\t for example, --formatVersion 1\n");
fprintf(stderr,
"\t --writePoolBundle write a pool.res file with all of the keys of all input bundles\n"
"\t --usePoolBundle [path-to-pool.res] point to keys from the pool.res keys pool bundle if they are available there;\n"
"\t makes .res files smaller but dependent on the pool bundle\n"
"\t (--writePoolBundle and --usePoolBundle cannot be combined)\n");
return illegalArg ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
}
if(options[VERBOSE].doesOccur) {
setVerbose(TRUE);
}
if(options[QUIET].doesOccur) {
setShowWarning(FALSE);
}
if(options[STRICT].doesOccur) {
setStrict(TRUE);
}
if(options[COPYRIGHT].doesOccur){
setIncludeCopyright(TRUE);
}
if(options[SOURCEDIR].doesOccur) {
inputDir = options[SOURCEDIR].value;
}
if(options[DESTDIR].doesOccur) {
outputDir = options[DESTDIR].value;
}
if(options[ENCODING].doesOccur) {
encoding = options[ENCODING].value;
}
if(options[ICUDATADIR].doesOccur) {
u_setDataDirectory(options[ICUDATADIR].value);
}
/* Initialize ICU */
u_init(&status);
if (U_FAILURE(status) && status != U_FILE_ACCESS_ERROR) {
/* Note: u_init() will try to open ICU property data.
* failures here are expected when building ICU from scratch.
* ignore them.
*/
fprintf(stderr, "%s: can not initialize ICU. status = %s\n",
argv[0], u_errorName(status));
exit(1);
}
status = U_ZERO_ERROR;
if(options[WRITE_JAVA].doesOccur) {
write_java = TRUE;
outputEnc = options[WRITE_JAVA].value;
}
if(options[WRITE_XLIFF].doesOccur) {
write_xliff = TRUE;
if(options[WRITE_XLIFF].value != NULL){
xliffOutputFileName = options[WRITE_XLIFF].value;
}
}
initParser();
/*added by Jing*/
if(options[LANGUAGE].doesOccur) {
language = options[LANGUAGE].value;
}
LocalPointer<SRBRoot> newPoolBundle;
if(options[WRITE_POOL_BUNDLE].doesOccur) {
newPoolBundle.adoptInsteadAndCheckErrorCode(new SRBRoot(NULL, TRUE, status), status);
if(U_FAILURE(status)) {
fprintf(stderr, "unable to create an empty bundle for the pool keys: %s\n", u_errorName(status));
return status;
} else {
const char *poolResName = "pool.res";
char *nameWithoutSuffix = static_cast<char *>(uprv_malloc(uprv_strlen(poolResName) + 1));
if (nameWithoutSuffix == NULL) {
fprintf(stderr, "out of memory error\n");
return U_MEMORY_ALLOCATION_ERROR;
}
uprv_strcpy(nameWithoutSuffix, poolResName);
*uprv_strrchr(nameWithoutSuffix, '.') = 0;
newPoolBundle->fLocale = nameWithoutSuffix;
}
}
if(options[USE_POOL_BUNDLE].doesOccur) {
const char *poolResName = "pool.res";
FileStream *poolFile;
int32_t poolFileSize;
int32_t indexLength;
/*
* TODO: Consolidate inputDir/filename handling from main() and processFile()
* into a common function, and use it here as well.
* Try to create toolutil functions for dealing with dir/filenames and
* loading ICU data files without udata_open().
* Share code with icupkg?
* Also, make_res_filename() seems to be unused. Review and remove.
*/
CharString poolFileName;
if (options[USE_POOL_BUNDLE].value!=NULL) {
poolFileName.append(options[USE_POOL_BUNDLE].value, status);
} else if (inputDir) {
poolFileName.append(inputDir, status);
}
poolFileName.appendPathPart(poolResName, status);
if (U_FAILURE(status)) {
return status;
}
poolFile = T_FileStream_open(poolFileName.data(), "rb");
if (poolFile == NULL) {
fprintf(stderr, "unable to open pool bundle file %s\n", poolFileName.data());
return 1;
}
poolFileSize = T_FileStream_size(poolFile);
if (poolFileSize < 32) {
fprintf(stderr, "the pool bundle file %s is too small\n", poolFileName.data());
return 1;
}
poolBundle.fBytes = new uint8_t[(poolFileSize + 15) & ~15];
if (poolFileSize > 0 && poolBundle.fBytes == NULL) {
fprintf(stderr, "unable to allocate memory for the pool bundle file %s\n", poolFileName.data());
return U_MEMORY_ALLOCATION_ERROR;
}
UDataSwapper *ds;
const DataHeader *header;
int32_t bytesRead = T_FileStream_read(poolFile, poolBundle.fBytes, poolFileSize);
if (bytesRead != poolFileSize) {
fprintf(stderr, "unable to read the pool bundle file %s\n", poolFileName.data());
return 1;
}
/*
* Swap the pool bundle so that a single checked-in file can be used.
* The swapper functions also test that the data looks like
* a well-formed .res file.
*/
ds = udata_openSwapperForInputData(poolBundle.fBytes, bytesRead,
U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &status);
if (U_FAILURE(status)) {
fprintf(stderr, "udata_openSwapperForInputData(pool bundle %s) failed: %s\n",
poolFileName.data(), u_errorName(status));
return status;
}
ures_swap(ds, poolBundle.fBytes, bytesRead, poolBundle.fBytes, &status);
udata_closeSwapper(ds);
if (U_FAILURE(status)) {
fprintf(stderr, "ures_swap(pool bundle %s) failed: %s\n",
poolFileName.data(), u_errorName(status));
return status;
}
header = (const DataHeader *)poolBundle.fBytes;
if (header->info.formatVersion[0] < 2) {
fprintf(stderr, "invalid format of pool bundle file %s\n", poolFileName.data());
return U_INVALID_FORMAT_ERROR;
}
const int32_t *pRoot = (const int32_t *)(
(const char *)header + header->dataHeader.headerSize);
poolBundle.fIndexes = pRoot + 1;
indexLength = poolBundle.fIndexes[URES_INDEX_LENGTH] & 0xff;
if (indexLength <= URES_INDEX_POOL_CHECKSUM) {
fprintf(stderr, "insufficient indexes[] in pool bundle file %s\n", poolFileName.data());
return U_INVALID_FORMAT_ERROR;
}
int32_t keysBottom = 1 + indexLength;
int32_t keysTop = poolBundle.fIndexes[URES_INDEX_KEYS_TOP];
poolBundle.fKeys = (const char *)(pRoot + keysBottom);
poolBundle.fKeysLength = (keysTop - keysBottom) * 4;
poolBundle.fChecksum = poolBundle.fIndexes[URES_INDEX_POOL_CHECKSUM];
for (i = 0; i < poolBundle.fKeysLength; ++i) {
if (poolBundle.fKeys[i] == 0) {
++poolBundle.fKeysCount;
}
}
// 16BitUnits[] begins with strings-v2.
// The strings-v2 may optionally be terminated by what looks like
// an explicit string length that exceeds the number of remaining 16-bit units.
int32_t stringUnitsLength = (poolBundle.fIndexes[URES_INDEX_16BIT_TOP] - keysTop) * 2;
if (stringUnitsLength >= 2 && getFormatVersion() >= 3) {
poolBundle.fStrings = new PseudoListResource(NULL, status);
if (poolBundle.fStrings == NULL) {
fprintf(stderr, "unable to allocate memory for the pool bundle strings %s\n",
poolFileName.data());
return U_MEMORY_ALLOCATION_ERROR;
}
// The PseudoListResource constructor call did not allocate further memory.
assert(U_SUCCESS(status));
const UChar *p = (const UChar *)(pRoot + keysTop);
int32_t remaining = stringUnitsLength;
do {
int32_t first = *p;
int8_t numCharsForLength;
int32_t length;
if (!U16_IS_TRAIL(first)) {
// NUL-terminated
numCharsForLength = 0;
for (length = 0;
length < remaining && p[length] != 0;
++length) {}
} else if (first < 0xdfef) {
numCharsForLength = 1;
length = first & 0x3ff;
} else if (first < 0xdfff && remaining >= 2) {
numCharsForLength = 2;
length = ((first - 0xdfef) << 16) | p[1];
} else if (first == 0xdfff && remaining >= 3) {
numCharsForLength = 3;
length = ((int32_t)p[1] << 16) | p[2];
} else {
break; // overrun
}
// Check for overrun before changing remaining,
// so that it is always accurate after the loop body.
if ((numCharsForLength + length) >= remaining ||
p[numCharsForLength + length] != 0) {
break; // overrun or explicitly terminated
}
int32_t poolStringIndex = stringUnitsLength - remaining;
// Maximum pool string index when suffix-sharing the last character.
int32_t maxStringIndex = poolStringIndex + numCharsForLength + length - 1;
if (maxStringIndex >= RES_MAX_OFFSET) {
// pool string index overrun
break;
}
p += numCharsForLength;
remaining -= numCharsForLength;
if (length != 0) {
StringResource *sr =
new StringResource(poolStringIndex, numCharsForLength,
p, length, status);
if (sr == NULL) {
fprintf(stderr, "unable to allocate memory for a pool bundle string %s\n",
poolFileName.data());
return U_MEMORY_ALLOCATION_ERROR;
}
poolBundle.fStrings->add(sr);
poolBundle.fStringIndexLimit = maxStringIndex + 1;
// The StringResource constructor did not allocate further memory.
assert(U_SUCCESS(status));
}
p += length + 1;
remaining -= length + 1;
} while (remaining > 0);
if (poolBundle.fStrings->fCount == 0) {
delete poolBundle.fStrings;
poolBundle.fStrings = NULL;
}
}
T_FileStream_close(poolFile);
setUsePoolBundle(TRUE);
if (isVerbose() && poolBundle.fStrings != NULL) {
printf("number of shared strings: %d\n", (int)poolBundle.fStrings->fCount);
int32_t length = poolBundle.fStringIndexLimit + 1; // incl. last NUL
printf("16-bit units for strings: %6d = %6d bytes\n",
(int)length, (int)length * 2);
}
}
if(!options[FORMAT_VERSION].doesOccur && getFormatVersion() == 3 &&
poolBundle.fStrings == NULL &&
!options[WRITE_POOL_BUNDLE].doesOccur) {
// If we just default to formatVersion 3
// but there are no pool bundle strings to share
// and we do not write a pool bundle,
// then write formatVersion 2 which is just as good.
setFormatVersion(2);
}
if(options[INCLUDE_UNIHAN_COLL].doesOccur) {
puts("genrb option --includeUnihanColl ignored: \n"
"CLDR 26/ICU 54 unihan data is small, except\n"
"the ucadata-unihan.icu version of the collation root data\n"
"is about 300kB larger than the ucadata-implicithan.icu version.");
}
if((argc-1)!=1) {
printf("genrb number of files: %d\n", argc - 1);
}
/* generate the binary files */
for(i = 1; i < argc; ++i) {
status = U_ZERO_ERROR;
arg = getLongPathname(argv[i]);
CharString theCurrentFileName;
if (inputDir) {
theCurrentFileName.append(inputDir, status);
}
theCurrentFileName.appendPathPart(arg, status);
if (U_FAILURE(status)) {
break;
}
gCurrentFileName = theCurrentFileName.data();
if (isVerbose()) {
printf("Processing file \"%s\"\n", theCurrentFileName.data());
}
processFile(arg, encoding, inputDir, outputDir, NULL,
newPoolBundle.getAlias(),
options[NO_BINARY_COLLATION].doesOccur, status);
}
poolBundle.close();
if(U_SUCCESS(status) && options[WRITE_POOL_BUNDLE].doesOccur) {
char outputFileName[256];
newPoolBundle->write(outputDir, NULL, outputFileName, sizeof(outputFileName), status);
if(U_FAILURE(status)) {
fprintf(stderr, "unable to write the pool bundle: %s\n", u_errorName(status));
}
}
u_cleanup();
/* Dont return warnings as a failure */
if (U_SUCCESS(status)) {
return 0;
}
return status;
}
static void TestHeapFunctions() {
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *rb = NULL;
char *icuDataDir;
UVersionInfo unicodeVersion = {0,0,0,0};
icuDataDir = safeGetICUDataDirectory(); /* save icu data dir, so we can put it back
* after doing u_cleanup(). */
/* Verify that ICU can be cleaned up and reinitialized successfully.
* Failure here usually means that some ICU service didn't clean up successfully,
* probably because some earlier test accidently left something open. */
ctest_resetICU();
/* Can not set memory functions if ICU is already initialized */
u_setMemoryFunctions(&gContext, myMemAlloc, myMemRealloc, myMemFree, &status);
TEST_STATUS(status, U_INVALID_STATE_ERROR);
/* Un-initialize ICU */
u_cleanup();
/* Can not set memory functions with NULL values */
status = U_ZERO_ERROR;
u_setMemoryFunctions(&gContext, NULL, myMemRealloc, myMemFree, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
status = U_ZERO_ERROR;
u_setMemoryFunctions(&gContext, myMemAlloc, NULL, myMemFree, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
status = U_ZERO_ERROR;
u_setMemoryFunctions(&gContext, myMemAlloc, myMemRealloc, NULL, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
/* u_setMemoryFunctions() should work with null or non-null context pointer */
status = U_ZERO_ERROR;
u_setMemoryFunctions(NULL, myMemAlloc, myMemRealloc, myMemFree, &status);
TEST_STATUS(status, U_ZERO_ERROR);
u_setMemoryFunctions(&gContext, myMemAlloc, myMemRealloc, myMemFree, &status);
TEST_STATUS(status, U_ZERO_ERROR);
/* After reinitializing ICU, we should not be able to set the memory funcs again. */
status = U_ZERO_ERROR;
u_setDataDirectory(icuDataDir);
u_init(&status);
TEST_STATUS(status, U_ZERO_ERROR);
u_setMemoryFunctions(NULL, myMemAlloc, myMemRealloc, myMemFree, &status);
TEST_STATUS(status, U_INVALID_STATE_ERROR);
/* Doing ICU operations should cause allocations to come through our test heap */
gBlockCount = 0;
status = U_ZERO_ERROR;
rb = ures_open(NULL, "es", &status);
TEST_STATUS(status, U_ZERO_ERROR);
if (gBlockCount == 0) {
log_err("Heap functions are not being called from ICU.\n");
}
ures_close(rb);
/* Cleanup should put the heap back to its default implementation. */
ctest_resetICU();
u_getUnicodeVersion(unicodeVersion);
if (unicodeVersion[0] <= 0) {
log_err("Properties doesn't reinitialize without u_init.\n");
}
status = U_ZERO_ERROR;
u_init(&status);
TEST_STATUS(status, U_ZERO_ERROR);
/* ICU operations should no longer cause allocations to come through our test heap */
gBlockCount = 0;
status = U_ZERO_ERROR;
rb = ures_open(NULL, "fr", &status);
TEST_STATUS(status, U_ZERO_ERROR);
if (gBlockCount != 0) {
log_err("Heap functions did not reset after u_cleanup.\n");
}
ures_close(rb);
free(icuDataDir);
ctest_resetICU();
}
int
main(int argc,
char* argv[])
{
UErrorCode status = U_ZERO_ERROR;
const char *arg = NULL;
const char *outputDir = NULL; /* NULL = no output directory, use current */
const char *inputDir = NULL;
const char *encoding = "";
int i;
U_MAIN_INIT_ARGS(argc, argv);
argc = u_parseArgs(argc, argv, (int32_t)(sizeof(options)/sizeof(options[0])), options);
/* error handling, printing usage message */
if(argc<0) {
fprintf(stderr, "%s: error in command line argument \"%s\"\n", argv[0], argv[-argc]);
} else if(argc<2) {
argc = -1;
}
if(options[VERSION].doesOccur) {
fprintf(stderr,
"%s version %s (ICU version %s).\n"
"%s\n",
argv[0], GENRB_VERSION, U_ICU_VERSION, U_COPYRIGHT_STRING);
return U_ZERO_ERROR;
}
if(argc<0 || options[HELP1].doesOccur || options[HELP2].doesOccur) {
/*
* Broken into chucks because the C89 standard says the minimum
* required supported string length is 509 bytes.
*/
fprintf(stderr,
"Usage: %s [OPTIONS] [FILES]\n"
"\tReads the list of resource bundle source files and creates\n"
"\tbinary version of reosurce bundles (.res files)\n",
argv[0]);
fprintf(stderr,
"Options:\n"
"\t-h or -? or --help this usage text\n"
"\t-q or --quiet do not display warnings\n"
"\t-v or --verbose print extra information when processing files\n"
"\t-V or --version prints out version number and exits\n"
"\t-c or --copyright include copyright notice\n");
fprintf(stderr,
"\t-e or --encoding encoding of source files\n"
"\t-d of --destdir destination directory, followed by the path, defaults to %s\n"
"\t-s or --sourcedir source directory for files followed by path, defaults to %s\n"
"\t-i or --icudatadir directory for locating any needed intermediate data files,\n"
"\t followed by path, defaults to %s\n",
u_getDataDirectory(), u_getDataDirectory(), u_getDataDirectory());
fprintf(stderr,
"\t-j or --write-java write a Java ListResourceBundle for ICU4J, followed by optional encoding\n"
"\t defaults to ASCII and \\uXXXX format.\n"
"\t-p or --package-name For ICU4J: package name for writing the ListResourceBundle for ICU4J,\n"
"\t defaults to com.ibm.icu.impl.data\n");
fprintf(stderr,
"\t-b or --bundle-name bundle name for writing the ListResourceBundle for ICU4J,\n"
"\t defaults to LocaleElements\n"
"\t-x or --write-xliff write a XLIFF file for the resource bundle. Followed by an optional output file name.\n"
"\t-k or --strict use pedantic parsing of syntax\n"
/*added by Jing*/
"\t-l or --language For XLIFF: language code compliant with ISO 639.\n");
return argc < 0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
}
if(options[VERBOSE].doesOccur) {
setVerbose(TRUE);
}
if(options[QUIET].doesOccur) {
setShowWarning(FALSE);
}
if(options[STRICT].doesOccur) {
setStrict(TRUE);
}
if(options[COPYRIGHT].doesOccur){
setIncludeCopyright(TRUE);
}
if(options[SOURCEDIR].doesOccur) {
inputDir = options[SOURCEDIR].value;
}
if(options[DESTDIR].doesOccur) {
outputDir = options[DESTDIR].value;
}
if(options[PACKAGE_NAME].doesOccur) {
gPackageName = options[PACKAGE_NAME].value;
if(!strcmp(gPackageName, "ICUDATA"))
{
gPackageName = U_ICUDATA_NAME;
}
if(gPackageName[0] == 0)
{
gPackageName = NULL;
}
}
if(options[ENCODING].doesOccur) {
encoding = options[ENCODING].value;
}
if(options[ICUDATADIR].doesOccur) {
u_setDataDirectory(options[ICUDATADIR].value);
}
/* Initialize ICU */
u_init(&status);
if (U_FAILURE(status) && status != U_FILE_ACCESS_ERROR) {
/* Note: u_init() will try to open ICU property data.
* failures here are expected when building ICU from scratch.
* ignore them.
*/
fprintf(stderr, "%s: can not initialize ICU. status = %s\n",
argv[0], u_errorName(status));
exit(1);
}
status = U_ZERO_ERROR;
if(options[WRITE_JAVA].doesOccur) {
write_java = TRUE;
outputEnc = options[WRITE_JAVA].value;
}
if(options[BUNDLE_NAME].doesOccur) {
bundleName = options[BUNDLE_NAME].value;
}
if(options[WRITE_XLIFF].doesOccur) {
write_xliff = TRUE;
if(options[WRITE_XLIFF].value != NULL){
xliffOutputFileName = options[WRITE_XLIFF].value;
}
}
if(options[NO_BINARY_COLLATION].doesOccur) {
initParser(FALSE);
} else {
initParser(TRUE);
}
/*added by Jing*/
if(options[LANGUAGE].doesOccur) {
language = options[LANGUAGE].value;
}
/* generate the binary files */
for(i = 1; i < argc; ++i) {
status = U_ZERO_ERROR;
arg = getLongPathname(argv[i]);
if (inputDir) {
uprv_strcpy(theCurrentFileName, inputDir);
uprv_strcat(theCurrentFileName, U_FILE_SEP_STRING);
} else {
*theCurrentFileName = 0;
}
uprv_strcat(theCurrentFileName, arg);
if (isVerbose()) {
printf("Processing file \"%s\"\n", theCurrentFileName);
}
processFile(arg, encoding, inputDir, outputDir, gPackageName, &status);
}
/* Dont return warnings as a failure */
if (! U_FAILURE(status)) {
return 0;
}
return status;
}
static void TestIncDecFunctions() {
UErrorCode status = U_ZERO_ERROR;
int32_t t = 1; /* random value to make sure that Inc/dec works */
char *dataDir;
/* Save ICU's data dir and tracing functions so that they can be resored
after cleanup and reinit. */
dataDir = safeGetICUDataDirectory();
/* Verify that ICU can be cleaned up and reinitialized successfully.
* Failure here usually means that some ICU service didn't clean up successfully,
* probably because some earlier test accidently left something open. */
ctest_resetICU();
/* Can not set mutex functions if ICU is already initialized */
u_setAtomicIncDecFunctions(&gIncDecContext, myIncFunc, myDecFunc, &status);
TEST_STATUS(status, U_INVALID_STATE_ERROR);
/* Clean up ICU */
u_cleanup();
/* Can not set functions with NULL values */
status = U_ZERO_ERROR;
u_setAtomicIncDecFunctions(&gIncDecContext, NULL, myDecFunc, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
status = U_ZERO_ERROR;
u_setAtomicIncDecFunctions(&gIncDecContext, myIncFunc, NULL, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
/* u_setIncDecFunctions() should work with null or non-null context pointer */
status = U_ZERO_ERROR;
gExpectedContext = NULL;
u_setAtomicIncDecFunctions(NULL, myIncFunc, myDecFunc, &status);
TEST_STATUS(status, U_ZERO_ERROR);
gExpectedContext = &gIncDecContext;
u_setAtomicIncDecFunctions(&gIncDecContext, myIncFunc, myDecFunc, &status);
TEST_STATUS(status, U_ZERO_ERROR);
/* After reinitializing ICU, we should not be able to set the inc/dec funcs again. */
status = U_ZERO_ERROR;
u_setDataDirectory(dataDir);
u_init(&status);
TEST_STATUS(status, U_ZERO_ERROR);
gExpectedContext = &gIncDecContext;
u_setAtomicIncDecFunctions(&gIncDecContext, myIncFunc, myDecFunc, &status);
TEST_STATUS(status, U_INVALID_STATE_ERROR);
/* Doing ICU operations should cause our functions to be called */
gIncCount = 0;
gDecCount = 0;
umtx_atomic_inc(&t);
TEST_ASSERT(t == 2);
umtx_atomic_dec(&t);
TEST_ASSERT(t == 1);
TEST_ASSERT(gIncCount > 0);
TEST_ASSERT(gDecCount > 0);
/* Cleanup should cancel use of our inc/dec functions. */
/* Additional ICU operations should not use them */
ctest_resetICU();
gIncCount = 0;
gDecCount = 0;
status = U_ZERO_ERROR;
u_setDataDirectory(dataDir);
u_init(&status);
TEST_ASSERT(gIncCount == 0);
TEST_ASSERT(gDecCount == 0);
status = U_ZERO_ERROR;
umtx_atomic_inc(&t);
umtx_atomic_dec(&t);
TEST_STATUS(status, U_ZERO_ERROR);
TEST_ASSERT(gIncCount == 0);
TEST_ASSERT(gDecCount == 0);
free(dataDir);
}
static void TestMutexFunctions() {
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *rb = NULL;
char *icuDataDir;
gMutexFailures = 0;
/* Save initial ICU state so that it can be restored later.
* u_cleanup(), which is called in this test, resets ICU's state.
*/
icuDataDir = safeGetICUDataDirectory();
/* Verify that ICU can be cleaned up and reinitialized successfully.
* Failure here usually means that some ICU service didn't clean up successfully,
* probably because some earlier test accidently left something open. */
ctest_resetICU();
/* Can not set mutex functions if ICU is already initialized */
u_setMutexFunctions(&gContext, myMutexInit, myMutexDestroy, myMutexLock, myMutexUnlock, &status);
TEST_STATUS(status, U_INVALID_STATE_ERROR);
/* Un-initialize ICU */
u_cleanup();
/* Can not set Mutex functions with NULL values */
status = U_ZERO_ERROR;
u_setMutexFunctions(&gContext, NULL, myMutexDestroy, myMutexLock, myMutexUnlock, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
status = U_ZERO_ERROR;
u_setMutexFunctions(&gContext, myMutexInit, NULL, myMutexLock, myMutexUnlock, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
status = U_ZERO_ERROR;
u_setMutexFunctions(&gContext, myMutexInit, myMutexDestroy, NULL, myMutexUnlock, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
status = U_ZERO_ERROR;
u_setMutexFunctions(&gContext, myMutexInit, myMutexDestroy, myMutexLock, NULL, &status);
TEST_STATUS(status, U_ILLEGAL_ARGUMENT_ERROR);
/* u_setMutexFunctions() should work with null or non-null context pointer */
status = U_ZERO_ERROR;
u_setMutexFunctions(&gContext, myMutexInit, myMutexDestroy, myMutexLock, myMutexUnlock, &status);
TEST_STATUS(status, U_ZERO_ERROR);
u_setMutexFunctions(&gContext, myMutexInit, myMutexDestroy, myMutexLock, myMutexUnlock, &status);
TEST_STATUS(status, U_ZERO_ERROR);
/* After reinitializing ICU, we should not be able to set the mutex funcs again. */
status = U_ZERO_ERROR;
u_setDataDirectory(icuDataDir);
u_init(&status);
TEST_STATUS(status, U_ZERO_ERROR);
u_setMutexFunctions(&gContext, myMutexInit, myMutexDestroy, myMutexLock, myMutexUnlock, &status);
TEST_STATUS(status, U_INVALID_STATE_ERROR);
/* Doing ICU operations should cause allocations to come through our test mutexes */
gBlockCount = 0;
status = U_ZERO_ERROR;
rb = ures_open(NULL, "es", &status);
TEST_STATUS(status, U_ZERO_ERROR);
TEST_ASSERT(gTotalMutexesInitialized > 0);
TEST_ASSERT(gTotalMutexesActive > 0);
ures_close(rb);
/* Cleanup should destroy all of the mutexes. */
ctest_resetICU();
status = U_ZERO_ERROR;
TEST_ASSERT(gTotalMutexesInitialized > 0);
TEST_ASSERT(gTotalMutexesActive == 0);
/* Additional ICU operations should no longer use our dummy test mutexes */
gTotalMutexesInitialized = 0;
gTotalMutexesActive = 0;
u_init(&status);
TEST_STATUS(status, U_ZERO_ERROR);
status = U_ZERO_ERROR;
rb = ures_open(NULL, "fr", &status);
TEST_STATUS(status, U_ZERO_ERROR);
TEST_ASSERT(gTotalMutexesInitialized == 0);
TEST_ASSERT(gTotalMutexesActive == 0);
ures_close(rb);
free(icuDataDir);
if(gMutexFailures) {
log_info("Note: these failures may be caused by ICU failing to initialize/uninitialize properly.\n");
log_verbose("Check for prior tests which may not have closed all open resources. See the internal function ures_flushCache()\n");
}
}
//----------------------------------------------------------------------------
//
// main for gencfu
//
//----------------------------------------------------------------------------
int main(int argc, char **argv) {
UErrorCode status = U_ZERO_ERROR;
const char *confFileName;
const char *confWSFileName;
const char *outFileName;
const char *outDir = NULL;
const char *copyright = NULL;
//
// Pick up and check the command line arguments,
// using the standard ICU tool utils option handling.
//
U_MAIN_INIT_ARGS(argc, argv);
progName = argv[0];
argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);
if(argc<0) {
// Unrecognized option
fprintf(stderr, "error in command line argument \"%s\"\n", argv[-argc]);
usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
}
if(options[0].doesOccur || options[1].doesOccur) {
// -? or -h for help.
usageAndDie(0);
}
if (!(options[3].doesOccur && options[4].doesOccur && options[5].doesOccur)) {
fprintf(stderr, "confusables file, whole script confusables file and output file must all be specified.\n");
usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
}
confFileName = options[3].value;
confWSFileName = options[4].value;
outFileName = options[5].value;
if (options[6].doesOccur) {
u_setDataDirectory(options[6].value);
}
status = U_ZERO_ERROR;
/* Combine the directory with the file name */
if(options[7].doesOccur) {
outDir = options[7].value;
}
if (options[8].doesOccur) {
copyright = U_COPYRIGHT_STRING;
}
#if UCONFIG_NO_REGULAR_EXPRESSIONS || UCONFIG_NO_NORMALIZATION || UCONFIG_NO_FILE_IO
// spoof detection data file parsing is dependent on regular expressions.
// TODO: have the tool return an error status. Requires fixing the ICU data build
// so that it doesn't abort entirely on that error.
UNewDataMemory *pData;
char msg[1024];
/* write message with just the name */
sprintf(msg, "gencfu writes dummy %s because of UCONFIG_NO_REGULAR_EXPRESSIONS and/or UCONFIG_NO_NORMALIZATION and/or UCONFIG_NO_FILE_IO, see uconfig.h", outFileName);
fprintf(stderr, "%s\n", msg);
/* write the dummy data file */
pData = udata_create(outDir, NULL, outFileName, &dummyDataInfo, NULL, &status);
udata_writeBlock(pData, msg, strlen(msg));
udata_finish(pData, &status);
return (int)status;
#else
/* Initialize ICU */
u_init(&status);
if (U_FAILURE(status)) {
fprintf(stderr, "%s: can not initialize ICU. status = %s\n",
argv[0], u_errorName(status));
exit(1);
}
status = U_ZERO_ERROR;
// Read in the confusables source file
int32_t confusablesLen = 0;
const char *confusables = readFile(confFileName, &confusablesLen);
if (confusables == NULL) {
printf("gencfu: error reading file \"%s\"\n", confFileName);
exit(-1);
}
int32_t wsConfusablesLen = 0;
const char *wsConfsables = readFile(confWSFileName, &wsConfusablesLen);
if (wsConfsables == NULL) {
printf("gencfu: error reading file \"%s\"\n", confFileName);
exit(-1);
}
//
// Create the Spoof Detector from the source confusables files.
// This will compile the data.
//
UParseError parseError;
parseError.line = 0;
parseError.offset = 0;
int32_t errType;
USpoofChecker *sc = uspoof_openFromSource(confusables, confusablesLen,
wsConfsables, wsConfusablesLen,
&errType, &parseError, &status);
if (U_FAILURE(status)) {
const char *errFile =
(errType == USPOOF_WHOLE_SCRIPT_CONFUSABLE)? confWSFileName : confFileName;
fprintf(stderr, "gencfu: uspoof_openFromSource error \"%s\" at file %s, line %d, column %d\n",
u_errorName(status), errFile, (int)parseError.line, (int)parseError.offset);
exit(status);
};
//
// Get the compiled rule data from the USpoofChecker.
//
uint32_t outDataSize;
uint8_t *outData;
outDataSize = uspoof_serialize(sc, NULL, 0, &status);
if (status != U_BUFFER_OVERFLOW_ERROR) {
fprintf(stderr, "gencfu: uspoof_serialize() returned %s\n", u_errorName(status));
exit(status);
}
status = U_ZERO_ERROR;
outData = new uint8_t[outDataSize];
uspoof_serialize(sc, outData, outDataSize, &status);
// Copy the data format version numbers from the spoof data header into the UDataMemory header.
uprv_memcpy(dh.info.formatVersion,
reinterpret_cast<SpoofDataHeader *>(outData)->fFormatVersion,
sizeof(dh.info.formatVersion));
//
// Create the output file
//
size_t bytesWritten;
UNewDataMemory *pData;
pData = udata_create(outDir, NULL, outFileName, &(dh.info), copyright, &status);
if(U_FAILURE(status)) {
fprintf(stderr, "gencfu: Could not open output file \"%s\", \"%s\"\n",
outFileName, u_errorName(status));
exit(status);
}
// Write the data itself.
udata_writeBlock(pData, outData, outDataSize);
// finish up
bytesWritten = udata_finish(pData, &status);
if(U_FAILURE(status)) {
fprintf(stderr, "gencfu: Error %d writing the output file\n", status);
exit(status);
}
if (bytesWritten != outDataSize) {
fprintf(stderr, "gencfu: Error writing to output file \"%s\"\n", outFileName);
exit(-1);
}
uspoof_close(sc);
delete [] outData;
delete [] confusables;
delete [] wsConfsables;
u_cleanup();
printf("gencfu: tool completed successfully.\n");
return 0;
#endif // UCONFIG_NO_REGULAR_EXPRESSIONS
}
int main(int argc, const char* const argv[])
{
int nerrors = 0;
UBool defaultDataFound;
TestNode *root;
const char *warnOrErr = "Failure";
UDate startTime, endTime;
int32_t diffTime;
/* initial check for the default converter */
UErrorCode errorCode = U_ZERO_ERROR;
UResourceBundle *rb;
UConverter *cnv;
U_MAIN_INIT_ARGS(argc, argv);
startTime = uprv_getRawUTCtime();
gOrigArgc = argc;
gOrigArgv = argv;
if (!initArgs(argc, argv, NULL, NULL)) {
/* Error already displayed. */
return -1;
}
/* Check whether ICU will initialize without forcing the build data directory into
* the ICU_DATA path. Success here means either the data dll contains data, or that
* this test program was run with ICU_DATA set externally. Failure of this check
* is normal when ICU data is not packaged into a shared library.
*
* Whether or not this test succeeds, we want to cleanup and reinitialize
* with a data path so that data loading from individual files can be tested.
*/
defaultDataFound = TRUE;
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### Note: ICU Init without build-specific setDataDirectory() failed. %s\n", u_errorName(errorCode));
defaultDataFound = FALSE;
}
u_cleanup();
#ifdef URES_DEBUG
fprintf(stderr, "After initial u_cleanup: RB cache %s empty.\n", ures_dumpCacheContents()?"WAS NOT":"was");
#endif
while (getTestOption(REPEAT_TESTS_OPTION) > 0) { /* Loop runs once per complete execution of the tests
* used for -r (repeat) test option. */
if (!initArgs(argc, argv, NULL, NULL)) {
/* Error already displayed. */
return -1;
}
errorCode = U_ZERO_ERROR;
/* Initialize ICU */
if (!defaultDataFound) {
ctest_setICU_DATA(); /* u_setDataDirectory() must happen Before u_init() */
}
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### ERROR! %s: u_init() failed with status = \"%s\".\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", argv[0], u_errorName(errorCode));
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exiting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
/* try more data */
cnv = ucnv_open(TRY_CNV_2, &errorCode);
if(cnv != 0) {
/* ok */
ucnv_close(cnv);
} else {
fprintf(stderr,
"*** %s! The converter for " TRY_CNV_2 " cannot be opened.\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", warnOrErr);
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exitting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
rb = ures_open(NULL, "en", &errorCode);
if(U_SUCCESS(errorCode)) {
/* ok */
ures_close(rb);
} else {
fprintf(stderr,
"*** %s! The \"en\" locale resource bundle cannot be opened.\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", warnOrErr);
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exitting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
errorCode = U_ZERO_ERROR;
rb = ures_open(NULL, NULL, &errorCode);
if(U_SUCCESS(errorCode)) {
/* ok */
if (errorCode == U_USING_DEFAULT_WARNING || errorCode == U_USING_FALLBACK_WARNING) {
fprintf(stderr,
"#### Note: The default locale %s is not available\n", uloc_getDefault());
}
ures_close(rb);
} else {
fprintf(stderr,
"*** %s! Can not open a resource bundle for the default locale %s\n", warnOrErr, uloc_getDefault());
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exitting. Use the '-w' option if data files were\n"
"*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
fprintf(stdout, "Default locale for this run is %s\n", uloc_getDefault());
/* Build a tree of all tests.
* Subsequently will be used to find / iterate the tests to run */
root = NULL;
addAllTests(&root);
/* Tests acutally run HERE. TODO: separate command line option parsing & setting from test execution!! */
nerrors = runTestRequest(root, argc, argv);
setTestOption(REPEAT_TESTS_OPTION, DECREMENT_OPTION_VALUE);
if (getTestOption(REPEAT_TESTS_OPTION) > 0) {
printf("Repeating tests %d more time(s)\n", getTestOption(REPEAT_TESTS_OPTION));
}
cleanUpTestTree(root);
#ifdef CTST_LEAK_CHECK
ctst_freeAll();
/* To check for leaks */
u_cleanup(); /* nuke the hashtable.. so that any still-open cnvs are leaked */
if(getTestOption(VERBOSITY_OPTION) && ctst_allocated_total>0) {
fprintf(stderr,"ctst_freeAll(): cleaned up after %d allocations (queue of %d)\n", ctst_allocated_total, CTST_MAX_ALLOC);
}
#ifdef URES_DEBUG
if(ures_dumpCacheContents()) {
fprintf(stderr, "Error: After final u_cleanup, RB cache was not empty.\n");
nerrors++;
} else {
fprintf(stderr,"OK: After final u_cleanup, RB cache was empty.\n");
}
#endif
#endif
} /* End of loop that repeats the entire test, if requested. (Normally doesn't loop) */
#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS
unistr_printLengths();
#endif
endTime = uprv_getRawUTCtime();
diffTime = (int32_t)(endTime - startTime);
printf("Elapsed Time: %02d:%02d:%02d.%03d\n",
(int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR),
(int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE),
(int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND),
(int)(diffTime%U_MILLIS_PER_SECOND));
return nerrors ? 1 : 0;
}