Update ICU to 54.1 step 1

source/tools/pkgdata/pkgdata.cpp

 /******************************************************************************
- *   Copyright (C) 2000-2013, International Business Machines
+ *   Copyright (C) 2000-2014, International Business Machines
  *   Corporation and others.  All Rights Reserved.
  *******************************************************************************
  *   file name:  pkgdata.cpp
  *   encoding:   ANSI X3.4 (1968)
  *   tab size:   8 (not used)
  *   indentation:4
  *
  *   created on: 2000may15
  *   created by: Steven \u24C7 Loomis
  *
@@ skipping 23 matching lines @@
 #include "toolutil.h"
 #include "unicode/uclean.h"
 #include "unewdata.h"
 #include "uoptions.h"
 #include "package.h"
 #include "pkg_icu.h"
 #include "pkg_genc.h"
 #include "pkg_gencmn.h"
 #include "flagparser.h"
 #include "filetools.h"
+#include "charstr.h"
 
 #if U_HAVE_POPEN
 # include <unistd.h>
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 
 U_CDECL_BEGIN
 #include "pkgtypes.h"
@@ skipping 10 matching lines @@
 static int32_t pkg_createSymLinks(const char *targetDir, UBool specialHandling=FALSE);
 static int32_t pkg_installLibrary(const char *installDir, const char *dir, UBool noVersion);
 static int32_t pkg_installFileMode(const char *installDir, const char *srcDir, const char *fileListName);
 static int32_t pkg_installCommonMode(const char *installDir, const char *fileName);
 
 #ifdef BUILD_DATA_WITHOUT_ASSEMBLY
 static int32_t pkg_createWithoutAssemblyCode(UPKGOptions *o, const char *targetDir, const char mode);
 #endif
 
 static int32_t pkg_createWithAssemblyCode(const char *targetDir, const char mode, const char *gencFilePath);
-static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command = NULL);
+static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command = NULL, UBool specialHandling=FALSE);
 static int32_t pkg_archiveLibrary(const char *targetDir, const char *version, UBool reverseExt);
 static void createFileNames(UPKGOptions *o, const char mode, const char *version_major, const char *version, const char *libName, const UBool reverseExt, UBool noVersion);
 static int32_t initializePkgDataFlags(UPKGOptions *o);
 
 static int32_t pkg_getOptionsFromICUConfig(UBool verbose, UOption *option);
 static int runCommand(const char* command, UBool specialHandling=FALSE);
 
 #define IN_COMMON_MODE(mode) (mode == 'a' || mode == 'c')
 #define IN_DLL_MODE(mode)    (mode == 'd' || mode == 'l')
 #define IN_STATIC_MODE(mode) (mode == 's')
@@ skipping 109 matching lines @@
 enum {
     LIB_FILE,
     LIB_FILE_VERSION_MAJOR,
     LIB_FILE_VERSION,
     LIB_FILE_VERSION_TMP,
 #if U_PLATFORM == U_PF_CYGWIN
     LIB_FILE_CYGWIN,
     LIB_FILE_CYGWIN_VERSION,
 #elif U_PLATFORM == U_PF_MINGW
     LIB_FILE_MINGW,
+#elif U_PLATFORM == U_PF_OS390
+    LIB_FILE_OS390BATCH_MAJOR,
+    LIB_FILE_OS390BATCH_VERSION,
 #endif
     LIB_FILENAMES_SIZE
 };
 static char libFileNames[LIB_FILENAMES_SIZE][256];
 
 static UPKGOptions  *pkg_checkFlag(UPKGOptions *o);
 
 const char options_help[][320]={
     "Set the data name",
 #ifdef U_MAKE_IS_NMAKE
@@ skipping 10 matching lines @@
     "Specify the destination directory for files",
     "Force rebuilding of all data",
     "Specify temporary dir (default: output dir)",
     "Install the data (specify target)",
     "Specify a custom source directory",
     "Specify a custom entrypoint name (default: short name)",
     "Specify a version when packaging in dll or static mode",
     "Add package to all file names if not present",
     "Library name to build (if different than package name)",
     "Quite mode. (e.g. Do not output a readme file for static libraries)",
-    "Build the data without assembly code"
+    "Build the data without assembly code",
+    "Build PDS dataset (zOS build only)"
 };
 
 const char  *progname = "PKGDATA";
 
 int
 main(int argc, char* argv[]) {
     int result = 0;
     /* FileStream  *out; */
     UPKGOptions  o;
     CharList    *tail;
