ICU 56 update step 1

source/tools/genrb/wrtxml.cpp

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2002-2014, International Business Machines
+*   Copyright (C) 2002-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *
 * File wrtxml.cpp
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   10/01/02    Ram         Creation.
@@ skipping 114 matching lines @@
  *
  * @author Michael Lecuyer (mjl@theorem.com)
  * @version 1.1 August 11, 1998
  */
 
 /* ICU is not endian portable, because ICU data generated on big endian machines can be
  * ported to big endian machines but not to little endian machines and vice versa. The
  * conversion is not portable across platforms with different endianess.
  */
 
-uint32_t computeCRC(char *ptr, uint32_t len, uint32_t lastcrc){
+uint32_t computeCRC(const char *ptr, uint32_t len, uint32_t lastcrc){
     int32_t crc;
     uint32_t temp1;
     uint32_t temp2;
 
     int32_t crc_ta[256];
     int i = 0;
     int j = 0;
     uint32_t crc2 = 0;
 
 #define CRC32_POLYNOMIAL 0xEDB88320
@@ skipping 262 matching lines @@
     if(U_SUCCESS(*status)){
         trim(&buf,&bufLen);
         write_utf8_file(out,UnicodeString(tagStart));
         write_utf8_file(out,UnicodeString(buf, bufLen, "UTF-8"));
         write_utf8_file(out,UnicodeString(tagEnd));
         write_utf8_file(out,UnicodeString("\n"));
 
     }
 }
 static void
-printNoteElements(struct UString *src, UErrorCode *status){
+printNoteElements(const UString *src, UErrorCode *status){
 
 #if UCONFIG_NO_REGULAR_EXPRESSIONS==0 /* donot compile when no RegularExpressions are available */
 
     int32_t capacity = 0;
     UChar* note = NULL;
     int32_t noteLen = 0;
     int32_t count = 0,i;
 
     if(src == NULL){
         return;
@@ skipping 60 matching lines @@
     UChar* desc  = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity);
     UChar* trans = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity);
 
     int32_t descLen = 0, transLen=0;
     if(desc==NULL || trans==NULL){
         *status = U_MEMORY_ALLOCATION_ERROR;
         uprv_free(desc);
         uprv_free(trans);
         return;
     }
+    // TODO: make src const, stop modifying it in-place, make printContainer() take const resource, etc.
     src->fLength = removeCmtText(src->fChars, src->fLength, status);
     descLen  = getDescription(src->fChars,src->fLength, &desc, capacity, status);
     transLen = getTranslate(src->fChars,src->fLength, &trans, capacity, status);
 
     /* first print translate attribute */
     if(transLen > 0){
         if(printTranslate){
             /* print translate attribute */
             buf = convertAndEscape(&buf, 0, &bufLen, trans, transLen, status);
             if(U_SUCCESS(*status)){
@@ skipping 23 matching lines @@
 
 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
 
 }
 
 /*
  * Print out a containing element, like:
  * <trans-unit id = "blah" resname = "blah" restype = "x-id-alias" translate = "no">
  * <group id "calendar_gregorian" resname = "gregorian" restype = "x-icu-array">
  */
-static char *printContainer(struct SResource *res, const char *container, const char *restype, const char *mimetype, const char *id, UErrorCode *status)
+static char *printContainer(SResource *res, const char *container, const char *restype, const char *mimetype, const char *id, UErrorCode *status)
 {
-    char resKeyBuffer[8];
     const char *resname = NULL;
     char *sid = NULL;
 
     write_tabs(out);
 
-    resname = res_getKeyString(srBundle, res, resKeyBuffer);
+    resname = res->getKeyString(srBundle);
     if (resname != NULL && *resname != 0) {
         sid = getID(id, resname, sid);
     } else {
         sid = getID(id, NULL, sid);
     }
 
     write_utf8_file(out, UnicodeString("<"));
     write_utf8_file(out, UnicodeString(container));
     printAttribute("id", sid, (int32_t) uprv_strlen(sid));
 
@@ skipping 41 matching lines @@
 static const char *application_mimetype = "application"; /* add "/octet-stream"? */
 
 static const char *alias_restype     = "x-icu-alias";
 static const char *array_restype     = "x-icu-array";
 static const char *binary_restype    = "x-icu-binary";
 static const char *integer_restype   = "x-icu-integer";
 static const char *intvector_restype = "x-icu-intvector";
 static const char *table_restype     = "x-icu-table";
 
 static void
-string_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
+string_write_xml(StringResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
 
     char *sid = NULL;
     char* buf = NULL;
     int32_t bufLen = 0;
 
     if(status==NULL || U_FAILURE(*status)){
         return;
     }
 
     sid = printContainer(res, trans_unit, NULL, NULL, id, status);
 
     write_tabs(out);
 
     write_utf8_file(out, UnicodeString(source));
 
-    buf = convertAndEscape(&buf, 0, &bufLen, res->u.fString.fChars, res->u.fString.fLength, status);
+    buf = convertAndEscape(&buf, 0, &bufLen, res->getBuffer(), res->length(), status);
 
     if (U_FAILURE(*status)) {
         return;
     }
 
     write_utf8_file(out, UnicodeString(buf, bufLen, "UTF-8"));
     write_utf8_file(out, UnicodeString(close_source));
 
     printNoteElements(&res->fComment, status);
 
     tabCount -= 1;
     write_tabs(out);
 
     write_utf8_file(out, UnicodeString(close_trans_unit));
 
     uprv_free(buf);
     uprv_free(sid);
 }
 
 static void
-alias_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
+alias_write_xml(AliasResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
     char *sid = NULL;
     char* buf = NULL;
     int32_t bufLen=0;
 
     sid = printContainer(res, trans_unit, alias_restype, NULL, id, status);
 
     write_tabs(out);
 
     write_utf8_file(out, UnicodeString(source));
 
-    buf = convertAndEscape(&buf, 0, &bufLen, res->u.fString.fChars, res->u.fString.fLength, status);
+    buf = convertAndEscape(&buf, 0, &bufLen, res->getBuffer(), res->length(), status);
 
     if(U_FAILURE(*status)){
         return;
     }
     write_utf8_file(out, UnicodeString(buf, bufLen, "UTF-8"));
     write_utf8_file(out, UnicodeString(close_source));
 
     printNoteElements(&res->fComment, status);
 
     tabCount -= 1;
     write_tabs(out);
 
     write_utf8_file(out, UnicodeString(close_trans_unit));
 
     uprv_free(buf);
     uprv_free(sid);
 }
 
 static void
-array_write_xml(struct SResource *res, const char* id, const char* language, UErrorCode *status) {
+array_write_xml(ArrayResource *res, const char* id, const char* language, UErrorCode *status) {
     char* sid = NULL;
     int index = 0;
 
     struct SResource *current = NULL;
 
     sid = printContainer(res, group, array_restype, NULL, id, status);
 
-    current = res->u.fArray.fFirst;
+    current = res->fFirst;
 
     while (current != NULL) {
         char c[256] = {0};
         char* subId = NULL;
 
         itostr(c, index, 10, 0);
         index += 1;
         subId = getID(sid, c, subId);
 
         res_write_xml(current, subId, language, FALSE, status);
         uprv_free(subId);
         subId = NULL;
 
         if(U_FAILURE(*status)){
             return;
         }
 
         current = current->fNext;
     }
 
     tabCount -= 1;
     write_tabs(out);
     write_utf8_file(out, UnicodeString(close_group));
 
     uprv_free(sid);
 }
 
 static void
-intvector_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
+intvector_write_xml(IntVectorResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
     char* sid = NULL;
     char* ivd = NULL;
     uint32_t i=0;
     uint32_t len=0;
     char buf[256] = {'0'};
 
     sid = printContainer(res, group, intvector_restype, NULL, id, status);
 
-    for(i = 0; i < res->u.fIntVector.fCount; i += 1) {
+    for(i = 0; i < res->fCount; i += 1) {
         char c[256] = {0};
 
         itostr(c, i, 10, 0);
         ivd = getID(sid, c, ivd);
-        len = itostr(buf, res->u.fIntVector.fArray[i], 10, 0);
+        len = itostr(buf, res->fArray[i], 10, 0);
 
         write_tabs(out);
         write_utf8_file(out, UnicodeString("<"));
         write_utf8_file(out, UnicodeString(trans_unit));
 
         printAttribute("id", ivd, (int32_t)uprv_strlen(ivd));
         printAttribute("restype", integer_restype, (int32_t) strlen(integer_restype));
 
         write_utf8_file(out, UnicodeString(">\n"));
 
@@ skipping 14 matching lines @@
 
     tabCount -= 1;
     write_tabs(out);
 
     write_utf8_file(out, UnicodeString(close_group));
     uprv_free(sid);
     sid = NULL;
 }
 
 static void
-int_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
+int_write_xml(IntResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
     char* sid = NULL;
     char buf[256] = {0};
     uint32_t len = 0;
 
     sid = printContainer(res, trans_unit, integer_restype, NULL, id, status);
 
     write_tabs(out);
 
     write_utf8_file(out, UnicodeString(source));
 
-    len = itostr(buf, res->u.fIntValue.fValue, 10, 0);
+    len = itostr(buf, res->fValue, 10, 0);
     write_utf8_file(out, UnicodeString(buf, len));
 
     write_utf8_file(out, UnicodeString(close_source));
 
     printNoteElements(&res->fComment, status);
 
     tabCount -= 1;
     write_tabs(out);
 
     write_utf8_file(out, UnicodeString(close_trans_unit));
 
     uprv_free(sid);
     sid = NULL;
 }
 
 static void
-bin_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
+bin_write_xml(BinaryResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
     const char* m_type = application_mimetype;
     char* sid = NULL;
     uint32_t crc = 0xFFFFFFFF;
 
     char fileName[1024] ={0};
     int32_t tLen = ( outDir == NULL) ? 0 :(int32_t)uprv_strlen(outDir);
     char* fn =  (char*) uprv_malloc(sizeof(char) * (tLen+1024 +
-                                                    (res->u.fBinaryValue.fFileName !=NULL ?
-                                                    uprv_strlen(res->u.fBinaryValue.fFileName) :0)));
+                                                    (res->fFileName !=NULL ?
+                                                    uprv_strlen(res->fFileName) :0)));
     const char* ext = NULL;
 
     char* f = NULL;
 
     fn[0]=0;
 
-    if(res->u.fBinaryValue.fFileName != NULL){
-        uprv_strcpy(fileName, res->u.fBinaryValue.fFileName);
+    if(res->fFileName != NULL){
+        uprv_strcpy(fileName, res->fFileName);
         f = uprv_strrchr(fileName, '\\');
 
         if (f != NULL) {
             f++;
         } else {
             f = fileName;
         }
 
         ext = uprv_strrchr(fileName, '.');
 
@@ skipping 42 matching lines @@
 
         write_tabs(out);
         write_utf8_file(out, UnicodeString(bin_source));
 
         tabCount += 1;
         write_tabs(out);
 
         write_utf8_file(out, UnicodeString(internal_file));
         printAttribute("form", application_mimetype, (int32_t) uprv_strlen(application_mimetype));
 
-        while(i <res->u.fBinaryValue.fLength){
-            len = itostr(temp, res->u.fBinaryValue.fData[i], 16, 2);
+        while(i <res->fLength){
+            len = itostr(temp, res->fData[i], 16, 2);
             crc = computeCRC(temp, len, crc);
             i++;
         }
 
         len = itostr(temp, crc, 10, 0);
         printAttribute("crc", temp, len);
 
         write_utf8_file(out, UnicodeString(">"));
 
         i = 0;
-        while(i <res->u.fBinaryValue.fLength){
-            len = itostr(temp, res->u.fBinaryValue.fData[i], 16, 2);
+        while(i <res->fLength){
+            len = itostr(temp, res->fData[i], 16, 2);
             write_utf8_file(out, UnicodeString(temp));
             i += 1;
         }
 
         write_utf8_file(out, UnicodeString(close_internal_file));
 
         tabCount -= 2;
         write_tabs(out);
 
         write_utf8_file(out, UnicodeString(close_bin_source));
         printNoteElements(&res->fComment, status);
 
         tabCount -= 1;
         write_tabs(out);
         write_utf8_file(out, UnicodeString(close_bin_unit));
 
         uprv_free(sid);
         sid = NULL;
     }
 
     uprv_free(fn);
 }
 
 
 
 static void
-table_write_xml(struct SResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status) {
+table_write_xml(TableResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status) {
 
     uint32_t  i         = 0;
 
     struct SResource *current = NULL;
     char* sid = NULL;
 
     if (U_FAILURE(*status)) {
         return ;
     }
 
     sid = printContainer(res, group, table_restype, NULL, id, status);
 
     if(isTopLevel) {
         sid[0] = '\0';
     }
 
-    current = res->u.fTable.fFirst;
+    current = res->fFirst;
     i = 0;
 
     while (current != NULL) {
         res_write_xml(current, sid, language, FALSE, status);
 
         if(U_FAILURE(*status)){
             return;
         }
 
         i += 1;
@@ skipping 12 matching lines @@
 void
 res_write_xml(struct SResource *res, const char* id,  const char* language, UBool isTopLevel, UErrorCode *status) {
 
     if (U_FAILURE(*status)) {
         return ;
     }
 
     if (res != NULL) {
         switch (res->fType) {
         case URES_STRING:
-             string_write_xml    (res, id, language, status);
+             string_write_xml    (static_cast<StringResource *>(res), id, language, status);
              return;
 
         case URES_ALIAS:
-             alias_write_xml     (res, id, language, status);
+             alias_write_xml     (static_cast<AliasResource *>(res), id, language, status);
              return;
 
         case URES_INT_VECTOR:
-             intvector_write_xml (res, id, language, status);
+             intvector_write_xml (static_cast<IntVectorResource *>(res), id, language, status);
              return;
 
         case URES_BINARY:
-             bin_write_xml       (res, id, language, status);
+             bin_write_xml       (static_cast<BinaryResource *>(res), id, language, status);
              return;
 
         case URES_INT:
-             int_write_xml       (res, id, language, status);
+             int_write_xml       (static_cast<IntResource *>(res), id, language, status);
              return;
 
         case URES_ARRAY:
-             array_write_xml     (res, id, language, status);
+             array_write_xml     (static_cast<ArrayResource *>(res), id, language, status);
              return;
 
         case URES_TABLE:
-             table_write_xml     (res, id, language, isTopLevel, status);
+             table_write_xml     (static_cast<TableResource *>(res), id, language, isTopLevel, status);
              return;
 
         default:
             break;
         }
     }
 
     *status = U_INTERNAL_PROGRAM_ERROR;
 }
 
@@ skipping 198 matching lines @@
 cleanup_bundle_write_xml:
     uprv_free(originalFileName);
     uprv_free(lang);
     if(xmlfileName != NULL) {
         uprv_free(xmlfileName);
     }
     if(outputFileName != NULL){
         uprv_free(outputFileName);
     }
 }