ICU 56 update step 1

source/tools/makeconv/makeconv.cpp

 /*
  ********************************************************************************
  *
- *   Copyright (C) 1998-2014, International Business Machines
+ *   Copyright (C) 1998-2015, International Business Machines
  *   Corporation and others.  All Rights Reserved.
  *
  ********************************************************************************
  *
  *
- *  makeconv.c:
+ *  makeconv.cpp:
  *  tool creating a binary (compressed) representation of the conversion mapping
  *  table (IBM NLTC ucmap format).
  *
  *  05/04/2000    helena     Added fallback mapping into the picture...
  *  06/29/2000  helena      Major rewrite of the callback APIs.
  */
 
 #include <stdio.h>
 #include "unicode/putil.h"
 #include "unicode/ucnv_err.h"
+#include "charstr.h"
 #include "ucnv_bld.h"
 #include "ucnv_imp.h"
 #include "ucnv_cnv.h"
 #include "cstring.h"
 #include "cmemory.h"
 #include "uinvchar.h"
 #include "filestrm.h"
 #include "toolutil.h"
 #include "uoptions.h"
 #include "unicode/udata.h"
@@ skipping 32 matching lines @@
             data->extData=NULL;
         }
         ucm_close(data->ucm);
         data->ucm=NULL;
     }
 }
 
 /*
  * from ucnvstat.c - static prototypes of data-based converters
  */
-extern const UConverterStaticData * ucnv_converterStaticData[UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES];
+U_CAPI const UConverterStaticData * ucnv_converterStaticData[UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES];
 
 /*
  * Global - verbosity
  */
 UBool VERBOSE = FALSE;
+UBool QUIET = FALSE;
 UBool SMALL = FALSE;
 UBool IGNORE_SISO_CHECK = FALSE;
 
 static void
 createConverter(ConvData *data, const char* converterName, UErrorCode *pErrorCode);
 
 /*
  * Set up the UNewData and write the converter..
  */
 static void
