Update ICU to 54.1 step 1

source/tools/gennorm2/n2builder.cpp

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2009-2012, International Business Machines
+*   Copyright (C) 2009-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  n2builder.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2009nov25
 *   created by: Markus W. Scherer
@@ skipping 11 matching lines @@
 #if U_HAVE_STD_STRING
 #include <vector>
 #endif
 #include "unicode/errorcode.h"
 #include "unicode/localpointer.h"
 #include "unicode/putil.h"
 #include "unicode/udata.h"
 #include "unicode/uniset.h"
 #include "unicode/unistr.h"
 #include "unicode/ustring.h"
+#include "charstr.h"
 #include "hash.h"
 #include "normalizer2impl.h"
 #include "toolutil.h"
 #include "unewdata.h"
 #include "utrie2.h"
 #include "uvectr32.h"
-
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+#include "writesrc.h"
 
 #if !UCONFIG_NO_NORMALIZATION
 
 /* UDataInfo cf. udata.h */
 static UDataInfo dataInfo={
     sizeof(UDataInfo),
     0,
 
     U_IS_BIG_ENDIAN,
     U_CHARSET_FAMILY,
     U_SIZEOF_UCHAR,
     0,
 
     { 0x4e, 0x72, 0x6d, 0x32 }, /* dataFormat="Nrm2" */
     { 2, 0, 0, 0 },             /* formatVersion */
     { 5, 2, 0, 0 }              /* dataVersion (Unicode version) */
 };
 
 U_NAMESPACE_BEGIN
 
 class HangulIterator {
 public:
     struct Range {
         UChar32 start, limit;
         uint16_t norm16;
     };
 
     HangulIterator() : rangeIndex(0) {}
     const Range *nextRange() {
-        if(rangeIndex<LENGTHOF(ranges)) {
+        if(rangeIndex<UPRV_LENGTHOF(ranges)) {
             return ranges+rangeIndex++;
         } else {
             return NULL;
         }
     }
     void reset() { rangeIndex=0; }
 private:
     static const Range ranges[4];
     int32_t rangeIndex;
 };
@@ skipping 79 matching lines @@
 U_CDECL_BEGIN
 
 static UBool U_CALLCONV
 enumRangeHandler(const void *context, UChar32 start, UChar32 end, uint32_t value) {
     return ((Normalizer2DBEnumerator *)context)->rangeHandler(start, end, value);
 }
 
 U_CDECL_END
 
 Normalizer2DataBuilder::Normalizer2DataBuilder(UErrorCode &errorCode) :
-        phase(0), overrideHandling(OVERRIDE_PREVIOUS), optimization(OPTIMIZE_NORMAL) {
+        phase(0), overrideHandling(OVERRIDE_PREVIOUS), optimization(OPTIMIZE_NORMAL),
+        norm16TrieLength(0) {
     memset(unicodeVersion, 0, sizeof(unicodeVersion));
     normTrie=utrie2_open(0, 0, &errorCode);
     normMem=utm_open("gennorm2 normalization structs", 10000, 0x110100, sizeof(Norm));
     norms=allocNorm();  // unused Norm struct at index 0
     memset(indexes, 0, sizeof(indexes));
     memset(smallFCD, 0, sizeof(smallFCD));
 }
 
 Normalizer2DataBuilder::~Normalizer2DataBuilder() {
     utrie2_close(normTrie);
@@ skipping 954 matching lines @@
     // which is harmless.
     // As a result, the minimum code points are always BMP code points.
     int32_t minCP=indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP];
     if(minCP>=0x10000) {
         indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=U16_LEAD(minCP);
     }
     minCP=indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP];
     if(minCP>=0x10000) {
         indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=U16_LEAD(minCP);
     }
-}
 
