830 lines
26 KiB
C
830 lines
26 KiB
C
/*
|
|
*******************************************************************************
|
|
*
|
|
* Copyright (C) 2000-2003, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
*******************************************************************************
|
|
*
|
|
* File wrtjava.c
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 01/11/02 Ram Creation.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#include <assert.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 "ucol_tok.h"
|
|
#include "uhash.h"
|
|
#include "uresimp.h"
|
|
#include "unicode/ustring.h"
|
|
|
|
void res_write_java(struct SResource *res,UErrorCode *status);
|
|
|
|
|
|
static const char copyRight[] =
|
|
"/* \n"
|
|
" *******************************************************************************\n"
|
|
" *\n"
|
|
" * Copyright (C) International Business Machines\n"
|
|
" * Corporation and others. All Rights Reserved.\n"
|
|
" *\n"
|
|
" *******************************************************************************\n"
|
|
" * $" "Source: $ \n"
|
|
" * $" "Date: $ \n"
|
|
" * $" "Revision: $ \n"
|
|
" *******************************************************************************\n"
|
|
" */\n\n";
|
|
static const char warningMsg[] =
|
|
"/*********************************************************************\n"
|
|
"######################################################################\n"
|
|
"\n"
|
|
" WARNING: This file is generated by genrb Version " GENRB_VERSION ".\n"
|
|
" If you edit this file, please make sure that, the source\n"
|
|
" of this file (XXXX.txt in LocaleElements_XXXX.java)\n"
|
|
" is also edited.\n"
|
|
"######################################################################\n"
|
|
" *********************************************************************\n"
|
|
" */\n\n";
|
|
static const char* openBrace="{\n";
|
|
static const char* closeClass=" };\n"
|
|
"}\n";
|
|
|
|
static const char* javaClass = "import java.util.ListResourceBundle;\n"
|
|
"import com.ibm.icu.impl.ICUListResourceBundle;\n\n"
|
|
"public class ";
|
|
|
|
static const char* javaClass1= " extends ICUListResourceBundle {\n\n"
|
|
" /**\n"
|
|
" * Overrides ListResourceBundle \n"
|
|
" */\n"
|
|
" public final Object[][] getContents() { \n"
|
|
" return contents;\n"
|
|
" }\n"
|
|
" private static Object[][] contents = {\n";
|
|
static const char* javaClassICU= " extends ICUListResourceBundle {\n\n"
|
|
" public %s () {\n"
|
|
" super.contents = data;\n"
|
|
" }\n"
|
|
" static final Object[][] data = new Object[][] { \n";
|
|
static int tabCount = 3;
|
|
|
|
static FileStream* out=NULL;
|
|
static struct SRBRoot* srBundle ;
|
|
static const char* outDir = NULL;
|
|
|
|
static const char* bName=NULL;
|
|
static const char* pName=NULL;
|
|
|
|
static void write_tabs(FileStream* os){
|
|
int i=0;
|
|
for(;i<=tabCount;i++){
|
|
T_FileStream_write(os," ",4);
|
|
}
|
|
}
|
|
|
|
#define ZERO 0x30
|
|
|
|
static const char* enc ="";
|
|
static UConverter* conv = NULL;
|
|
static char NUMBER = ZERO;
|
|
|
|
static int32_t
|
|
uCharsToChars( char* target,int32_t targetLen, 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){
|
|
uprv_strcat(target,"\\f");
|
|
}
|
|
j+=2;
|
|
}else if(source[i] == '"'){
|
|
if(source[i-1]=='\''){
|
|
if(j+2<targetLen){
|
|
uprv_strcat(target,"\\");
|
|
target[j+1]= (char)source[i];
|
|
}
|
|
j+=2;
|
|
}else if(source[i-1]!='\\'){
|
|
|
|
if(j+2<targetLen){
|
|
uprv_strcat(target,"\\");
|
|
target[j+1]= (char)source[i];
|
|
}
|
|
j+=2;
|
|
}else if(source[i-1]=='\\'){
|
|
target[j++]= (char)source[i];
|
|
}
|
|
}else if(source[i]=='\\'){
|
|
if(i+1<sourceLen){
|
|
switch(source[i+1]){
|
|
case ',':
|
|
case '!':
|
|
case '?':
|
|
case '#':
|
|
case '.':
|
|
case '%':
|
|
case '&':
|
|
case ':':
|
|
case ';':
|
|
if(j+2<targetLen){
|
|
uprv_strcat(target,"\\\\");
|
|
}
|
|
j+=2;
|
|
break;
|
|
case '"':
|
|
case '\'':
|
|
if(j+3<targetLen){
|
|
uprv_strcat(target,"\\\\\\");
|
|
}
|
|
j+=3;
|
|
break;
|
|
default :
|
|
if(j<targetLen){
|
|
target[j]=(char)source[i];
|
|
}
|
|
j++;
|
|
break;
|
|
}
|
|
}else{
|
|
if(j<targetLen){
|
|
uprv_strcat(target,"\\\\");
|
|
}
|
|
j+=2;
|
|
}
|
|
}else if(source[i]>=0x20 && source[i]<0x7F/*ASCII*/){
|
|
if(j<targetLen){
|
|
target[j] = (char) source[i];
|
|
}
|
|
j++;
|
|
}else{
|
|
if(*enc =='\0' || source[i]==0x0000){
|
|
uprv_strcpy(str,"\\u");
|
|
itostr(str+2,source[i],16,4);
|
|
if(j+6<targetLen){
|
|
uprv_strcat(target,str);
|
|
}
|
|
j+=6;
|
|
}else{
|
|
char dest[30] = {0};
|
|
int retVal=ucnv_fromUChars(conv,dest,30,source+i,1,status);
|
|
if(U_FAILURE(*status)){
|
|
return 0;
|
|
}
|
|
if(j+retVal<targetLen){
|
|
uprv_strcat(target,dest);
|
|
}
|
|
j+=retVal;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return j;
|
|
}
|
|
|
|
|
|
static uint32_t
|
|
strrch(const char* source,uint32_t sourceLen,char find){
|
|
const char* tSourceEnd =source + (sourceLen-1);
|
|
while(tSourceEnd>= source){
|
|
if(*tSourceEnd==find){
|
|
return (uint32_t)(tSourceEnd-source);
|
|
}
|
|
tSourceEnd--;
|
|
}
|
|
return (uint32_t)(tSourceEnd-source);
|
|
}
|
|
|
|
static int32_t getColumnCount(int32_t len){
|
|
int32_t columnCount = 80;
|
|
int32_t maxLines = 3000;
|
|
int32_t adjustedLen = len*5; /* assume that every codepoint is represented in \uXXXX format*/
|
|
/*
|
|
* 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){
|
|
|
|
uint32_t length = srcLen*8;
|
|
uint32_t bufLen = 0;
|
|
char* buf = (char*) malloc(sizeof(char)*length);
|
|
|
|
uint32_t columnCount = getColumnCount(srcLen);
|
|
|
|
/* test for NULL */
|
|
if(buf == NULL) {
|
|
*status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
|
|
memset(buf,0,length);
|
|
|
|
bufLen = uCharsToChars(buf,length,src,srcLen,status);
|
|
|
|
if(printEndLine) write_tabs(out);
|
|
|
|
if(U_FAILURE(*status)){
|
|
return;
|
|
}
|
|
|
|
if(bufLen+(tabCount*4) > columnCount ){
|
|
uint32_t len = 0;
|
|
char* current = buf;
|
|
uint32_t add;
|
|
while(len < bufLen){
|
|
add = columnCount-(tabCount*4)-5/* for ", +\n */;
|
|
current = buf +len;
|
|
if (add < (bufLen-len)) {
|
|
uint32_t index = strrch(current,add,'\\');
|
|
if (index > add) {
|
|
index = add;
|
|
} else {
|
|
int32_t num =index-1;
|
|
uint32_t seqLen;
|
|
while(num>0){
|
|
if(current[num]=='\\'){
|
|
num--;
|
|
}else{
|
|
break;
|
|
}
|
|
}
|
|
if ((index-num)%2==0) {
|
|
index--;
|
|
}
|
|
seqLen = (current[index+1]=='u') ? 6 : 2;
|
|
if ((add-index) < seqLen) {
|
|
add = index + seqLen;
|
|
}
|
|
}
|
|
}
|
|
T_FileStream_write(out,"\"",1);
|
|
if(len+add<bufLen){
|
|
T_FileStream_write(out,current,add);
|
|
T_FileStream_write(out,"\" +\n",4);
|
|
write_tabs(out);
|
|
}else{
|
|
T_FileStream_write(out,current,bufLen-len);
|
|
}
|
|
len+=add;
|
|
}
|
|
}else{
|
|
T_FileStream_write(out,"\"",1);
|
|
T_FileStream_write(out, buf,bufLen);
|
|
}
|
|
if(printEndLine){
|
|
T_FileStream_write(out,"\",\n",3);
|
|
}else{
|
|
T_FileStream_write(out,"\"",1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
write_utf8_file(struct SResource *res, const char *file, UErrorCode *status){
|
|
char fileName[1024] ={0};
|
|
FileStream* datFile = NULL;
|
|
const char* type = "new ICUListResourceBundle.ResourceString(";
|
|
char* dest = (char*) uprv_malloc( 8 * res->u.fString.fLength);
|
|
int32_t len = 0;
|
|
if(outDir){
|
|
uprv_strcat(fileName,outDir);
|
|
if(outDir[uprv_strlen(outDir)-1]!=U_FILE_SEP_CHAR){
|
|
uprv_strcat(fileName,U_FILE_SEP_STRING);
|
|
}
|
|
}
|
|
uprv_strcat(fileName,file);/* UCARULES.utf8 UTF-8 file */
|
|
|
|
write_tabs(out);
|
|
|
|
T_FileStream_write(out, type, (int32_t)uprv_strlen(type));
|
|
T_FileStream_write(out, "\"", 1);
|
|
T_FileStream_write(out, file, (int32_t)uprv_strlen(file));
|
|
T_FileStream_write(out, "\")\n", 3);
|
|
datFile=T_FileStream_open(fileName,"w");
|
|
|
|
if(!dest){
|
|
*status=U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
|
|
u_strToUTF8(dest,8*res->u.fString.fLength,&len,res->u.fString.fChars,res->u.fString.fLength,status);
|
|
if(U_FAILURE(*status)){
|
|
T_FileStream_close(datFile);
|
|
uprv_free(dest);
|
|
return;
|
|
}
|
|
T_FileStream_write(datFile,dest,len);
|
|
T_FileStream_close(datFile);
|
|
uprv_free(dest);
|
|
}
|
|
#define MAX_SEQUENCE_LENGTH 30000
|
|
/* Writing Functions */
|
|
static void
|
|
string_write_java(struct SResource *res,UErrorCode *status) {
|
|
if(res->fKey > 0 && uprv_strcmp(srBundle->fKeys+res->fKey,"%%UCARULES")==0 ){
|
|
|
|
const char* file = "UCARules.utf8";
|
|
write_utf8_file(res, file, status);
|
|
}else if(res->fKey > 0 && uprv_strcmp(srBundle->fKeys+res->fKey,"Sequence")==0
|
|
&& res->fType == RES_STRING
|
|
&& res->u.fString.fLength > MAX_SEQUENCE_LENGTH){
|
|
char file[1024] = {0};
|
|
uprv_strcpy(file, "CollationSequence_");
|
|
uprv_strcat(file, srBundle->fLocale);
|
|
uprv_strcat(file, ".utf8");
|
|
write_utf8_file(res, file, status);
|
|
|
|
}else{
|
|
str_write_java(res->u.fString.fChars,res->u.fString.fLength,TRUE,status);
|
|
|
|
if(res->fKey > 0 && uprv_strcmp(srBundle->fKeys+res->fKey,"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);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
alias_write_java(struct SResource *res,UErrorCode *status) {
|
|
static const char str[] = "new ICUListResourceBundle.Alias(";
|
|
write_tabs(out);
|
|
T_FileStream_write(out,str,(int32_t)uprv_strlen(str));
|
|
|
|
/*str_write_java(res->u.fString.fChars,res->u.fString.fLength,FALSE,status);*/
|
|
/*if(*res->u.fString.fChars == RES_PATH_SEPARATOR) {*/
|
|
/* there is a path included
|
|
locale = u_strchr(res->u.fString.fChars +1, RES_PATH_SEPARATOR);
|
|
*locale = 0;
|
|
locale++;
|
|
|
|
T_FileStream_write(out,"\"/",2);
|
|
T_FileStream_write(out,apName,(int32_t)uprv_strlen(apName));
|
|
T_FileStream_write(out,"/",1);
|
|
T_FileStream_write(out,abName,(int32_t)uprv_strlen(abName));
|
|
T_FileStream_write(out,"/\"+",3);
|
|
str_write_java(locale,res->u.fString.fLength-(locale-res->u.fString.fChars),FALSE,status);
|
|
} else {
|
|
str_write_java(res->u.fString.fChars,res->u.fString.fLength,FALSE,status);
|
|
}*/
|
|
|
|
str_write_java(res->u.fString.fChars,res->u.fString.fLength,FALSE,status);
|
|
|
|
T_FileStream_write(out,"),\n",3);
|
|
}
|
|
|
|
static void
|
|
array_write_java( struct SResource *res, UErrorCode *status) {
|
|
|
|
uint32_t i = 0;
|
|
const char* arr ="new String[] { \n";
|
|
struct SResource *current = NULL;
|
|
struct SResource *first =NULL;
|
|
UBool decrementTabs = FALSE;
|
|
UBool allStrings = TRUE;
|
|
|
|
if (U_FAILURE(*status)) {
|
|
return;
|
|
}
|
|
|
|
if (res->u.fArray.fCount > 0) {
|
|
|
|
current = res->u.fArray.fFirst;
|
|
i = 0;
|
|
while(current != NULL){
|
|
if(current->fType!=URES_STRING){
|
|
allStrings = FALSE;
|
|
break;
|
|
}
|
|
current= current->fNext;
|
|
}
|
|
|
|
current = res->u.fArray.fFirst;
|
|
if(allStrings==FALSE){
|
|
const char* object = "new Object[]{\n";
|
|
write_tabs(out);
|
|
T_FileStream_write(out, object, (int32_t)uprv_strlen(object));
|
|
tabCount++;
|
|
decrementTabs = TRUE;
|
|
}else{
|
|
write_tabs(out);
|
|
T_FileStream_write(out, arr, (int32_t)uprv_strlen(arr));
|
|
tabCount++;
|
|
}
|
|
first=current;
|
|
while (current != NULL) {
|
|
/*if(current->fType==URES_STRING){
|
|
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) {
|
|
uint32_t i = 0;
|
|
const char* intArr = "new Integer[] {\n";
|
|
const char* intC = "new Integer(";
|
|
const char* stringArr = "new String[]{\n";
|
|
char buf[100];
|
|
int len =0;
|
|
buf[0]=0;
|
|
write_tabs(out);
|
|
|
|
if(res->fKey > 0 && uprv_strcmp(srBundle->fKeys+res->fKey,"DateTimeElements")==0){
|
|
T_FileStream_write(out, stringArr, (int32_t)uprv_strlen(stringArr));
|
|
tabCount++;
|
|
for(i = 0; i<res->u.fIntVector.fCount; i++) {
|
|
write_tabs(out);
|
|
len=itostr(buf,res->u.fIntVector.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++) {
|
|
write_tabs(out);
|
|
T_FileStream_write(out, intC, (int32_t)uprv_strlen(intC));
|
|
len=itostr(buf,res->u.fIntVector.fArray[i],10,0);
|
|
T_FileStream_write(out,buf,len);
|
|
T_FileStream_write(out,"),",2);
|
|
T_FileStream_write(out,"\n",1);
|
|
}
|
|
}
|
|
tabCount--;
|
|
write_tabs(out);
|
|
T_FileStream_write(out,"},\n",3);
|
|
}
|
|
|
|
static void
|
|
int_write_java(struct SResource *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);
|
|
T_FileStream_write(out,buf,len);
|
|
T_FileStream_write(out,"),\n",3 );
|
|
|
|
}
|
|
|
|
static void
|
|
bin_write_java( struct SResource *res, UErrorCode *status) {
|
|
const char* type = "new ICUListResourceBundle.CompressedBinary(";
|
|
const char* ext;
|
|
int32_t srcLen=res->u.fBinaryValue.fLength;
|
|
|
|
if(srcLen>0 ){
|
|
uint16_t* target=NULL;
|
|
uint16_t* saveTarget = NULL;
|
|
int32_t tgtLen = 0;
|
|
|
|
if(res->fKey > 0 && (uprv_strcmp(srBundle->fKeys+res->fKey,"%%CollationBin")==0 || uprv_strcmp(srBundle->fKeys+res->fKey,"BreakDictionaryData")==0)){
|
|
char fileName[1024] ={0};
|
|
char fn[1024] = {0};
|
|
FileStream* datFile = NULL;
|
|
if(uprv_strcmp(srBundle->fKeys+res->fKey,"BreakDictionaryData")==0){
|
|
uprv_strcat(fileName,"BreakDictionaryData");
|
|
ext = ".brk";
|
|
}else{
|
|
uprv_strcat(fileName,"CollationElements");
|
|
ext=".col";
|
|
}
|
|
if(uprv_strcmp(srBundle->fLocale,"root")!=0){
|
|
uprv_strcat(fileName,"_");
|
|
uprv_strcat(fileName,srBundle->fLocale);
|
|
if(NUMBER > ZERO){
|
|
uprv_strcat(fileName, "_");
|
|
uprv_strcat(fileName, &NUMBER);
|
|
}
|
|
NUMBER++;
|
|
}
|
|
|
|
uprv_strcat(fileName,ext);
|
|
if(outDir ){
|
|
uprv_strcat(fn,outDir);
|
|
if(outDir[uprv_strlen(outDir)-1]!=U_FILE_SEP_CHAR){
|
|
uprv_strcat(fn,U_FILE_SEP_STRING);
|
|
}
|
|
}
|
|
uprv_strcat(fn,fileName);
|
|
type = "new ICUListResourceBundle.ResourceBinary(";
|
|
write_tabs(out);
|
|
T_FileStream_write(out, type, (int32_t)uprv_strlen(type));
|
|
T_FileStream_write(out, "\"", 1);
|
|
T_FileStream_write(out, fileName, (int32_t)uprv_strlen(fileName));
|
|
T_FileStream_write(out, "\"),\n", 4);
|
|
|
|
datFile=T_FileStream_open(fn,"w");
|
|
T_FileStream_write(datFile, res->u.fBinaryValue.fData, res->u.fBinaryValue.fLength);
|
|
T_FileStream_close(datFile);
|
|
|
|
}else{
|
|
|
|
srcLen = res->u.fBinaryValue.fLength;
|
|
tgtLen = srcLen * 2;
|
|
target = (uint16_t*)malloc(sizeof(uint16_t) * tgtLen);
|
|
saveTarget = target;
|
|
if(target){
|
|
tgtLen = byteArrayToRLEString(res->u.fBinaryValue.fData,
|
|
srcLen,target, tgtLen,status);
|
|
if(U_FAILURE(*status)){
|
|
printf("Could not encode got error : %s \n", u_errorName(*status));
|
|
return;
|
|
}
|
|
#if DEBUG
|
|
/***************** Test Roundtripping *********************/
|
|
{
|
|
int32_t myTargetLen = rleStringToByteArray(target,tgtLen,NULL,0,status);
|
|
uint8_t* myTarget = (uint8_t*) malloc(sizeof(uint8_t) * myTargetLen);
|
|
|
|
/* test for NULL */
|
|
if(myTarget == NULL) {
|
|
*status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
|
|
int i=0;
|
|
int32_t retVal=0;
|
|
|
|
*status = U_ZERO_ERROR;
|
|
retVal=rleStringToByteArray(target,tgtLen,myTarget,myTargetLen,status);
|
|
if(U_SUCCESS(*status)){
|
|
|
|
for(i=0; i< srcLen;i++){
|
|
if(res->u.fBinaryValue.fData[i]!= myTarget[i]){
|
|
printf("the encoded string cannot be decoded Expected : 0x%02X Got : %: 0x%02X at %i\n",res->u.fBinaryValue.fData[i],myTarget[i], i);
|
|
}
|
|
}
|
|
}else{
|
|
printf("Could not decode got error : %s \n", u_errorName(*status));
|
|
}
|
|
free(myTarget);
|
|
|
|
}
|
|
#endif
|
|
|
|
}else{
|
|
*status = U_MEMORY_ALLOCATION_ERROR;
|
|
return;
|
|
}
|
|
|
|
write_tabs(out);
|
|
T_FileStream_write(out, type, (int32_t)uprv_strlen(type));
|
|
T_FileStream_write(out, "\n", 1);
|
|
tabCount++;
|
|
write_tabs(out);
|
|
str_write_java(target, tgtLen,FALSE, status);
|
|
tabCount--;
|
|
T_FileStream_write(out, "),\n", 3);
|
|
|
|
free(target);
|
|
|
|
}
|
|
|
|
}else{
|
|
write_tabs(out);
|
|
T_FileStream_write(out,type,(int32_t)uprv_strlen(type));
|
|
T_FileStream_write(out,"null),\n",7);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static UBool start = TRUE;
|
|
|
|
static void
|
|
table_write_java(struct SResource *res, UErrorCode *status) {
|
|
uint32_t i = 0;
|
|
UBool allStrings =TRUE;
|
|
struct SResource *current = NULL;
|
|
struct SResource *save = NULL;
|
|
const char* obj = "new Object[][]{\n";
|
|
|
|
if (U_FAILURE(*status)) {
|
|
return ;
|
|
}
|
|
|
|
if (res->u.fTable.fCount > 0) {
|
|
if(start==FALSE){
|
|
write_tabs(out);
|
|
T_FileStream_write(out, obj, (int32_t)uprv_strlen(obj));
|
|
tabCount++;
|
|
}
|
|
start = FALSE;
|
|
save = current = res->u.fTable.fFirst;
|
|
i = 0;
|
|
|
|
|
|
while (current != NULL) {
|
|
assert(i < res->u.fTable.fCount);
|
|
write_tabs(out);
|
|
|
|
T_FileStream_write(out, openBrace, 2);
|
|
|
|
|
|
tabCount++;
|
|
allStrings=FALSE;
|
|
|
|
write_tabs(out);
|
|
if(current->fKey > 0){
|
|
T_FileStream_write(out, "\"", 1);
|
|
T_FileStream_write(out, srBundle->fKeys+current->fKey,
|
|
(int32_t)uprv_strlen(srBundle->fKeys+current->fKey));
|
|
T_FileStream_write(out, "\",\n", 2);
|
|
|
|
T_FileStream_write(out, "\n", 1);
|
|
}
|
|
res_write_java(current, status);
|
|
if(U_FAILURE(*status)){
|
|
return;
|
|
}
|
|
i++;
|
|
current = current->fNext;
|
|
tabCount--;
|
|
write_tabs(out);
|
|
T_FileStream_write(out, "},\n", 3);
|
|
}
|
|
if(tabCount>4){
|
|
tabCount--;
|
|
write_tabs(out);
|
|
T_FileStream_write(out, "},\n", 3);
|
|
}
|
|
|
|
} else {
|
|
write_tabs(out);
|
|
T_FileStream_write(out,obj,(int32_t)uprv_strlen(obj));
|
|
|
|
write_tabs(out);
|
|
T_FileStream_write(out,"},\n",3);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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);
|
|
return;
|
|
case URES_ALIAS:
|
|
alias_write_java (res, status);
|
|
return;
|
|
case URES_INT_VECTOR:
|
|
intvector_write_java (res, status);
|
|
return;
|
|
case URES_BINARY:
|
|
bin_write_java (res, status);
|
|
return;
|
|
case URES_INT:
|
|
int_write_java (res, status);
|
|
return;
|
|
case URES_ARRAY:
|
|
array_write_java (res, status);
|
|
return;
|
|
case URES_TABLE:
|
|
case URES_TABLE32:
|
|
table_write_java (res, status);
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
*status = U_INTERNAL_PROGRAM_ERROR;
|
|
}
|
|
|
|
void
|
|
bundle_write_java(struct SRBRoot *bundle, const char *outputDir,const char* outputEnc,
|
|
char *writtenFilename, int writtenFilenameLen,
|
|
const char* packageName, const char* bundleName,
|
|
UErrorCode *status) {
|
|
|
|
char fileName[256] = {'\0'};
|
|
char className[256]={'\0'};
|
|
char constructor[1000] = { 0 };
|
|
UBool j1 =FALSE;
|
|
outDir = outputDir;
|
|
|
|
bName = (bundleName==NULL) ? "LocaleElements" : bundleName;
|
|
pName = (packageName==NULL)? "com.ibm.icu.impl.data" : packageName;
|
|
|
|
uprv_strcpy(className, bName);
|
|
srBundle = bundle;
|
|
if(uprv_strcmp(srBundle->fLocale,"root")!=0){
|
|
uprv_strcat(className,"_");
|
|
uprv_strcat(className,srBundle->fLocale);
|
|
}
|
|
if(outputDir){
|
|
uprv_strcpy(fileName, outputDir);
|
|
if(outputDir[uprv_strlen(outputDir)-1] !=U_FILE_SEP_CHAR){
|
|
uprv_strcat(fileName,U_FILE_SEP_STRING);
|
|
}
|
|
uprv_strcat(fileName,className);
|
|
uprv_strcat(fileName,".java");
|
|
}else{
|
|
uprv_strcat(fileName,className);
|
|
uprv_strcat(fileName,".java");
|
|
}
|
|
|
|
if (writtenFilename) {
|
|
uprv_strncpy(writtenFilename, fileName, writtenFilenameLen);
|
|
}
|
|
|
|
if (U_FAILURE(*status)) {
|
|
return;
|
|
}
|
|
|
|
out= T_FileStream_open(fileName,"w");
|
|
|
|
if(out==NULL){
|
|
*status = U_FILE_ACCESS_ERROR;
|
|
return;
|
|
}
|
|
if(getIncludeCopyright()){
|
|
T_FileStream_write(out, copyRight, (int32_t)uprv_strlen(copyRight));
|
|
T_FileStream_write(out, warningMsg, (int32_t)uprv_strlen(warningMsg));
|
|
}
|
|
T_FileStream_write(out,"package ",(int32_t)uprv_strlen("package "));
|
|
T_FileStream_write(out,pName,(int32_t)uprv_strlen(pName));
|
|
T_FileStream_write(out,";\n\n",3);
|
|
T_FileStream_write(out, javaClass, (int32_t)uprv_strlen(javaClass));
|
|
T_FileStream_write(out, className, (int32_t)uprv_strlen(className));
|
|
if(j1){
|
|
T_FileStream_write(out, javaClass1, (int32_t)uprv_strlen(javaClass1));
|
|
}else{
|
|
sprintf(constructor,javaClassICU,className);
|
|
T_FileStream_write(out, constructor, (int32_t)uprv_strlen(constructor));
|
|
}
|
|
|
|
if(outputEnc && *outputEnc!='\0'){
|
|
/* store the output encoding */
|
|
enc = outputEnc;
|
|
conv=ucnv_open(enc,status);
|
|
if(U_FAILURE(*status)){
|
|
return;
|
|
}
|
|
}
|
|
res_write_java(bundle->fRoot, status);
|
|
|
|
T_FileStream_write(out, closeClass, (int32_t)uprv_strlen(closeClass));
|
|
|
|
T_FileStream_close(out);
|
|
|
|
ucnv_close(conv);
|
|
}
|