]> git.saurik.com Git - apple/icu.git/blob - icuSources/tools/pkgdata/pkgdata.cpp
projects / apple / icu.git / blob
? search:


226e4b3f6b773848f632b97f75e56cd3c1d98b13
[apple/icu.git] / icuSources / tools / pkgdata / pkgdata.cpp
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 return result;
508 }
509
510 static int runCommand(const char* command, UBool specialHandling) {
511 char *cmd = NULL;
512 char cmdBuffer[SMALL_BUFFER_MAX_SIZE];
513 int32_t len = static_cast<int32_t>(strlen(command));
514
515 if (len == 0) {
516 return 0;
517 }
518
519 if (!specialHandling) {
520 #if defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW || U_PLATFORM == U_PF_OS400
521 if ((len + BUFFER_PADDING_SIZE) >= SMALL_BUFFER_MAX_SIZE) {
522 cmd = (char *)uprv_malloc(len + BUFFER_PADDING_SIZE);
523 } else {
524 cmd = cmdBuffer;
525 }
526 #if defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW
527 sprintf(cmd, "bash -c \"%s\"", command);
528
529 #elif U_PLATFORM == U_PF_OS400
530 sprintf(cmd, "QSH CMD('%s')", command);
531 #endif
532 #else
533 goto normal_command_mode;
534 #endif
535 } else {
536 #if !(defined(USING_CYGWIN) || U_PLATFORM == U_PF_MINGW || U_PLATFORM == U_PF_OS400)
537 normal_command_mode:
538 #endif
539 cmd = (char *)command;
540 }
541
542 printf("pkgdata: %s\n", cmd);
543 int result = system(cmd);
544 if (result != 0) {
545 fprintf(stderr, "-- return status = %d\n", result);
546 result = 1; // system() result code is platform specific.
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%s",
908 (strstr(libName, "icudt") ? "lib" : ""),
909 pkgDataFlags[LIBPREFIX],
910 libName);
911 }
912 #else
913 sprintf(libFileNames[LIB_FILE], "%s%s",
914 pkgDataFlags[LIBPREFIX],
915 libName);
916 #endif
917
918 if(o->verbose) {
919 fprintf(stdout, "# libFileName[LIB_FILE] = %s\n", libFileNames[LIB_FILE]);
920 }
921
922 #if U_PLATFORM == U_PF_MINGW
923 // Name the import library lib*.dll.a
924 sprintf(libFileNames[LIB_FILE_MINGW], "lib%s.dll.a", libName);
925 #elif U_PLATFORM == U_PF_CYGWIN
926 sprintf(libFileNames[LIB_FILE_CYGWIN], "cyg%s%s%s",
927 libName,
928 FILE_EXTENSION_SEP,
929 pkgDataFlags[SO_EXT]);
930 sprintf(libFileNames[LIB_FILE_CYGWIN_VERSION], "cyg%s%s%s%s",
931 libName,
932 version_major,
933 FILE_EXTENSION_SEP,
934 pkgDataFlags[SO_EXT]);
935
936 uprv_strcat(pkgDataFlags[SO_EXT], ".");
937 uprv_strcat(pkgDataFlags[SO_EXT], pkgDataFlags[A_EXT]);
938 #elif U_PLATFORM == U_PF_OS400 || defined(_AIX)
939 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s",
940 libFileNames[LIB_FILE],
941 FILE_EXTENSION_SEP,
942 pkgDataFlags[SOBJ_EXT]);
943 #elif U_PLATFORM == U_PF_OS390
944 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s%s%s",
945 libFileNames[LIB_FILE],
946 pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
947 reverseExt ? version : pkgDataFlags[SOBJ_EXT],
948 FILE_EXTENSION_SEP,
949 reverseExt ? pkgDataFlags[SOBJ_EXT] : version);
950
951 sprintf(libFileNames[LIB_FILE_OS390BATCH_VERSION], "%s%s.x",
952 libFileNames[LIB_FILE],
953 version);
954 sprintf(libFileNames[LIB_FILE_OS390BATCH_MAJOR], "%s%s.x",
955 libFileNames[LIB_FILE],
956 version_major);
957 #else
958 if (noVersion && !reverseExt) {
959 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s",
960 libFileNames[LIB_FILE],
961 FILE_SUFFIX,
962 pkgDataFlags[SOBJ_EXT]);
963 } else {
964 sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s%s%s",
965 libFileNames[LIB_FILE],
966 FILE_SUFFIX,
967 reverseExt ? version : pkgDataFlags[SOBJ_EXT],
968 FILE_EXTENSION_SEP,
969 reverseExt ? pkgDataFlags[SOBJ_EXT] : version);
970 }
971 #endif
972 if (noVersion && !reverseExt) {
973 sprintf(libFileNames[LIB_FILE_VERSION_MAJOR], "%s%s%s",
974 libFileNames[LIB_FILE],
975 FILE_SUFFIX,
976 pkgDataFlags[SO_EXT]);
977
978 sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s",
979 libFileNames[LIB_FILE],
980 FILE_SUFFIX,
981 pkgDataFlags[SO_EXT]);
982 } else {
983 sprintf(libFileNames[LIB_FILE_VERSION_MAJOR], "%s%s%s%s%s",
984 libFileNames[LIB_FILE],
985 FILE_SUFFIX,
986 reverseExt ? version_major : pkgDataFlags[SO_EXT],
987 FILE_EXTENSION_SEP,
988 reverseExt ? pkgDataFlags[SO_EXT] : version_major);
989
990 sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s%s%s",
991 libFileNames[LIB_FILE],
992 FILE_SUFFIX,
993 reverseExt ? version : pkgDataFlags[SO_EXT],
994 FILE_EXTENSION_SEP,
995 reverseExt ? pkgDataFlags[SO_EXT] : version);
996 }
997
998 if(o->verbose) {
999 fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s\n", libFileNames[LIB_FILE_VERSION]);
1000 }
1001
1002 #if U_PF_MINGW <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
1003 /* Cygwin and MinGW only deals with the version major number. */
1004 uprv_strcpy(libFileNames[LIB_FILE_VERSION_TMP], libFileNames[LIB_FILE_VERSION_MAJOR]);
1005 #endif
1006
1007 if(IN_STATIC_MODE(mode)) {
1008 sprintf(libFileNames[LIB_FILE_VERSION], "%s.%s", libFileNames[LIB_FILE], pkgDataFlags[A_EXT]);
1009 libFileNames[LIB_FILE_VERSION_MAJOR][0]=0;
1010 if(o->verbose) {
1011 fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s (static)\n", libFileNames[LIB_FILE_VERSION]);
1012 }
1013 }
1014 }
1015
1016 /* Create the symbolic links for the final library file. */
1017 static int32_t pkg_createSymLinks(const char *targetDir, UBool specialHandling) {
1018 int32_t result = 0;
1019 char cmd[LARGE_BUFFER_MAX_SIZE];
1020 char name1[SMALL_BUFFER_MAX_SIZE]; /* symlink file name */
1021 char name2[SMALL_BUFFER_MAX_SIZE]; /* file name to symlink */
1022 const char* FILE_EXTENSION_SEP = uprv_strlen(pkgDataFlags[SO_EXT]) == 0 ? "" : ".";
1023
1024 #if U_PLATFORM != U_PF_CYGWIN
1025 /* No symbolic link to make. */
1026 if (uprv_strlen(libFileNames[LIB_FILE_VERSION]) == 0 || uprv_strlen(libFileNames[LIB_FILE_VERSION_MAJOR]) == 0 ||
1027 uprv_strcmp(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_MAJOR]) == 0) {
1028 return result;
1029 }
1030
1031 sprintf(cmd, "cd %s && %s %s && %s %s %s",
1032 targetDir,
1033 RM_CMD,
1034 libFileNames[LIB_FILE_VERSION_MAJOR],
1035 LN_CMD,
1036 libFileNames[LIB_FILE_VERSION],
1037 libFileNames[LIB_FILE_VERSION_MAJOR]);
1038 result = runCommand(cmd);
1039 if (result != 0) {
1040 fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd);
1041 return result;
1042 }
1043 #endif
1044
1045 if (specialHandling) {
1046 #if U_PLATFORM == U_PF_CYGWIN
1047 sprintf(name1, "%s", libFileNames[LIB_FILE_CYGWIN]);
1048 sprintf(name2, "%s", libFileNames[LIB_FILE_CYGWIN_VERSION]);
1049 #elif U_PLATFORM == U_PF_OS390
1050 /* Create the symbolic links for the import data */
1051 /* Use the cmd buffer to store path to import data file to check its existence */
1052 sprintf(cmd, "%s/%s", targetDir, libFileNames[LIB_FILE_OS390BATCH_VERSION]);
1053 if (T_FileStream_file_exists(cmd)) {
1054 sprintf(cmd, "cd %s && %s %s && %s %s %s",
1055 targetDir,
1056 RM_CMD,
1057 libFileNames[LIB_FILE_OS390BATCH_MAJOR],
1058 LN_CMD,
1059 libFileNames[LIB_FILE_OS390BATCH_VERSION],
1060 libFileNames[LIB_FILE_OS390BATCH_MAJOR]);
1061 result = runCommand(cmd);
1062 if (result != 0) {
1063 fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd);
1064 return result;
1065 }
1066
1067 sprintf(cmd, "cd %s && %s %s.x && %s %s %s.x",
1068 targetDir,
1069 RM_CMD,
1070 libFileNames[LIB_FILE],
1071 LN_CMD,
1072 libFileNames[LIB_FILE_OS390BATCH_VERSION],
1073 libFileNames[LIB_FILE]);
1074 result = runCommand(cmd);
1075 if (result != 0) {
1076 fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd);
1077 return result;
1078 }
1079 }
1080
1081 /* Needs to be set here because special handling skips it */
1082 sprintf(name1, "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]);
1083 sprintf(name2, "%s", libFileNames[LIB_FILE_VERSION]);
1084 #else
1085 goto normal_symlink_mode;
1086 #endif
1087 } else {
1088 #if U_PLATFORM != U_PF_CYGWIN
1089 normal_symlink_mode:
1090 #endif
1091 sprintf(name1, "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]);
1092 sprintf(name2, "%s", libFileNames[LIB_FILE_VERSION]);
1093 }
1094
1095 sprintf(cmd, "cd %s && %s %s && %s %s %s",
1096 targetDir,
1097 RM_CMD,
1098 name1,
1099 LN_CMD,
1100 name2,
1101 name1);
1102
1103 result = runCommand(cmd);
1104
1105 return result;
1106 }
1107
1108 static int32_t pkg_installLibrary(const char *installDir, const char *targetDir, UBool noVersion) {
1109 int32_t result = 0;
1110 char cmd[SMALL_BUFFER_MAX_SIZE];
1111
1112 sprintf(cmd, "cd %s && %s %s %s%s%s",
1113 targetDir,
1114 pkgDataFlags[INSTALL_CMD],
1115 libFileNames[LIB_FILE_VERSION],
1116 installDir, PKGDATA_FILE_SEP_STRING, libFileNames[LIB_FILE_VERSION]
1117 );
1118
1119 result = runCommand(cmd);
1120
1121 if (result != 0) {
1122 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd);
1123 return result;
1124 }
1125
1126 #ifdef CYGWINMSVC
1127 sprintf(cmd, "cd %s && %s %s.lib %s",
1128 targetDir,
1129 pkgDataFlags[INSTALL_CMD],
1130 libFileNames[LIB_FILE],
1131 installDir
1132 );
1133 result = runCommand(cmd);
1134
1135 if (result != 0) {
1136 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd);
1137 return result;
1138 }
1139 #elif U_PLATFORM == U_PF_CYGWIN
1140 sprintf(cmd, "cd %s && %s %s %s",
1141 targetDir,
1142 pkgDataFlags[INSTALL_CMD],
1143 libFileNames[LIB_FILE_CYGWIN_VERSION],
1144 installDir
1145 );
1146 result = runCommand(cmd);
1147
1148 if (result != 0) {
1149 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd);
1150 return result;
1151 }
1152
1153 #elif U_PLATFORM == U_PF_OS390
1154 if (T_FileStream_file_exists(libFileNames[LIB_FILE_OS390BATCH_VERSION])) {
1155 sprintf(cmd, "%s %s %s",
1156 pkgDataFlags[INSTALL_CMD],
1157 libFileNames[LIB_FILE_OS390BATCH_VERSION],
1158 installDir
1159 );
1160 result = runCommand(cmd);
1161
1162 if (result != 0) {
1163 fprintf(stderr, "Error installing library. Failed command: %s\n", cmd);
1164 return result;
1165 }
1166 }
1167 #endif
1168
1169 if (noVersion) {
1170 return result;
1171 } else {
1172 return pkg_createSymLinks(installDir, TRUE);
1173 }
1174 }
1175
1176 static int32_t pkg_installCommonMode(const char *installDir, const char *fileName) {
1177 int32_t result = 0;
1178 char cmd[SMALL_BUFFER_MAX_SIZE] = "";
1179
1180 if (!T_FileStream_file_exists(installDir)) {
1181 UErrorCode status = U_ZERO_ERROR;
1182
1183 uprv_mkdir(installDir, &status);
1184 if (U_FAILURE(status)) {
1185 fprintf(stderr, "Error creating installation directory: %s\n", installDir);
1186 return -1;
1187 }
1188 }
1189 #ifndef U_WINDOWS_WITH_MSVC
1190 sprintf(cmd, "%s %s %s", pkgDataFlags[INSTALL_CMD], fileName, installDir);
1191 #else
1192 sprintf(cmd, "%s %s %s %s", WIN_INSTALL_CMD, fileName, installDir, WIN_INSTALL_CMD_FLAGS);
1193 #endif
1194
1195 result = runCommand(cmd);
1196 if (result != 0) {
1197 fprintf(stderr, "Failed to install data file with command: %s\n", cmd);
1198 }
1199
1200 return result;
1201 }
1202
1203 #ifdef U_WINDOWS_MSVC
1204 /* Copy commands for installing the raw data files on Windows. */
1205 #define WIN_INSTALL_CMD "xcopy"
1206 #define WIN_INSTALL_CMD_FLAGS "/E /Y /K"
1207 #endif
1208 static int32_t pkg_installFileMode(const char *installDir, const char *srcDir, const char *fileListName) {
1209 int32_t result = 0;
1210 char cmd[SMALL_BUFFER_MAX_SIZE] = "";
1211
1212 if (!T_FileStream_file_exists(installDir)) {
1213 UErrorCode status = U_ZERO_ERROR;
1214
1215 uprv_mkdir(installDir, &status);
1216 if (U_FAILURE(status)) {
1217 fprintf(stderr, "Error creating installation directory: %s\n", installDir);
1218 return -1;
1219 }
1220 }
1221 #ifndef U_WINDOWS_WITH_MSVC
1222 char buffer[SMALL_BUFFER_MAX_SIZE] = "";
1223 int32_t bufferLength = 0;
1224
1225 FileStream *f = T_FileStream_open(fileListName, "r");
1226 if (f != NULL) {
1227 for(;;) {
1228 if (T_FileStream_readLine(f, buffer, SMALL_BUFFER_MAX_SIZE) != NULL) {
1229 bufferLength = static_cast<int32_t>(uprv_strlen(buffer));
1230 /* Remove new line character. */
1231 if (bufferLength > 0) {
1232 buffer[bufferLength-1] = 0;
1233 }
1234
1235 sprintf(cmd, "%s %s%s%s %s%s%s",
1236 pkgDataFlags[INSTALL_CMD],
1237 srcDir, PKGDATA_FILE_SEP_STRING, buffer,
1238 installDir, PKGDATA_FILE_SEP_STRING, buffer);
1239
1240 result = runCommand(cmd);
1241 if (result != 0) {
1242 fprintf(stderr, "Failed to install data file with command: %s\n", cmd);
1243 break;
1244 }
1245 } else {
1246 if (!T_FileStream_eof(f)) {
1247 fprintf(stderr, "Failed to read line from file: %s\n", fileListName);
1248 result = -1;
1249 }
1250 break;
1251 }
1252 }
1253 T_FileStream_close(f);
1254 } else {
1255 result = -1;
1256 fprintf(stderr, "Unable to open list file: %s\n", fileListName);
1257 }
1258 #else
1259 sprintf(cmd, "%s %s %s %s", WIN_INSTALL_CMD, srcDir, installDir, WIN_INSTALL_CMD_FLAGS);
1260 result = runCommand(cmd);
1261 if (result != 0) {
1262 fprintf(stderr, "Failed to install data file with command: %s\n", cmd);
1263 }
1264 #endif
1265
1266 return result;
1267 }
1268
1269 /* Archiving of the library file may be needed depending on the platform and options given.
1270 * If archiving is not needed, copy over the library file name.
1271 */
1272 static int32_t pkg_archiveLibrary(const char *targetDir, const char *version, UBool reverseExt) {
1273 int32_t result = 0;
1274 char cmd[LARGE_BUFFER_MAX_SIZE];
1275
1276 /* If the shared object suffix and the final object suffix is different and the final object suffix and the
1277 * archive file suffix is the same, then the final library needs to be archived.
1278 */
1279 if (uprv_strcmp(pkgDataFlags[SOBJ_EXT], pkgDataFlags[SO_EXT]) != 0 && uprv_strcmp(pkgDataFlags[A_EXT], pkgDataFlags[SO_EXT]) == 0) {
1280 sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s.%s",
1281 libFileNames[LIB_FILE],
1282 pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
1283 reverseExt ? version : pkgDataFlags[SO_EXT],
1284 reverseExt ? pkgDataFlags[SO_EXT] : version);
1285
1286 sprintf(cmd, "%s %s %s%s %s%s",
1287 pkgDataFlags[AR],
1288 pkgDataFlags[ARFLAGS],
1289 targetDir,
1290 libFileNames[LIB_FILE_VERSION],
1291 targetDir,
1292 libFileNames[LIB_FILE_VERSION_TMP]);
1293
1294 result = runCommand(cmd);
1295 if (result != 0) {
1296 fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd);
1297 return result;
1298 }
1299
1300 sprintf(cmd, "%s %s%s",
1301 pkgDataFlags[RANLIB],
1302 targetDir,
1303 libFileNames[LIB_FILE_VERSION]);
1304
1305 result = runCommand(cmd);
1306 if (result != 0) {
1307 fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd);
1308 return result;
1309 }
1310
1311 /* Remove unneeded library file. */
1312 sprintf(cmd, "%s %s%s",
1313 RM_CMD,
1314 targetDir,
1315 libFileNames[LIB_FILE_VERSION_TMP]);
1316
1317 result = runCommand(cmd);
1318 if (result != 0) {
1319 fprintf(stderr, "Error creating archive library. Failed command: %s\n", cmd);
1320 return result;
1321 }
1322
1323 } else {
1324 uprv_strcpy(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_TMP]);
1325 }
1326
1327 return result;
1328 }
1329
1330 /*
1331 * Using the compiler information from the configuration file set by -O option, generate the library file.
1332 * command may be given to allow for a larger buffer for cmd.
1333 */
1334 static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command, UBool specialHandling) {
1335 int32_t result = 0;
1336 char *cmd = NULL;
1337 UBool freeCmd = FALSE;
1338 int32_t length = 0;
1339
1340 (void)specialHandling; // Suppress unused variable compiler warnings on platforms where all usage
1341 // of this parameter is #ifdefed out.
1342
1343 /* This is necessary because if packaging is done without assembly code, objectFile might be extremely large
1344 * containing many object files and so the calling function should supply a command buffer that is large
1345 * enough to handle this. Otherwise, use the default size.
1346 */
1347 if (command != NULL) {
1348 cmd = command;
1349 }
1350
1351 if (IN_STATIC_MODE(mode)) {
1352 if (cmd == NULL) {
1353 length = static_cast<int32_t>(uprv_strlen(pkgDataFlags[AR]) + uprv_strlen(pkgDataFlags[ARFLAGS]) + uprv_strlen(targetDir) +
1354 uprv_strlen(libFileNames[LIB_FILE_VERSION]) + uprv_strlen(objectFile) + uprv_strlen(pkgDataFlags[RANLIB]) + BUFFER_PADDING_SIZE);
1355 if ((cmd = (char *)uprv_malloc(sizeof(char) * length)) == NULL) {
1356 fprintf(stderr, "Unable to allocate memory for command.\n");
1357 return -1;
1358 }
1359 freeCmd = TRUE;
1360 }
1361 sprintf(cmd, "%s %s %s%s %s",
1362 pkgDataFlags[AR],
1363 pkgDataFlags[ARFLAGS],
1364 targetDir,
1365 libFileNames[LIB_FILE_VERSION],
1366 objectFile);
1367
1368 result = runCommand(cmd);
1369 if (result == 0) {
1370 sprintf(cmd, "%s %s%s",
1371 pkgDataFlags[RANLIB],
1372 targetDir,
1373 libFileNames[LIB_FILE_VERSION]);
1374
1375 result = runCommand(cmd);
1376 }
1377 } else /* if (IN_DLL_MODE(mode)) */ {
1378 if (cmd == NULL) {
1379 length = static_cast<int32_t>(uprv_strlen(pkgDataFlags[GENLIB]) + uprv_strlen(pkgDataFlags[LDICUDTFLAGS]) +
1380 ((uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_VERSION_TMP])) * 2) +
1381 uprv_strlen(objectFile) + uprv_strlen(pkgDataFlags[LD_SONAME]) +
1382 uprv_strlen(pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR]) +
1383 uprv_strlen(pkgDataFlags[RPATH_FLAGS]) + uprv_strlen(pkgDataFlags[BIR_FLAGS]) + BUFFER_PADDING_SIZE);
1384 #if U_PLATFORM == U_PF_CYGWIN
1385 length += static_cast<int32_t>(uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_CYGWIN_VERSION]));
1386 #elif U_PLATFORM == U_PF_MINGW
1387 length += static_cast<int32_t>(uprv_strlen(targetDir) + uprv_strlen(libFileNames[LIB_FILE_MINGW]));
1388 #endif
1389 if ((cmd = (char *)uprv_malloc(sizeof(char) * length)) == NULL) {
1390 fprintf(stderr, "Unable to allocate memory for command.\n");
1391 return -1;
1392 }
1393 freeCmd = TRUE;
1394 }
1395 #if U_PLATFORM == U_PF_MINGW
1396 sprintf(cmd, "%s%s%s %s -o %s%s %s %s%s %s %s",
1397 pkgDataFlags[GENLIB],
1398 targetDir,
1399 libFileNames[LIB_FILE_MINGW],
1400 pkgDataFlags[LDICUDTFLAGS],
1401 targetDir,
1402 libFileNames[LIB_FILE_VERSION_TMP],
1403 #elif U_PLATFORM == U_PF_CYGWIN
1404 sprintf(cmd, "%s%s%s %s -o %s%s %s %s%s %s %s",
1405 pkgDataFlags[GENLIB],
1406 targetDir,
1407 libFileNames[LIB_FILE_VERSION_TMP],
1408 pkgDataFlags[LDICUDTFLAGS],
1409 targetDir,
1410 libFileNames[LIB_FILE_CYGWIN_VERSION],
1411 #elif U_PLATFORM == U_PF_AIX
1412 sprintf(cmd, "%s %s%s;%s %s -o %s%s %s %s%s %s %s",
1413 RM_CMD,
1414 targetDir,
1415 libFileNames[LIB_FILE_VERSION_TMP],
1416 pkgDataFlags[GENLIB],
1417 pkgDataFlags[LDICUDTFLAGS],
1418 targetDir,
1419 libFileNames[LIB_FILE_VERSION_TMP],
1420 #else
1421 sprintf(cmd, "%s %s -o %s%s %s %s%s %s %s",
1422 pkgDataFlags[GENLIB],
1423 pkgDataFlags[LDICUDTFLAGS],
1424 targetDir,
1425 libFileNames[LIB_FILE_VERSION_TMP],
1426 #endif
1427 objectFile,
1428 pkgDataFlags[LD_SONAME],
1429 pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR],
1430 pkgDataFlags[RPATH_FLAGS],
1431 pkgDataFlags[BIR_FLAGS]);
1432
1433 /* Generate the library file. */
1434 result = runCommand(cmd);
1435
1436 #if U_PLATFORM == U_PF_OS390
1437 char *env_tmp;
1438 char PDS_LibName[512];
1439 char PDS_Name[512];
1440
1441 PDS_Name[0] = 0;
1442 PDS_LibName[0] = 0;
1443 if (specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata") == 0) {
1444 if (env_tmp = getenv("ICU_PDS_NAME")) {
1445 sprintf(PDS_Name, "%s%s",
1446 env_tmp,
1447 "DA");
1448 strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX"));
1449 } else if (env_tmp = getenv("PDS_NAME_PREFIX")) {
1450 sprintf(PDS_Name, "%s%s",
1451 env_tmp,
1452 U_ICU_VERSION_SHORT "DA");
1453 } else {
1454 sprintf(PDS_Name, "%s%s",
1455 "IXMI",
1456 U_ICU_VERSION_SHORT "DA");
1457 }
1458 } else if (!specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata_stub") == 0) {
1459 if (env_tmp = getenv("ICU_PDS_NAME")) {
1460 sprintf(PDS_Name, "%s%s",
1461 env_tmp,
1462 "D1");
1463 strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX"));
1464 } else if (env_tmp = getenv("PDS_NAME_PREFIX")) {
1465 sprintf(PDS_Name, "%s%s",
1466 env_tmp,
1467 U_ICU_VERSION_SHORT "D1");
1468 } else {
1469 sprintf(PDS_Name, "%s%s",
1470 "IXMI",
1471 U_ICU_VERSION_SHORT "D1");
1472 }
1473 }
1474
1475 if (PDS_Name[0]) {
1476 sprintf(PDS_LibName,"%s%s%s%s%s",
1477 "\"//'",
1478 getenv("LOADMOD"),
1479 "(",
1480 PDS_Name,
1481 ")'\"");
1482 sprintf(cmd, "%s %s -o %s %s %s%s %s %s",
1483 pkgDataFlags[GENLIB],
1484 pkgDataFlags[LDICUDTFLAGS],
1485 PDS_LibName,
1486 objectFile,
1487 pkgDataFlags[LD_SONAME],
1488 pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR],
1489 pkgDataFlags[RPATH_FLAGS],
1490 pkgDataFlags[BIR_FLAGS]);
1491
1492 result = runCommand(cmd);
1493 }
1494 #endif
1495 }
1496
1497 if (result != 0) {
1498 fprintf(stderr, "Error generating library file. Failed command: %s\n", cmd);
1499 }
1500
1501 if (freeCmd) {
1502 uprv_free(cmd);
1503 }
1504
1505 return result;
1506 }
1507
1508 static int32_t pkg_createWithAssemblyCode(const char *targetDir, const char mode, const char *gencFilePath) {
1509 char tempObjectFile[SMALL_BUFFER_MAX_SIZE] = "";
1510 char *cmd;
1511 int32_t result = 0;
1512
1513 int32_t length = 0;
1514
1515 /* Remove the ending .s and replace it with .o for the new object file. */
1516 uprv_strcpy(tempObjectFile, gencFilePath);
1517 tempObjectFile[uprv_strlen(tempObjectFile)-1] = 'o';
1518
1519 length = static_cast<int32_t>(uprv_strlen(pkgDataFlags[COMPILER]) + uprv_strlen(pkgDataFlags[LIBFLAGS])
1520 + uprv_strlen(tempObjectFile) + uprv_strlen(gencFilePath) + BUFFER_PADDING_SIZE);
1521
1522 cmd = (char *)uprv_malloc(sizeof(char) * length);
1523 if (cmd == NULL) {
1524 return -1;
1525 }
1526
1527 /* Generate the object file. */
1528 sprintf(cmd, "%s %s -o %s %s",
1529 pkgDataFlags[COMPILER],
1530 pkgDataFlags[LIBFLAGS],
1531 tempObjectFile,
1532 gencFilePath);
1533
1534 result = runCommand(cmd);
1535 uprv_free(cmd);
1536 if (result != 0) {
1537 fprintf(stderr, "Error creating with assembly code. Failed command: %s\n", cmd);
1538 return result;
1539 }
1540
1541 return pkg_generateLibraryFile(targetDir, mode, tempObjectFile);
1542 }
1543
1544 #ifdef BUILD_DATA_WITHOUT_ASSEMBLY
1545 /*
1546 * Generation of the data library without assembly code needs to compile each data file
1547 * individually and then link it all together.
1548 * Note: Any update to the directory structure of the data needs to be reflected here.
1549 */
1550 enum {
1551 DATA_PREFIX_BRKITR,
1552 DATA_PREFIX_COLL,
1553 DATA_PREFIX_CURR,
1554 DATA_PREFIX_LANG,
1555 DATA_PREFIX_RBNF,
1556 DATA_PREFIX_REGION,
1557 DATA_PREFIX_TRANSLIT,
1558 DATA_PREFIX_ZONE,
1559 DATA_PREFIX_UNIT,
1560 DATA_PREFIX_LENGTH
1561 };
1562
1563 const static char DATA_PREFIX[DATA_PREFIX_LENGTH][10] = {
1564 "brkitr",
1565 "coll",
1566 "curr",
1567 "lang",
1568 "rbnf",
1569 "region",
1570 "translit",
1571 "zone",
1572 "unit"
1573 };
1574
1575 static int32_t pkg_createWithoutAssemblyCode(UPKGOptions *o, const char *targetDir, const char mode) {
1576 int32_t result = 0;
1577 CharList *list = o->filePaths;
1578 CharList *listNames = o->files;
1579 int32_t listSize = pkg_countCharList(list);
1580 char *buffer;
1581 char *cmd;
1582 char gencmnFile[SMALL_BUFFER_MAX_SIZE] = "";
1583 char tempObjectFile[SMALL_BUFFER_MAX_SIZE] = "";
1584 #ifdef USE_SINGLE_CCODE_FILE
1585 char icudtAll[SMALL_BUFFER_MAX_SIZE] = "";
1586 FileStream *icudtAllFile = NULL;
1587
1588 sprintf(icudtAll, "%s%s%sall.c",
1589 o->tmpDir,
1590 PKGDATA_FILE_SEP_STRING,
1591 libFileNames[LIB_FILE]);
1592 /* Remove previous icudtall.c file. */
1593 if (T_FileStream_file_exists(icudtAll) && (result = remove(icudtAll)) != 0) {
1594 fprintf(stderr, "Unable to remove old icudtall file: %s\n", icudtAll);
1595 return result;
1596 }
1597
1598 if((icudtAllFile = T_FileStream_open(icudtAll, "w"))==NULL) {
1599 fprintf(stderr, "Unable to write to icudtall file: %s\n", icudtAll);
1600 return result;
1601 }
1602 #endif
1603
1604 if (list == NULL || listNames == NULL) {
1605 /* list and listNames should never be NULL since we are looping through the CharList with
1606 * the given size.
1607 */
1608 return -1;
1609 }
1610
1611 if ((cmd = (char *)uprv_malloc((listSize + 2) * SMALL_BUFFER_MAX_SIZE)) == NULL) {
1612 fprintf(stderr, "Unable to allocate memory for cmd.\n");
1613 return -1;
1614 } else if ((buffer = (char *)uprv_malloc((listSize + 1) * SMALL_BUFFER_MAX_SIZE)) == NULL) {
1615 fprintf(stderr, "Unable to allocate memory for buffer.\n");
1616 uprv_free(cmd);
1617 return -1;
1618 }
1619
1620 for (int32_t i = 0; i < (listSize + 1); i++) {
1621 const char *file ;
1622 const char *name;
1623
1624 if (i == 0) {
1625 /* The first iteration calls the gencmn function and initailizes the buffer. */
1626 createCommonDataFile(o->tmpDir, o->shortName, o->entryName, NULL, o->srcDir, o->comment, o->fileListFiles->str, 0, TRUE, o->verbose, gencmnFile);
1627 buffer[0] = 0;
1628 #ifdef USE_SINGLE_CCODE_FILE
1629 uprv_strcpy(tempObjectFile, gencmnFile);
1630 tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o';
1631
1632 sprintf(cmd, "%s %s -o %s %s",
1633 pkgDataFlags[COMPILER],
1634 pkgDataFlags[LIBFLAGS],
1635 tempObjectFile,
1636 gencmnFile);
1637
1638 result = runCommand(cmd);
1639 if (result != 0) {
1640 break;
1641 }
1642
1643 sprintf(buffer, "%s",tempObjectFile);
1644 #endif
1645 } else {
1646 char newName[SMALL_BUFFER_MAX_SIZE];
1647 char dataName[SMALL_BUFFER_MAX_SIZE];
1648 char dataDirName[SMALL_BUFFER_MAX_SIZE];
1649 const char *pSubstring;
1650 file = list->str;
1651 name = listNames->str;
1652
1653 newName[0] = dataName[0] = 0;
1654 for (int32_t n = 0; n < DATA_PREFIX_LENGTH; n++) {
1655 dataDirName[0] = 0;
1656 sprintf(dataDirName, "%s%s", DATA_PREFIX[n], PKGDATA_FILE_SEP_STRING);
1657 /* If the name contains a prefix (indicating directory), alter the new name accordingly. */
1658 pSubstring = uprv_strstr(name, dataDirName);
1659 if (pSubstring != NULL) {
1660 char newNameTmp[SMALL_BUFFER_MAX_SIZE] = "";
1661 const char *p = name + uprv_strlen(dataDirName);
1662 for (int32_t i = 0;;i++) {
1663 if (p[i] == '.') {
1664 newNameTmp[i] = '_';
1665 continue;
1666 }
1667 newNameTmp[i] = p[i];
1668 if (p[i] == 0) {
1669 break;
1670 }
1671 }
1672 sprintf(newName, "%s_%s",
1673 DATA_PREFIX[n],
1674 newNameTmp);
1675 sprintf(dataName, "%s_%s",
1676 o->shortName,
1677 DATA_PREFIX[n]);
1678 }
1679 if (newName[0] != 0) {
1680 break;
1681 }
1682 }
1683
1684 if(o->verbose) {
1685 printf("# Generating %s \n", gencmnFile);
1686 }
1687
1688 writeCCode(file, o->tmpDir, dataName[0] != 0 ? dataName : o->shortName, newName[0] != 0 ? newName : NULL, gencmnFile);
1689
1690 #ifdef USE_SINGLE_CCODE_FILE
1691 sprintf(cmd, "#include \"%s\"\n", gencmnFile);
1692 T_FileStream_writeLine(icudtAllFile, cmd);
1693 /* don't delete the file */
1694 #endif
1695 }
1696
1697 #ifndef USE_SINGLE_CCODE_FILE
1698 uprv_strcpy(tempObjectFile, gencmnFile);
1699 tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o';
1700
1701 sprintf(cmd, "%s %s -o %s %s",
1702 pkgDataFlags[COMPILER],
1703 pkgDataFlags[LIBFLAGS],
1704 tempObjectFile,
1705 gencmnFile);
1706 result = runCommand(cmd);
1707 if (result != 0) {
1708 fprintf(stderr, "Error creating library without assembly code. Failed command: %s\n", cmd);
1709 break;
1710 }
1711
1712 uprv_strcat(buffer, " ");
1713 uprv_strcat(buffer, tempObjectFile);
1714
1715 #endif
1716
1717 if (i > 0) {
1718 list = list->next;
1719 listNames = listNames->next;
1720 }
1721 }
1722
1723 #ifdef USE_SINGLE_CCODE_FILE
1724 T_FileStream_close(icudtAllFile);
1725 uprv_strcpy(tempObjectFile, icudtAll);
1726 tempObjectFile[uprv_strlen(tempObjectFile) - 1] = 'o';
1727
1728 sprintf(cmd, "%s %s -I. -o %s %s",
1729 pkgDataFlags[COMPILER],
1730 pkgDataFlags[LIBFLAGS],
1731 tempObjectFile,
1732 icudtAll);
1733
1734 result = runCommand(cmd);
1735 if (result == 0) {
1736 uprv_strcat(buffer, " ");
1737 uprv_strcat(buffer, tempObjectFile);
1738 } else {
1739 fprintf(stderr, "Error creating library without assembly code. Failed command: %s\n", cmd);
1740 }
1741 #endif
1742
1743 if (result == 0) {
1744 /* Generate the library file. */
1745 #if U_PLATFORM == U_PF_OS390
1746 result = pkg_generateLibraryFile(targetDir, mode, buffer, cmd, (o->pdsbuild && IN_DLL_MODE(mode)));
1747 #else
1748 result = pkg_generateLibraryFile(targetDir,mode, buffer, cmd);
1749 #endif
1750 }
1751
1752 uprv_free(buffer);
1753 uprv_free(cmd);
1754
1755 return result;
1756 }
1757 #endif
1758
1759 #ifdef WINDOWS_WITH_MSVC
1760 #define LINK_CMD "link.exe /nologo /release /out:"
1761 #define LINK_FLAGS "/DLL /NOENTRY /MANIFEST:NO /implib:"
1762 #ifdef _WIN64
1763 #define LINK_EXTRA_UWP_FLAGS "/NXCOMPAT /DYNAMICBASE /APPCONTAINER "
1764 #else
1765 #define LINK_EXTRA_UWP_FLAGS "/NXCOMPAT /SAFESEH /DYNAMICBASE /APPCONTAINER /MACHINE:X86"
1766 #endif
1767 #define LINK_EXTRA_UWP_FLAGS_ARM "/NXCOMPAT /DYNAMICBASE /APPCONTAINER /MACHINE:ARM"
1768 #define LINK_EXTRA_NO_UWP_FLAGS "/base:0x4ad00000 "
1769 #define LIB_CMD "LIB.exe /nologo /out:"
1770 #define LIB_FILE "icudt.lib"
1771 #define LIB_EXT UDATA_LIB_SUFFIX
1772 #define DLL_EXT UDATA_SO_SUFFIX
1773
1774 static int32_t pkg_createWindowsDLL(const char mode, const char *gencFilePath, UPKGOptions *o) {
1775 int32_t result = 0;
1776 char cmd[LARGE_BUFFER_MAX_SIZE];
1777 if (IN_STATIC_MODE(mode)) {
1778 char staticLibFilePath[SMALL_BUFFER_MAX_SIZE] = "";
1779
1780 #ifdef CYGWINMSVC
1781 sprintf(staticLibFilePath, "%s%s%s%s%s",
1782 o->targetDir,
1783 PKGDATA_FILE_SEP_STRING,
1784 pkgDataFlags[LIBPREFIX],
1785 o->libName,
1786 LIB_EXT);
1787 #else
1788 sprintf(staticLibFilePath, "%s%s%s%s%s",
1789 o->targetDir,
1790 PKGDATA_FILE_SEP_STRING,
1791 (strstr(o->libName, "icudt") ? "s" : ""),
1792 o->libName,
1793 LIB_EXT);
1794 #endif
1795
1796 sprintf(cmd, "%s\"%s\" \"%s\"",
1797 LIB_CMD,
1798 staticLibFilePath,
1799 gencFilePath);
1800 } else if (IN_DLL_MODE(mode)) {
1801 char dllFilePath[SMALL_BUFFER_MAX_SIZE] = "";
1802 char libFilePath[SMALL_BUFFER_MAX_SIZE] = "";
1803 char resFilePath[SMALL_BUFFER_MAX_SIZE] = "";
1804 char tmpResFilePath[SMALL_BUFFER_MAX_SIZE] = "";
1805
1806 #ifdef CYGWINMSVC
1807 uprv_strcpy(dllFilePath, o->targetDir);
1808 #else
1809 uprv_strcpy(dllFilePath, o->srcDir);
1810 #endif
1811 uprv_strcat(dllFilePath, PKGDATA_FILE_SEP_STRING);
1812 uprv_strcpy(libFilePath, dllFilePath);
1813
1814 #ifdef CYGWINMSVC
1815 uprv_strcat(libFilePath, o->libName);
1816 uprv_strcat(libFilePath, ".lib");
1817
1818 uprv_strcat(dllFilePath, o->libName);
1819 uprv_strcat(dllFilePath, o->version);
1820 #else
1821 if (strstr(o->libName, "icudt")) {
1822 uprv_strcat(libFilePath, LIB_FILE);
1823 } else {
1824 uprv_strcat(libFilePath, o->libName);
1825 uprv_strcat(libFilePath, ".lib");
1826 }
1827 uprv_strcat(dllFilePath, o->entryName);
1828 #endif
1829 uprv_strcat(dllFilePath, DLL_EXT);
1830
1831 uprv_strcpy(tmpResFilePath, o->tmpDir);
1832 uprv_strcat(tmpResFilePath, PKGDATA_FILE_SEP_STRING);
1833 uprv_strcat(tmpResFilePath, ICUDATA_RES_FILE);
1834
1835 if (T_FileStream_file_exists(tmpResFilePath)) {
1836 sprintf(resFilePath, "\"%s\"", tmpResFilePath);
1837 }
1838
1839 /* Check if dll file and lib file exists and that it is not newer than genc file. */
1840 if (!o->rebuild && (T_FileStream_file_exists(dllFilePath) && isFileModTimeLater(dllFilePath, gencFilePath)) &&
1841 (T_FileStream_file_exists(libFilePath) && isFileModTimeLater(libFilePath, gencFilePath))) {
1842 if(o->verbose) {
1843 printf("# Not rebuilding %s - up to date.\n", gencFilePath);
1844 }
1845 return 0;
1846 }
1847
1848 char *extraFlags = "";
1849 #ifdef WINDOWS_WITH_MSVC
1850 if (options[UWP_BUILD].doesOccur)
1851 {
1852 if (options[UWP_ARM_BUILD].doesOccur)
1853 {
1854 extraFlags = LINK_EXTRA_UWP_FLAGS_ARM;
1855 }
1856 else
1857 {
1858 extraFlags = LINK_EXTRA_UWP_FLAGS;
1859 }
1860 }
1861 else
1862 {
1863 extraFlags = LINK_EXTRA_NO_UWP_FLAGS;
1864 }
1865 #endif
1866 sprintf(cmd, "%s\"%s\" %s %s\"%s\" \"%s\" %s",
1867 LINK_CMD,
1868 dllFilePath,
1869 extraFlags,
1870 LINK_FLAGS,
1871 libFilePath,
1872 gencFilePath,
1873 resFilePath
1874 );
1875 }
1876
1877 result = runCommand(cmd, TRUE);
1878 if (result != 0) {
1879 fprintf(stderr, "Error creating Windows DLL library. Failed command: %s\n", cmd);
1880 }
1881
1882 return result;
1883 }
1884 #endif
1885
1886 static UPKGOptions *pkg_checkFlag(UPKGOptions *o) {
1887 #if U_PLATFORM == U_PF_AIX
1888 /* AIX needs a map file. */
1889 char *flag = NULL;
1890 int32_t length = 0;
1891 char tmpbuffer[SMALL_BUFFER_MAX_SIZE];
1892 const char MAP_FILE_EXT[] = ".map";
1893 FileStream *f = NULL;
1894 char mapFile[SMALL_BUFFER_MAX_SIZE] = "";
1895 int32_t start = -1;
1896 uint32_t count = 0;
1897 const char rm_cmd[] = "rm -f all ;";
1898
1899 flag = pkgDataFlags[GENLIB];
1900
1901 /* This portion of the code removes 'rm -f all' in the GENLIB.
1902 * Only occurs in AIX.
1903 */
1904 if (uprv_strstr(flag, rm_cmd) != NULL) {
1905 char *tmpGenlibFlagBuffer = NULL;
1906 int32_t i, offset;
1907
1908 length = static_cast<int32_t>(uprv_strlen(flag) + 1);
1909 tmpGenlibFlagBuffer = (char *)uprv_malloc(length);
1910 if (tmpGenlibFlagBuffer == NULL) {
1911 /* Memory allocation error */
1912 fprintf(stderr,"Unable to allocate buffer of size: %d.\n", length);
1913 return NULL;
1914 }
1915
1916 uprv_strcpy(tmpGenlibFlagBuffer, flag);
1917
1918 offset = static_cast<int32_t>(uprv_strlen(rm_cmd));
1919
1920 for (i = 0; i < (length - offset); i++) {
1921 flag[i] = tmpGenlibFlagBuffer[offset + i];
1922 }
1923
1924 /* Zero terminate the string */
1925 flag[i] = 0;
1926
1927 uprv_free(tmpGenlibFlagBuffer);
1928 }
1929
1930 flag = pkgDataFlags[BIR_FLAGS];
1931 length = static_cast<int32_t>(uprv_strlen(pkgDataFlags[BIR_FLAGS]));
1932
1933 for (int32_t i = 0; i < length; i++) {
1934 if (flag[i] == MAP_FILE_EXT[count]) {
1935 if (count == 0) {
1936 start = i;
1937 }
1938 count++;
1939 } else {
1940 count = 0;
1941 }
1942
1943 if (count == uprv_strlen(MAP_FILE_EXT)) {
1944 break;
1945 }
1946 }
1947
1948 if (start >= 0) {
1949 int32_t index = 0;
1950 for (int32_t i = 0;;i++) {
1951 if (i == start) {
1952 for (int32_t n = 0;;n++) {
1953 if (o->shortName[n] == 0) {
1954 break;
1955 }
1956 tmpbuffer[index++] = o->shortName[n];
1957 }
1958 }
1959
1960 tmpbuffer[index++] = flag[i];
1961
1962 if (flag[i] == 0) {
1963 break;
1964 }
1965 }
1966
1967 uprv_memset(flag, 0, length);
1968 uprv_strcpy(flag, tmpbuffer);
1969
1970 uprv_strcpy(mapFile, o->shortName);
1971 uprv_strcat(mapFile, MAP_FILE_EXT);
1972
1973 f = T_FileStream_open(mapFile, "w");
1974 if (f == NULL) {
1975 fprintf(stderr,"Unable to create map file: %s.\n", mapFile);
1976 return NULL;
1977 } else {
1978 sprintf(tmpbuffer, "%s%s ", o->entryName, UDATA_CMN_INTERMEDIATE_SUFFIX);
1979
1980 T_FileStream_writeLine(f, tmpbuffer);
1981
1982 T_FileStream_close(f);
1983 }
1984 }
1985 #elif U_PLATFORM == U_PF_CYGWIN || U_PLATFORM == U_PF_MINGW
1986 /* Cygwin needs to change flag options. */
1987 char *flag = NULL;
1988 int32_t length = 0;
1989
1990 flag = pkgDataFlags[GENLIB];
1991 length = static_cast<int32_t>(uprv_strlen(pkgDataFlags[GENLIB]));
1992
1993 int32_t position = length - 1;
1994
1995 for(;position >= 0;position--) {
1996 if (flag[position] == '=') {
1997 position++;
1998 break;
1999 }
2000 }
2001
2002 uprv_memset(flag + position, 0, length - position);
2003 #elif U_PLATFORM == U_PF_OS400
2004 /* OS/400 needs to fix the ld options (swap single quote with double quote) */
2005 char *flag = NULL;
2006 int32_t length = 0;
2007
2008 flag = pkgDataFlags[GENLIB];
2009 length = static_cast<int32_t>(uprv_strlen(pkgDataFlags[GENLIB]));
2010
2011 int32_t position = length - 1;
2012
2013 for(int32_t i = 0; i < length; i++) {
2014 if (flag[i] == '\'') {
2015 flag[i] = '\"';
2016 }
2017 }
2018 #endif
2019 // Don't really need a return value, just need to stop compiler warnings about
2020 // the unused parameter 'o' on platforms where it is not otherwise used.
2021 return o;
2022 }
2023
2024 static void loadLists(UPKGOptions *o, UErrorCode *status)
2025 {
2026 CharList *l, *tail = NULL, *tail2 = NULL;
2027 FileStream *in;
2028 char line[16384];
2029 char *linePtr, *lineNext;
2030 const uint32_t lineMax = 16300;
2031 char *tmp;
2032 int32_t tmpLength = 0;
2033 char *s;
2034 int32_t ln=0; /* line number */
2035
2036 for(l = o->fileListFiles; l; l = l->next) {
2037 if(o->verbose) {
2038 fprintf(stdout, "# pkgdata: Reading %s..\n", l->str);
2039 }
2040 /* TODO: stdin */
2041 in = T_FileStream_open(l->str, "r"); /* open files list */
2042
2043 if(!in) {
2044 fprintf(stderr, "Error opening <%s>.\n", l->str);
2045 *status = U_FILE_ACCESS_ERROR;
2046 return;
2047 }
2048
2049 while(T_FileStream_readLine(in, line, sizeof(line))!=NULL) { /* for each line */
2050 ln++;
2051 if(uprv_strlen(line)>lineMax) {
2052 fprintf(stderr, "%s:%d - line too long (over %d chars)\n", l->str, (int)ln, (int)lineMax);
2053 exit(1);
2054 }
2055 /* remove spaces at the beginning */
2056 linePtr = line;
2057 /* On z/OS, disable call to isspace (#9996). Investigate using uprv_isspace instead (#9999) */
2058 #if U_PLATFORM != U_PF_OS390
2059 while(isspace(*linePtr)) {
2060 linePtr++;
2061 }
2062 #endif
2063 s=linePtr;
2064 /* remove trailing newline characters */
2065 while(*s!=0) {
2066 if(*s=='\r' || *s=='\n') {
2067 *s=0;
2068 break;
2069 }
2070 ++s;
2071 }
2072 if((*linePtr == 0) || (*linePtr == '#')) {
2073 continue; /* comment or empty line */
2074 }
2075
2076 /* Now, process the line */
2077 lineNext = NULL;
2078
2079 while(linePtr && *linePtr) { /* process space-separated items */
2080 while(*linePtr == ' ') {
2081 linePtr++;
2082 }
2083 /* Find the next quote */
2084 if(linePtr[0] == '"')
2085 {
2086 lineNext = uprv_strchr(linePtr+1, '"');
2087 if(lineNext == NULL) {
2088 fprintf(stderr, "%s:%d - missing trailing double quote (\")\n",
2089 l->str, (int)ln);
2090 exit(1);
2091 } else {
2092 lineNext++;
2093 if(*lineNext) {
2094 if(*lineNext != ' ') {
2095 fprintf(stderr, "%s:%d - malformed quoted line at position %d, expected ' ' got '%c'\n",
2096 l->str, (int)ln, (int)(lineNext-line), (*lineNext)?*lineNext:'0');
2097 exit(1);
2098 }
2099 *lineNext = 0;
2100 lineNext++;
2101 }
2102 }
2103 } else {
2104 lineNext = uprv_strchr(linePtr, ' ');
2105 if(lineNext) {
2106 *lineNext = 0; /* terminate at space */
2107 lineNext++;
2108 }
2109 }
2110
2111 /* add the file */
2112 s = (char*)getLongPathname(linePtr);
2113
2114 /* normal mode.. o->files is just the bare list without package names */
2115 o->files = pkg_appendToList(o->files, &tail, uprv_strdup(linePtr));
2116 if(uprv_pathIsAbsolute(s) || s[0] == '.') {
2117 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);
2118 exit(U_ILLEGAL_ARGUMENT_ERROR);
2119 }
2120 /* The +5 is to add a little extra space for, among other things, PKGDATA_FILE_SEP_STRING */
2121 tmpLength = static_cast<int32_t>(uprv_strlen(o->srcDir) + uprv_strlen(s) + 5);
2122 if((tmp = (char *)uprv_malloc(tmpLength)) == NULL) {
2123 fprintf(stderr, "pkgdata: Error: Unable to allocate tmp buffer size: %d\n", tmpLength);
2124 exit(U_MEMORY_ALLOCATION_ERROR);
2125 }
2126 uprv_strcpy(tmp, o->srcDir);
2127 uprv_strcat(tmp, o->srcDir[uprv_strlen(o->srcDir)-1] == U_FILE_SEP_CHAR ? "" : PKGDATA_FILE_SEP_STRING);
2128 uprv_strcat(tmp, s);
2129 o->filePaths = pkg_appendToList(o->filePaths, &tail2, tmp);
2130 linePtr = lineNext;
2131 } /* for each entry on line */
2132 } /* for each line */
2133 T_FileStream_close(in);
2134 } /* for each file list file */
2135 }
2136
2137 /* Try calling icu-config directly to get the option file. */
2138 static int32_t pkg_getOptionsFromICUConfig(UBool verbose, UOption *option) {
2139 #if U_HAVE_POPEN
2140 LocalPipeFilePointer p;
2141 size_t n;
2142 static char buf[512] = "";
2143 icu::CharString cmdBuf;
2144 UErrorCode status = U_ZERO_ERROR;
2145 const char cmd[] = "icu-config --incpkgdatafile";
2146 char dirBuf[1024] = "";
2147 /* #1 try the same path where pkgdata was called from. */
2148 findDirname(progname, dirBuf, UPRV_LENGTHOF(dirBuf), &status);
2149 if(U_SUCCESS(status)) {
2150 cmdBuf.append(dirBuf, status);
2151 if (cmdBuf[0] != 0) {
2152 cmdBuf.append( U_FILE_SEP_STRING, status );
2153 }
2154 cmdBuf.append( cmd, status );
2155
2156 if(verbose) {
2157 fprintf(stdout, "# Calling icu-config: %s\n", cmdBuf.data());
2158 }
2159 p.adoptInstead(popen(cmdBuf.data(), "r"));
2160 }
2161
2162 if(p.isNull() || (n = fread(buf, 1, UPRV_LENGTHOF(buf)-1, p.getAlias())) <= 0) {
2163 if(verbose) {
2164 fprintf(stdout, "# Calling icu-config: %s\n", cmd);
2165 }
2166
2167 p.adoptInstead(popen(cmd, "r"));
2168 if(p.isNull() || (n = fread(buf, 1, UPRV_LENGTHOF(buf)-1, p.getAlias())) <= 0) {
2169 fprintf(stderr, "%s: icu-config: No icu-config found. (fix PATH or use -O option)\n", progname);
2170 return -1;
2171 }
2172 }
2173
2174 for (int32_t length = strlen(buf) - 1; length >= 0; length--) {
2175 if (buf[length] == '\n' || buf[length] == ' ') {
2176 buf[length] = 0;
2177 } else {
2178 break;
2179 }
2180 }
2181
2182 if(buf[strlen(buf)-1]=='\n')
2183 {
2184 buf[strlen(buf)-1]=0;
2185 }
2186
2187 if(buf[0] == 0)
2188 {
2189 fprintf(stderr, "%s: icu-config: invalid response from icu-config (fix PATH or use -O option)\n", progname);
2190 return -1;
2191 }
2192
2193 if(verbose) {
2194 fprintf(stdout, "# icu-config said: %s\n", buf);
2195 }
2196
2197 option->value = buf;
2198 option->doesOccur = TRUE;
2199
2200 return 0;
2201 #else
2202 return -1;
2203 #endif
2204 }
2205
2206 #ifdef CAN_WRITE_OBJ_CODE
2207 /* Create optMatchArch for genccode architecture detection */
2208 static void pkg_createOptMatchArch(char *optMatchArch) {
2209 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN)
2210 const char* code = "void oma(){}";
2211 const char* source = "oma.c";
2212 const char* obj = "oma.obj";
2213 FileStream* stream = NULL;
2214
2215 stream = T_FileStream_open(source,"w");
2216 if (stream != NULL) {
2217 T_FileStream_writeLine(stream, code);
2218 T_FileStream_close(stream);
2219
2220 char cmd[LARGE_BUFFER_MAX_SIZE];
2221 sprintf(cmd, "%s %s -o %s",
2222 pkgDataFlags[COMPILER],
2223 source,
2224 obj);
2225
2226 if (runCommand(cmd) == 0){
2227 sprintf(optMatchArch, "%s", obj);
2228 }
2229 else {
2230 fprintf(stderr, "Failed to compile %s\n", source);
2231 }
2232 if(!T_FileStream_remove(source)){
2233 fprintf(stderr, "T_FileStream_remove failed to delete %s\n", source);
2234 }
2235 }
2236 else {
2237 fprintf(stderr, "T_FileStream_open failed to open %s for writing\n", source);
2238 }
2239 #endif
2240 }
2241 static void pkg_destroyOptMatchArch(char *optMatchArch) {
2242 if(T_FileStream_file_exists(optMatchArch) && !T_FileStream_remove(optMatchArch)){
2243 fprintf(stderr, "T_FileStream_remove failed to delete %s\n", optMatchArch);
2244 }
2245 }
2246 #endif
mirror of ICU