-void Normalizer2DataBuilder::writeBinaryFile(const char *filename) {
-    processData();
-
-    IcuToolErrorCode errorCode("gennorm2/writeBinaryFile()");
     utrie2_freeze(norm16Trie, UTRIE2_16_VALUE_BITS, errorCode);
-    int32_t norm16TrieLength=utrie2_serialize(norm16Trie, NULL, 0, errorCode);
+    norm16TrieLength=utrie2_serialize(norm16Trie, NULL, 0, errorCode);
     if(errorCode.get()!=U_BUFFER_OVERFLOW_ERROR) {
         fprintf(stderr, "gennorm2 error: unable to freeze/serialize the normalization trie - %s\n",
                 errorCode.errorName());
         exit(errorCode.reset());
     }
     errorCode.reset();
-    LocalArray<uint8_t> norm16TrieBytes(new uint8_t[norm16TrieLength]);
-    utrie2_serialize(norm16Trie, norm16TrieBytes.getAlias(), norm16TrieLength, errorCode);
-    errorCode.assertSuccess();
 
     int32_t offset=(int32_t)sizeof(indexes);
     indexes[Normalizer2Impl::IX_NORM_TRIE_OFFSET]=offset;
     offset+=norm16TrieLength;
     indexes[Normalizer2Impl::IX_EXTRA_DATA_OFFSET]=offset;
     offset+=extraData.length()*2;
     indexes[Normalizer2Impl::IX_SMALL_FCD_OFFSET]=offset;
     offset+=sizeof(smallFCD);
     int32_t totalSize=offset;
     for(int32_t i=Normalizer2Impl::IX_RESERVED3_OFFSET; i<=Normalizer2Impl::IX_TOTAL_SIZE; ++i) {
@@ skipping 12 matching lines @@
         printf("minNoNo:                           0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO]);
         printf("limitNoNo:                         0x%04x\n", (int)indexes[Normalizer2Impl::IX_LIMIT_NO_NO]);
         printf("minMaybeYes:                       0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]);
     }
 
     UVersionInfo nullVersion={ 0, 0, 0, 0 };
     if(0==memcmp(nullVersion, unicodeVersion, 4)) {
         u_versionFromString(unicodeVersion, U_UNICODE_VERSION);
     }
     memcpy(dataInfo.dataVersion, unicodeVersion, 4);
+}
+
+void Normalizer2DataBuilder::writeBinaryFile(const char *filename) {
+    processData();
+
+    IcuToolErrorCode errorCode("gennorm2/writeBinaryFile()");
+    LocalArray<uint8_t> norm16TrieBytes(new uint8_t[norm16TrieLength]);
+    utrie2_serialize(norm16Trie, norm16TrieBytes.getAlias(), norm16TrieLength, errorCode);
+    errorCode.assertSuccess();
+
     UNewDataMemory *pData=
         udata_create(NULL, NULL, filename, &dataInfo,
                      haveCopyright ? U_COPYRIGHT_STRING : NULL, errorCode);
     if(errorCode.isFailure()) {
         fprintf(stderr, "gennorm2 error: unable to create the output file %s - %s\n",
                 filename, errorCode.errorName());
         exit(errorCode.reset());
     }
     udata_writeBlock(pData, indexes, sizeof(indexes));
     udata_writeBlock(pData, norm16TrieBytes.getAlias(), norm16TrieLength);
     udata_writeUString(pData, extraData.getBuffer(), extraData.length());
     udata_writeBlock(pData, smallFCD, sizeof(smallFCD));
     int32_t writtenSize=udata_finish(pData, errorCode);
     if(errorCode.isFailure()) {
         fprintf(stderr, "gennorm2: error %s writing the output file\n", errorCode.errorName());
         exit(errorCode.reset());
     }
+    int32_t totalSize=indexes[Normalizer2Impl::IX_TOTAL_SIZE];
     if(writtenSize!=totalSize) {
         fprintf(stderr, "gennorm2 error: written size %ld != calculated size %ld\n",
             (long)writtenSize, (long)totalSize);
         exit(U_INTERNAL_PROGRAM_ERROR);
     }
 }
 
+void
+Normalizer2DataBuilder::writeCSourceFile(const char *filename) {
+    processData();
+
+    IcuToolErrorCode errorCode("gennorm2/writeCSourceFile()");
+    const char *basename=findBasename(filename);
+    CharString path(filename, (int32_t)(basename-filename), errorCode);
+    CharString dataName(basename, errorCode);
+    const char *extension=strrchr(basename, '.');
+    if(extension!=NULL) {
+        dataName.truncate((int32_t)(extension-basename));
+    }
+    errorCode.assertSuccess();
+
+    LocalArray<uint8_t> norm16TrieBytes(new uint8_t[norm16TrieLength]);
+    utrie2_serialize(norm16Trie, norm16TrieBytes.getAlias(), norm16TrieLength, errorCode);
+    errorCode.assertSuccess();
+
+    FILE *f=usrc_create(path.data(), basename, "icu/source/tools/gennorm2/n2builder.cpp");
+    if(f==NULL) {
+        fprintf(stderr, "gennorm2/writeCSourceFile() error: unable to create the output file %s\n",
+                filename);
+        exit(U_FILE_ACCESS_ERROR);
+        return;
+    }
+    char line[100];
+    sprintf(line, "static const UVersionInfo %s_formatVersion={", dataName.data());
+    usrc_writeArray(f, line, dataInfo.formatVersion, 8, 4, "};\n");
+    sprintf(line, "static const UVersionInfo %s_dataVersion={", dataName.data());
+    usrc_writeArray(f, line, dataInfo.dataVersion, 8, 4, "};\n\n");
+    sprintf(line, "static const int32_t %s_indexes[Normalizer2Impl::IX_COUNT]={\n",
+            dataName.data());
+    usrc_writeArray(f,
+        line,
+        indexes, 32, Normalizer2Impl::IX_COUNT,
+        "\n};\n\n");
+    sprintf(line, "static const uint16_t %s_trieIndex[%%ld]={\n", dataName.data());
+    usrc_writeUTrie2Arrays(f,
+        line, NULL,
+        norm16Trie,
+        "\n};\n\n");
+    sprintf(line, "static const uint16_t %s_extraData[%%ld]={\n", dataName.data());
+    usrc_writeArray(f,
+        line,
+        extraData.getBuffer(), 16, extraData.length(),
+        "\n};\n\n");
+    sprintf(line, "static const uint8_t %s_smallFCD[%%ld]={\n", dataName.data());
+    usrc_writeArray(f,
+        line,
+        smallFCD, 8, sizeof(smallFCD),
+        "\n};\n\n");
+    /*fputs(  // TODO
+        "static const UCaseProps %s_singleton={\n"
+        "  NULL,\n"
+        "  %s_indexes,\n"
+        "  %s_extraData,\n"
+        "  %s_smallFCD,\n",
+        f);*/
+    sprintf(line, "static const UTrie2 %s_trie={\n", dataName.data());
+    char line2[100];
+    sprintf(line2, "%s_trieIndex", dataName.data());
+    usrc_writeUTrie2Struct(f,
+        line,
+        norm16Trie, line2, NULL,
+        "};\n");
+    fclose(f);
+}
+
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_NORMALIZATION */
 
 /*
  * Hey, Emacs, please set the following:
  *
  * Local Variables:
  * indent-tabs-mode: nil
  * End:
  */