1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /****************************************************************************** 4 * Copyright (C) 2000-2016, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 ******************************************************************************* 7 * file name: pkgdata.cpp 8 * encoding: ANSI X3.4 (1968) 9 * tab size: 8 (not used) 10 * indentation:4 11 * 12 * created on: 2000may15 13 * created by: Steven \u24C7 Loomis 14 * 15 * This program packages the ICU data into different forms 16 * (DLL, common data, etc.) 17 */ 18 19 // Defines _XOPEN_SOURCE for access to POSIX functions. 20 // Must be before any other #includes. 21 #include "uposixdefs.h" 22 23 #include "unicode/utypes.h" 24 25 #include "unicode/putil.h" 26 #include "putilimp.h" 27 28 #if U_HAVE_POPEN 29 #if (U_PF_MINGW <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN) && defined(__STRICT_ANSI__) 30 /* popen/pclose aren't defined in strict ANSI on Cygwin and MinGW */ 31 #undef __STRICT_ANSI__ 32 #endif 33 #endif 34 35 #include "cmemory.h" 36 #include "cstring.h" 37 #include "filestrm.h" 38 #include "toolutil.h" 39 #include "unicode/uclean.h" 40 #include "unewdata.h" 41 #include "uoptions.h" 42 #include "package.h" 43 #include "pkg_icu.h" 44 #include "pkg_genc.h" 45 #include "pkg_gencmn.h" 46 #include "flagparser.h" 47 #include "filetools.h" 48 #include "charstr.h" 49 50 #if U_HAVE_POPEN 51 # include <unistd.h> 52 #endif 53 54 #include <stdio.h> 55 #include <stdlib.h> 56 57 U_CDECL_BEGIN 58 #include "pkgtypes.h" 59 U_CDECL_END 60 61 #if U_HAVE_POPEN 62 63 using icu::LocalPointerBase; 64 65 U_DEFINE_LOCAL_OPEN_POINTER(LocalPipeFilePointer, FILE, pclose); 66 67 #endif 68 69 static void loadLists(UPKGOptions *o, UErrorCode *status); 70 71 static int32_t pkg_executeOptions(UPKGOptions *o); 72 73 #ifdef WINDOWS_WITH_MSVC 74 static int32_t pkg_createWindowsDLL(const char mode, const char *gencFilePath, UPKGOptions *o); 75 #endif 76 static int32_t pkg_createSymLinks(const char *targetDir, UBool specialHandling=FALSE); 77 static int32_t pkg_installLibrary(const char *installDir, const char *dir, UBool noVersion); 78 static int32_t pkg_installFileMode(const char *installDir, const char *srcDir, const char *fileListName); 79 static int32_t pkg_installCommonMode(const char *installDir, const char *fileName); 80 81 #ifdef BUILD_DATA_WITHOUT_ASSEMBLY 82 static int32_t pkg_createWithoutAssemblyCode(UPKGOptions *o, const char *targetDir, const char mode); 83 #endif 84 85 #ifdef CAN_WRITE_OBJ_CODE 86 static void pkg_createOptMatchArch(char *optMatchArch); 87 static void pkg_destroyOptMatchArch(char *optMatchArch); 88 #endif 89 90 static int32_t pkg_createWithAssemblyCode(const char *targetDir, const char mode, const char *gencFilePath); 91 static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command = NULL, UBool specialHandling=FALSE); 92 static int32_t pkg_archiveLibrary(const char *targetDir, const char *version, UBool reverseExt); 93 static void createFileNames(UPKGOptions *o, const char mode, const char *version_major, const char *version, const char *libName, const UBool reverseExt, UBool noVersion); 94 static int32_t initializePkgDataFlags(UPKGOptions *o); 95 96 static int32_t pkg_getOptionsFromICUConfig(UBool verbose, UOption *option); 97 static int runCommand(const char* command, UBool specialHandling=FALSE); 98 99 #define IN_COMMON_MODE(mode) (mode == 'a' || mode == 'c') 100 #define IN_DLL_MODE(mode) (mode == 'd' || mode == 'l') 101 #define IN_STATIC_MODE(mode) (mode == 's') 102 #define IN_FILES_MODE(mode) (mode == 'f') 103 104 enum { 105 NAME, 106 BLDOPT, 107 MODE, 108 HELP, 109 HELP_QUESTION_MARK, 110 VERBOSE, 111 COPYRIGHT, 112 COMMENT, 113 DESTDIR, 114 REBUILD, 115 TEMPDIR, 116 INSTALL, 117 SOURCEDIR, 118 ENTRYPOINT, 119 REVISION, 120 FORCE_PREFIX, 121 LIBNAME, 122 QUIET, 123 WITHOUT_ASSEMBLY, 124 PDS_BUILD, 125 UWP_BUILD, 126 UWP_ARM_BUILD 127 }; 128 129 /* This sets the modes that are available */ 130 static struct { 131 const char *name, *alt_name; 132 const char *desc; 133 } modes[] = { 134 { "files", 0, "Uses raw data files (no effect). Installation copies all files to the target location." }, 135 #if U_PLATFORM_HAS_WIN32_API 136 { "dll", "library", "Generates one common data file and one shared library, <package>.dll"}, 137 { "common", "archive", "Generates just the common file, <package>.dat"}, 138 { "static", "static", "Generates one statically linked library, " LIB_PREFIX "<package>" UDATA_LIB_SUFFIX } 139 #else 140 #ifdef UDATA_SO_SUFFIX 141 { "dll", "library", "Generates one shared library, <package>" UDATA_SO_SUFFIX }, 142 #endif 143 { "common", "archive", "Generates one common data file, <package>.dat" }, 144 { "static", "static", "Generates one statically linked library, " LIB_PREFIX "<package>" UDATA_LIB_SUFFIX } 145 #endif 146 }; 147 148 static UOption options[]={ 149 /*00*/ UOPTION_DEF( "name", 'p', UOPT_REQUIRES_ARG), 150 /*01*/ UOPTION_DEF( "bldopt", 'O', UOPT_REQUIRES_ARG), /* on Win32 it is release or debug */ 151 /*02*/ UOPTION_DEF( "mode", 'm', UOPT_REQUIRES_ARG), 152 /*03*/ UOPTION_HELP_H, /* -h */ 153 /*04*/ UOPTION_HELP_QUESTION_MARK, /* -? */ 154 /*05*/ UOPTION_VERBOSE, /* -v */ 155 /*06*/ UOPTION_COPYRIGHT, /* -c */ 156 /*07*/ UOPTION_DEF( "comment", 'C', UOPT_REQUIRES_ARG), 157 /*08*/ UOPTION_DESTDIR, /* -d */ 158 /*11*/ UOPTION_DEF( "rebuild", 'F', UOPT_NO_ARG), 159 /*12*/ UOPTION_DEF( "tempdir", 'T', UOPT_REQUIRES_ARG), 160 /*13*/ UOPTION_DEF( "install", 'I', UOPT_REQUIRES_ARG), 161 /*14*/ UOPTION_SOURCEDIR , 162 /*15*/ UOPTION_DEF( "entrypoint", 'e', UOPT_REQUIRES_ARG), 163 /*16*/ UOPTION_DEF( "revision", 'r', UOPT_REQUIRES_ARG), 164 /*17*/ UOPTION_DEF( "force-prefix", 'f', UOPT_NO_ARG), 165 /*18*/ UOPTION_DEF( "libname", 'L', UOPT_REQUIRES_ARG), 166 /*19*/ UOPTION_DEF( "quiet", 'q', UOPT_NO_ARG), 167 /*20*/ UOPTION_DEF( "without-assembly", 'w', UOPT_NO_ARG), 168 /*21*/ UOPTION_DEF("zos-pds-build", 'z', UOPT_NO_ARG), 169 /*22*/ UOPTION_DEF("windows-uwp-build", 'u', UOPT_NO_ARG), 170 /*23*/ UOPTION_DEF("windows-uwp-arm-build", 'a', UOPT_NO_ARG) 171 }; 172 173 /* This enum and the following char array should be kept in sync. */ 174 enum { 175 GENCCODE_ASSEMBLY_TYPE, 176 SO_EXT, 177 SOBJ_EXT, 178 A_EXT, 179 LIBPREFIX, 180 LIB_EXT_ORDER, 181 COMPILER, 182 LIBFLAGS, 183 GENLIB, 184 LDICUDTFLAGS, 185 LD_SONAME, 186 RPATH_FLAGS, 187 BIR_FLAGS, 188 AR, 189 ARFLAGS, 190 RANLIB, 191 INSTALL_CMD, 192 PKGDATA_FLAGS_SIZE 193 }; 194 static const char* FLAG_NAMES[PKGDATA_FLAGS_SIZE] = { 195 "GENCCODE_ASSEMBLY_TYPE", 196 "SO", 197 "SOBJ", 198 "A", 199 "LIBPREFIX", 200 "LIB_EXT_ORDER", 201 "COMPILE", 202 "LIBFLAGS", 203 "GENLIB", 204 "LDICUDTFLAGS", 205 "LD_SONAME", 206 "RPATH_FLAGS", 207 "BIR_LDFLAGS", 208 "AR", 209 "ARFLAGS", 210 "RANLIB", 211 "INSTALL_CMD" 212 }; 213 static char **pkgDataFlags = NULL; 214 215 enum { 216 LIB_FILE, 217 LIB_FILE_VERSION_MAJOR, 218 LIB_FILE_VERSION, 219 LIB_FILE_VERSION_TMP, 220 #if U_PLATFORM == U_PF_CYGWIN 221 LIB_FILE_CYGWIN, 222 LIB_FILE_CYGWIN_VERSION, 223 #elif U_PLATFORM == U_PF_MINGW 224 LIB_FILE_MINGW, 225 #elif U_PLATFORM == U_PF_OS390 226 LIB_FILE_OS390BATCH_MAJOR, 227 LIB_FILE_OS390BATCH_VERSION, 228 #endif 229 LIB_FILENAMES_SIZE 230 }; 231 static char libFileNames[LIB_FILENAMES_SIZE][256]; 232 233 static UPKGOptions *pkg_checkFlag(UPKGOptions *o); 234 235 const char options_help[][320]={ 236 "Set the data name", 237 #ifdef U_MAKE_IS_NMAKE 238 "The directory where the ICU is located (e.g. <ICUROOT> which contains the bin directory)", 239 #else 240 "Specify options for the builder.", 241 #endif 242 "Specify the mode of building (see below; default: common)", 243 "This usage text", 244 "This usage text", 245 "Make the output verbose", 246 "Use the standard ICU copyright", 247 "Use a custom comment (instead of the copyright)", 248 "Specify the destination directory for files", 249 "Force rebuilding of all data", 250 "Specify temporary dir (default: output dir)", 251 "Install the data (specify target)", 252 "Specify a custom source directory", 253 "Specify a custom entrypoint name (default: short name)", 254 "Specify a version when packaging in dll or static mode", 255 "Add package to all file names if not present", 256 "Library name to build (if different than package name)", 257 "Quiet mode. (e.g. Do not output a readme file for static libraries)", 258 "Build the data without assembly code", 259 "Build PDS dataset (zOS build only)", 260 "Build for Universal Windows Platform (Windows build only)", 261 "Set DLL machine type for UWP to target windows ARM (Windows UWP build only)" 262 }; 263 264 const char *progname = "PKGDATA"; 265 266 int 267 main(int argc, char* argv[]) { 268 int result = 0; 269 /* FileStream *out; */ 270 UPKGOptions o; 271 CharList *tail; 272 UBool needsHelp = FALSE; 273 UErrorCode status = U_ZERO_ERROR; 274 /* char tmp[1024]; */ 275 uint32_t i; 276 int32_t n; 277 278 U_MAIN_INIT_ARGS(argc, argv); 279 280 progname = argv[0]; 281 282 options[MODE].value = "common"; 283 284 /* read command line options */ 285 argc=u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options); 286 287 /* error handling, printing usage message */ 288 /* I've decided to simply print an error and quit. This tool has too 289 many options to just display them all of the time. */ 290 291 if(options[HELP].doesOccur || options[HELP_QUESTION_MARK].doesOccur) { 292 needsHelp = TRUE; 293 } 294 else { 295 if(!needsHelp && argc<0) { 296 fprintf(stderr, 297 "%s: error in command line argument \"%s\"\n", 298 progname, 299 argv[-argc]); 300 fprintf(stderr, "Run '%s --help' for help.\n", progname); 301 return 1; 302 } 303 304 305 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) 306 if(!options[BLDOPT].doesOccur && uprv_strcmp(options[MODE].value, "common") != 0) { 307 if (pkg_getOptionsFromICUConfig(options[VERBOSE].doesOccur, &options[BLDOPT]) != 0) { 308 fprintf(stderr, " required parameter is missing: -O is required for static and shared builds.\n"); 309 fprintf(stderr, "Run '%s --help' for help.\n", progname); 310 return 1; 311 } 312 } 313 #else 314 if(options[BLDOPT].doesOccur) { 315 fprintf(stdout, "Warning: You are using the -O option which is not needed for MSVC build on Windows.\n"); 316 } 317 #endif 318 319 if(!options[NAME].doesOccur) /* -O we already have - don't report it. */ 320 { 321 fprintf(stderr, " required parameter -p is missing \n"); 322 fprintf(stderr, "Run '%s --help' for help.\n", progname); 323 return 1; 324 } 325 326 if(argc == 1) { 327 fprintf(stderr, 328 "No input files specified.\n" 329 "Run '%s --help' for help.\n", progname); 330 return 1; 331 } 332 } /* end !needsHelp */ 333 334 if(argc<0 || needsHelp ) { 335 fprintf(stderr, 336 "usage: %s [-options] [-] [packageFile] \n" 337 "\tProduce packaged ICU data from the given list(s) of files.\n" 338 "\t'-' by itself means to read from stdin.\n" 339 "\tpackageFile is a text file containing the list of files to package.\n", 340 progname); 341 342 fprintf(stderr, "\n options:\n"); 343 for(i=0;i<UPRV_LENGTHOF(options);i++) { 344 fprintf(stderr, "%-5s -%c %s%-10s %s\n", 345 (i<1?"[REQ]":""), 346 options[i].shortName, 347 options[i].longName ? "or --" : " ", 348 options[i].longName ? options[i].longName : "", 349 options_help[i]); 350 } 351 352 fprintf(stderr, "modes: (-m option)\n"); 353 for(i=0;i<UPRV_LENGTHOF(modes);i++) { 354 fprintf(stderr, " %-9s ", modes[i].name); 355 if (modes[i].alt_name) { 356 fprintf(stderr, "/ %-9s", modes[i].alt_name); 357 } else { 358 fprintf(stderr, " "); 359 } 360 fprintf(stderr, " %s\n", modes[i].desc); 361 } 362 return 1; 363 } 364 365 /* OK, fill in the options struct */ 366 uprv_memset(&o, 0, sizeof(o)); 367 368 o.mode = options[MODE].value; 369 o.version = options[REVISION].doesOccur ? options[REVISION].value : 0; 370 371 o.shortName = options[NAME].value; 372 { 373 int32_t len = (int32_t)uprv_strlen(o.shortName); 374 char *csname, *cp; 375 const char *sp; 376 377 cp = csname = (char *) uprv_malloc((len + 1 + 1) * sizeof(*o.cShortName)); 378 if (*(sp = o.shortName)) { 379 *cp++ = isalpha(*sp) ? * sp : '_'; 380 for (++sp; *sp; ++sp) { 381 *cp++ = isalnum(*sp) ? *sp : '_'; 382 } 383 } 384 *cp = 0; 385 386 o.cShortName = csname; 387 } 388 389 if(options[LIBNAME].doesOccur) { /* get libname from shortname, or explicit -L parameter */ 390 o.libName = options[LIBNAME].value; 391 } else { 392 o.libName = o.shortName; 393 } 394 395 if(options[QUIET].doesOccur) { 396 o.quiet = TRUE; 397 } else { 398 o.quiet = FALSE; 399 } 400 401 if(options[PDS_BUILD].doesOccur) { 402 #if U_PLATFORM == U_PF_OS390 403 o.pdsbuild = TRUE; 404 #else 405 o.pdsbuild = FALSE; 406 fprintf(stdout, "Warning: You are using the -z option which only works on z/OS.\n"); 407 408 #endif 409 } else { 410 o.pdsbuild = FALSE; 411 } 412 413 o.verbose = options[VERBOSE].doesOccur; 414 415 416 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) /* on UNIX, we'll just include the file... */ 417 if (options[BLDOPT].doesOccur) { 418 o.options = options[BLDOPT].value; 419 } else { 420 o.options = NULL; 421 } 422 #endif 423 if(options[COPYRIGHT].doesOccur) { 424 o.comment = U_COPYRIGHT_STRING; 425 } else if (options[COMMENT].doesOccur) { 426 o.comment = options[COMMENT].value; 427 } 428 429 if( options[DESTDIR].doesOccur ) { 430 o.targetDir = options[DESTDIR].value; 431 } else { 432 o.targetDir = "."; /* cwd */ 433 } 434 435 o.rebuild = options[REBUILD].doesOccur; 436 437 if( options[TEMPDIR].doesOccur ) { 438 o.tmpDir = options[TEMPDIR].value; 439 } else { 440 o.tmpDir = o.targetDir; 441 } 442 443 if( options[INSTALL].doesOccur ) { 444 o.install = options[INSTALL].value; 445 } else { 446 o.install = NULL; 447 } 448 449 if( options[SOURCEDIR].doesOccur ) { 450 o.srcDir = options[SOURCEDIR].value; 451 } else { 452 o.srcDir = "."; 453 } 454 455 if( options[ENTRYPOINT].doesOccur ) { 456 o.entryName = options[ENTRYPOINT].value; 457 } else { 458 o.entryName = o.cShortName; 459 } 460 461 o.withoutAssembly = FALSE; 462 if (options[WITHOUT_ASSEMBLY].doesOccur) { 463 #ifndef BUILD_DATA_WITHOUT_ASSEMBLY 464 fprintf(stdout, "Warning: You are using the option to build without assembly code which is not supported on this platform.\n"); 465 fprintf(stdout, "Warning: This option will be ignored.\n"); 466 #else 467 o.withoutAssembly = TRUE; 468 #endif 469 } 470 471 /* OK options are set up. Now the file lists. */ 472 tail = NULL; 473 for( n=1; n<argc; n++) { 474 o.fileListFiles = pkg_appendToList(o.fileListFiles, &tail, uprv_strdup(argv[n])); 475 } 476 477 /* load the files */ 478 loadLists(&o, &status); 479 if( U_FAILURE(status) ) { 480 fprintf(stderr, "error loading input file lists: %s\n", u_errorName(status)); 481 return 2; 482 } 483 484 result = pkg_executeOptions(&o); 485 486 if (pkgDataFlags != NULL) { 487 for (n = 0; n < PKGDATA_FLAGS_SIZE; n++) { 488 if (pkgDataFlags[n] != NULL) { 489 uprv_free(pkgDataFlags[n]); 490 } 491 } 492 uprv_free(pkgDataFlags); 493 } 494 495 if (o.cShortName != NULL) { 496 uprv_free((char *)o.cShortName); 497 } 498 if (o.fileListFiles != NULL) { 499 pkg_deleteList(o.fileListFiles); 500 } 501 if (o.filePaths != NULL) { 502 pkg_deleteList(o.filePaths); 503 } 504 if (o.files != NULL) { 505 pkg_deleteList(o.files); 506 } 507 508 return result; 509 } 510 511 static int runCommand(const char* command, UBool specialHandling) { 512 char *cmd = NULL; 513 char cmdBuffer[SMALL_BUFFER_MAX_SIZE]; 514 int32_t len = strlen(command); 515 516 if (len == 0) { 517 return 0; 518 } 519 520 if (!specialHandling) { 521 #if defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW || U_PLATFORM == U_PF_OS400 522 if ((len + BUFFER_PADDING_SIZE) >= SMALL_BUFFER_MAX_SIZE) { 523 cmd = (char *)uprv_malloc(len + BUFFER_PADDING_SIZE); 524 } else { 525 cmd = cmdBuffer; 526 } 527 #if defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW 528 sprintf(cmd, "bash -c \"%s\"", command); 529 530 #elif U_PLATFORM == U_PF_OS400 531 sprintf(cmd, "QSH CMD('%s')", command); 532 #endif 533 #else 534 goto normal_command_mode; 535 #endif 536 } else { 537 #if !(defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW || U_PLATFORM == U_PF_OS400) 538 normal_command_mode: 539 #endif 540 cmd = (char *)command; 541 } 542 543 printf("pkgdata: %s\n", cmd); 544 int result = system(cmd); 545 if (result != 0) { 546 fprintf(stderr, "-- return status = %d\n", result); 547 } 548 549 if (cmd != cmdBuffer && cmd != command) { 550 uprv_free(cmd); 551 } 552 553 return result; 554 } 555 556 #define LN_CMD "ln -s" 557 #define RM_CMD "rm -f" 558 559 static int32_t pkg_executeOptions(UPKGOptions *o) { 560 int32_t result = 0; 561 562 const char mode = o->mode[0]; 563 char targetDir[SMALL_BUFFER_MAX_SIZE] = ""; 564 char tmpDir[SMALL_BUFFER_MAX_SIZE] = ""; 565 char datFileName[SMALL_BUFFER_MAX_SIZE] = ""; 566 char datFileNamePath[LARGE_BUFFER_MAX_SIZE] = ""; 567 char checkLibFile[LARGE_BUFFER_MAX_SIZE] = ""; 568 569 initializePkgDataFlags(o); 570 571 if (IN_FILES_MODE(mode)) { 572 /* Copy the raw data to the installation directory. */ 573 if (o->install != NULL) { 574 uprv_strcpy(targetDir, o->install); 575 if (o->shortName != NULL) { 576 uprv_strcat(targetDir, PKGDATA_FILE_SEP_STRING); 577 uprv_strcat(targetDir, o->shortName); 578 } 579 580 if(o->verbose) { 581 fprintf(stdout, "# Install: Files mode, copying files to %s..\n", targetDir); 582 } 583 result = pkg_installFileMode(targetDir, o->srcDir, o->fileListFiles->str); 584 } 585 return result; 586 } else /* if (IN_COMMON_MODE(mode) || IN_DLL_MODE(mode) || IN_STATIC_MODE(mode)) */ { 587 UBool noVersion = FALSE; 588 589 uprv_strcpy(targetDir, o->targetDir); 590 uprv_strcat(targetDir, PKGDATA_FILE_SEP_STRING); 591 592 uprv_strcpy(tmpDir, o->tmpDir); 593 uprv_strcat(tmpDir, PKGDATA_FILE_SEP_STRING); 594 595 uprv_strcpy(datFileNamePath, tmpDir); 596 597 uprv_strcpy(datFileName, o->shortName); 598 uprv_strcat(datFileName, UDATA_CMN_SUFFIX); 599 600 uprv_strcat(datFileNamePath, datFileName); 601 602 if(o->verbose) { 603 fprintf(stdout, "# Writing package file %s ..\n", datFileNamePath); 604 } 605 result = writePackageDatFile(datFileNamePath, o->comment, o->srcDir, o->fileListFiles->str, NULL, U_CHARSET_FAMILY ? 'e' : U_IS_BIG_ENDIAN ? 'b' : 'l'); 606 if (result != 0) { 607 fprintf(stderr,"Error writing package dat file.\n"); 608 return result; 609 } 610 611 if (IN_COMMON_MODE(mode)) { 612 char targetFileNamePath[LARGE_BUFFER_MAX_SIZE] = ""; 613 614 uprv_strcpy(targetFileNamePath, targetDir); 615 uprv_strcat(targetFileNamePath, datFileName); 616 617 /* Move the dat file created to the target directory. */ 618 if (uprv_strcmp(datFileNamePath, targetFileNamePath) != 0) { 619 if (T_FileStream_file_exists(targetFileNamePath)) { 620 if ((result = remove(targetFileNamePath)) != 0) { 621 fprintf(stderr, "Unable to remove old dat file: %s\n", 622 targetFileNamePath); 623 return result; 624 } 625 } 626 627 result = rename(datFileNamePath, targetFileNamePath); 628 629 if (o->verbose) { 630 fprintf(stdout, "# Moving package file to %s ..\n", 631 targetFileNamePath); 632 } 633 if (result != 0) { 634 fprintf( 635 stderr, 636 "Unable to move dat file (%s) to target location (%s).\n", 637 datFileNamePath, targetFileNamePath); 638 return result; 639 } 640 } 641 642 if (o->install != NULL) { 643 result = pkg_installCommonMode(o->install, targetFileNamePath); 644 } 645 646 return result; 647 } else /* if (IN_STATIC_MODE(mode) || IN_DLL_MODE(mode)) */ { 648 char gencFilePath[SMALL_BUFFER_MAX_SIZE] = ""; 649 char version_major[10] = ""; 650 UBool reverseExt = FALSE; 651 652 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) 653 /* Get the version major number. */ 654 if (o->version != NULL) { 655 for (uint32_t i = 0;i < sizeof(version_major);i++) { 656 if (o->version[i] == '.') { 657 version_major[i] = 0; 658 break; 659 } 660 version_major[i] = o->version[i]; 661 } 662 } else { 663 noVersion = TRUE; 664 if (IN_DLL_MODE(mode)) { 665 fprintf(stdout, "Warning: Providing a revision number with the -r option is recommended when packaging data in the current mode.\n"); 666 } 667 } 668 669 #if U_PLATFORM != U_PF_OS400 670 /* Certain platforms have different library extension ordering. (e.g. libicudata.##.so vs libicudata.so.##) 671 * reverseExt is FALSE if the suffix should be the version number. 672 */ 673 if (pkgDataFlags[LIB_EXT_ORDER][uprv_strlen(pkgDataFlags[LIB_EXT_ORDER])-1] == pkgDataFlags[SO_EXT][uprv_strlen(pkgDataFlags[SO_EXT])-1]) { 674 reverseExt = TRUE; 675 } 676 #endif 677 /* Using the base libName and version number, generate the library file names. */ 678 createFileNames(o, mode, version_major, o->version == NULL ? "" : o->version, o->libName, reverseExt, noVersion); 679 680 if ((o->version!=NULL || IN_STATIC_MODE(mode)) && o->rebuild == FALSE && o->pdsbuild == FALSE) { 681 /* Check to see if a previous built data library file exists and check if it is the latest. */ 682 sprintf(checkLibFile, "%s%s", targetDir, libFileNames[LIB_FILE_VERSION]); 683 if (T_FileStream_file_exists(checkLibFile)) { 684 if (isFileModTimeLater(checkLibFile, o->srcDir, TRUE) && isFileModTimeLater(checkLibFile, o->options)) { 685 if (o->install != NULL) { 686 if(o->verbose) { 687 fprintf(stdout, "# Installing already-built library into %s\n", o->install); 688 } 689 result = pkg_installLibrary(o->install, targetDir, noVersion); 690 } else { 691 if(o->verbose) { 692 printf("# Not rebuilding %s - up to date.\n", checkLibFile); 693 } 694 } 695 return result; 696 } else if (o->verbose && (o->install!=NULL)) { 697 fprintf(stdout, "# Not installing up-to-date library %s into %s\n", checkLibFile, o->install); 698 } 699 } else if(o->verbose && (o->install!=NULL)) { 700 fprintf(stdout, "# Not installing missing %s into %s\n", checkLibFile, o->install); 701 } 702 } 703 704 if (pkg_checkFlag(o) == NULL) { 705 /* Error occurred. */ 706 return result; 707 } 708 #endif 709 710 if (!o->withoutAssembly && pkgDataFlags[GENCCODE_ASSEMBLY_TYPE][0] != 0) { 711 const char* genccodeAssembly = pkgDataFlags[GENCCODE_ASSEMBLY_TYPE]; 712 713 if(o->verbose) { 714 fprintf(stdout, "# Generating assembly code %s of type %s ..\n", gencFilePath, genccodeAssembly); 715 } 716 717 /* Offset genccodeAssembly by 3 because "-a " */ 718 if (genccodeAssembly && 719 (uprv_strlen(genccodeAssembly)>3) && 720 checkAssemblyHeaderName(genccodeAssembly+3)) { 721 writeAssemblyCode(datFileNamePath, o->tmpDir, o->entryName, NULL, gencFilePath); 722 723 result = pkg_createWithAssemblyCode(targetDir, mode, gencFilePath); 724 if (result != 0) { 725 fprintf(stderr, "Error generating assembly code for data.\n"); 726 return result; 727 } else if (IN_STATIC_MODE(mode)) { 728 if(o->install != NULL) { 729 if(o->verbose) { 730 fprintf(stdout, "# Installing static library into %s\n", o->install); 731 } 732 result = pkg_installLibrary(o->install, targetDir, noVersion); 733 } 734 return result; 735 } 736 } else { 737 fprintf(stderr,"Assembly type \"%s\" is unknown.\n", genccodeAssembly); 738 return -1; 739 } 740 } else { 741 if(o->verbose) { 742 fprintf(stdout, "# Writing object code to %s ..\n", gencFilePath); 743 } 744 if (o->withoutAssembly) { 745 #ifdef BUILD_DATA_WITHOUT_ASSEMBLY 746 result = pkg_createWithoutAssemblyCode(o, targetDir, mode); 747 #else 748 /* This error should not occur. */ 749 fprintf(stderr, "Error- BUILD_DATA_WITHOUT_ASSEMBLY is not defined. Internal error.\n"); 750 #endif 751 } else { 752 #ifdef CAN_WRITE_OBJ_CODE 753 /* Try to detect the arch type, use NULL if unsuccessful */ 754 char optMatchArch[10] = { 0 }; 755 pkg_createOptMatchArch(optMatchArch); 756 writeObjectCode(datFileNamePath, o->tmpDir, o->entryName, (optMatchArch[0] == 0 ? NULL : optMatchArch), NULL, gencFilePath); 757 pkg_destroyOptMatchArch(optMatchArch); 758 #if U_PLATFORM_IS_LINUX_BASED 759 result = pkg_generateLibraryFile(targetDir, mode, gencFilePath); 760 #elif defined(WINDOWS_WITH_MSVC) 761 result = pkg_createWindowsDLL(mode, gencFilePath, o); 762 #endif 763 #elif defined(BUILD_DATA_WITHOUT_ASSEMBLY) 764 result = pkg_createWithoutAssemblyCode(o, targetDir, mode); 765 #else 766 fprintf(stderr, "Error- neither CAN_WRITE_OBJ_CODE nor BUILD_DATA_WITHOUT_ASSEMBLY are defined. Internal error.\n"); 767 return 1; 768 #endif 769 } 770 771 if (result != 0) { 772 fprintf(stderr, "Error generating package data.\n"); 773 return result; 774 } 775 } 776 #if !U_PLATFORM_USES_ONLY_WIN32_API 777 if(!IN_STATIC_MODE(mode)) { 778 /* Certain platforms uses archive library. (e.g. AIX) */ 779 if(o->verbose) { 780 fprintf(stdout, "# Creating data archive library file ..\n"); 781 } 782 result = pkg_archiveLibrary(targetDir, o->version, reverseExt); 783 if (result != 0) { 784 fprintf(stderr, "Error creating data archive library file.\n"); 785 return result; 786 } 787 #if U_PLATFORM != U_PF_OS400 788 if (!noVersion) { 789 /* Create symbolic links for the final library file. */ 790 #if U_PLATFORM == U_PF_OS390 791 result = pkg_createSymLinks(targetDir, o->pdsbuild); 792 #else 793 result = pkg_createSymLinks(targetDir, noVersion); 794 #endif 795 if (result != 0) { 796 fprintf(stderr, "Error creating symbolic links of the data library file.\n"); 797 return result; 798 } 799 } 800 #endif 801 } /* !IN_STATIC_MODE */ 802 #endif 803 804 #if !U_PLATFORM_USES_ONLY_WIN32_API 805 /* Install the libraries if option was set. */ 806 if (o->install != NULL) { 807 if(o->verbose) { 808 fprintf(stdout, "# Installing library file to %s ..\n", o->install); 809 } 810 result = pkg_installLibrary(o->install, targetDir, noVersion); 811 if (result != 0) { 812 fprintf(stderr, "Error installing the data library.\n"); 813 return result; 814 } 815 } 816 #endif 817 } 818 } 819 return result; 820 } 821 822 /* Initialize the pkgDataFlags with the option file given. */ 823 static int32_t initializePkgDataFlags(UPKGOptions *o) { 824 UErrorCode status = U_ZERO_ERROR; 825 int32_t result = 0; 826 int32_t currentBufferSize = SMALL_BUFFER_MAX_SIZE; 827 int32_t tmpResult = 0; 828 829 /* Initialize pkgdataFlags */ 830 pkgDataFlags = (char**)uprv_malloc(sizeof(char*) * PKGDATA_FLAGS_SIZE); 831 832 /* If we run out of space, allocate more */ 833 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) 834 do { 835 #endif 836 if (pkgDataFlags != NULL) { 837 for (int32_t i = 0; i < PKGDATA_FLAGS_SIZE; i++) { 838 pkgDataFlags[i] = (char*)uprv_malloc(sizeof(char) * currentBufferSize); 839 if (pkgDataFlags[i] != NULL) { 840 pkgDataFlags[i][0] = 0; 841 } else { 842 fprintf(stderr,"Error allocating memory for pkgDataFlags.\n"); 843 /* If an error occurs, ensure that the rest of the array is NULL */ 844 for (int32_t n = i + 1; n < PKGDATA_FLAGS_SIZE; n++) { 845 pkgDataFlags[n] = NULL; 846 } 847 return -1; 848 } 849 } 850 } else { 851 fprintf(stderr,"Error allocating memory for pkgDataFlags.\n"); 852 return -1; 853 } 854 855 if (o->options == NULL) { 856 return result; 857 } 858 859 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) 860 /* Read in options file. */ 861 if(o->verbose) { 862 fprintf(stdout, "# Reading options file %s\n", o->options); 863 } 864 status = U_ZERO_ERROR; 865 tmpResult = parseFlagsFile(o->options, pkgDataFlags, currentBufferSize, FLAG_NAMES, (int32_t)PKGDATA_FLAGS_SIZE, &status); 866 if (status == U_BUFFER_OVERFLOW_ERROR) { 867 for (int32_t i = 0; i < PKGDATA_FLAGS_SIZE; i++) { 868 if (pkgDataFlags[i]) { 869 uprv_free(pkgDataFlags[i]); 870 pkgDataFlags[i] = NULL; 871 } 872 } 873 currentBufferSize = tmpResult; 874 } else if (U_FAILURE(status)) { 875 fprintf(stderr,"Unable to open or read \"%s\" option file. status = %s\n", o->options, u_errorName(status)); 876 return -1; 877 } 878 #endif 879 if(o->verbose) { 880 fprintf(stdout, "# pkgDataFlags=\n"); 881 for(int32_t i=0;i<PKGDATA_FLAGS_SIZE;i++) { 882 fprintf(stdout, " [%d] %s: %s\n", i, FLAG_NAMES[i], pkgDataFlags[i]); 883 } 884 fprintf(stdout, "\n"); 885 } 886 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) 887 } while (status == U_BUFFER_OVERFLOW_ERROR); 888 #endif 889 890 return result; 891 } 892 893 894 /* 895 * Given the base libName and version numbers, generate the libary file names and store it in libFileNames. 896 * Depending on the configuration, the library name may either end with version number or shared object suffix. 897 */ 898 static void createFileNames(UPKGOptions *o, const char mode, const char *version_major, const char *version, const char *libName, UBool reverseExt, UBool noVersion) { 899 const char* FILE_EXTENSION_SEP = uprv_strlen(pkgDataFlags[SO_EXT]) == 0 ? "" : "."; 900 const char* FILE_SUFFIX = pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : ""; 901 902 #if U_PLATFORM == U_PF_MINGW 903 /* MinGW does not need the library prefix when building in dll mode. */ 904 if (IN_DLL_MODE(mode)) { 905 sprintf(libFileNames[LIB_FILE], "%s", libName); 906 } else { 907 sprintf(libFileNames[LIB_FILE], "%s%s", 908 pkgDataFlags[LIBPREFIX], 909 libName); 910 } 911 #else 912 sprintf(libFileNames[LIB_FILE], "%s%s", 913 pkgDataFlags[LIBPREFIX], 914 libName); 915 #endif 916 917 if(o->verbose) { 918 fprintf(stdout, "# libFileName[LIB_FILE] = %s\n", libFileNames[LIB_FILE]); 919 } 920 921 #if U_PLATFORM == U_PF_MINGW 922 // Name the import library lib*.dll.a 923 sprintf(libFileNames[LIB_FILE_MINGW], "lib%s.dll.a", libName); 924 #elif U_PLATFORM == U_PF_CYGWIN 925 sprintf(libFileNames[LIB_FILE_CYGWIN], "cyg%s%s%s", 926 libName, 927 FILE_EXTENSION_SEP, 928 pkgDataFlags[SO_EXT]); 929 sprintf(libFileNames[LIB_FILE_CYGWIN_VERSION], "cyg%s%s%s%s", 930 libName, 931 version_major, 932 FILE_EXTENSION_SEP, 933 pkgDataFlags[SO_EXT]); 934 935 uprv_strcat(pkgDataFlags[SO_EXT], "."); 936 uprv_strcat(pkgDataFlags[SO_EXT], pkgDataFlags[A_EXT]); 937 #elif U_PLATFORM == U_PF_OS400 || defined(_AIX) 938 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s", 939 libFileNames[LIB_FILE], 940 FILE_EXTENSION_SEP, 941 pkgDataFlags[SOBJ_EXT]); 942 #elif U_PLATFORM == U_PF_OS390 943 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s%s%s", 944 libFileNames[LIB_FILE], 945 pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "", 946 reverseExt ? version : pkgDataFlags[SOBJ_EXT], 947 FILE_EXTENSION_SEP, 948 reverseExt ? pkgDataFlags[SOBJ_EXT] : version); 949 950 sprintf(libFileNames[LIB_FILE_OS390BATCH_VERSION], "%s%s.x", 951 libFileNames[LIB_FILE], 952 version); 953 sprintf(libFileNames[LIB_FILE_OS390BATCH_MAJOR], "%s%s.x", 954 libFileNames[LIB_FILE], 955 version_major); 956 #else 957 if (noVersion && !reverseExt) { 958 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s", 959 libFileNames[LIB_FILE], 960 FILE_SUFFIX, 961 pkgDataFlags[SOBJ_EXT]); 962 } else { 963 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s%s%s", 964 libFileNames[LIB_FILE], 965 FILE_SUFFIX, 966 reverseExt ? version : pkgDataFlags[SOBJ_EXT], 967 FILE_EXTENSION_SEP, 968 reverseExt ? pkgDataFlags[SOBJ_EXT] : version); 969 } 970 #endif 971 if (noVersion && !reverseExt) { 972 sprintf(libFileNames[LIB_FILE_VERSION_MAJOR], "%s%s%s", 973 libFileNames[LIB_FILE], 974 FILE_SUFFIX, 975 pkgDataFlags[SO_EXT]); 976 977 sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s", 978 libFileNames[LIB_FILE], 979 FILE_SUFFIX, 980 pkgDataFlags[SO_EXT]); 981 } else { 982 sprintf(libFileNames[LIB_FILE_VERSION_MAJOR], "%s%s%s%s%s", 983 libFileNames[LIB_FILE], 984 FILE_SUFFIX, 985 reverseExt ? version_major : pkgDataFlags[SO_EXT], 986 FILE_EXTENSION_SEP, 987 reverseExt ? pkgDataFlags[SO_EXT] : version_major); 988 989 sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s%s%s", 990 libFileNames[LIB_FILE], 991 FILE_SUFFIX, 992 reverseExt ? version : pkgDataFlags[SO_EXT], 993 FILE_EXTENSION_SEP, 994 reverseExt ? pkgDataFlags[SO_EXT] : version); 995 } 996 997 if(o->verbose) { 998 fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s\n", libFileNames[LIB_FILE_VERSION]); 999 } 1000 1001 #if U_PF_MINGW <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN 1002 /* Cygwin and MinGW only deals with the version major number. */ 1003 uprv_strcpy(libFileNames[LIB_FILE_VERSION_TMP], libFileNames[LIB_FILE_VERSION_MAJOR]); 1004 #endif 1005 1006 if(IN_STATIC_MODE(mode)) { 1007 sprintf(libFileNames[LIB_FILE_VERSION], "%s.%s", libFileNames[LIB_FILE], pkgDataFlags[A_EXT]); 1008 libFileNames[LIB_FILE_VERSION_MAJOR][0]=0; 1009 if(o->verbose) { 1010 fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s (static)\n", libFileNames[LIB_FILE_VERSION]); 1011 } 1012 } 1013 } 1014 1015 /* Create the symbolic links for the final library file. */ 1016 static int32_t pkg_createSymLinks(const char *targetDir, UBool specialHandling) { 1017 int32_t result = 0; 1018 char cmd[LARGE_BUFFER_MAX_SIZE]; 1019 char name1[SMALL_BUFFER_MAX_SIZE]; /* symlink file name */ 1020 char name2[SMALL_BUFFER_MAX_SIZE]; /* file name to symlink */ 1021 const char* FILE_EXTENSION_SEP = uprv_strlen(pkgDataFlags[SO_EXT]) == 0 ? "" : "."; 1022 1023 #if !defined(USING_CYGWIN) && U_PLATFORM != U_PF_MINGW 1024 /* No symbolic link to make. */ 1025 if (uprv_strlen(libFileNames[LIB_FILE_VERSION]) == 0 || uprv_strlen(libFileNames[LIB_FILE_VERSION_MAJOR]) == 0 || 1026 uprv_strcmp(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_MAJOR]) == 0) { 1027 return result; 1028 } 1029 1030 sprintf(cmd, "cd %s && %s %s && %s %s %s", 1031 targetDir, 1032 RM_CMD, 1033 libFileNames[LIB_FILE_VERSION_MAJOR], 1034 LN_CMD, 1035 libFileNames[LIB_FILE_VERSION], 1036 libFileNames[LIB_FILE_VERSION_MAJOR]); 1037 result = runCommand(cmd); 1038 if (result != 0) { 1039 fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd); 1040 return result; 1041 } 1042 #endif 1043 1044 if (specialHandling) { 1045 #if U_PLATFORM == U_PF_CYGWIN 1046 sprintf(name1, "%s", libFileNames[LIB_FILE_CYGWIN]); 1047 sprintf(name2, "%s", libFileNames[LIB_FILE_CYGWIN_VERSION]); 1048 #elif U_PLATFORM == U_PF_OS390 1049 /* Create the symbolic links for the import data */ 1050 /* Use the cmd buffer to store path to import data file to check its existence */ 1051 sprintf(cmd, "%s/%s", targetDir, libFileNames[LIB_FILE_OS390BATCH_VERSION]); 1052 if (T_FileStream_file_exists(cmd)) { 1053 sprintf(cmd, "cd %s && %s %s && %s %s %s", 1054 targetDir, 1055 RM_CMD, 1056 libFileNames[LIB_FILE_OS390BATCH_MAJOR], 1057 LN_CMD, 1058 libFileNames[LIB_FILE_OS390BATCH_VERSION], 1059 libFileNames[LIB_FILE_OS390BATCH_MAJOR]); 1060 result = runCommand(cmd); 1061 if (result != 0) { 1062 fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd); 1063 return result; 1064 } 1065 1066 sprintf(cmd, "cd %s && %s %s.x && %s %s %s.x", 1067 targetDir, 1068 RM_CMD, 1069 libFileNames[LIB_FILE], 1070 LN_CMD, 1071 libFileNames[LIB_FILE_OS390BATCH_VERSION], 1072 libFileNames[LIB_FILE]); 1073 result = runCommand(cmd); 1074 if (result != 0) { 1075 fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd); 1076 return result; 1077 } 1078 } 1079 1080 /* Needs to be set here because special handling skips it */ 1081 sprintf(name1, "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]); 1082 sprintf(name2, "%s", libFileNames[LIB_FILE_VERSION]); 1083 #else 1084 goto normal_symlink_mode; 1085 #endif 1086 } else { 1087 #if U_PLATFORM != U_PF_CYGWIN 1088 normal_symlink_mode: 1089 #endif 1090 sprintf(name1, "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]); 1091 sprintf(name2, "%s", libFileNames[LIB_FILE_VERSION]); 1092 } 1093 1094 sprintf(cmd, "cd %s && %s %s && %s %s %s", 1095 targetDir, 1096 RM_CMD, 1097 name1, 1098 LN_CMD, 1099 name2, 1100 name1); 1101 1102 result = runCommand(cmd); 1103 1104 return result; 1105 } 1106 1107 static int32_t pkg_installLibrary(const char *installDir, const char *targetDir, UBool noVersion) { 1108 int32_t result = 0; 1109 char cmd[SMALL_BUFFER_MAX_SIZE]; 1110 1111 sprintf(cmd, "cd %s && %s %s %s%s%s", 1112 targetDir, 1113 pkgDataFlags[INSTALL_CMD], 1114 libFileNames[LIB_FILE_VERSION], 1115 installDir, PKGDATA_FILE_SEP_STRING, libFileNames[LIB_FILE_VERSION] 1116 ); 1117 1118 result = runCommand(cmd); 1119 1120 if (result != 0) { 1121 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); 1122 return result; 1123 } 1124 1125 #ifdef CYGWINMSVC 1126 sprintf(cmd, "cd %s && %s %s.lib %s", 1127 targetDir, 1128 pkgDataFlags[INSTALL_CMD], 1129 libFileNames[LIB_FILE], 1130 installDir 1131 ); 1132 result = runCommand(cmd); 1133 1134 if (result != 0) { 1135 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); 1136 return result; 1137 } 1138 #elif U_PLATFORM == U_PF_CYGWIN 1139 sprintf(cmd, "cd %s && %s %s %s", 1140 targetDir, 1141 pkgDataFlags[INSTALL_CMD], 1142 libFileNames[LIB_FILE_CYGWIN_VERSION], 1143 installDir 1144 ); 1145 result = runCommand(cmd); 1146 1147 if (result != 0) { 1148 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); 1149 return result; 1150 } 1151 1152 #elif U_PLATFORM == U_PF_OS390 1153 if (T_FileStream_file_exists(libFileNames[LIB_FILE_OS390BATCH_VERSION])) { 1154 sprintf(cmd, "%s %s %s", 1155 pkgDataFlags[INSTALL_CMD], 1156 libFileNames[LIB_FILE_OS390BATCH_VERSION], 1157 installDir 1158 ); 1159 result = runCommand(cmd); 1160 1161 if (result != 0) { 1162 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd); 1163 return result; 1164 } 1165 } 1166 #endif 1167 1168 if (noVersion) { 1169 return result; 1170 } else { 1171 return pkg_createSymLinks(installDir, TRUE); 1172 } 1173 } 1174 1175 static int32_t pkg_installCommonMode(const char *installDir, const char *fileName) { 1176 int32_t result = 0; 1177 char cmd[SMALL_BUFFER_MAX_SIZE] = ""; 1178 1179 if (!T_FileStream_file_exists(installDir)) { 1180 UErrorCode status = U_ZERO_ERROR; 1181 1182 uprv_mkdir(installDir, &status); 1183 if (U_FAILURE(status)) { 1184 fprintf(stderr, "Error creating installation directory: %s\n", installDir); 1185 return -1; 1186 } 1187 } 1188 #ifndef U_WINDOWS_WITH_MSVC 1189 sprintf(cmd, "%s %s %s", pkgDataFlags[INSTALL_CMD], fileName, installDir); 1190 #else 1191 sprintf(cmd, "%s %s %s %s", WIN_INSTALL_CMD, fileName, installDir, WIN_INSTALL_CMD_FLAGS); 1192 #endif 1193 1194 result = runCommand(cmd); 1195 if (result != 0) { 1196 fprintf(stderr, "Failed to install data file with command: %s\n", cmd); 1197 } 1198 1199 return result; 1200 } 1201 1202 #ifdef U_WINDOWS_MSVC 1203 /* Copy commands for installing the raw data files on Windows. */ 1204 #define WIN_INSTALL_CMD "xcopy" 1205 #define WIN_INSTALL_CMD_FLAGS "/E /Y /K" 1206 #endif 1207 static int32_t pkg_installFileMode(const char *installDir, const char *srcDir, const char *fileListName) { 1208 int32_t result = 0; 1209 char cmd[SMALL_BUFFER_MAX_SIZE] = ""; 1210 1211 if (!T_FileStream_file_exists(installDir)) { 1212 UErrorCode status = U_ZERO_ERROR; 1213 1214 uprv_mkdir(installDir, &status); 1215 if (U_FAILURE(status)) { 1216 fprintf(stderr, "Error creating installation directory: %s\n", installDir); 1217 return -1; 1218 } 1219 } 1220 #ifndef U_WINDOWS_WITH_MSVC 1221 char buffer[SMALL_BUFFER_MAX_SIZE] = ""; 1222 int32_t bufferLength = 0; 1223 1224 FileStream *f = T_FileStream_open(fileListName, "r"); 1225 if (f != NULL) { 1226 for(;;) { 1227 if (T_FileStream_readLine(f, buffer, SMALL_BUFFER_MAX_SIZE) != NULL) { 1228 bufferLength = uprv_strlen(buffer); 1229 /* Remove new line character. */ 1230 if (bufferLength > 0) { 1231 buffer[bufferLength-1] = 0; 1232 } 1233 1234 sprintf(cmd, "%s %s%s%s %s%s%s", 1235 pkgDataFlags[INSTALL_CMD], 1236 srcDir, PKGDATA_FILE_SEP_STRING, buffer, 1237 installDir, PKGDATA_FILE_SEP_STRING, buffer); 1238 1239 result = runCommand(cmd); 1240 if (result != 0) { 1241 fprintf(stderr, "Failed to install data file with command: %s\n", cmd); 1242 break; 1243 } 1244 } else { 1245 if (!T_FileStream_eof(f)) { 1246 fprintf(stderr, "Failed to read line from file: %s\n", fileListName); 1247 result = -1; 1248 } 1249 break; 1250 } 1251 } 1252 T_FileStream_close(f); 1253 } else { 1254 result = -1; 1255 fprintf(stderr, "Unable to open list file: %s\n", fileListName); 1256 } 1257 #else 1258 sprintf(cmd, "%s %s %s %s", WIN_INSTALL_CMD, srcDir, installDir, WIN_INSTALL_CMD_FLAGS); 1259 result = runCommand(cmd); 1260 if (result != 0) { 1261 fprintf(stderr, "Failed to install data file with command: %s\n", cmd); 1262 } 1263 #endif 1264 1265 return result; 1266 } 1267 1268 /* Archiving of the library file may be needed depending on the platform and options given. 1269 * If archiving is not needed, copy over the library file name. 1270 */ 1271 static int32_t pkg_archiveLibrary(const char *targetDir, const char *version, UBool reverseExt) { 1272 int32_t result = 0; 1273 char cmd[LARGE_BUFFER_MAX_SIZE]; 1274 1275 /* If the shared object suffix and the final object suffix is different and the final object suffix and the 1276 * archive file suffix is the same, then the final library needs to be archived. 1277 */ 1278 if (uprv_strcmp(pkgDataFlags[SOBJ_EXT], pkgDataFlags[SO_EXT]) != 0 && uprv_strcmp(pkgDataFlags[A_EXT], pkgDataFlags[SO_EXT]) == 0) { 1279 sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s.%s", 1280 libFileNames[LIB_FILE], 1281 pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "", 1282 reverseExt ? version : pkgDataFlags[SO_EXT], 1283 reverseExt ? pkgDataFlags[SO_EXT] : version); 1284 1285 sprintf(cmd, "%s %s %s%s %s%s", 1286 pkgDataFlags[AR], 1287 pkgDataFlags[ARFLAGS], 1288 targetDir, 1289 libFileNames[LIB_FILE_VERSION], 1290 targetDir, 1291 libFileNames[LIB_FILE_VERSION_TMP]); 1292 1293 result = runCommand(cmd); 1294 if (result != 0) { 1295 fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd); 1296 return result; 1297 } 1298 1299 sprintf(cmd, "%s %s%s", 1300 pkgDataFlags[RANLIB], 1301 targetDir, 1302 libFileNames[LIB_FILE_VERSION]); 1303 1304 result = runCommand(cmd); 1305 if (result != 0) { 1306 fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd); 1307 return result; 1308 } 1309 1310 /* Remove unneeded library file. */ 1311 sprintf(cmd, "%s %s%s", 1312 RM_CMD, 1313 targetDir, 1314 libFileNames[LIB_FILE_VERSION_TMP]); 1315 1316 result = runCommand(cmd); 1317 if (result != 0) { 1318 fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd); 1319 return result; 1320 } 1321 1322 } else { 1323 uprv_strcpy(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_TMP]); 1324 } 1325 1326 return result; 1327 } 1328 1329 /* 1330 * Using the compiler information from the configuration file set by -O option, generate the library file. 1331 * command may be given to allow for a larger buffer for cmd. 1332 */ 1333 static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command, UBool specialHandling) { 1334 int32_t result = 0; 1335 char *cmd = NULL; 1336 UBool freeCmd = FALSE; 1337 int32_t length = 0; 1338 1339 (void)specialHandling; // Suppress unused variable compiler warnings on platforms where all usage 1340 // of this parameter is #ifdefed out. 1341 1342 /* This is necessary because if packaging is done without assembly code, objectFile might be extremely large 1343 * containing many object files and so the calling function should supply a command buffer that is large 1344 * enough to handle this. Otherwise, use the default size. 1345 */ 1346 if (command != NULL) { 1347 cmd = command; 1348 } 1349 1350 if (IN_STATIC_MODE(mode)) { 1351 if (cmd == NULL) { 1352 length = uprv_strlen(pkgDataFlags[AR]) + uprv_strlen(pkgDataFlags[ARFLAGS]) + uprv_strlen(targetDir) + 1353 uprv_strlen(libFileNames[LIB_FILE_VERSION]) + uprv_strlen(objectFile) + uprv_strlen(pkgDataFlags[RANLIB]) + BUFFER_PADDING_SIZE; 1354 if ((cmd = (char *)uprv_malloc(sizeof(char) * length)) == NULL) { 1355 fprintf(stderr, "Unable to allocate memory for command.\n"); 1356 return -1; 1357 } 1358 freeCmd = TRUE; 1359 } 1360 sprintf(cmd, "%s %s %s%s %s", 1361 pkgDataFlags[AR], 1362 pkgDataFlags[ARFLAGS], 1363 targetDir, 1364 libFileNames[LIB_FILE_VERSION], 1365 objectFile); 1366 1367 result = runCommand(cmd); 1368 if (result == 0) { 1369 sprintf(cmd, "%s %s%s", 1370 pkgDataFlags[RANLIB], 1371 targetDir, 1372 libFileNames[LIB_FILE_VERSION]); 1373 1374 result = runCommand(cmd); 1375 } 1376 } else /* if (IN_DLL_MODE(mode)) */ { 1377 if (cmd == NULL) { 1378 length = uprv_strlen(pkgDataFlags[GENLIB]) + uprv_strlen(pkgDataFlags[LDICUDTFLAGS]) + 1379 ((uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_VERSION_TMP])) * 2) + 1380 uprv_strlen(objectFile) + uprv_strlen(pkgDataFlags[LD_SONAME]) + 1381 uprv_strlen(pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR]) + 1382 uprv_strlen(pkgDataFlags[RPATH_FLAGS]) + uprv_strlen(pkgDataFlags[BIR_FLAGS]) + BUFFER_PADDING_SIZE; 1383 #if U_PLATFORM == U_PF_CYGWIN 1384 length += uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_CYGWIN_VERSION]); 1385 #elif U_PLATFORM == U_PF_MINGW 1386 length += uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_MINGW]); 1387 #endif 1388 if ((cmd = (char *)uprv_malloc(sizeof(char) * length)) == NULL) { 1389 fprintf(stderr, "Unable to allocate memory for command.\n"); 1390 return -1; 1391 } 1392 freeCmd = TRUE; 1393 } 1394 #if U_PLATFORM == U_PF_MINGW 1395 sprintf(cmd, "%s%s%s %s -o %s%s %s %s%s %s %s", 1396 pkgDataFlags[GENLIB], 1397 targetDir, 1398 libFileNames[LIB_FILE_MINGW], 1399 pkgDataFlags[LDICUDTFLAGS], 1400 targetDir, 1401 libFileNames[LIB_FILE_VERSION_TMP], 1402 #elif U_PLATFORM == U_PF_CYGWIN 1403 sprintf(cmd, "%s%s%s %s -o %s%s %s %s%s %s %s", 1404 pkgDataFlags[GENLIB], 1405 targetDir, 1406 libFileNames[LIB_FILE_VERSION_TMP], 1407 pkgDataFlags[LDICUDTFLAGS], 1408 targetDir, 1409 libFileNames[LIB_FILE_CYGWIN_VERSION], 1410 #elif U_PLATFORM == U_PF_AIX 1411 sprintf(cmd, "%s %s%s;%s %s -o %s%s %s %s%s %s %s", 1412 RM_CMD, 1413 targetDir, 1414 libFileNames[LIB_FILE_VERSION_TMP], 1415 pkgDataFlags[GENLIB], 1416 pkgDataFlags[LDICUDTFLAGS], 1417 targetDir, 1418 libFileNames[LIB_FILE_VERSION_TMP], 1419 #else 1420 sprintf(cmd, "%s %s -o %s%s %s %s%s %s %s", 1421 pkgDataFlags[GENLIB], 1422 pkgDataFlags[LDICUDTFLAGS], 1423 targetDir, 1424 libFileNames[LIB_FILE_VERSION_TMP], 1425 #endif 1426 objectFile, 1427 pkgDataFlags[LD_SONAME], 1428 pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR], 1429 pkgDataFlags[RPATH_FLAGS], 1430 pkgDataFlags[BIR_FLAGS]); 1431 1432 /* Generate the library file. */ 1433 result = runCommand(cmd); 1434 1435 #if U_PLATFORM == U_PF_OS390 1436 char *env_tmp; 1437 char PDS_LibName[512]; 1438 char PDS_Name[512]; 1439 1440 PDS_Name[0] = 0; 1441 PDS_LibName[0] = 0; 1442 if (specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata") == 0) { 1443 if (env_tmp = getenv("ICU_PDS_NAME")) { 1444 sprintf(PDS_Name, "%s%s", 1445 env_tmp, 1446 "DA"); 1447 strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX")); 1448 } else if (env_tmp = getenv("PDS_NAME_PREFIX")) { 1449 sprintf(PDS_Name, "%s%s", 1450 env_tmp, 1451 U_ICU_VERSION_SHORT "DA"); 1452 } else { 1453 sprintf(PDS_Name, "%s%s", 1454 "IXMI", 1455 U_ICU_VERSION_SHORT "DA"); 1456 } 1457 } else if (!specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata_stub") == 0) { 1458 if (env_tmp = getenv("ICU_PDS_NAME")) { 1459 sprintf(PDS_Name, "%s%s", 1460 env_tmp, 1461 "D1"); 1462 strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX")); 1463 } else if (env_tmp = getenv("PDS_NAME_PREFIX")) { 1464 sprintf(PDS_Name, "%s%s", 1465 env_tmp, 1466 U_ICU_VERSION_SHORT "D1"); 1467 } else { 1468 sprintf(PDS_Name, "%s%s", 1469 "IXMI", 1470 U_ICU_VERSION_SHORT "D1"); 1471 } 1472 } 1473 1474 if (PDS_Name[0]) { 1475 sprintf(PDS_LibName,"%s%s%s%s%s", 1476 "\"//'", 1477 getenv("LOADMOD"), 1478 "(", 1479 PDS_Name, 1480 ")'\""); 1481 sprintf(cmd, "%s %s -o %s %s %s%s %s %s", 1482 pkgDataFlags[GENLIB], 1483 pkgDataFlags[LDICUDTFLAGS], 1484 PDS_LibName, 1485 objectFile, 1486 pkgDataFlags[LD_SONAME], 1487 pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR], 1488 pkgDataFlags[RPATH_FLAGS], 1489 pkgDataFlags[BIR_FLAGS]); 1490 1491 result = runCommand(cmd); 1492 } 1493 #endif 1494 } 1495 1496 if (result != 0) { 1497 fprintf(stderr, "Error generating library file. Failed command: %s\n", cmd); 1498 } 1499 1500 if (freeCmd) { 1501 uprv_free(cmd); 1502 } 1503 1504 return result; 1505 } 1506 1507 static int32_t pkg_createWithAssemblyCode(const char *targetDir, const char mode, const char *gencFilePath) { 1508 char tempObjectFile[SMALL_BUFFER_MAX_SIZE] = ""; 1509 char *cmd; 1510 int32_t result = 0; 1511 1512 int32_t length = 0; 1513 1514 /* Remove the ending .s and replace it with .o for the new object file. */ 1515 uprv_strcpy(tempObjectFile, gencFilePath); 1516 tempObjectFile[uprv_strlen(tempObjectFile)-1] = 'o'; 1517 1518 length = uprv_strlen(pkgDataFlags[COMPILER]) + uprv_strlen(pkgDataFlags[LIBFLAGS]) 1519 + uprv_strlen(tempObjectFile) + uprv_strlen(gencFilePath) + BUFFER_PADDING_SIZE; 1520 1521 cmd = (char *)uprv_malloc(sizeof(char) * length); 1522 if (cmd == NULL) { 1523 return -1; 1524 } 1525 1526 /* Generate the object file. */ 1527 sprintf(cmd, "%s %s -o %s %s", 1528 pkgDataFlags[COMPILER], 1529 pkgDataFlags[LIBFLAGS], 1530 tempObjectFile, 1531 gencFilePath); 1532 1533 result = runCommand(cmd); 1534 uprv_free(cmd); 1535 if (result != 0) { 1536 fprintf(stderr, "Error creating with assembly code. Failed command: %s\n", cmd); 1537 return result; 1538 } 1539 1540 return pkg_generateLibraryFile(targetDir, mode, tempObjectFile); 1541 } 1542 1543 #ifdef BUILD_DATA_WITHOUT_ASSEMBLY 1544 /* 1545 * Generation of the data library without assembly code needs to compile each data file 1546 * individually and then link it all together. 1547 * Note: Any update to the directory structure of the data needs to be reflected here. 1548 */ 1549 enum { 1550 DATA_PREFIX_BRKITR, 1551 DATA_PREFIX_COLL, 1552 DATA_PREFIX_CURR, 1553 DATA_PREFIX_LANG, 1554 DATA_PREFIX_RBNF, 1555 DATA_PREFIX_REGION, 1556 DATA_PREFIX_TRANSLIT, 1557 DATA_PREFIX_ZONE, 1558 DATA_PREFIX_UNIT, 1559 DATA_PREFIX_LENGTH 1560 }; 1561 1562 const static char DATA_PREFIX[DATA_PREFIX_LENGTH][10] = { 1563 "brkitr", 1564 "coll", 1565 "curr", 1566 "lang", 1567 "rbnf", 1568 "region", 1569 "translit", 1570 "zone", 1571 "unit" 1572 }; 1573 1574 static int32_t pkg_createWithoutAssemblyCode(UPKGOptions *o, const char *targetDir, const char mode) { 1575 int32_t result = 0; 1576 CharList *list = o->filePaths; 1577 CharList *listNames = o->files; 1578 int32_t listSize = pkg_countCharList(list); 1579 char *buffer; 1580 char *cmd; 1581 char gencmnFile[SMALL_BUFFER_MAX_SIZE] = ""; 1582 char tempObjectFile[SMALL_BUFFER_MAX_SIZE] = ""; 1583 #ifdef USE_SINGLE_CCODE_FILE 1584 char icudtAll[SMALL_BUFFER_MAX_SIZE] = ""; 1585 FileStream *icudtAllFile = NULL; 1586 1587 sprintf(icudtAll, "%s%s%sall.c", 1588 o->tmpDir, 1589 PKGDATA_FILE_SEP_STRING, 1590 libFileNames[LIB_FILE]); 1591 /* Remove previous icudtall.c file. */ 1592 if (T_FileStream_file_exists(icudtAll) && (result = remove(icudtAll)) != 0) { 1593 fprintf(stderr, "Unable to remove old icudtall file: %s\n", icudtAll); 1594 return result; 1595 } 1596 1597 if((icudtAllFile = T_FileStream_open(icudtAll, "w"))==NULL) { 1598 fprintf(stderr, "Unable to write to icudtall file: %s\n", icudtAll); 1599 return result; 1600 } 1601 #endif 1602 1603 if (list == NULL || listNames == NULL) { 1604 /* list and listNames should never be NULL since we are looping through the CharList with 1605 * the given size. 1606 */ 1607 return -1; 1608 } 1609 1610 if ((cmd = (char *)uprv_malloc((listSize + 2) * SMALL_BUFFER_MAX_SIZE)) == NULL) { 1611 fprintf(stderr, "Unable to allocate memory for cmd.\n"); 1612 return -1; 1613 } else if ((buffer = (char *)uprv_malloc((listSize + 1) * SMALL_BUFFER_MAX_SIZE)) == NULL) { 1614 fprintf(stderr, "Unable to allocate memory for buffer.\n"); 1615 uprv_free(cmd); 1616 return -1; 1617 } 1618 1619 for (int32_t i = 0; i < (listSize + 1); i++) { 1620 const char *file ; 1621 const char *name; 1622 1623 if (i == 0) { 1624 /* The first iteration calls the gencmn function and initailizes the buffer. */ 1625 createCommonDataFile(o->tmpDir, o->shortName, o->entryName, NULL, o->srcDir, o->comment, o->fileListFiles->str, 0, TRUE, o->verbose, gencmnFile); 1626 buffer[0] = 0; 1627 #ifdef USE_SINGLE_CCODE_FILE 1628 uprv_strcpy(tempObjectFile, gencmnFile); 1629 tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o'; 1630 1631 sprintf(cmd, "%s %s -o %s %s", 1632 pkgDataFlags[COMPILER], 1633 pkgDataFlags[LIBFLAGS], 1634 tempObjectFile, 1635 gencmnFile); 1636 1637 result = runCommand(cmd); 1638 if (result != 0) { 1639 break; 1640 } 1641 1642 sprintf(buffer, "%s",tempObjectFile); 1643 #endif 1644 } else { 1645 char newName[SMALL_BUFFER_MAX_SIZE]; 1646 char dataName[SMALL_BUFFER_MAX_SIZE]; 1647 char dataDirName[SMALL_BUFFER_MAX_SIZE]; 1648 const char *pSubstring; 1649 file = list->str; 1650 name = listNames->str; 1651 1652 newName[0] = dataName[0] = 0; 1653 for (int32_t n = 0; n < DATA_PREFIX_LENGTH; n++) { 1654 dataDirName[0] = 0; 1655 sprintf(dataDirName, "%s%s", DATA_PREFIX[n], PKGDATA_FILE_SEP_STRING); 1656 /* If the name contains a prefix (indicating directory), alter the new name accordingly. */ 1657 pSubstring = uprv_strstr(name, dataDirName); 1658 if (pSubstring != NULL) { 1659 char newNameTmp[SMALL_BUFFER_MAX_SIZE] = ""; 1660 const char *p = name + uprv_strlen(dataDirName); 1661 for (int32_t i = 0;;i++) { 1662 if (p[i] == '.') { 1663 newNameTmp[i] = '_'; 1664 continue; 1665 } 1666 newNameTmp[i] = p[i]; 1667 if (p[i] == 0) { 1668 break; 1669 } 1670 } 1671 sprintf(newName, "%s_%s", 1672 DATA_PREFIX[n], 1673 newNameTmp); 1674 sprintf(dataName, "%s_%s", 1675 o->shortName, 1676 DATA_PREFIX[n]); 1677 } 1678 if (newName[0] != 0) { 1679 break; 1680 } 1681 } 1682 1683 if(o->verbose) { 1684 printf("# Generating %s \n", gencmnFile); 1685 } 1686 1687 writeCCode(file, o->tmpDir, dataName[0] != 0 ? dataName : o->shortName, newName[0] != 0 ? newName : NULL, gencmnFile); 1688 1689 #ifdef USE_SINGLE_CCODE_FILE 1690 sprintf(cmd, "#include \"%s\"\n", gencmnFile); 1691 T_FileStream_writeLine(icudtAllFile, cmd); 1692 /* don't delete the file */ 1693 #endif 1694 } 1695 1696 #ifndef USE_SINGLE_CCODE_FILE 1697 uprv_strcpy(tempObjectFile, gencmnFile); 1698 tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o'; 1699 1700 sprintf(cmd, "%s %s -o %s %s", 1701 pkgDataFlags[COMPILER], 1702 pkgDataFlags[LIBFLAGS], 1703 tempObjectFile, 1704 gencmnFile); 1705 result = runCommand(cmd); 1706 if (result != 0) { 1707 fprintf(stderr, "Error creating library without assembly code. Failed command: %s\n", cmd); 1708 break; 1709 } 1710 1711 uprv_strcat(buffer, " "); 1712 uprv_strcat(buffer, tempObjectFile); 1713 1714 #endif 1715 1716 if (i > 0) { 1717 list = list->next; 1718 listNames = listNames->next; 1719 } 1720 } 1721 1722 #ifdef USE_SINGLE_CCODE_FILE 1723 T_FileStream_close(icudtAllFile); 1724 uprv_strcpy(tempObjectFile, icudtAll); 1725 tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o'; 1726 1727 sprintf(cmd, "%s %s -I. -o %s %s", 1728 pkgDataFlags[COMPILER], 1729 pkgDataFlags[LIBFLAGS], 1730 tempObjectFile, 1731 icudtAll); 1732 1733 result = runCommand(cmd); 1734 if (result == 0) { 1735 uprv_strcat(buffer, " "); 1736 uprv_strcat(buffer, tempObjectFile); 1737 } else { 1738 fprintf(stderr, "Error creating library without assembly code. Failed command: %s\n", cmd); 1739 } 1740 #endif 1741 1742 if (result == 0) { 1743 /* Generate the library file. */ 1744 #if U_PLATFORM == U_PF_OS390 1745 result = pkg_generateLibraryFile(targetDir, mode, buffer, cmd, (o->pdsbuild && IN_DLL_MODE(mode))); 1746 #else 1747 result = pkg_generateLibraryFile(targetDir,mode, buffer, cmd); 1748 #endif 1749 } 1750 1751 uprv_free(buffer); 1752 uprv_free(cmd); 1753 1754 return result; 1755 } 1756 #endif 1757 1758 #ifdef WINDOWS_WITH_MSVC 1759 #define LINK_CMD "link.exe /nologo /release /out:" 1760 #define LINK_FLAGS "/DLL /NOENTRY /MANIFEST:NO /implib:" 1761 #ifdef _WIN64 1762 #define LINK_EXTRA_UWP_FLAGS "/NXCOMPAT /DYNAMICBASE /APPCONTAINER " 1763 #else 1764 #define LINK_EXTRA_UWP_FLAGS "/NXCOMPAT /SAFESEH /DYNAMICBASE /APPCONTAINER /MACHINE:X86" 1765 #endif 1766 #define LINK_EXTRA_UWP_FLAGS_ARM "/NXCOMPAT /DYNAMICBASE /APPCONTAINER /MACHINE:ARM" 1767 #define LINK_EXTRA_NO_UWP_FLAGS "/base:0x4ad00000 " 1768 #define LIB_CMD "LIB.exe /nologo /out:" 1769 #define LIB_FILE "icudt.lib" 1770 #define LIB_EXT UDATA_LIB_SUFFIX 1771 #define DLL_EXT UDATA_SO_SUFFIX 1772 1773 static int32_t pkg_createWindowsDLL(const char mode, const char *gencFilePath, UPKGOptions *o) { 1774 int32_t result = 0; 1775 char cmd[LARGE_BUFFER_MAX_SIZE]; 1776 if (IN_STATIC_MODE(mode)) { 1777 char staticLibFilePath[SMALL_BUFFER_MAX_SIZE] = ""; 1778 1779 #ifdef CYGWINMSVC 1780 sprintf(staticLibFilePath, "%s%s%s%s%s", 1781 o->targetDir, 1782 PKGDATA_FILE_SEP_STRING, 1783 pkgDataFlags[LIBPREFIX], 1784 o->libName, 1785 LIB_EXT); 1786 #else 1787 sprintf(staticLibFilePath, "%s%s%s%s%s", 1788 o->targetDir, 1789 PKGDATA_FILE_SEP_STRING, 1790 (strstr(o->libName, "icudt") ? "s" : ""), 1791 o->libName, 1792 LIB_EXT); 1793 #endif 1794 1795 sprintf(cmd, "%s\"%s\" \"%s\"", 1796 LIB_CMD, 1797 staticLibFilePath, 1798 gencFilePath); 1799 } else if (IN_DLL_MODE(mode)) { 1800 char dllFilePath[SMALL_BUFFER_MAX_SIZE] = ""; 1801 char libFilePath[SMALL_BUFFER_MAX_SIZE] = ""; 1802 char resFilePath[SMALL_BUFFER_MAX_SIZE] = ""; 1803 char tmpResFilePath[SMALL_BUFFER_MAX_SIZE] = ""; 1804 1805 #ifdef CYGWINMSVC 1806 uprv_strcpy(dllFilePath, o->targetDir); 1807 #else 1808 uprv_strcpy(dllFilePath, o->srcDir); 1809 #endif 1810 uprv_strcat(dllFilePath, PKGDATA_FILE_SEP_STRING); 1811 uprv_strcpy(libFilePath, dllFilePath); 1812 1813 #ifdef CYGWINMSVC 1814 uprv_strcat(libFilePath, o->libName); 1815 uprv_strcat(libFilePath, ".lib"); 1816 1817 uprv_strcat(dllFilePath, o->libName); 1818 uprv_strcat(dllFilePath, o->version); 1819 #else 1820 if (strstr(o->libName, "icudt")) { 1821 uprv_strcat(libFilePath, LIB_FILE); 1822 } else { 1823 uprv_strcat(libFilePath, o->libName); 1824 uprv_strcat(libFilePath, ".lib"); 1825 } 1826 uprv_strcat(dllFilePath, o->entryName); 1827 #endif 1828 uprv_strcat(dllFilePath, DLL_EXT); 1829 1830 uprv_strcpy(tmpResFilePath, o->tmpDir); 1831 uprv_strcat(tmpResFilePath, PKGDATA_FILE_SEP_STRING); 1832 uprv_strcat(tmpResFilePath, ICUDATA_RES_FILE); 1833 1834 if (T_FileStream_file_exists(tmpResFilePath)) { 1835 sprintf(resFilePath, "\"%s\"", tmpResFilePath); 1836 } 1837 1838 /* Check if dll file and lib file exists and that it is not newer than genc file. */ 1839 if (!o->rebuild && (T_FileStream_file_exists(dllFilePath) && isFileModTimeLater(dllFilePath, gencFilePath)) && 1840 (T_FileStream_file_exists(libFilePath) && isFileModTimeLater(libFilePath, gencFilePath))) { 1841 if(o->verbose) { 1842 printf("# Not rebuilding %s - up to date.\n", gencFilePath); 1843 } 1844 return 0; 1845 } 1846 1847 char *extraFlags = ""; 1848 #ifdef WINDOWS_WITH_MSVC 1849 if (options[UWP_BUILD].doesOccur) 1850 { 1851 if (options[UWP_ARM_BUILD].doesOccur) 1852 { 1853 extraFlags = LINK_EXTRA_UWP_FLAGS_ARM; 1854 } 1855 else 1856 { 1857 extraFlags = LINK_EXTRA_UWP_FLAGS; 1858 } 1859 } 1860 else 1861 { 1862 extraFlags = LINK_EXTRA_NO_UWP_FLAGS; 1863 } 1864 #endif 1865 sprintf(cmd, "%s\"%s\" %s %s\"%s\" \"%s\" %s", 1866 LINK_CMD, 1867 dllFilePath, 1868 extraFlags, 1869 LINK_FLAGS, 1870 libFilePath, 1871 gencFilePath, 1872 resFilePath 1873 ); 1874 } 1875 1876 result = runCommand(cmd, TRUE); 1877 if (result != 0) { 1878 fprintf(stderr, "Error creating Windows DLL library. Failed command: %s\n", cmd); 1879 } 1880 1881 return result; 1882 } 1883 #endif 1884 1885 static UPKGOptions *pkg_checkFlag(UPKGOptions *o) { 1886 #if U_PLATFORM == U_PF_AIX 1887 /* AIX needs a map file. */ 1888 char *flag = NULL; 1889 int32_t length = 0; 1890 char tmpbuffer[SMALL_BUFFER_MAX_SIZE]; 1891 const char MAP_FILE_EXT[] = ".map"; 1892 FileStream *f = NULL; 1893 char mapFile[SMALL_BUFFER_MAX_SIZE] = ""; 1894 int32_t start = -1; 1895 uint32_t count = 0; 1896 const char rm_cmd[] = "rm -f all ;"; 1897 1898 flag = pkgDataFlags[GENLIB]; 1899 1900 /* This portion of the code removes 'rm -f all' in the GENLIB. 1901 * Only occurs in AIX. 1902 */ 1903 if (uprv_strstr(flag, rm_cmd) != NULL) { 1904 char *tmpGenlibFlagBuffer = NULL; 1905 int32_t i, offset; 1906 1907 length = uprv_strlen(flag) + 1; 1908 tmpGenlibFlagBuffer = (char *)uprv_malloc(length); 1909 if (tmpGenlibFlagBuffer == NULL) { 1910 /* Memory allocation error */ 1911 fprintf(stderr,"Unable to allocate buffer of size: %d.\n", length); 1912 return NULL; 1913 } 1914 1915 uprv_strcpy(tmpGenlibFlagBuffer, flag); 1916 1917 offset = uprv_strlen(rm_cmd); 1918 1919 for (i = 0; i < (length - offset); i++) { 1920 flag[i] = tmpGenlibFlagBuffer[offset + i]; 1921 } 1922 1923 /* Zero terminate the string */ 1924 flag[i] = 0; 1925 1926 uprv_free(tmpGenlibFlagBuffer); 1927 } 1928 1929 flag = pkgDataFlags[BIR_FLAGS]; 1930 length = uprv_strlen(pkgDataFlags[BIR_FLAGS]); 1931 1932 for (int32_t i = 0; i < length; i++) { 1933 if (flag[i] == MAP_FILE_EXT[count]) { 1934 if (count == 0) { 1935 start = i; 1936 } 1937 count++; 1938 } else { 1939 count = 0; 1940 } 1941 1942 if (count == uprv_strlen(MAP_FILE_EXT)) { 1943 break; 1944 } 1945 } 1946 1947 if (start >= 0) { 1948 int32_t index = 0; 1949 for (int32_t i = 0;;i++) { 1950 if (i == start) { 1951 for (int32_t n = 0;;n++) { 1952 if (o->shortName[n] == 0) { 1953 break; 1954 } 1955 tmpbuffer[index++] = o->shortName[n]; 1956 } 1957 } 1958 1959 tmpbuffer[index++] = flag[i]; 1960 1961 if (flag[i] == 0) { 1962 break; 1963 } 1964 } 1965 1966 uprv_memset(flag, 0, length); 1967 uprv_strcpy(flag, tmpbuffer); 1968 1969 uprv_strcpy(mapFile, o->shortName); 1970 uprv_strcat(mapFile, MAP_FILE_EXT); 1971 1972 f = T_FileStream_open(mapFile, "w"); 1973 if (f == NULL) { 1974 fprintf(stderr,"Unable to create map file: %s.\n", mapFile); 1975 return NULL; 1976 } else { 1977 sprintf(tmpbuffer, "%s%s ", o->entryName, UDATA_CMN_INTERMEDIATE_SUFFIX); 1978 1979 T_FileStream_writeLine(f, tmpbuffer); 1980 1981 T_FileStream_close(f); 1982 } 1983 } 1984 #elif U_PLATFORM == U_PF_CYGWIN || U_PLATFORM == U_PF_MINGW 1985 /* Cygwin needs to change flag options. */ 1986 char *flag = NULL; 1987 int32_t length = 0; 1988 1989 flag = pkgDataFlags[GENLIB]; 1990 length = uprv_strlen(pkgDataFlags[GENLIB]); 1991 1992 int32_t position = length - 1; 1993 1994 for(;position >= 0;position--) { 1995 if (flag[position] == '=') { 1996 position++; 1997 break; 1998 } 1999 } 2000 2001 uprv_memset(flag + position, 0, length - position); 2002 #elif U_PLATFORM == U_PF_OS400 2003 /* OS/400 needs to fix the ld options (swap single quote with double quote) */ 2004 char *flag = NULL; 2005 int32_t length = 0; 2006 2007 flag = pkgDataFlags[GENLIB]; 2008 length = uprv_strlen(pkgDataFlags[GENLIB]); 2009 2010 int32_t position = length - 1; 2011 2012 for(int32_t i = 0; i < length; i++) { 2013 if (flag[i] == '\'') { 2014 flag[i] = '\"'; 2015 } 2016 } 2017 #endif 2018 // Don't really need a return value, just need to stop compiler warnings about 2019 // the unused parameter 'o' on platforms where it is not otherwise used. 2020 return o; 2021 } 2022 2023 static void loadLists(UPKGOptions *o, UErrorCode *status) 2024 { 2025 CharList *l, *tail = NULL, *tail2 = NULL; 2026 FileStream *in; 2027 char line[16384]; 2028 char *linePtr, *lineNext; 2029 const uint32_t lineMax = 16300; 2030 char *tmp; 2031 int32_t tmpLength = 0; 2032 char *s; 2033 int32_t ln=0; /* line number */ 2034 2035 for(l = o->fileListFiles; l; l = l->next) { 2036 if(o->verbose) { 2037 fprintf(stdout, "# pkgdata: Reading %s..\n", l->str); 2038 } 2039 /* TODO: stdin */ 2040 in = T_FileStream_open(l->str, "r"); /* open files list */ 2041 2042 if(!in) { 2043 fprintf(stderr, "Error opening <%s>.\n", l->str); 2044 *status = U_FILE_ACCESS_ERROR; 2045 return; 2046 } 2047 2048 while(T_FileStream_readLine(in, line, sizeof(line))!=NULL) { /* for each line */ 2049 ln++; 2050 if(uprv_strlen(line)>lineMax) { 2051 fprintf(stderr, "%s:%d - line too long (over %d chars)\n", l->str, (int)ln, (int)lineMax); 2052 exit(1); 2053 } 2054 /* remove spaces at the beginning */ 2055 linePtr = line; 2056 /* On z/OS, disable call to isspace (#9996). Investigate using uprv_isspace instead (#9999) */ 2057 #if U_PLATFORM != U_PF_OS390 2058 while(isspace(*linePtr)) { 2059 linePtr++; 2060 } 2061 #endif 2062 s=linePtr; 2063 /* remove trailing newline characters */ 2064 while(*s!=0) { 2065 if(*s=='\r' || *s=='\n') { 2066 *s=0; 2067 break; 2068 } 2069 ++s; 2070 } 2071 if((*linePtr == 0) || (*linePtr == '#')) { 2072 continue; /* comment or empty line */ 2073 } 2074 2075 /* Now, process the line */ 2076 lineNext = NULL; 2077 2078 while(linePtr && *linePtr) { /* process space-separated items */ 2079 while(*linePtr == ' ') { 2080 linePtr++; 2081 } 2082 /* Find the next quote */ 2083 if(linePtr[0] == '"') 2084 { 2085 lineNext = uprv_strchr(linePtr+1, '"'); 2086 if(lineNext == NULL) { 2087 fprintf(stderr, "%s:%d - missing trailing double quote (\")\n", 2088 l->str, (int)ln); 2089 exit(1); 2090 } else { 2091 lineNext++; 2092 if(*lineNext) { 2093 if(*lineNext != ' ') { 2094 fprintf(stderr, "%s:%d - malformed quoted line at position %d, expected ' ' got '%c'\n", 2095 l->str, (int)ln, (int)(lineNext-line), (*lineNext)?*lineNext:'0'); 2096 exit(1); 2097 } 2098 *lineNext = 0; 2099 lineNext++; 2100 } 2101 } 2102 } else { 2103 lineNext = uprv_strchr(linePtr, ' '); 2104 if(lineNext) { 2105 *lineNext = 0; /* terminate at space */ 2106 lineNext++; 2107 } 2108 } 2109 2110 /* add the file */ 2111 s = (char*)getLongPathname(linePtr); 2112 2113 /* normal mode.. o->files is just the bare list without package names */ 2114 o->files = pkg_appendToList(o->files, &tail, uprv_strdup(linePtr)); 2115 if(uprv_pathIsAbsolute(s) || s[0] == '.') { 2116 fprintf(stderr, "pkgdata: Error: absolute path encountered. Old style paths are not supported. Use relative paths such as 'fur.res' or 'translit%cfur.res'.\n\tBad path: '%s'\n", U_FILE_SEP_CHAR, s); 2117 exit(U_ILLEGAL_ARGUMENT_ERROR); 2118 } 2119 tmpLength = uprv_strlen(o->srcDir) + 2120 uprv_strlen(s) + 5; /* 5 is to add a little extra space for, among other things, PKGDATA_FILE_SEP_STRING */ 2121 if((tmp = (char *)uprv_malloc(tmpLength)) == NULL) { 2122 fprintf(stderr, "pkgdata: Error: Unable to allocate tmp buffer size: %d\n", tmpLength); 2123 exit(U_MEMORY_ALLOCATION_ERROR); 2124 } 2125 uprv_strcpy(tmp, o->srcDir); 2126 uprv_strcat(tmp, o->srcDir[uprv_strlen(o->srcDir)-1] == U_FILE_SEP_CHAR ? "" : PKGDATA_FILE_SEP_STRING); 2127 uprv_strcat(tmp, s); 2128 o->filePaths = pkg_appendToList(o->filePaths, &tail2, tmp); 2129 linePtr = lineNext; 2130 } /* for each entry on line */ 2131 } /* for each line */ 2132 T_FileStream_close(in); 2133 } /* for each file list file */ 2134 } 2135 2136 /* Try calling icu-config directly to get the option file. */ 2137 static int32_t pkg_getOptionsFromICUConfig(UBool verbose, UOption *option) { 2138 #if U_HAVE_POPEN 2139 LocalPipeFilePointer p; 2140 size_t n; 2141 static char buf[512] = ""; 2142 icu::CharString cmdBuf; 2143 UErrorCode status = U_ZERO_ERROR; 2144 const char cmd[] = "icu-config --incpkgdatafile"; 2145 char dirBuf[1024] = ""; 2146 /* #1 try the same path where pkgdata was called from. */ 2147 findDirname(progname, dirBuf, UPRV_LENGTHOF(dirBuf), &status); 2148 if(U_SUCCESS(status)) { 2149 cmdBuf.append(dirBuf, status); 2150 if (cmdBuf[0] != 0) { 2151 cmdBuf.append( U_FILE_SEP_STRING, status ); 2152 } 2153 cmdBuf.append( cmd, status ); 2154 2155 if(verbose) { 2156 fprintf(stdout, "# Calling icu-config: %s\n", cmdBuf.data()); 2157 } 2158 p.adoptInstead(popen(cmdBuf.data(), "r")); 2159 } 2160 2161 if(p.isNull() || (n = fread(buf, 1, UPRV_LENGTHOF(buf)-1, p.getAlias())) <= 0) { 2162 if(verbose) { 2163 fprintf(stdout, "# Calling icu-config: %s\n", cmd); 2164 } 2165 2166 p.adoptInstead(popen(cmd, "r")); 2167 if(p.isNull() || (n = fread(buf, 1, UPRV_LENGTHOF(buf)-1, p.getAlias())) <= 0) { 2168 fprintf(stderr, "%s: icu-config: No icu-config found. (fix PATH or use -O option)\n", progname); 2169 return -1; 2170 } 2171 } 2172 2173 for (int32_t length = strlen(buf) - 1; length >= 0; length--) { 2174 if (buf[length] == '\n' || buf[length] == ' ') { 2175 buf[length] = 0; 2176 } else { 2177 break; 2178 } 2179 } 2180 2181 if(buf[strlen(buf)-1]=='\n') 2182 { 2183 buf[strlen(buf)-1]=0; 2184 } 2185 2186 if(buf[0] == 0) 2187 { 2188 fprintf(stderr, "%s: icu-config: invalid response from icu-config (fix PATH or use -O option)\n", progname); 2189 return -1; 2190 } 2191 2192 if(verbose) { 2193 fprintf(stdout, "# icu-config said: %s\n", buf); 2194 } 2195 2196 option->value = buf; 2197 option->doesOccur = TRUE; 2198 2199 return 0; 2200 #else 2201 return -1; 2202 #endif 2203 } 2204 2205 #ifdef CAN_WRITE_OBJ_CODE 2206 /* Create optMatchArch for genccode architecture detection */ 2207 static void pkg_createOptMatchArch(char *optMatchArch) { 2208 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) 2209 const char* code = "void oma(){}"; 2210 const char* source = "oma.c"; 2211 const char* obj = "oma.obj"; 2212 FileStream* stream = NULL; 2213 2214 stream = T_FileStream_open(source,"w"); 2215 if (stream != NULL) { 2216 T_FileStream_writeLine(stream, code); 2217 T_FileStream_close(stream); 2218 2219 char cmd[LARGE_BUFFER_MAX_SIZE]; 2220 sprintf(cmd, "%s %s -o %s", 2221 pkgDataFlags[COMPILER], 2222 source, 2223 obj); 2224 2225 if (runCommand(cmd) == 0){ 2226 sprintf(optMatchArch, "%s", obj); 2227 } 2228 else { 2229 fprintf(stderr, "Failed to compile %s\n", source); 2230 } 2231 if(!T_FileStream_remove(source)){ 2232 fprintf(stderr, "T_FileStream_remove failed to delete %s\n", source); 2233 } 2234 } 2235 else { 2236 fprintf(stderr, "T_FileStream_open failed to open %s for writing\n", source); 2237 } 2238 #endif 2239 } 2240 static void pkg_destroyOptMatchArch(char *optMatchArch) { 2241 if(T_FileStream_file_exists(optMatchArch) && !T_FileStream_remove(optMatchArch)){ 2242 fprintf(stderr, "T_FileStream_remove failed to delete %s\n", optMatchArch); 2243 } 2244 } 2245 #endif 2246