@@ skipping 78 matching lines @@
 
 enum {
     OPT_HELP_H,
     OPT_HELP_QUESTION_MARK,
     OPT_COPYRIGHT,
     OPT_VERSION,
     OPT_DESTDIR,
     OPT_VERBOSE,
     OPT_SMALL,
     OPT_IGNORE_SISO_CHECK,
+    OPT_QUIET,
+
     OPT_COUNT
 };
 
 static UOption options[]={
     UOPTION_HELP_H,
     UOPTION_HELP_QUESTION_MARK,
     UOPTION_COPYRIGHT,
     UOPTION_VERSION,
     UOPTION_DESTDIR,
     UOPTION_VERBOSE,
     { "small", NULL, NULL, NULL, '\1', UOPT_NO_ARG, 0 },
-    { "ignore-siso-check", NULL, NULL, NULL, '\1', UOPT_NO_ARG, 0 }
+    { "ignore-siso-check", NULL, NULL, NULL, '\1', UOPT_NO_ARG, 0 },
+    UOPTION_QUIET,
 };
 
 int main(int argc, char* argv[])
 {
     ConvData data;
-    UErrorCode err = U_ZERO_ERROR, localError;
-    char outFileName[UCNV_MAX_FULL_FILE_NAME_LENGTH];
-    const char* destdir, *arg;
-    size_t destdirlen;
-    char* dot = NULL, *outBasename;
     char cnvName[UCNV_MAX_FULL_FILE_NAME_LENGTH];
-    char cnvNameWithPkg[UCNV_MAX_FULL_FILE_NAME_LENGTH];
-    UVersionInfo icuVersion;
-    UBool printFilename;
-
-    err = U_ZERO_ERROR;
 
     U_MAIN_INIT_ARGS(argc, argv);
 
     /* Set up the ICU version number */
+    UVersionInfo icuVersion;
     u_getVersion(icuVersion);
     uprv_memcpy(&dataInfo.dataVersion, &icuVersion, sizeof(UVersionInfo));
 
     /* preset then read command line options */
     options[OPT_DESTDIR].value=u_getDataDirectory();
     argc=u_parseArgs(argc, argv, UPRV_LENGTHOF(options), options);
 
     /* error handling, printing usage message */
     if(argc<0) {
         fprintf(stderr,
             "error in command line argument \"%s\"\n",
             argv[-argc]);
     } else if(argc<2) {
         argc=-1;
     }
     if(argc<0 || options[OPT_HELP_H].doesOccur || options[OPT_HELP_QUESTION_MARK].doesOccur) {
         FILE *stdfile=argc<0 ? stderr : stdout;
         fprintf(stdfile,
             "usage: %s [-options] files...\n"
             "\tread .ucm codepage mapping files and write .cnv files\n"
             "options:\n"
             "\t-h or -? or --help  this usage text\n"
             "\t-V or --version     show a version message\n"
             "\t-c or --copyright   include a copyright notice\n"
             "\t-d or --destdir     destination directory, followed by the path\n"
-            "\t-v or --verbose     Turn on verbose output\n",
+            "\t-v or --verbose     Turn on verbose output\n"
+            "\t-q or --quiet       do not display warnings and progress\n",
             argv[0]);
         fprintf(stdfile,
             "\t      --small       Generate smaller .cnv files. They will be\n"
             "\t                    significantly smaller but may not be compatible with\n"
             "\t                    older versions of ICU and will require heap memory\n"
             "\t                    allocation when loaded.\n"
             "\t      --ignore-siso-check         Use SI/SO other than 0xf/0xe.\n");
         return argc<0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
     }
 
     if(options[OPT_VERSION].doesOccur) {
         printf("makeconv version %u.%u, ICU tool to read .ucm codepage mapping files and write .cnv files\n",
                dataInfo.formatVersion[0], dataInfo.formatVersion[1]);
         printf("%s\n", U_COPYRIGHT_STRING);
         exit(0);
     }
 
     /* get the options values */
     haveCopyright = options[OPT_COPYRIGHT].doesOccur;
-    destdir = options[OPT_DESTDIR].value;
+    const char *destdir = options[OPT_DESTDIR].value;
     VERBOSE = options[OPT_VERBOSE].doesOccur;
+    QUIET = options[OPT_QUIET].doesOccur;
     SMALL = options[OPT_SMALL].doesOccur;
 
     if (options[OPT_IGNORE_SISO_CHECK].doesOccur) {
         IGNORE_SISO_CHECK = TRUE;
     }
 
+    icu::CharString outFileName;
+    UErrorCode err = U_ZERO_ERROR;
     if (destdir != NULL && *destdir != 0) {
-        uprv_strcpy(outFileName, destdir);
-        destdirlen = uprv_strlen(destdir);
-        outBasename = outFileName + destdirlen;
-        if (*(outBasename - 1) != U_FILE_SEP_CHAR) {
-            *outBasename++ = U_FILE_SEP_CHAR;
-            ++destdirlen;
+        outFileName.append(destdir, err).ensureEndsWithFileSeparator(err);
+        if (U_FAILURE(err)) {
+            return err;
         }
-    } else {
-        destdirlen = 0;
-        outBasename = outFileName;
     }
+    int32_t outBasenameStart = outFileName.length();
 
 #if DEBUG
     {
       int i;
       printf("makeconv: processing %d files...\n", argc - 1);
       for(i=1; i<argc; ++i) {
         printf("%s ", argv[i]);
       }
       printf("\n");
       fflush(stdout);
     }
 #endif
 
-    err = U_ZERO_ERROR;
-    printFilename = (UBool) (argc > 2 || VERBOSE);
+    UBool printFilename = (UBool) (argc > 2 || VERBOSE);
     for (++argv; --argc; ++argv)
     {
-        arg = getLongPathname(*argv);
-
-        /* Check for potential buffer overflow */
-        if(strlen(arg) >= UCNV_MAX_FULL_FILE_NAME_LENGTH)
-        {
-            fprintf(stderr, "%s\n", u_errorName(U_BUFFER_OVERFLOW_ERROR));
-            return U_BUFFER_OVERFLOW_ERROR;
-        }
+        UErrorCode localError = U_ZERO_ERROR;
+        const char *arg = getLongPathname(*argv);
 
         /*produces the right destination path for display*/
-        if (destdirlen != 0)
+        outFileName.truncate(outBasenameStart);
+        if (outBasenameStart != 0)
         {
-            const char *basename;
-
             /* find the last file sepator */
-            basename = findBasename(arg);
-            uprv_strcpy(outBasename, basename);
+            const char *basename = findBasename(arg);
+            outFileName.append(basename, localError);
         }
         else
         {
-            uprv_strcpy(outFileName, arg);
+            outFileName.append(arg, localError);
+        }
+        if (U_FAILURE(localError)) {
+            return localError;
         }
 
         /*removes the extension if any is found*/
-        dot = uprv_strrchr(outBasename, '.');
-        if (dot)
-        {
-            *dot = '\0';
+        int32_t lastDotIndex = outFileName.lastIndexOf('.');
+        if (lastDotIndex >= outBasenameStart) {
+            outFileName.truncate(lastDotIndex);
         }
 
         /* the basename without extension is the converter name */
-        uprv_strcpy(cnvName, outBasename);
+        if ((outFileName.length() - outBasenameStart) >= UPRV_LENGTHOF(cnvName)) {
+            fprintf(stderr, "converter name %s too long\n", outFileName.data() + outBasenameStart);
+            return U_BUFFER_OVERFLOW_ERROR;
+        }
+        uprv_strcpy(cnvName, outFileName.data() + outBasenameStart);
 
         /*Adds the target extension*/
-        uprv_strcat(outBasename, CONVERTER_FILE_EXTENSION);
+        outFileName.append(CONVERTER_FILE_EXTENSION, localError);
+        if (U_FAILURE(localError)) {
+            return localError;
+        }
 
 #if DEBUG
         printf("makeconv: processing %s  ...\n", arg);
         fflush(stdout);
 #endif
-        localError = U_ZERO_ERROR;
         initConvData(&data);
         createConverter(&data, arg, &localError);
 
         if (U_FAILURE(localError))
         {
             /* if an error is found, print out an error msg and keep going */
-            fprintf(stderr, "Error creating converter for \"%s\" file for \"%s\" (%s)\n", outFileName, arg,
-                u_errorName(localError));
+            fprintf(stderr, "Error creating converter for \"%s\" file for \"%s\" (%s)\n",
+                    outFileName.data(), arg, u_errorName(localError));
             if(U_SUCCESS(err)) {
                 err = localError;
             }
         }
         else
         {
             /* Insure the static data name matches the  file name */
             /* Changed to ignore directory and only compare base name
              LDH 1/2/08*/
             char *p;
             p = strrchr(cnvName, U_FILE_SEP_CHAR); /* Find last file separator */
 
             if(p == NULL)            /* OK, try alternate */
             {
                 p = strrchr(cnvName, U_FILE_ALT_SEP_CHAR);
                 if(p == NULL)
                 {
                     p=cnvName; /* If no separators, no problem */
                 }
             }
             else
             {
-                p++;   /* If found separtor, don't include it in compare */
+                p++;   /* If found separator, don't include it in compare */
             }
-            if(uprv_stricmp(p,data.staticData.name))
+            if(uprv_stricmp(p,data.staticData.name) && !QUIET)
             {
                 fprintf(stderr, "Warning: %s%s claims to be '%s'\n",
                     cnvName,  CONVERTER_FILE_EXTENSION,
                     data.staticData.name);
             }
 
             uprv_strcpy((char*)data.staticData.name, cnvName);
 
             if(!uprv_isInvariantString((char*)data.staticData.name, -1)) {
                 fprintf(stderr,
                     "Error: A converter name must contain only invariant characters.\n"
                     "%s is not a valid converter name.\n",
                     data.staticData.name);
                 if(U_SUCCESS(err)) {
                     err = U_INVALID_TABLE_FORMAT;
                 }
             }
 
-            uprv_strcpy(cnvNameWithPkg, cnvName);
-
             localError = U_ZERO_ERROR;
-            writeConverterData(&data, cnvNameWithPkg, destdir, &localError);
+            writeConverterData(&data, cnvName, destdir, &localError);
 
             if(U_FAILURE(localError))
             {
                 /* if an error is found, print out an error msg and keep going*/
-                fprintf(stderr, "Error writing \"%s\" file for \"%s\" (%s)\n", outFileName, arg,
+                fprintf(stderr, "Error writing \"%s\" file for \"%s\" (%s)\n", outFileName.data(), arg,
                     u_errorName(localError));
                 if(U_SUCCESS(err)) {
                     err = localError;
                 }
             }
             else if (printFilename)
             {
-                puts(outBasename);
+                puts(outFileName.data() + outBasenameStart);
             }
         }
         fflush(stdout);
         fflush(stderr);
 
         cleanupConvData(&data);
     }
 
     return err;
 }
@@ skipping 12 matching lines @@
         *pCCSID=(int32_t)uprv_strtoul(name, NULL, 10);
     } else {
         *pPlatform=UCNV_UNKNOWN;
         *pCCSID=0;
     }
 }
 
 static void
 readHeader(ConvData *data,
            FileStream* convFile,
-           const char* converterName,
            UErrorCode *pErrorCode) {
     char line[1024];
     char *s, *key, *value;
     const UConverterStaticData *prototype;
     UConverterStaticData *staticData;
 
     if(U_FAILURE(*pErrorCode)) {
         return;
     }
 
@@ skipping 127 matching lines @@
     }
 
     data->ucm=ucm_open();
 
     convFile=T_FileStream_open(converterName, "r");
     if(convFile==NULL) {
         *pErrorCode=U_FILE_ACCESS_ERROR;
         return FALSE;
     }
 
-    readHeader(data, convFile, converterName, pErrorCode);
+    readHeader(data, convFile, pErrorCode);
     if(U_FAILURE(*pErrorCode)) {
         return FALSE;
     }
 
     if(data->ucm->baseName[0]==0) {
         dataIsBase=TRUE;
         baseStates=&data->ucm->states;
         ucm_processStates(baseStates, IGNORE_SISO_CHECK);
     } else {
         dataIsBase=FALSE;
@@ skipping 256 matching lines @@
 }
 
 /*
  * Hey, Emacs, please set the following:
  *
  * Local Variables:
  * indent-tabs-mode: nil
  * End:
  *
  */