| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ******************************************************************************* | |
| 3 * | |
| 4 * Copyright (C) 1998-2014, International Business Machines | |
| 5 * Corporation and others. All Rights Reserved. | |
| 6 * | |
| 7 ******************************************************************************* | |
| 8 * | |
| 9 * File genrb.c | |
| 10 * | |
| 11 * Modification History: | |
| 12 * | |
| 13 * Date Name Description | |
| 14 * 05/25/99 stephen Creation. | |
| 15 * 5/10/01 Ram removed ustdio dependency | |
| 16 ******************************************************************************* | |
| 17 */ | |
| 18 | |
| 19 #include "genrb.h" | |
| 20 #include "unicode/uclean.h" | |
| 21 | |
| 22 #include "ucmndata.h" /* TODO: for reading the pool bundle */ | |
| 23 | |
| 24 /* Protos */ | |
| 25 void processFile(const char *filename, const char* cp, const char *inputDir, co
nst char *outputDir, | |
| 26 const char *packageName, UBool omitBinaryCollation, UErrorCode *status); | |
| 27 static char *make_res_filename(const char *filename, const char *outputDir, | |
| 28 const char *packageName, UErrorCode *status); | |
| 29 | |
| 30 /* File suffixes */ | |
| 31 #define RES_SUFFIX ".res" | |
| 32 #define COL_SUFFIX ".col" | |
| 33 | |
| 34 static char theCurrentFileName[2048]; | |
| 35 const char *gCurrentFileName = theCurrentFileName; | |
| 36 #ifdef XP_MAC_CONSOLE | |
| 37 #include <console.h> | |
| 38 #endif | |
| 39 | |
| 40 enum | |
| 41 { | |
| 42 HELP1, | |
| 43 HELP2, | |
| 44 VERBOSE, | |
| 45 QUIET, | |
| 46 VERSION, | |
| 47 SOURCEDIR, | |
| 48 DESTDIR, | |
| 49 ENCODING, | |
| 50 ICUDATADIR, | |
| 51 WRITE_JAVA, | |
| 52 COPYRIGHT, | |
| 53 JAVA_PACKAGE, | |
| 54 BUNDLE_NAME, | |
| 55 WRITE_XLIFF, | |
| 56 STRICT, | |
| 57 NO_BINARY_COLLATION, | |
| 58 LANGUAGE, | |
| 59 NO_COLLATION_RULES, | |
| 60 FORMAT_VERSION, | |
| 61 WRITE_POOL_BUNDLE, | |
| 62 USE_POOL_BUNDLE, | |
| 63 INCLUDE_UNIHAN_COLL | |
| 64 }; | |
| 65 | |
| 66 UOption options[]={ | |
| 67 UOPTION_HELP_H, | |
| 68 UOPTION_HELP_QUESTION_MARK, | |
| 69 UOPTION_VERBOSE, | |
| 70 UOPTION_QUIET, | |
| 71 UOPTION_VERSION, | |
| 72 UOPTION_SOURCEDIR, | |
| 73 UOPTION_DESTDIR, | |
| 74 UOPTION_ENCODING, | |
| 75 UOPTION_ICUDATADIR, | |
| 76 UOPTION_WRITE_JAVA, | |
| 77 UOPTION_COPYRIGHT, | |
| 78 UOPTION_DEF("java-package", '\x01', UOPT_REQUIRES_ARG), | |
| 79 UOPTION_BUNDLE_NAME, | |
| 80 UOPTION_DEF("write-xliff", 'x', UOPT_OPTIONAL_ARG), | |
| 81 UOPTION_DEF("strict", 'k', UOPT_NO_ARG), /* 14 */ | |
| 82 UOPTION_DEF("noBinaryCollation", 'C', UOPT_NO_ARG),/* 15 *
/ | |
| 83 UOPTION_DEF("language", 'l', UOPT_REQUIRES_ARG), /* 16 */ | |
| 84 UOPTION_DEF("omitCollationRules", 'R', UOPT_NO_ARG),/* 17
*/ | |
| 85 UOPTION_DEF("formatVersion", '\x01', UOPT_REQUIRES_ARG),/*
18 */ | |
| 86 UOPTION_DEF("writePoolBundle", '\x01', UOPT_NO_ARG),/* 19
*/ | |
| 87 UOPTION_DEF("usePoolBundle", '\x01', UOPT_OPTIONAL_ARG),/*
20 */ | |
| 88 UOPTION_DEF("includeUnihanColl", '\x01', UOPT_NO_ARG),/* 2
1 */ /* temporary, don't display in usage info */ | |
| 89 }; | |
| 90 | |
| 91 static UBool write_java = FALSE; | |
| 92 static UBool write_xliff = FALSE; | |
| 93 static const char* outputEnc =""; | |
| 94 static struct SRBRoot *newPoolBundle = NULL; | |
| 95 | |
| 96 /* TODO: separate header file for ResFile? */ | |
| 97 typedef struct ResFile { | |
| 98 uint8_t *fBytes; | |
| 99 const int32_t *fIndexes; | |
| 100 const char *fKeys; | |
| 101 int32_t fKeysLength; | |
| 102 int32_t fKeysCount; | |
| 103 int32_t fChecksum; | |
| 104 } ResFile; | |
| 105 | |
| 106 static ResFile poolBundle = { NULL }; | |
| 107 | |
| 108 /*added by Jing*/ | |
| 109 static const char* language = NULL; | |
| 110 static const char* xliffOutputFileName = NULL; | |
| 111 int | |
| 112 main(int argc, | |
| 113 char* argv[]) | |
| 114 { | |
| 115 UErrorCode status = U_ZERO_ERROR; | |
| 116 const char *arg = NULL; | |
| 117 const char *outputDir = NULL; /* NULL = no output directory, use current */ | |
| 118 const char *inputDir = NULL; | |
| 119 const char *encoding = ""; | |
| 120 int i; | |
| 121 UBool illegalArg = FALSE; | |
| 122 | |
| 123 U_MAIN_INIT_ARGS(argc, argv); | |
| 124 | |
| 125 options[JAVA_PACKAGE].value = "com.ibm.icu.impl.data"; | |
| 126 options[BUNDLE_NAME].value = "LocaleElements"; | |
| 127 argc = u_parseArgs(argc, argv, (int32_t)(sizeof(options)/sizeof(options[0]))
, options); | |
| 128 | |
| 129 /* error handling, printing usage message */ | |
| 130 if(argc<0) { | |
| 131 fprintf(stderr, "%s: error in command line argument \"%s\"\n", argv[0],
argv[-argc]); | |
| 132 } else if(argc<2) { | |
| 133 argc = -1; | |
| 134 } | |
| 135 if(options[WRITE_POOL_BUNDLE].doesOccur && options[USE_POOL_BUNDLE].doesOccu
r) { | |
| 136 fprintf(stderr, "%s: cannot combine --writePoolBundle and --usePoolBundl
e\n", argv[0]); | |
| 137 argc = -1; | |
| 138 } | |
| 139 if(options[FORMAT_VERSION].doesOccur) { | |
| 140 const char *s = options[FORMAT_VERSION].value; | |
| 141 if(uprv_strlen(s) != 1 || (s[0] != '1' && s[0] != '2')) { | |
| 142 fprintf(stderr, "%s: unsupported --formatVersion %s\n", argv[0], s); | |
| 143 argc = -1; | |
| 144 } else if(s[0] == '1' && | |
| 145 (options[WRITE_POOL_BUNDLE].doesOccur || options[USE_POOL_BUND
LE].doesOccur) | |
| 146 ) { | |
| 147 fprintf(stderr, "%s: cannot combine --formatVersion 1 with --writePo
olBundle or --usePoolBundle\n", argv[0]); | |
| 148 argc = -1; | |
| 149 } else { | |
| 150 setFormatVersion(s[0] - '0'); | |
| 151 } | |
| 152 } | |
| 153 | |
| 154 if(options[VERSION].doesOccur) { | |
| 155 fprintf(stderr, | |
| 156 "%s version %s (ICU version %s).\n" | |
| 157 "%s\n", | |
| 158 argv[0], GENRB_VERSION, U_ICU_VERSION, U_COPYRIGHT_STRING); | |
| 159 return U_ZERO_ERROR; | |
| 160 } | |
| 161 | |
| 162 if(argc<0) { | |
| 163 illegalArg = TRUE; | |
| 164 } else if((options[JAVA_PACKAGE].doesOccur || options[BUNDLE_NAME].doesOccur
) && | |
| 165 !options[WRITE_JAVA].doesOccur) { | |
| 166 fprintf(stderr, | |
| 167 "%s error: command line argument --java-package or --bundle-name
" | |
| 168 "without --write-java\n", | |
| 169 argv[0]); | |
| 170 illegalArg = TRUE; | |
| 171 } | |
| 172 | |
| 173 if(illegalArg || options[HELP1].doesOccur || options[HELP2].doesOccur) { | |
| 174 /* | |
| 175 * Broken into chunks because the C89 standard says the minimum | |
| 176 * required supported string length is 509 bytes. | |
| 177 */ | |
| 178 fprintf(stderr, | |
| 179 "Usage: %s [OPTIONS] [FILES]\n" | |
| 180 "\tReads the list of resource bundle source files and creates\n" | |
| 181 "\tbinary version of resource bundles (.res files)\n", | |
| 182 argv[0]); | |
| 183 fprintf(stderr, | |
| 184 "Options:\n" | |
| 185 "\t-h or -? or --help this usage text\n" | |
| 186 "\t-q or --quiet do not display warnings\n" | |
| 187 "\t-v or --verbose print extra information when process
ing files\n" | |
| 188 "\t-V or --version prints out version number and exits\
n" | |
| 189 "\t-c or --copyright include copyright notice\n"); | |
| 190 fprintf(stderr, | |
| 191 "\t-e or --encoding encoding of source files\n" | |
| 192 "\t-d of --destdir destination directory, followed by t
he path, defaults to %s\n" | |
| 193 "\t-s or --sourcedir source directory for files followed
by path, defaults to %s\n" | |
| 194 "\t-i or --icudatadir directory for locating any needed in
termediate data files,\n" | |
| 195 "\t followed by path, defaults to %s\n", | |
| 196 u_getDataDirectory(), u_getDataDirectory(), u_getDataDirectory()
); | |
| 197 fprintf(stderr, | |
| 198 "\t-j or --write-java write a Java ListResourceBundle for
ICU4J, followed by optional encoding\n" | |
| 199 "\t defaults to ASCII and \\uXXXX format
.\n" | |
| 200 "\t --java-package For --write-java: package name for w
riting the ListResourceBundle,\n" | |
| 201 "\t defaults to com.ibm.icu.impl.data\n"
); | |
| 202 fprintf(stderr, | |
| 203 "\t-b or --bundle-name For --write-java: root resource bund
le name for writing the ListResourceBundle,\n" | |
| 204 "\t defaults to LocaleElements\n" | |
| 205 "\t-x or --write-xliff write an XLIFF file for the resource
bundle. Followed by\n" | |
| 206 "\t an optional output file name.\n" | |
| 207 "\t-k or --strict use pedantic parsing of syntax\n" | |
| 208 /*added by Jing*/ | |
| 209 "\t-l or --language for XLIFF: language code compliant w
ith BCP 47.\n"); | |
| 210 fprintf(stderr, | |
| 211 "\t-C or --noBinaryCollation do not generate binary collation i
mage;\n" | |
| 212 "\t makes .res file smaller but collat
or instantiation much slower;\n" | |
| 213 "\t maintains ability to get tailoring
rules\n" | |
| 214 "\t-R or --omitCollationRules do not include collation (tailorin
g) rules;\n" | |
| 215 "\t makes .res file smaller and mainta
ins collator instantiation speed\n" | |
| 216 "\t but tailoring rules will not be av
ailable (they are rarely used)\n"); | |
| 217 fprintf(stderr, | |
| 218 "\t --formatVersion write a .res file compatible with
the requested formatVersion (single digit);\n" | |
| 219 "\t for example, --formatVersion 1\n")
; | |
| 220 fprintf(stderr, | |
| 221 "\t --writePoolBundle write a pool.res file with all of
the keys of all input bundles\n" | |
| 222 "\t --usePoolBundle [path-to-pool.res] point to keys from
the pool.res keys pool bundle if they are available there;\n" | |
| 223 "\t makes .res files smaller but depen
dent on the pool bundle\n" | |
| 224 "\t (--writePoolBundle and --usePoolBu
ndle cannot be combined)\n"); | |
| 225 | |
| 226 return illegalArg ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR; | |
| 227 } | |
| 228 | |
| 229 if(options[VERBOSE].doesOccur) { | |
| 230 setVerbose(TRUE); | |
| 231 } | |
| 232 | |
| 233 if(options[QUIET].doesOccur) { | |
| 234 setShowWarning(FALSE); | |
| 235 } | |
| 236 if(options[STRICT].doesOccur) { | |
| 237 setStrict(TRUE); | |
| 238 } | |
| 239 if(options[COPYRIGHT].doesOccur){ | |
| 240 setIncludeCopyright(TRUE); | |
| 241 } | |
| 242 | |
| 243 if(options[SOURCEDIR].doesOccur) { | |
| 244 inputDir = options[SOURCEDIR].value; | |
| 245 } | |
| 246 | |
| 247 if(options[DESTDIR].doesOccur) { | |
| 248 outputDir = options[DESTDIR].value; | |
| 249 } | |
| 250 | |
| 251 if(options[ENCODING].doesOccur) { | |
| 252 encoding = options[ENCODING].value; | |
| 253 } | |
| 254 | |
| 255 if(options[ICUDATADIR].doesOccur) { | |
| 256 u_setDataDirectory(options[ICUDATADIR].value); | |
| 257 } | |
| 258 /* Initialize ICU */ | |
| 259 u_init(&status); | |
| 260 if (U_FAILURE(status) && status != U_FILE_ACCESS_ERROR) { | |
| 261 /* Note: u_init() will try to open ICU property data. | |
| 262 * failures here are expected when building ICU from scratch. | |
| 263 * ignore them. | |
| 264 */ | |
| 265 fprintf(stderr, "%s: can not initialize ICU. status = %s\n", | |
| 266 argv[0], u_errorName(status)); | |
| 267 exit(1); | |
| 268 } | |
| 269 status = U_ZERO_ERROR; | |
| 270 if(options[WRITE_JAVA].doesOccur) { | |
| 271 write_java = TRUE; | |
| 272 outputEnc = options[WRITE_JAVA].value; | |
| 273 } | |
| 274 | |
| 275 if(options[WRITE_XLIFF].doesOccur) { | |
| 276 write_xliff = TRUE; | |
| 277 if(options[WRITE_XLIFF].value != NULL){ | |
| 278 xliffOutputFileName = options[WRITE_XLIFF].value; | |
| 279 } | |
| 280 } | |
| 281 | |
| 282 initParser(); | |
| 283 | |
| 284 /*added by Jing*/ | |
| 285 if(options[LANGUAGE].doesOccur) { | |
| 286 language = options[LANGUAGE].value; | |
| 287 } | |
| 288 | |
| 289 if(options[WRITE_POOL_BUNDLE].doesOccur) { | |
| 290 newPoolBundle = bundle_open(NULL, TRUE, &status); | |
| 291 if(U_FAILURE(status)) { | |
| 292 fprintf(stderr, "unable to create an empty bundle for the pool keys:
%s\n", u_errorName(status)); | |
| 293 return status; | |
| 294 } else { | |
| 295 const char *poolResName = "pool.res"; | |
| 296 char *nameWithoutSuffix = uprv_malloc(uprv_strlen(poolResName) + 1); | |
| 297 if (nameWithoutSuffix == NULL) { | |
| 298 fprintf(stderr, "out of memory error\n"); | |
| 299 return U_MEMORY_ALLOCATION_ERROR; | |
| 300 } | |
| 301 uprv_strcpy(nameWithoutSuffix, poolResName); | |
| 302 *uprv_strrchr(nameWithoutSuffix, '.') = 0; | |
| 303 newPoolBundle->fLocale = nameWithoutSuffix; | |
| 304 } | |
| 305 } | |
| 306 | |
| 307 if(options[USE_POOL_BUNDLE].doesOccur) { | |
| 308 const char *poolResName = "pool.res"; | |
| 309 FileStream *poolFile; | |
| 310 int32_t poolFileSize; | |
| 311 int32_t indexLength; | |
| 312 /* | |
| 313 * TODO: Consolidate inputDir/filename handling from main() and processF
ile() | |
| 314 * into a common function, and use it here as well. | |
| 315 * Try to create toolutil functions for dealing with dir/filenames and | |
| 316 * loading ICU data files without udata_open(). | |
| 317 * Share code with icupkg? | |
| 318 * Also, make_res_filename() seems to be unused. Review and remove. | |
| 319 */ | |
| 320 if (options[USE_POOL_BUNDLE].value!=NULL) { | |
| 321 uprv_strcpy(theCurrentFileName, options[USE_POOL_BUNDLE].value); | |
| 322 uprv_strcat(theCurrentFileName, U_FILE_SEP_STRING); | |
| 323 } else if (inputDir) { | |
| 324 uprv_strcpy(theCurrentFileName, inputDir); | |
| 325 uprv_strcat(theCurrentFileName, U_FILE_SEP_STRING); | |
| 326 } else { | |
| 327 *theCurrentFileName = 0; | |
| 328 } | |
| 329 uprv_strcat(theCurrentFileName, poolResName); | |
| 330 poolFile = T_FileStream_open(theCurrentFileName, "rb"); | |
| 331 if (poolFile == NULL) { | |
| 332 fprintf(stderr, "unable to open pool bundle file %s\n", theCurrentFi
leName); | |
| 333 return 1; | |
| 334 } | |
| 335 poolFileSize = T_FileStream_size(poolFile); | |
| 336 if (poolFileSize < 32) { | |
| 337 fprintf(stderr, "the pool bundle file %s is too small\n", theCurrent
FileName); | |
| 338 return 1; | |
| 339 } | |
| 340 poolBundle.fBytes = (uint8_t *)uprv_malloc((poolFileSize + 15) & ~15); | |
| 341 if (poolFileSize > 0 && poolBundle.fBytes == NULL) { | |
| 342 fprintf(stderr, "unable to allocate memory for the pool bundle file
%s\n", theCurrentFileName); | |
| 343 return U_MEMORY_ALLOCATION_ERROR; | |
| 344 } else { | |
| 345 UDataSwapper *ds; | |
| 346 const DataHeader *header; | |
| 347 int32_t bytesRead = T_FileStream_read(poolFile, poolBundle.fBytes, p
oolFileSize); | |
| 348 int32_t keysBottom; | |
| 349 if (bytesRead != poolFileSize) { | |
| 350 fprintf(stderr, "unable to read the pool bundle file %s\n", theC
urrentFileName); | |
| 351 return 1; | |
| 352 } | |
| 353 /* | |
| 354 * Swap the pool bundle so that a single checked-in file can be used
. | |
| 355 * The swapper functions also test that the data looks like | |
| 356 * a well-formed .res file. | |
| 357 */ | |
| 358 ds = udata_openSwapperForInputData(poolBundle.fBytes, bytesRead, | |
| 359 U_IS_BIG_ENDIAN, U_CHARSET_FAMILY
, &status); | |
| 360 if (U_FAILURE(status)) { | |
| 361 fprintf(stderr, "udata_openSwapperForInputData(pool bundle %s) f
ailed: %s\n", | |
| 362 theCurrentFileName, u_errorName(status)); | |
| 363 return status; | |
| 364 } | |
| 365 ures_swap(ds, poolBundle.fBytes, bytesRead, poolBundle.fBytes, &stat
us); | |
| 366 udata_closeSwapper(ds); | |
| 367 if (U_FAILURE(status)) { | |
| 368 fprintf(stderr, "ures_swap(pool bundle %s) failed: %s\n", | |
| 369 theCurrentFileName, u_errorName(status)); | |
| 370 return status; | |
| 371 } | |
| 372 header = (const DataHeader *)poolBundle.fBytes; | |
| 373 if (header->info.formatVersion[0]!=2) { | |
| 374 fprintf(stderr, "invalid format of pool bundle file %s\n", theCu
rrentFileName); | |
| 375 return U_INVALID_FORMAT_ERROR; | |
| 376 } | |
| 377 poolBundle.fKeys = (const char *)header + header->dataHeader.headerS
ize; | |
| 378 poolBundle.fIndexes = (const int32_t *)poolBundle.fKeys + 1; | |
| 379 indexLength = poolBundle.fIndexes[URES_INDEX_LENGTH] & 0xff; | |
| 380 if (indexLength <= URES_INDEX_POOL_CHECKSUM) { | |
| 381 fprintf(stderr, "insufficient indexes[] in pool bundle file %s\n
", theCurrentFileName); | |
| 382 return U_INVALID_FORMAT_ERROR; | |
| 383 } | |
| 384 keysBottom = (1 + indexLength) * 4; | |
| 385 poolBundle.fKeys += keysBottom; | |
| 386 poolBundle.fKeysLength = (poolBundle.fIndexes[URES_INDEX_KEYS_TOP] *
4) - keysBottom; | |
| 387 poolBundle.fChecksum = poolBundle.fIndexes[URES_INDEX_POOL_CHECKSUM]
; | |
| 388 } | |
| 389 for (i = 0; i < poolBundle.fKeysLength; ++i) { | |
| 390 if (poolBundle.fKeys[i] == 0) { | |
| 391 ++poolBundle.fKeysCount; | |
| 392 } | |
| 393 } | |
| 394 T_FileStream_close(poolFile); | |
| 395 setUsePoolBundle(TRUE); | |
| 396 } | |
| 397 | |
| 398 if(options[INCLUDE_UNIHAN_COLL].doesOccur) { | |
| 399 puts("genrb option --includeUnihanColl ignored: \n" | |
| 400 "CLDR 26/ICU 54 unihan data is small, except\n" | |
| 401 "the ucadata-unihan.icu version of the collation root data\n" | |
| 402 "is about 300kB larger than the ucadata-implicithan.icu version.
"); | |
| 403 } | |
| 404 | |
| 405 if((argc-1)!=1) { | |
| 406 printf("genrb number of files: %d\n", argc - 1); | |
| 407 } | |
| 408 /* generate the binary files */ | |
| 409 for(i = 1; i < argc; ++i) { | |
| 410 status = U_ZERO_ERROR; | |
| 411 arg = getLongPathname(argv[i]); | |
| 412 | |
| 413 if (inputDir) { | |
| 414 uprv_strcpy(theCurrentFileName, inputDir); | |
| 415 uprv_strcat(theCurrentFileName, U_FILE_SEP_STRING); | |
| 416 } else { | |
| 417 *theCurrentFileName = 0; | |
| 418 } | |
| 419 uprv_strcat(theCurrentFileName, arg); | |
| 420 | |
| 421 if (isVerbose()) { | |
| 422 printf("Processing file \"%s\"\n", theCurrentFileName); | |
| 423 } | |
| 424 processFile(arg, encoding, inputDir, outputDir, NULL, | |
| 425 options[NO_BINARY_COLLATION].doesOccur, | |
| 426 &status); | |
| 427 } | |
| 428 | |
| 429 uprv_free(poolBundle.fBytes); | |
| 430 | |
| 431 if(options[WRITE_POOL_BUNDLE].doesOccur) { | |
| 432 char outputFileName[256]; | |
| 433 bundle_write(newPoolBundle, outputDir, NULL, outputFileName, sizeof(outp
utFileName), &status); | |
| 434 bundle_close(newPoolBundle, &status); | |
| 435 if(U_FAILURE(status)) { | |
| 436 fprintf(stderr, "unable to write the pool bundle: %s\n", u_errorName
(status)); | |
| 437 } | |
| 438 } | |
| 439 | |
| 440 u_cleanup(); | |
| 441 | |
| 442 /* Dont return warnings as a failure */ | |
| 443 if (U_SUCCESS(status)) { | |
| 444 return 0; | |
| 445 } | |
| 446 | |
| 447 return status; | |
| 448 } | |
| 449 | |
| 450 /* Process a file */ | |
| 451 void | |
| 452 processFile( | |
| 453 const char *filename, const char *cp, const char *inputDir, const char *outp
utDir, const char *packageName, | |
| 454 UBool omitBinaryCollation, UErrorCode *status) { | |
| 455 /*FileStream *in = NULL;*/ | |
| 456 struct SRBRoot *data = NULL; | |
| 457 UCHARBUF *ucbuf = NULL; | |
| 458 char *rbname = NULL; | |
| 459 char *openFileName = NULL; | |
| 460 char *inputDirBuf = NULL; | |
| 461 | |
| 462 char outputFileName[256]; | |
| 463 | |
| 464 int32_t dirlen = 0; | |
| 465 int32_t filelen = 0; | |
| 466 | |
| 467 | |
| 468 if (status==NULL || U_FAILURE(*status)) { | |
| 469 return; | |
| 470 } | |
| 471 if(filename==NULL){ | |
| 472 *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| 473 return; | |
| 474 }else{ | |
| 475 filelen = (int32_t)uprv_strlen(filename); | |
| 476 } | |
| 477 | |
| 478 if(inputDir == NULL) { | |
| 479 const char *filenameBegin = uprv_strrchr(filename, U_FILE_SEP_CHAR); | |
| 480 openFileName = (char *) uprv_malloc(dirlen + filelen + 2); | |
| 481 openFileName[0] = '\0'; | |
| 482 if (filenameBegin != NULL) { | |
| 483 /* | |
| 484 * When a filename ../../../data/root.txt is specified, | |
| 485 * we presume that the input directory is ../../../data | |
| 486 * This is very important when the resource file includes | |
| 487 * another file, like UCARules.txt or thaidict.brk. | |
| 488 */ | |
| 489 int32_t filenameSize = (int32_t)(filenameBegin - filename + 1); | |
| 490 inputDirBuf = uprv_strncpy((char *)uprv_malloc(filenameSize), filena
me, filenameSize); | |
| 491 | |
| 492 /* test for NULL */ | |
| 493 if(inputDirBuf == NULL) { | |
| 494 *status = U_MEMORY_ALLOCATION_ERROR; | |
| 495 goto finish; | |
| 496 } | |
| 497 | |
| 498 inputDirBuf[filenameSize - 1] = 0; | |
| 499 inputDir = inputDirBuf; | |
| 500 dirlen = (int32_t)uprv_strlen(inputDir); | |
| 501 } | |
| 502 }else{ | |
| 503 dirlen = (int32_t)uprv_strlen(inputDir); | |
| 504 | |
| 505 if(inputDir[dirlen-1] != U_FILE_SEP_CHAR) { | |
| 506 openFileName = (char *) uprv_malloc(dirlen + filelen + 2); | |
| 507 | |
| 508 /* test for NULL */ | |
| 509 if(openFileName == NULL) { | |
| 510 *status = U_MEMORY_ALLOCATION_ERROR; | |
| 511 goto finish; | |
| 512 } | |
| 513 | |
| 514 openFileName[0] = '\0'; | |
| 515 /* | |
| 516 * append the input dir to openFileName if the first char in | |
| 517 * filename is not file seperation char and the last char input dire
ctory is not '.'. | |
| 518 * This is to support : | |
| 519 * genrb -s. /home/icu/data | |
| 520 * genrb -s. icu/data | |
| 521 * The user cannot mix notations like | |
| 522 * genrb -s. /icu/data --- the absolute path specified. -s redundant | |
| 523 * user should use | |
| 524 * genrb -s. icu/data --- start from CWD and look in icu/data dir | |
| 525 */ | |
| 526 if( (filename[0] != U_FILE_SEP_CHAR) && (inputDir[dirlen-1] !='.')){ | |
| 527 uprv_strcpy(openFileName, inputDir); | |
| 528 openFileName[dirlen] = U_FILE_SEP_CHAR; | |
| 529 } | |
| 530 openFileName[dirlen + 1] = '\0'; | |
| 531 } else { | |
| 532 openFileName = (char *) uprv_malloc(dirlen + filelen + 1); | |
| 533 | |
| 534 /* test for NULL */ | |
| 535 if(openFileName == NULL) { | |
| 536 *status = U_MEMORY_ALLOCATION_ERROR; | |
| 537 goto finish; | |
| 538 } | |
| 539 | |
| 540 uprv_strcpy(openFileName, inputDir); | |
| 541 | |
| 542 } | |
| 543 } | |
| 544 | |
| 545 uprv_strcat(openFileName, filename); | |
| 546 | |
| 547 ucbuf = ucbuf_open(openFileName, &cp,getShowWarning(),TRUE, status); | |
| 548 if(*status == U_FILE_ACCESS_ERROR) { | |
| 549 | |
| 550 fprintf(stderr, "couldn't open file %s\n", openFileName == NULL ? filena
me : openFileName); | |
| 551 goto finish; | |
| 552 } | |
| 553 if (ucbuf == NULL || U_FAILURE(*status)) { | |
| 554 fprintf(stderr, "An error occured processing file %s. Error: %s\n", open
FileName == NULL ? filename : openFileName,u_errorName(*status)); | |
| 555 goto finish; | |
| 556 } | |
| 557 /* auto detected popular encodings? */ | |
| 558 if (cp!=NULL && isVerbose()) { | |
| 559 printf("autodetected encoding %s\n", cp); | |
| 560 } | |
| 561 /* Parse the data into an SRBRoot */ | |
| 562 data = parse(ucbuf, inputDir, outputDir, filename, | |
| 563 !omitBinaryCollation, options[NO_COLLATION_RULES].doesOccur, st
atus); | |
| 564 | |
| 565 if (data == NULL || U_FAILURE(*status)) { | |
| 566 fprintf(stderr, "couldn't parse the file %s. Error:%s\n", filename,u_err
orName(*status)); | |
| 567 goto finish; | |
| 568 } | |
| 569 if(options[WRITE_POOL_BUNDLE].doesOccur) { | |
| 570 int32_t newKeysLength; | |
| 571 const char *newKeys, *newKeysLimit; | |
| 572 bundle_compactKeys(data, status); | |
| 573 newKeys = bundle_getKeyBytes(data, &newKeysLength); | |
| 574 bundle_addKeyBytes(newPoolBundle, newKeys, newKeysLength, status); | |
| 575 if(U_FAILURE(*status)) { | |
| 576 fprintf(stderr, "bundle_compactKeys(%s) or bundle_getKeyBytes() fail
ed: %s\n", | |
| 577 filename, u_errorName(*status)); | |
| 578 goto finish; | |
| 579 } | |
| 580 /* count the number of just-added key strings */ | |
| 581 for(newKeysLimit = newKeys + newKeysLength; newKeys < newKeysLimit; ++ne
wKeys) { | |
| 582 if(*newKeys == 0) { | |
| 583 ++newPoolBundle->fKeysCount; | |
| 584 } | |
| 585 } | |
| 586 } | |
| 587 | |
| 588 if(options[USE_POOL_BUNDLE].doesOccur) { | |
| 589 data->fPoolBundleKeys = poolBundle.fKeys; | |
| 590 data->fPoolBundleKeysLength = poolBundle.fKeysLength; | |
| 591 data->fPoolBundleKeysCount = poolBundle.fKeysCount; | |
| 592 data->fPoolChecksum = poolBundle.fChecksum; | |
| 593 } | |
| 594 | |
| 595 /* Determine the target rb filename */ | |
| 596 rbname = make_res_filename(filename, outputDir, packageName, status); | |
| 597 if(U_FAILURE(*status)) { | |
| 598 fprintf(stderr, "couldn't make the res fileName for bundle %s. Error:%s
\n", filename,u_errorName(*status)); | |
| 599 goto finish; | |
| 600 } | |
| 601 if(write_java== TRUE){ | |
| 602 bundle_write_java(data,outputDir,outputEnc, outputFileName, sizeof(outpu
tFileName), | |
| 603 options[JAVA_PACKAGE].value, options[BUNDLE_NAME].valu
e, status); | |
| 604 }else if(write_xliff ==TRUE){ | |
| 605 bundle_write_xml(data,outputDir,outputEnc, filename, outputFileName, siz
eof(outputFileName),language, xliffOutputFileName,status); | |
| 606 }else{ | |
| 607 /* Write the data to the file */ | |
| 608 bundle_write(data, outputDir, packageName, outputFileName, sizeof(output
FileName), status); | |
| 609 } | |
| 610 if (U_FAILURE(*status)) { | |
| 611 fprintf(stderr, "couldn't write bundle %s. Error:%s\n", outputFileName,u
_errorName(*status)); | |
| 612 } | |
| 613 bundle_close(data, status); | |
| 614 | |
| 615 finish: | |
| 616 | |
| 617 if (inputDirBuf != NULL) { | |
| 618 uprv_free(inputDirBuf); | |
| 619 } | |
| 620 | |
| 621 if (openFileName != NULL) { | |
| 622 uprv_free(openFileName); | |
| 623 } | |
| 624 | |
| 625 if(ucbuf) { | |
| 626 ucbuf_close(ucbuf); | |
| 627 } | |
| 628 | |
| 629 if (rbname) { | |
| 630 uprv_free(rbname); | |
| 631 } | |
| 632 } | |
| 633 | |
| 634 /* Generate the target .res file name from the input file name */ | |
| 635 static char* | |
| 636 make_res_filename(const char *filename, | |
| 637 const char *outputDir, | |
| 638 const char *packageName, | |
| 639 UErrorCode *status) { | |
| 640 char *basename; | |
| 641 char *dirname; | |
| 642 char *resName; | |
| 643 | |
| 644 int32_t pkgLen = 0; /* length of package prefix */ | |
| 645 | |
| 646 | |
| 647 if (U_FAILURE(*status)) { | |
| 648 return 0; | |
| 649 } | |
| 650 | |
| 651 if(packageName != NULL) | |
| 652 { | |
| 653 pkgLen = (int32_t)(1 + uprv_strlen(packageName)); | |
| 654 } | |
| 655 | |
| 656 /* setup */ | |
| 657 basename = dirname = resName = 0; | |
| 658 | |
| 659 /* determine basename, and compiled file names */ | |
| 660 basename = (char*) uprv_malloc(sizeof(char) * (uprv_strlen(filename) + 1)); | |
| 661 if(basename == 0) { | |
| 662 *status = U_MEMORY_ALLOCATION_ERROR; | |
| 663 goto finish; | |
| 664 } | |
| 665 | |
| 666 get_basename(basename, filename); | |
| 667 | |
| 668 dirname = (char*) uprv_malloc(sizeof(char) * (uprv_strlen(filename) + 1)); | |
| 669 if(dirname == 0) { | |
| 670 *status = U_MEMORY_ALLOCATION_ERROR; | |
| 671 goto finish; | |
| 672 } | |
| 673 | |
| 674 get_dirname(dirname, filename); | |
| 675 | |
| 676 if (outputDir == NULL) { | |
| 677 /* output in same dir as .txt */ | |
| 678 resName = (char*) uprv_malloc(sizeof(char) * (uprv_strlen(dirname) | |
| 679 + pkgLen | |
| 680 + uprv_strlen(basename) | |
| 681 + uprv_strlen(RES_SUFFIX) + 8)); | |
| 682 if(resName == 0) { | |
| 683 *status = U_MEMORY_ALLOCATION_ERROR; | |
| 684 goto finish; | |
| 685 } | |
| 686 | |
| 687 uprv_strcpy(resName, dirname); | |
| 688 | |
| 689 if(packageName != NULL) | |
| 690 { | |
| 691 uprv_strcat(resName, packageName); | |
| 692 uprv_strcat(resName, "_"); | |
| 693 } | |
| 694 | |
| 695 uprv_strcat(resName, basename); | |
| 696 | |
| 697 } else { | |
| 698 int32_t dirlen = (int32_t)uprv_strlen(outputDir); | |
| 699 int32_t basenamelen = (int32_t)uprv_strlen(basename); | |
| 700 | |
| 701 resName = (char*) uprv_malloc(sizeof(char) * (dirlen + pkgLen + basename
len + 8)); | |
| 702 | |
| 703 if (resName == NULL) { | |
| 704 *status = U_MEMORY_ALLOCATION_ERROR; | |
| 705 goto finish; | |
| 706 } | |
| 707 | |
| 708 uprv_strcpy(resName, outputDir); | |
| 709 | |
| 710 if(outputDir[dirlen] != U_FILE_SEP_CHAR) { | |
| 711 resName[dirlen] = U_FILE_SEP_CHAR; | |
| 712 resName[dirlen + 1] = '\0'; | |
| 713 } | |
| 714 | |
| 715 if(packageName != NULL) | |
| 716 { | |
| 717 uprv_strcat(resName, packageName); | |
| 718 uprv_strcat(resName, "_"); | |
| 719 } | |
| 720 | |
| 721 uprv_strcat(resName, basename); | |
| 722 } | |
| 723 | |
| 724 finish: | |
| 725 uprv_free(basename); | |
| 726 uprv_free(dirname); | |
| 727 | |
| 728 return resName; | |
| 729 } | |
| 730 | |
| 731 /* | |
| 732 * Local Variables: | |
| 733 * indent-tabs-mode: nil | |
| 734 * End: | |
| 735 */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1621843002:
ICU 56 update step 1 (Closed)
Base URL: https://chromium.googlesource.com/chromium/deps/icu.git@561