@@ skipping 120 matching lines @@
       o.libName = o.shortName;
     }
 
     if(options[QUIET].doesOccur) {
       o.quiet = TRUE;
     } else {
       o.quiet = FALSE;
     }
 
     if(options[PDS_BUILD].doesOccur) {
+#if U_PLATFORM == U_PF_OS390
       o.pdsbuild = TRUE;
+#else
+      o.pdsbuild = FALSE;
+      fprintf(stdout, "Warning: You are using the -z option which only works on z/OS.\n");
+
+#endif
     } else {
       o.pdsbuild = FALSE;
     }
 
     o.verbose   = options[VERBOSE].doesOccur;
 
 
 #if !defined(WINDOWS_WITH_MSVC) || defined(USING_CYGWIN) /* on UNIX, we'll just include the file... */
     if (options[BLDOPT].doesOccur) {
         o.options   = options[BLDOPT].value;
@@ skipping 251 matching lines @@
             /* Certain platforms have different library extension ordering. (e.g. libicudata.##.so vs libicudata.so.##)
              * reverseExt is FALSE if the suffix should be the version number.
              */
             if (pkgDataFlags[LIB_EXT_ORDER][uprv_strlen(pkgDataFlags[LIB_EXT_ORDER])-1] == pkgDataFlags[SO_EXT][uprv_strlen(pkgDataFlags[SO_EXT])-1]) {
                 reverseExt = TRUE;
             }
 #endif
             /* Using the base libName and version number, generate the library file names. */
             createFileNames(o, mode, version_major, o->version == NULL ? "" : o->version, o->libName, reverseExt, noVersion);
 
-            if ((o->version!=NULL || IN_STATIC_MODE(mode)) && o->rebuild == FALSE) {
+            if ((o->version!=NULL || IN_STATIC_MODE(mode)) && o->rebuild == FALSE && o->pdsbuild == FALSE) {
                 /* Check to see if a previous built data library file exists and check if it is the latest. */
                 sprintf(checkLibFile, "%s%s", targetDir, libFileNames[LIB_FILE_VERSION]);
                 if (T_FileStream_file_exists(checkLibFile)) {
                     if (isFileModTimeLater(checkLibFile, o->srcDir, TRUE) && isFileModTimeLater(checkLibFile, o->options)) {
                         if (o->install != NULL) {
                           if(o->verbose) {
                             fprintf(stdout, "# Installing already-built library into %s\n", o->install);
                           }
                           result = pkg_installLibrary(o->install, targetDir, noVersion);
                         } else {
@@ skipping 86 matching lines @@
                 }
                 result = pkg_archiveLibrary(targetDir, o->version, reverseExt);
                 if (result != 0) {
                     fprintf(stderr, "Error creating data archive library file.\n");
                    return result;
                 }
 #if U_PLATFORM != U_PF_OS400
                 if (!noVersion) {
                     /* Create symbolic links for the final library file. */
 #if U_PLATFORM == U_PF_OS390
-                    if (!o->pdsbuild) {
-                        result = pkg_createSymLinks(targetDir, noVersion);
-                    }
+                    result = pkg_createSymLinks(targetDir, o->pdsbuild);
 #else
                     result = pkg_createSymLinks(targetDir, noVersion);
 #endif
                     if (result != 0) {
                         fprintf(stderr, "Error creating symbolic links of the data library file.\n");
                         return result;
                     }
                 }
 #endif
             } /* !IN_STATIC_MODE */
@@ skipping 80 matching lines @@
 
     return result;
 }
 
 
 /*
  * Given the base libName and version numbers, generate the libary file names and store it in libFileNames.
  * Depending on the configuration, the library name may either end with version number or shared object suffix.
  */
 static void createFileNames(UPKGOptions *o, const char mode, const char *version_major, const char *version, const char *libName, UBool reverseExt, UBool noVersion) {
+    const char* FILE_EXTENSION_SEP = uprv_strlen(pkgDataFlags[SO_EXT]) == 0 ? "" : ".";
+    const char* FILE_SUFFIX = pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "";
+
 #if U_PLATFORM == U_PF_MINGW
         /* MinGW does not need the library prefix when building in dll mode. */
         if (IN_DLL_MODE(mode)) {
             sprintf(libFileNames[LIB_FILE], "%s", libName);
         } else {
             sprintf(libFileNames[LIB_FILE], "%s%s",
                     pkgDataFlags[LIBPREFIX],
                     libName);
         }
 #else
         sprintf(libFileNames[LIB_FILE], "%s%s",
                 pkgDataFlags[LIBPREFIX],
                 libName);
 #endif
 
         if(o->verbose) {
           fprintf(stdout, "# libFileName[LIB_FILE] = %s\n", libFileNames[LIB_FILE]);
         }
 
 #if U_PLATFORM == U_PF_MINGW
         sprintf(libFileNames[LIB_FILE_MINGW], "%s%s.lib", pkgDataFlags[LIBPREFIX], libName);
 #elif U_PLATFORM == U_PF_CYGWIN
-        sprintf(libFileNames[LIB_FILE_CYGWIN], "cyg%s.%s",
+        sprintf(libFileNames[LIB_FILE_CYGWIN], "cyg%s%s%s",
                 libName,
+                FILE_EXTENSION_SEP,
                 pkgDataFlags[SO_EXT]);
-        sprintf(libFileNames[LIB_FILE_CYGWIN_VERSION], "cyg%s%s.%s",
+        sprintf(libFileNames[LIB_FILE_CYGWIN_VERSION], "cyg%s%s%s%s",
                 libName,
                 version_major,
+                FILE_EXTENSION_SEP,
                 pkgDataFlags[SO_EXT]);
 
         uprv_strcat(pkgDataFlags[SO_EXT], ".");
         uprv_strcat(pkgDataFlags[SO_EXT], pkgDataFlags[A_EXT]);
 #elif U_PLATFORM == U_PF_OS400 || defined(_AIX)
-        sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s.%s",
+        sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s",
                 libFileNames[LIB_FILE],
+                FILE_EXTENSION_SEP,
                 pkgDataFlags[SOBJ_EXT]);
-#elif U_PLATFROM == U_PF_OS390
-            if (o->pdsbuild) {
-                sprintf(libFileNames[LIB_FILE], "%s",
-                    libName);
-                sprintf(libFileNames[LIB_FILE_VERSION_TMP], "\"%s\"",
-                        libFileNames[LIB_FILE]);
-            } else {
-                sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s.%s",
-                        libFileNames[LIB_FILE],
-                        pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
-                        reverseExt ? version : pkgDataFlags[SOBJ_EXT],
-                        reverseExt ? pkgDataFlags[SOBJ_EXT] : version);
-            }
+#elif U_PLATFORM == U_PF_OS390
+        sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s%s%s",
+                    libFileNames[LIB_FILE],
+                    pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
+                    reverseExt ? version : pkgDataFlags[SOBJ_EXT],
+                    FILE_EXTENSION_SEP,
+                    reverseExt ? pkgDataFlags[SOBJ_EXT] : version);
+
+        sprintf(libFileNames[LIB_FILE_OS390BATCH_VERSION], "%s%s.x",
+                    libFileNames[LIB_FILE],
+                    version);
+        sprintf(libFileNames[LIB_FILE_OS390BATCH_MAJOR], "%s%s.x",
+                    libFileNames[LIB_FILE],
+                    version_major);
 #else
         if (noVersion && !reverseExt) {
             sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s",
                     libFileNames[LIB_FILE],
-                    pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
+                    FILE_SUFFIX,
                     pkgDataFlags[SOBJ_EXT]);
         } else {
-            sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s.%s",
+            sprintf(libFileNames[LIB_FILE_VERSION_TMP], "%s%s%s%s%s",
                     libFileNames[LIB_FILE],
-                    pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
+                    FILE_SUFFIX,
                     reverseExt ? version : pkgDataFlags[SOBJ_EXT],
+                    FILE_EXTENSION_SEP,
                     reverseExt ? pkgDataFlags[SOBJ_EXT] : version);
         }
 #endif
         if (noVersion && !reverseExt) {
             sprintf(libFileNames[LIB_FILE_VERSION_MAJOR], "%s%s%s",
                     libFileNames[LIB_FILE],
-                    pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
+                    FILE_SUFFIX,
                     pkgDataFlags[SO_EXT]);
 
             sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s",
                     libFileNames[LIB_FILE],
-                    pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
+                    FILE_SUFFIX,
                     pkgDataFlags[SO_EXT]);
         } else {
-            sprintf(libFileNames[LIB_FILE_VERSION_MAJOR], "%s%s%s.%s",
+            sprintf(libFileNames[LIB_FILE_VERSION_MAJOR], "%s%s%s%s%s",
                     libFileNames[LIB_FILE],
-                    pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
+                    FILE_SUFFIX,
                     reverseExt ? version_major : pkgDataFlags[SO_EXT],
+                    FILE_EXTENSION_SEP,
                     reverseExt ? pkgDataFlags[SO_EXT] : version_major);
 
-            sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s.%s",
+            sprintf(libFileNames[LIB_FILE_VERSION], "%s%s%s%s%s",
                     libFileNames[LIB_FILE],
-                    pkgDataFlags[LIB_EXT_ORDER][0] == '.' ? "." : "",
+                    FILE_SUFFIX,
                     reverseExt ? version : pkgDataFlags[SO_EXT],
+                    FILE_EXTENSION_SEP,
                     reverseExt ? pkgDataFlags[SO_EXT] : version);
         }
 
         if(o->verbose) {
           fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s\n", libFileNames[LIB_FILE_VERSION]);
         }
 
 #if U_PF_MINGW <= U_PLATFORM && U_PLATFORM <= U_PF_CYGWIN
         /* Cygwin and MinGW only deals with the version major number. */
         uprv_strcpy(libFileNames[LIB_FILE_VERSION_TMP], libFileNames[LIB_FILE_VERSION_MAJOR]);
 #endif
 
         if(IN_STATIC_MODE(mode)) {
             sprintf(libFileNames[LIB_FILE_VERSION], "%s.%s", libFileNames[LIB_FILE], pkgDataFlags[A_EXT]);
             libFileNames[LIB_FILE_VERSION_MAJOR][0]=0;
             if(o->verbose) {
               fprintf(stdout, "# libFileName[LIB_FILE_VERSION] = %s  (static)\n", libFileNames[LIB_FILE_VERSION]);
             }
         }
 }
 
 /* Create the symbolic links for the final library file. */
 static int32_t pkg_createSymLinks(const char *targetDir, UBool specialHandling) {
     int32_t result = 0;
     char cmd[LARGE_BUFFER_MAX_SIZE];
     char name1[SMALL_BUFFER_MAX_SIZE]; /* symlink file name */
     char name2[SMALL_BUFFER_MAX_SIZE]; /* file name to symlink */
+    const char* FILE_EXTENSION_SEP = uprv_strlen(pkgDataFlags[SO_EXT]) == 0 ? "" : ".";
 
 #if !defined(USING_CYGWIN) && U_PLATFORM != U_PF_MINGW
     /* No symbolic link to make. */
     if (uprv_strlen(libFileNames[LIB_FILE_VERSION]) == 0 || uprv_strlen(libFileNames[LIB_FILE_VERSION_MAJOR]) == 0 ||
         uprv_strcmp(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_MAJOR]) == 0) {
         return result;
     }
     
     sprintf(cmd, "cd %s && %s %s && %s %s %s",
             targetDir,
             RM_CMD,
             libFileNames[LIB_FILE_VERSION_MAJOR],
             LN_CMD,
             libFileNames[LIB_FILE_VERSION],
             libFileNames[LIB_FILE_VERSION_MAJOR]);
     result = runCommand(cmd);
     if (result != 0) {
         fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd);
         return result;
     }
 #endif
 
     if (specialHandling) {
 #if U_PLATFORM == U_PF_CYGWIN
         sprintf(name1, "%s", libFileNames[LIB_FILE_CYGWIN]);
         sprintf(name2, "%s", libFileNames[LIB_FILE_CYGWIN_VERSION]);
+#elif U_PLATFORM == U_PF_OS390
+        /* Create the symbolic links for the import data */
+        /* Use the cmd buffer to store path to import data file to check its existence */
+        sprintf(cmd, "%s/%s", targetDir, libFileNames[LIB_FILE_OS390BATCH_VERSION]);
+        if (T_FileStream_file_exists(cmd)) {
+            sprintf(cmd, "cd %s && %s %s && %s %s %s",
+                    targetDir,
+                    RM_CMD,
+                    libFileNames[LIB_FILE_OS390BATCH_MAJOR],
+                    LN_CMD,
+                    libFileNames[LIB_FILE_OS390BATCH_VERSION],
+                    libFileNames[LIB_FILE_OS390BATCH_MAJOR]);
+            result = runCommand(cmd);
+            if (result != 0) {
+                fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd);
+                return result;
+            }
+
+            sprintf(cmd, "cd %s && %s %s.x && %s %s %s.x",
+                    targetDir,
+                    RM_CMD,
+                    libFileNames[LIB_FILE],
+                    LN_CMD,
+                    libFileNames[LIB_FILE_OS390BATCH_VERSION],
+                    libFileNames[LIB_FILE]);
+            result = runCommand(cmd);
+            if (result != 0) {
+                fprintf(stderr, "Error creating symbolic links. Failed command: %s\n", cmd);
+                return result;
+            }
+        }
+
+        /* Needs to be set here because special handling skips it */
+        sprintf(name1, "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]);
+        sprintf(name2, "%s", libFileNames[LIB_FILE_VERSION]);
 #else
         goto normal_symlink_mode;
 #endif
     } else {
 #if U_PLATFORM != U_PF_CYGWIN
 normal_symlink_mode:
 #endif
-        sprintf(name1, "%s.%s", libFileNames[LIB_FILE], pkgDataFlags[SO_EXT]);
+        sprintf(name1, "%s%s%s", libFileNames[LIB_FILE], FILE_EXTENSION_SEP, pkgDataFlags[SO_EXT]);
         sprintf(name2, "%s", libFileNames[LIB_FILE_VERSION]);
     }
 
     sprintf(cmd, "cd %s && %s %s && %s %s %s",
             targetDir,
             RM_CMD,
             name1,
             LN_CMD,
             name2,
             name1);
