ICU 56 update step 1

source/tools/gendict/gendict.cpp

 /*
 **********************************************************************
-*   Copyright (C) 2002-2013, International Business Machines
+*   Copyright (C) 2002-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *
 * File gendict.cpp
 */
 
 #include "unicode/utypes.h"
 #include "unicode/uchar.h"
 #include "unicode/ucnv.h"
 #include "unicode/uniset.h"
@@ skipping 22 matching lines @@
 #include <stdlib.h>
 #include <string.h>
 
 #include "putilimp.h"
 UDate startTime;
 
 static int elapsedTime() {
   return (int)uprv_floor((uprv_getRawUTCtime()-startTime)/1000.0);
 }
 
-#if U_PLATFORM_IMPLEMENTS_POSIX && !U_PLATFORM_HAS_WIN32_API
-
-#include <signal.h>
-#include <unistd.h>
-
-const char *wToolname="gendict";
-const char *wOutname="(some file)";
-
-const int firstSeconds = 5; /* seconds between notices*/
-const int nextSeconds = 15; /* seconds between notices*/
-
-static void alarm_fn(int /*n*/) {
-  printf("%s: still writing\t%s (%ds)\t...\n",    wToolname, wOutname, elapsedTime());
-  
-  signal(SIGALRM, &alarm_fn);
-  alarm(nextSeconds); // reset the alarm
-}
-
-static void install_watchdog(const char *toolName, const char *outFileName) {
-  wToolname=toolName;
-  wOutname=outFileName;
-
-  signal(SIGALRM, &alarm_fn);
-
-  alarm(firstSeconds); // set the alarm
-}
-
-#else
-static void install_watchdog(const char*, const char*) {
-  // not implemented
-}
-#endif
-
-
-
-
 U_NAMESPACE_USE
 
 static char *progName;
 static UOption options[]={
     UOPTION_HELP_H,             /* 0 */
     UOPTION_HELP_QUESTION_MARK, /* 1 */
     UOPTION_VERBOSE,            /* 2 */
     UOPTION_ICUDATADIR,         /* 4 */
     UOPTION_COPYRIGHT,          /* 5 */
     { "uchars", NULL, NULL, NULL, '\1', UOPT_NO_ARG, 0}, /* 6 */
     { "bytes", NULL, NULL, NULL, '\1', UOPT_NO_ARG, 0}, /* 7 */
     { "transform", NULL, NULL, NULL, '\1', UOPT_REQUIRES_ARG, 0}, /* 8 */
+    UOPTION_QUIET,              /* 9 */
 };
 
 enum arguments {
     ARG_HELP = 0,
     ARG_QMARK,
     ARG_VERBOSE,
     ARG_ICUDATADIR,
     ARG_COPYRIGHT,
     ARG_UCHARS,
     ARG_BYTES,
-    ARG_TRANSFORM
+    ARG_TRANSFORM,
+    ARG_QUIET
 };
 
 // prints out the standard usage method describing command line arguments, 
 // then bails out with the desired exit code
 static void usageAndDie(UErrorCode retCode) {
     fprintf((U_SUCCESS(retCode) ? stdout : stderr), "Usage: %s -trietype [-options] input-dictionary-file output-file\n", progName);
     fprintf((U_SUCCESS(retCode) ? stdout : stderr),
            "\tRead in a word list and write out a string trie dictionary\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-v or --verbose     turn on verbose output\n"
+           "\t-q or --quiet       do not display warnings and progress\n"
            "\t-i or --icudatadir  directory for locating any needed intermediate data files,\n" // TODO: figure out if we need this option
            "\t                    followed by path, defaults to %s\n"
            "\t--uchars            output a UCharsTrie (mutually exclusive with -b!)\n"
            "\t--bytes             output a BytesTrie (mutually exclusive with -u!)\n"
            "\t--transform         the kind of transform to use (eg --transform offset-40A3,\n"
            "\t                    which specifies an offset transform with constant 0x40A3)\n",
             u_getDataDirectory());
     exit(retCode);
 }
 
@@ skipping 156 matching lines @@
         fprintf(stderr, "error in command line argument \"%s\"\n", argv[-argc]);
         usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
     }
 
     if(options[ARG_HELP].doesOccur || options[ARG_QMARK].doesOccur) {
         //  -? or -h for help.
         usageAndDie(U_ZERO_ERROR);
     }
 
     UBool verbose = options[ARG_VERBOSE].doesOccur;
+    UBool quiet = options[ARG_QUIET].doesOccur;
 
     if (argc < 3) {
         fprintf(stderr, "input and output file must both be specified.\n");
         usageAndDie(U_ILLEGAL_ARGUMENT_ERROR);
     }
     const char *outFileName  = argv[2];
     const char *wordFileName = argv[1];
 
     startTime = uprv_getRawUTCtime(); // initialize start timer
-    // set up the watchdog
-    install_watchdog(progName, outFileName);
 
-    if (options[ARG_ICUDATADIR].doesOccur) {
+        if (options[ARG_ICUDATADIR].doesOccur) {
         u_setDataDirectory(options[ARG_ICUDATADIR].value);
     }
 
     const char *copyright = NULL;
     if (options[ARG_COPYRIGHT].doesOccur) {
         copyright = U_COPYRIGHT_STRING;
     }
 
     if (options[ARG_UCHARS].doesOccur == options[ARG_BYTES].doesOccur) {
         fprintf(stderr, "you must specify exactly one type of trie to output!\n");
@@ skipping 158 matching lines @@
     if (status.isFailure()) {
         fprintf(stderr, "gendict: error \"%s\" writing the output file\n", status.errorName());
         exit(status.reset());
     }
 
     if (bytesWritten != (size_t)size) {
         fprintf(stderr, "Error writing to output file \"%s\"\n", outFileName);
         exit(U_INTERNAL_PROGRAM_ERROR);
     }
 
-    printf("%s: done writing\t%s (%ds).\n", progName, outFileName, elapsedTime());
+    if (!quiet) { printf("%s: done writing\t%s (%ds).\n", progName, outFileName, elapsedTime()); }
 
 #ifdef TEST_GENDICT
     if (isBytesTrie) {
         BytesTrie::Iterator it(outData, outDataSize, status);
         while (it.hasNext()) {
             it.next(status);
             const StringPiece s = it.getString();
             int32_t val = it.getValue();
             printf("%s -> %i\n", s.data(), val);
         }
     } else {
         UCharsTrie::Iterator it((const UChar *)outData, outDataSize, status);
         while (it.hasNext()) {
             it.next(status);
             const UnicodeString s = it.getString();
             int32_t val = it.getValue();
             char tmp[1024];
             s.extract(0, s.length(), tmp, 1024);
             printf("%s -> %i\n", tmp, val);
         }
     }
 #endif
 
     return 0;
 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */
 }