ICU 56 update step 1

source/tools/genrb/wrtjava.cpp

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2000-2012, International Business Machines
+*   Copyright (C) 2000-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *
-* File wrtjava.c
+* File wrtjava.cpp
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   01/11/02    Ram         Creation.
 *   02/12/08    Spieth      Fix errant 'new Object[][]{' insertion
 *   02/19/08    Spieth      Removed ICUListResourceBundle dependancy
 *******************************************************************************
 */
 
 #include <assert.h>
+#include "unicode/unistr.h"
 #include "reslist.h"
 #include "unewdata.h"
 #include "unicode/ures.h"
 #include "errmsg.h"
 #include "filestrm.h"
 #include "cstring.h"
 #include "unicode/ucnv.h"
 #include "genrb.h"
 #include "rle.h"
 #include "uhash.h"
@@ skipping 62 matching lines @@
         T_FileStream_write(os,"    ",4);
     }
 }
 
 #define ZERO 0x30
 
 static const char* enc ="";
 static UConverter* conv = NULL;
 
 static int32_t
-uCharsToChars( char* target,int32_t targetLen, UChar* source, int32_t sourceLen,UErrorCode* status){
+uCharsToChars(char *target, int32_t targetLen, const UChar *source, int32_t sourceLen, UErrorCode *status) {
     int i=0, j=0;
     char str[30]={'\0'};
     while(i<sourceLen){
         if (source[i] == '\n') {
             if (j + 2 < targetLen) {
                 uprv_strcat(target, "\\n");
             }
             j += 2;
         }else if(source[i]==0x0D){
             if(j+2<targetLen){
@@ skipping 104 matching lines @@
     /*
      * calculate the number of lines that
      * may be required if column count is 80
      */
     if (maxLines  < (adjustedLen / columnCount) ){
         columnCount = adjustedLen / maxLines;
     }
     return columnCount;
 }
 static void
-str_write_java( uint16_t* src, int32_t srcLen, UBool printEndLine, UErrorCode *status){
+str_write_java(const UChar *src, int32_t srcLen, UBool printEndLine, UErrorCode *status) {
 
     uint32_t length = srcLen*8;
     uint32_t bufLen = 0;
     uint32_t columnCount;
     char* buf = (char*) malloc(sizeof(char)*length);
 
     if(buf == NULL) {
         *status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
@@ skipping 58 matching lines @@
     if(printEndLine){
         T_FileStream_write(out,"\",\n",3);
     }else{
         T_FileStream_write(out,"\"",1);
     }
     uprv_free(buf);
 }
 
 /* Writing Functions */
 static void
-string_write_java(struct SResource *res,UErrorCode *status) {
-    char resKeyBuffer[8];
-    const char *resname = res_getKeyString(srBundle, res, resKeyBuffer);
+string_write_java(const StringResource *res,UErrorCode *status) {
+    (void)res->getKeyString(srBundle);
 
-    str_write_java(res->u.fString.fChars,res->u.fString.fLength,TRUE,status);
-    
-        if(resname != NULL && uprv_strcmp(resname,"Rule")==0)
-        {
-        UChar* buf = (UChar*) uprv_malloc(sizeof(UChar)*res->u.fString.fLength);
-        uprv_memcpy(buf,res->u.fString.fChars,res->u.fString.fLength);
-        uprv_free(buf);
-    }
-
+    str_write_java(res->getBuffer(), res->length(), TRUE, status);
 }
 
 static void
-array_write_java( struct SResource *res, UErrorCode *status) {
+array_write_java(const ArrayResource *res, UErrorCode *status) {
 
     uint32_t  i         = 0;
     const char* arr ="new String[] { \n";
     struct SResource *current = NULL;
     UBool allStrings    = TRUE;
 
     if (U_FAILURE(*status)) {
         return;
     }
 
-    if (res->u.fArray.fCount > 0) {
+    if (res->fCount > 0) {
 
-        current = res->u.fArray.fFirst;
+        current = res->fFirst;
         i = 0;
         while(current != NULL){
-            if(current->fType!=URES_STRING){
+            if(!current->isString()){
                 allStrings = FALSE;
                 break;
             }
             current= current->fNext;
         }
 
-        current = res->u.fArray.fFirst;
+        current = res->fFirst;
         if(allStrings==FALSE){
             const char* object = "new Object[]{\n";
             write_tabs(out);
             T_FileStream_write(out, object, (int32_t)uprv_strlen(object));
             tabCount++;
         }else{
             write_tabs(out);
             T_FileStream_write(out, arr, (int32_t)uprv_strlen(arr));
             tabCount++;
         }
         while (current != NULL) {
-            /*if(current->fType==URES_STRING){
+            /*if(current->isString()){
                 write_tabs(out);
             }*/
             res_write_java(current, status);
             if(U_FAILURE(*status)){
                 return;
             }
             i++;
             current = current->fNext;
         }
         T_FileStream_write(out,"\n",1);
 
         tabCount--;
         write_tabs(out);
         T_FileStream_write(out,"},\n",3);
 
     } else {
         write_tabs(out);
         T_FileStream_write(out,arr,(int32_t)uprv_strlen(arr));
         write_tabs(out);
         T_FileStream_write(out,"},\n",3);
     }
 }
 
 static void
-intvector_write_java( struct SResource *res, UErrorCode *status) {
+intvector_write_java(const IntVectorResource *res, UErrorCode * /*status*/) {
     uint32_t i = 0;
     const char* intArr = "new int[] {\n";
     /* const char* intC   = "new Integer(";   */
     const char* stringArr = "new String[]{\n";
-    char resKeyBuffer[8];
-    const char *resname = res_getKeyString(srBundle, res, resKeyBuffer);
+    const char *resname = res->getKeyString(srBundle);
     char buf[100];
     int len =0;
     buf[0]=0;
     write_tabs(out);
 
     if(resname != NULL && uprv_strcmp(resname,"DateTimeElements")==0){
         T_FileStream_write(out, stringArr, (int32_t)uprv_strlen(stringArr));
         tabCount++;
-        for(i = 0; i<res->u.fIntVector.fCount; i++) {
+        for(i = 0; i<res->fCount; i++) {
             write_tabs(out);
-            len=itostr(buf,res->u.fIntVector.fArray[i],10,0);
+            len=itostr(buf,res->fArray[i],10,0);
             T_FileStream_write(out,"\"",1);
             T_FileStream_write(out,buf,len);
             T_FileStream_write(out,"\",",2);
             T_FileStream_write(out,"\n",1);
         }
     }else{
         T_FileStream_write(out, intArr, (int32_t)uprv_strlen(intArr));
         tabCount++;
-        for(i = 0; i<res->u.fIntVector.fCount; i++) {
+        for(i = 0; i<res->fCount; i++) {
             write_tabs(out);
             /* T_FileStream_write(out, intC, (int32_t)uprv_strlen(intC)); */
-            len=itostr(buf,res->u.fIntVector.fArray[i],10,0);
+            len=itostr(buf,res->fArray[i],10,0);
             T_FileStream_write(out,buf,len);
             /* T_FileStream_write(out,"),",2);  */
             /* T_FileStream_write(out,"\n",1);  */
             T_FileStream_write(out,",\n",2);
         }
     }
     tabCount--;
     write_tabs(out);
     T_FileStream_write(out,"},\n",3);
 }
 
 static void
-int_write_java(struct SResource *res,UErrorCode *status) {
+int_write_java(const IntResource *res, UErrorCode * /*status*/) {
     const char* intC   =  "new Integer(";
     char buf[100];
     int len =0;
     buf[0]=0;
 
     /* write the binary data */
     write_tabs(out);
     T_FileStream_write(out, intC, (int32_t)uprv_strlen(intC));
-    len=itostr(buf, res->u.fIntValue.fValue, 10, 0);
+    len=itostr(buf, res->fValue, 10, 0);
     T_FileStream_write(out,buf,len);
     T_FileStream_write(out,"),\n",3 );
 
 }
 
 static void
-bytes_write_java( struct SResource *res, UErrorCode *status) {
+bytes_write_java(const BinaryResource *res, UErrorCode * /*status*/) {
         const char* type  = "new byte[] {";
         const char* byteDecl = "%i, ";
     char byteBuffer[100] = { 0 };
         uint8_t*  byteArray = NULL;
     int byteIterator = 0;
         
-    int32_t srcLen=res->u.fBinaryValue.fLength;
+    int32_t srcLen=res->fLength;
         
     if(srcLen>0 )
         {
-        byteArray = res->u.fBinaryValue.fData;
+        byteArray = res->fData;
 
         write_tabs(out);
         T_FileStream_write(out, type, (int32_t)uprv_strlen(type));
         T_FileStream_write(out, "\n", 1);
         tabCount++;
 
                 for (;byteIterator<srcLen;byteIterator++)
                 {
             if (byteIterator%16 == 0)
                         {
@@ skipping 34 matching lines @@
         write_tabs(out);
         T_FileStream_write(out,type,(int32_t)uprv_strlen(type));
                 T_FileStream_write(out,"},\n",3);
     }
 
 }
 
 static UBool start = TRUE;
 
 static void
-table_write_java(struct SResource *res, UErrorCode *status) {
+table_write_java(const TableResource *res, UErrorCode *status) {
     uint32_t  i         = 0;
     struct SResource *current = NULL;
     const char* obj = "new Object[][]{\n";
 
     if (U_FAILURE(*status)) {
         return ;
     }
 
-    if (res->u.fTable.fCount > 0) {
+    if (res->fCount > 0) {
         if(start==FALSE){
             write_tabs(out);
             T_FileStream_write(out, obj, (int32_t)uprv_strlen(obj));
             tabCount++;
         }
         start = FALSE;
-        current = res->u.fTable.fFirst;
+        current = res->fFirst;
         i       = 0;
 
 
         while (current != NULL) {
-            char currentKeyBuffer[8];
-            const char *currentKeyString = res_getKeyString(srBundle, current, currentKeyBuffer);
+            const char *currentKeyString = current->getKeyString(srBundle);
 
-            assert(i < res->u.fTable.fCount);
+            assert(i < res->fCount);
             write_tabs(out);
 
             T_FileStream_write(out, openBrace, 2);
 
 
             tabCount++;
 
             write_tabs(out);
             if(currentKeyString != NULL) {
                 T_FileStream_write(out, "\"", 1);
@@ skipping 33 matching lines @@
 void
 res_write_java(struct SResource *res,UErrorCode *status) {
 
     if (U_FAILURE(*status)) {
         return ;
     }
 
     if (res != NULL) {
         switch (res->fType) {
         case URES_STRING:
-             string_write_java    (res, status);
+             string_write_java    (static_cast<const StringResource *>(res), status);
              return;
         case URES_ALIAS:
              printf("Encountered unsupported resource type %d of alias\n", res->fType);
              *status = U_UNSUPPORTED_ERROR;
                          return;
         case URES_INT_VECTOR:
-             intvector_write_java (res, status);
+             intvector_write_java (static_cast<const IntVectorResource *>(res), status);
              return;
         case URES_BINARY:
-             bytes_write_java     (res, status);
+             bytes_write_java     (static_cast<const BinaryResource *>(res), status);
              return;
         case URES_INT:
-             int_write_java       (res, status);
+             int_write_java       (static_cast<const IntResource *>(res), status);
              return;
         case URES_ARRAY:
-             array_write_java     (res, status);
+             array_write_java     (static_cast<const ArrayResource *>(res), status);
              return;
         case URES_TABLE:
-             table_write_java     (res, status);
+             table_write_java     (static_cast<const TableResource *>(res), status);
              return;
         default:
             break;
         }
     }
 
     *status = U_INTERNAL_PROGRAM_ERROR;
 }
 
 void
@@ skipping 73 matching lines @@
         }
     }
     res_write_java(bundle->fRoot, status);
 
     T_FileStream_write(out, closeClass, (int32_t)uprv_strlen(closeClass));
 
     T_FileStream_close(out);
 
     ucnv_close(conv);
 }