@@ skipping 40 matching lines @@
             pkgDataFlags[INSTALL_CMD],
             libFileNames[LIB_FILE_CYGWIN_VERSION],
             installDir
             );
     result = runCommand(cmd);
 
     if (result != 0) {
         fprintf(stderr, "Error installing library. Failed command: %s\n", cmd);
         return result;
     }
+
+#elif U_PLATFORM == U_PF_OS390
+    if (T_FileStream_file_exists(libFileNames[LIB_FILE_OS390BATCH_VERSION])) {
+        sprintf(cmd, "%s %s %s",
+                pkgDataFlags[INSTALL_CMD],
+                libFileNames[LIB_FILE_OS390BATCH_VERSION],
+                installDir
+                );
+        result = runCommand(cmd);
+
+        if (result != 0) {
+            fprintf(stderr, "Error installing library. Failed command: %s\n", cmd);
+            return result;
+        }
+    }
 #endif
 
     if (noVersion) {
         return result;
     } else {
         return pkg_createSymLinks(installDir, TRUE);
     }
 }
 
 static int32_t pkg_installCommonMode(const char *installDir, const char *fileName) {
@@ skipping 147 matching lines @@
         uprv_strcpy(libFileNames[LIB_FILE_VERSION], libFileNames[LIB_FILE_VERSION_TMP]);
     }
 
     return result;
 }
 
 /*
  * Using the compiler information from the configuration file set by -O option, generate the library file.
  * command may be given to allow for a larger buffer for cmd.
  */
-static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command) {
+static int32_t pkg_generateLibraryFile(const char *targetDir, const char mode, const char *objectFile, char *command, UBool specialHandling) {
     int32_t result = 0;
     char *cmd = NULL;
     UBool freeCmd = FALSE;
     int32_t length = 0;
 
+    (void)specialHandling;  // Suppress unused variable compiler warnings on platforms where all usage
+                            // of this parameter is #ifdefed out.
+
     /* This is necessary because if packaging is done without assembly code, objectFile might be extremely large
      * containing many object files and so the calling function should supply a command buffer that is large
      * enough to handle this. Otherwise, use the default size.
      */
     if (command != NULL) {
         cmd = command;
     }
 
     if (IN_STATIC_MODE(mode)) {
         if (cmd == NULL) {
@@ skipping 73 matching lines @@
 #endif
                 objectFile,
                 pkgDataFlags[LD_SONAME],
                 pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR],
                 pkgDataFlags[RPATH_FLAGS],
                 pkgDataFlags[BIR_FLAGS]);
 
         /* Generate the library file. */
         result = runCommand(cmd);
 
-#if U_PLATFORM == U_PF_OS390 && defined(OS390BATCH)
+#if U_PLATFORM == U_PF_OS390
+        char *env_tmp;
         char PDS_LibName[512];
-        if (uprv_strcmp(libFileNames[LIB_FILE],"libicudata") == 0) {
-            sprintf(PDS_LibName,"%s%s%s",
+        char PDS_Name[512];
+
+        PDS_Name[0] = 0;
+        PDS_LibName[0] = 0;
+        if (specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata") == 0) {
+            if (env_tmp = getenv("ICU_PDS_NAME")) {
+                sprintf(PDS_Name, "%s%s",
+                        env_tmp,
+                        "DA");
+                strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX"));
+            } else if (env_tmp = getenv("PDS_NAME_PREFIX")) {
+                sprintf(PDS_Name, "%s%s",
+                        env_tmp,
+                        U_ICU_VERSION_SHORT "DA");
+            } else {
+                sprintf(PDS_Name, "%s%s",
+                        "IXMI",
+                        U_ICU_VERSION_SHORT "DA");
+            }
+        } else if (!specialHandling && uprv_strcmp(libFileNames[LIB_FILE],"libicudata_stub") == 0) {
+            if (env_tmp = getenv("ICU_PDS_NAME")) {
+                sprintf(PDS_Name, "%s%s",
+                        env_tmp,
+                        "D1");
+                strcat(PDS_Name, getenv("ICU_PDS_NAME_SUFFIX"));
+            } else if (env_tmp = getenv("PDS_NAME_PREFIX")) {
+                sprintf(PDS_Name, "%s%s",
+                        env_tmp,
+                        U_ICU_VERSION_SHORT "D1");
+            } else {
+                sprintf(PDS_Name, "%s%s",
+                        "IXMI",
+                        U_ICU_VERSION_SHORT "D1");
+            }
+        }
+
+        if (PDS_Name[0]) {
+            sprintf(PDS_LibName,"%s%s%s%s%s",
                     "\"//'",
                     getenv("LOADMOD"),
-                    "(IXMI" U_ICU_VERSION_SHORT "DA)'\"");
-        } else if (uprv_strcmp(libFileNames[LIB_FILE],"libicudata_stub") == 0) {
-           sprintf(PDS_LibName,"%s%s%s",
-                   "\"//'",
-                   getenv("LOADMOD"),
-                   "(IXMI" U_ICU_VERSION_SHORT "D1)'\"");
-           sprintf(cmd, "%s %s -o %s %s %s%s %s %s",
+                    "(",
+                    PDS_Name,
+                    ")'\"");
+            sprintf(cmd, "%s %s -o %s %s %s%s %s %s",
                    pkgDataFlags[GENLIB],
                    pkgDataFlags[LDICUDTFLAGS],
                    PDS_LibName,
                    objectFile,
                    pkgDataFlags[LD_SONAME],
                    pkgDataFlags[LD_SONAME][0] == 0 ? "" : libFileNames[LIB_FILE_VERSION_MAJOR],
                    pkgDataFlags[RPATH_FLAGS],
                    pkgDataFlags[BIR_FLAGS]);
+
+            result = runCommand(cmd);
         }
-        result = runCommand(cmd);
 #endif
     }
 
     if (result != 0) {
         fprintf(stderr, "Error generating library file. Failed command: %s\n", cmd);
     }
 
     if (freeCmd) {
         uprv_free(cmd);
     }
@@ skipping 45 matching lines @@
  */
 enum {
     DATA_PREFIX_BRKITR,
     DATA_PREFIX_COLL,
     DATA_PREFIX_CURR,
     DATA_PREFIX_LANG,
     DATA_PREFIX_RBNF,
     DATA_PREFIX_REGION,
     DATA_PREFIX_TRANSLIT,
     DATA_PREFIX_ZONE,
+    DATA_PREFIX_UNIT,
     DATA_PREFIX_LENGTH
 };
 
 const static char DATA_PREFIX[DATA_PREFIX_LENGTH][10] = {
         "brkitr",
         "coll",
         "curr",
         "lang",
         "rbnf",
         "region",
         "translit",
-        "zone"
+        "zone",
+        "unit"
 };
 
 static int32_t pkg_createWithoutAssemblyCode(UPKGOptions *o, const char *targetDir, const char mode) {
     int32_t result = 0;
     CharList *list = o->filePaths;
     CharList *listNames = o->files;
     int32_t listSize = pkg_countCharList(list);
     char *buffer;
     char *cmd;
     char gencmnFile[SMALL_BUFFER_MAX_SIZE] = "";
@@ skipping 153 matching lines @@
         uprv_strcat(buffer, " ");
         uprv_strcat(buffer, tempObjectFile);
     } else {
         fprintf(stderr, "Error creating library without assembly code. Failed command: %s\n", cmd);
     }
 #endif
 
     if (result == 0) {
         /* Generate the library file. */
 #if U_PLATFORM == U_PF_OS390
-        if (o->pdsbuild && IN_DLL_MODE(mode)) {
-            result = pkg_generateLibraryFile("",mode, buffer, cmd);
-        } else {
-            result = pkg_generateLibraryFile(targetDir,mode, buffer, cmd);
-        }
+        result = pkg_generateLibraryFile(targetDir, mode, buffer, cmd, (o->pdsbuild && IN_DLL_MODE(mode)));
 #else
         result = pkg_generateLibraryFile(targetDir,mode, buffer, cmd);
 #endif
     }
 
     uprv_free(buffer);
     uprv_free(cmd);
 
     return result;
 }
@@ skipping 350 matching lines @@
         T_FileStream_close(in);
     } /* for each file list file */
 }
 
 /* Try calling icu-config directly to get the option file. */
  static int32_t pkg_getOptionsFromICUConfig(UBool verbose, UOption *option) {
 #if U_HAVE_POPEN
     FILE *p = NULL;
     size_t n;
     static char buf[512] = "";
-    char cmdBuf[1024];
+    icu::CharString cmdBuf;
     UErrorCode status = U_ZERO_ERROR;
     const char cmd[] = "icu-config --incpkgdatafile";
-
+    char dirBuf[1024] = "";
     /* #1 try the same path where pkgdata was called from. */
-    findDirname(progname, cmdBuf, 1024, &status);
+    findDirname(progname, dirBuf, UPRV_LENGTHOF(dirBuf), &status);
     if(U_SUCCESS(status)) {
+      cmdBuf.append(dirBuf, status);
       if (cmdBuf[0] != 0) {
-          uprv_strncat(cmdBuf, U_FILE_SEP_STRING, 1024);
+        cmdBuf.append( U_FILE_SEP_STRING, status );
       }
-      uprv_strncat(cmdBuf, cmd, 1024);
+      cmdBuf.append( cmd, status );
       
       if(verbose) {
-        fprintf(stdout, "# Calling icu-config: %s\n", cmdBuf);
+        fprintf(stdout, "# Calling icu-config: %s\n", cmdBuf.data());
       }
-      p = popen(cmdBuf, "r");
+      p = popen(cmdBuf.data(), "r");
     }
 
-    if(p == NULL || (n = fread(buf, 1, 511, p)) <= 0) {
+      if(p == NULL || (n = fread(buf, 1, UPRV_LENGTHOF(buf)-1, p)) <= 0) {
       if(verbose) {
         fprintf(stdout, "# Calling icu-config: %s\n", cmd);
       }
       pclose(p);
 
       p = popen(cmd, "r");
-      if(p == NULL || (n = fread(buf, 1, 511, p)) <= 0) {
+      if(p == NULL || (n = fread(buf, 1, UPRV_LENGTHOF(buf)-1, p)) <= 0) {
           fprintf(stderr, "%s: icu-config: No icu-config found. (fix PATH or use -O option)\n", progname);
           return -1;
       }
     }
 
     pclose(p);
 
     for (int32_t length = strlen(buf) - 1; length >= 0; length--) {
         if (buf[length] == '\n' || buf[length] == ' ') {
             buf[length] = 0;
@@ skipping 18 matching lines @@
     }
 
     option->value = buf;
     option->doesOccur = TRUE;
 
     return 0;
 #else
     return -1;
 #endif
 }