| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * |
| * 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. |
| * 02/07/08 Spieth Correct XLIFF generation on EBCDIC platform |
| * |
| ******************************************************************************* |
| */ |
| |
| // Safer use of UnicodeString. |
| #ifndef UNISTR_FROM_CHAR_EXPLICIT |
| # define UNISTR_FROM_CHAR_EXPLICIT explicit |
| #endif |
| |
| // Less important, but still a good idea. |
| #ifndef UNISTR_FROM_STRING_EXPLICIT |
| # define UNISTR_FROM_STRING_EXPLICIT explicit |
| #endif |
| |
| #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" |
| #include "uresimp.h" |
| #include "unicode/ustring.h" |
| #include "unicode/uchar.h" |
| #include "ustr.h" |
| #include "prscmnts.h" |
| #include "unicode/unistr.h" |
| #include "unicode/utf8.h" |
| #include "unicode/utf16.h" |
| #include <time.h> |
| |
| U_NAMESPACE_USE |
| |
| static int tabCount = 0; |
| |
| static FileStream* out=NULL; |
| static struct SRBRoot* srBundle ; |
| static const char* outDir = NULL; |
| static const char* enc =""; |
| static UConverter* conv = NULL; |
| |
| const char* const* ISOLanguages; |
| const char* const* ISOCountries; |
| const char* textExt = ".txt"; |
| const char* xliffExt = ".xlf"; |
| |
| static int32_t write_utf8_file(FileStream* fileStream, UnicodeString outString) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| int32_t len = 0; |
| |
| // preflight to get the destination buffer size |
| u_strToUTF8(NULL, |
| 0, |
| &len, |
| toUCharPtr(outString.getBuffer()), |
| outString.length(), |
| &status); |
| |
| // allocate the buffer |
| char* dest = (char*)uprv_malloc(len); |
| status = U_ZERO_ERROR; |
| |
| // convert the data |
| u_strToUTF8(dest, |
| len, |
| &len, |
| toUCharPtr(outString.getBuffer()), |
| outString.length(), |
| &status); |
| |
| // write data to out file |
| int32_t ret = T_FileStream_write(fileStream, dest, len); |
| uprv_free(dest); |
| return (ret); |
| } |
| |
| /*write indentation for formatting*/ |
| static void write_tabs(FileStream* os){ |
| int i=0; |
| for(;i<=tabCount;i++){ |
| write_utf8_file(os,UnicodeString(" ")); |
| } |
| } |
| |
| /*get ID for each element. ID is globally unique.*/ |
| static char* getID(const char* id, const char* curKey, char* result) { |
| if(curKey == NULL) { |
| result = (char *)uprv_malloc(sizeof(char)*uprv_strlen(id) + 1); |
| uprv_memset(result, 0, sizeof(char)*uprv_strlen(id) + 1); |
| uprv_strcpy(result, id); |
| } else { |
| result = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(id) + 1 + uprv_strlen(curKey)) + 1); |
| uprv_memset(result, 0, sizeof(char)*(uprv_strlen(id) + 1 + uprv_strlen(curKey)) + 1); |
| if(id[0]!='\0'){ |
| uprv_strcpy(result, id); |
| uprv_strcat(result, "_"); |
| } |
| uprv_strcat(result, curKey); |
| } |
| return result; |
| } |
| |
| /*compute CRC for binary code*/ |
| /* The code is from http://www.theorem.com/java/CRC32.java |
| * Calculates the CRC32 - 32 bit Cyclical Redundancy Check |
| * <P> This check is used in numerous systems to verify the integrity |
| * of information. It's also used as a hashing function. Unlike a regular |
| * checksum, it's sensitive to the order of the characters. |
| * It produces a 32 bit |
| * |
| * @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(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 |
| |
| /*build crc table*/ |
| for (i = 0; i <= 255; i++) { |
| crc2 = i; |
| for (j = 8; j > 0; j--) { |
| if ((crc2 & 1) == 1) { |
| crc2 = (crc2 >> 1) ^ CRC32_POLYNOMIAL; |
| } else { |
| crc2 >>= 1; |
| } |
| } |
| crc_ta[i] = crc2; |
| } |
| |
| crc = lastcrc; |
| while(len--!=0) { |
| temp1 = (uint32_t)crc>>8; |
| temp2 = crc_ta[(crc^*ptr) & 0xFF]; |
| crc = temp1^temp2; |
| ptr++; |
| } |
| return(crc); |
| } |
| |
| static void strnrepchr(char* src, int32_t srcLen, char s, char r){ |
| int32_t i = 0; |
| for(i=0;i<srcLen;i++){ |
| if(src[i]==s){ |
| src[i]=r; |
| } |
| } |
| } |
| /* Parse the filename, and get its language information. |
| * If it fails to get the language information from the filename, |
| * use "en" as the default value for language |
| */ |
| static char* parseFilename(const char* id, char* /*lang*/) { |
| int idLen = (int) uprv_strlen(id); |
| char* localeID = (char*) uprv_malloc(idLen); |
| int pos = 0; |
| int canonCapacity = 0; |
| char* canon = NULL; |
| int canonLen = 0; |
| /*int i;*/ |
| UErrorCode status = U_ZERO_ERROR; |
| const char *ext = uprv_strchr(id, '.'); |
| |
| if(ext != NULL){ |
| pos = (int) (ext - id); |
| } else { |
| pos = idLen; |
| } |
| uprv_memcpy(localeID, id, pos); |
| localeID[pos]=0; /* NUL terminate the string */ |
| |
| canonCapacity =pos*3; |
| canon = (char*) uprv_malloc(canonCapacity); |
| canonLen = uloc_canonicalize(localeID, canon, canonCapacity, &status); |
| |
| if(U_FAILURE(status)){ |
| fprintf(stderr, "Could not canonicalize the locale ID: %s. Error: %s\n", localeID, u_errorName(status)); |
| exit(status); |
| } |
| strnrepchr(canon, canonLen, '_', '-'); |
| return canon; |
| } |
| |
| static const char* xmlHeader = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; |
| #if 0 |
| static const char* bundleStart = "<xliff version = \"1.2\" " |
| "xmlns='urn:oasis:names:tc:xliff:document:1.2' " |
| "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' " |
| "xsi:schemaLocation='urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd'>\n"; |
| #else |
| static const char* bundleStart = "<xliff version = \"1.1\" " |
| "xmlns='urn:oasis:names:tc:xliff:document:1.1' " |
| "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' " |
| "xsi:schemaLocation='urn:oasis:names:tc:xliff:document:1.1 http://www.oasis-open.org/committees/xliff/documents/xliff-core-1.1.xsd'>\n"; |
| #endif |
| static const char* bundleEnd = "</xliff>\n"; |
| |
| void res_write_xml(struct SResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status); |
| |
| static char* convertAndEscape(char** pDest, int32_t destCap, int32_t* destLength, |
| const UChar* src, int32_t srcLen, UErrorCode* status){ |
| int32_t srcIndex=0; |
| char* dest=NULL; |
| char* temp=NULL; |
| int32_t destLen=0; |
| UChar32 c = 0; |
| |
| if(status==NULL || U_FAILURE(*status) || pDest==NULL || srcLen==0 || src == NULL){ |
| return NULL; |
| } |
| dest =*pDest; |
| if(dest==NULL || destCap <=0){ |
| destCap = srcLen * 8; |
| dest = (char*) uprv_malloc(sizeof(char) * destCap); |
| if(dest==NULL){ |
| *status=U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| } |
| |
| dest[0]=0; |
| |
| while(srcIndex<srcLen){ |
| U16_NEXT(src, srcIndex, srcLen, c); |
| |
| if (U16_IS_LEAD(c) || U16_IS_TRAIL(c)) { |
| *status = U_ILLEGAL_CHAR_FOUND; |
| fprintf(stderr, "Illegal Surrogate! \n"); |
| uprv_free(dest); |
| return NULL; |
| } |
| |
| if((destLen+U8_LENGTH(c)) < destCap){ |
| |
| /* ASCII Range */ |
| if(c <=0x007F){ |
| switch(c) { |
| case '\x26': |
| uprv_strcpy(dest+( destLen),"\x26\x61\x6d\x70\x3b"); /* &*/ |
| destLen+=(int32_t)uprv_strlen("\x26\x61\x6d\x70\x3b"); |
| break; |
| case '\x3c': |
| uprv_strcpy(dest+(destLen),"\x26\x6c\x74\x3b"); /* <*/ |
| destLen+=(int32_t)uprv_strlen("\x26\x6c\x74\x3b"); |
| break; |
| case '\x3e': |
| uprv_strcpy(dest+(destLen),"\x26\x67\x74\x3b"); /* >*/ |
| destLen+=(int32_t)uprv_strlen("\x26\x67\x74\x3b"); |
| break; |
| case '\x22': |
| uprv_strcpy(dest+(destLen),"\x26\x71\x75\x6f\x74\x3b"); /* "*/ |
| destLen+=(int32_t)uprv_strlen("\x26\x71\x75\x6f\x74\x3b"); |
| break; |
| case '\x27': |
| uprv_strcpy(dest+(destLen),"\x26\x61\x70\x6f\x73\x3b"); /* ' */ |
| destLen+=(int32_t)uprv_strlen("\x26\x61\x70\x6f\x73\x3b"); |
| break; |
| |
| /* Disallow C0 controls except TAB, CR, LF*/ |
| case 0x00: |
| case 0x01: |
| case 0x02: |
| case 0x03: |
| case 0x04: |
| case 0x05: |
| case 0x06: |
| case 0x07: |
| case 0x08: |
| /*case 0x09:*/ |
| /*case 0x0A: */ |
| case 0x0B: |
| case 0x0C: |
| /*case 0x0D:*/ |
| case 0x0E: |
| case 0x0F: |
| case 0x10: |
| case 0x11: |
| case 0x12: |
| case 0x13: |
| case 0x14: |
| case 0x15: |
| case 0x16: |
| case 0x17: |
| case 0x18: |
| case 0x19: |
| case 0x1A: |
| case 0x1B: |
| case 0x1C: |
| case 0x1D: |
| case 0x1E: |
| case 0x1F: |
| *status = U_ILLEGAL_CHAR_FOUND; |
| fprintf(stderr, "Illegal Character \\u%04X!\n",(int)c); |
| uprv_free(dest); |
| return NULL; |
| default: |
| dest[destLen++]=(char)c; |
| } |
| }else{ |
| UBool isError = FALSE; |
| U8_APPEND((unsigned char*)dest,destLen,destCap,c,isError); |
| if(isError){ |
| *status = U_ILLEGAL_CHAR_FOUND; |
| fprintf(stderr, "Illegal Character \\U%08X!\n",(int)c); |
| uprv_free(dest); |
| return NULL; |
| } |
| } |
| }else{ |
| destCap += destLen; |
| |
| temp = (char*) uprv_malloc(sizeof(char)*destCap); |
| if(temp==NULL){ |
| *status=U_MEMORY_ALLOCATION_ERROR; |
| uprv_free(dest); |
| return NULL; |
| } |
| uprv_memmove(temp,dest,destLen); |
| destLen=0; |
| uprv_free(dest); |
| dest=temp; |
| temp=NULL; |
| } |
| |
| } |
| *destLength = destLen; |
| return dest; |
| } |
| |
| #define ASTERISK 0x002A |
| #define SPACE 0x0020 |
| #define CR 0x000A |
| #define LF 0x000D |
| #define AT_SIGN 0x0040 |
| |
| #if UCONFIG_NO_REGULAR_EXPRESSIONS==0 |
| static void |
| trim(char **src, int32_t *len){ |
| |
| char *s = NULL; |
| int32_t i = 0; |
| if(src == NULL || *src == NULL){ |
| return; |
| } |
| s = *src; |
| /* trim from the end */ |
| for( i=(*len-1); i>= 0; i--){ |
| switch(s[i]){ |
| case ASTERISK: |
| case SPACE: |
| case CR: |
| case LF: |
| s[i] = 0; |
| continue; |
| default: |
| break; |
| } |
| break; |
| |
| } |
| *len = i+1; |
| } |
| |
| static void |
| print(UChar* src, int32_t srcLen,const char *tagStart,const char *tagEnd, UErrorCode *status){ |
| int32_t bufCapacity = srcLen*4; |
| char *buf = NULL; |
| int32_t bufLen = 0; |
| |
| if(U_FAILURE(*status)){ |
| return; |
| } |
| |
| buf = (char*) (uprv_malloc(bufCapacity)); |
| if(buf==0){ |
| fprintf(stderr, "Could not allocate memory!!"); |
| exit(U_MEMORY_ALLOCATION_ERROR); |
| } |
| buf = convertAndEscape(&buf, bufCapacity, &bufLen, src, srcLen,status); |
| 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")); |
| |
| } |
| } |
| #endif |
| |
| static void |
| 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; |
| } |
| |
| capacity = src->fLength; |
| note = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity); |
| |
| count = getCount(src->fChars,src->fLength, UPC_NOTE, status); |
| if(U_FAILURE(*status)){ |
| uprv_free(note); |
| return; |
| } |
| for(i=0; i < count; i++){ |
| noteLen = getAt(src->fChars,src->fLength, ¬e, capacity, i, UPC_NOTE, status); |
| if(U_FAILURE(*status)){ |
| uprv_free(note); |
| return; |
| } |
| if(noteLen > 0){ |
| write_tabs(out); |
| print(note, noteLen,"<note>", "</note>", status); |
| } |
| } |
| uprv_free(note); |
| #else |
| |
| fprintf(stderr, "Warning: Could not output comments to XLIFF file. ICU has been built without RegularExpression support.\n"); |
| |
| #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */ |
| |
| } |
| |
| static void printAttribute(const char *name, const char *value, int32_t /*len*/) |
| { |
| write_utf8_file(out, UnicodeString(" ")); |
| write_utf8_file(out, UnicodeString(name)); |
| write_utf8_file(out, UnicodeString(" = \"")); |
| write_utf8_file(out, UnicodeString(value)); |
| write_utf8_file(out, UnicodeString("\"")); |
| } |
| |
| #if UCONFIG_NO_REGULAR_EXPRESSIONS==0 /* donot compile when no RegularExpressions are available */ |
| static void printAttribute(const char *name, const UnicodeString value, int32_t /*len*/) |
| { |
| write_utf8_file(out, UnicodeString(" ")); |
| write_utf8_file(out, UnicodeString(name)); |
| write_utf8_file(out, UnicodeString(" = \"")); |
| write_utf8_file(out, value); |
| write_utf8_file(out, UnicodeString("\"")); |
| } |
| #endif |
| |
| static void |
| printComments(struct UString *src, const char *resName, UBool printTranslate, UErrorCode *status){ |
| |
| #if UCONFIG_NO_REGULAR_EXPRESSIONS==0 /* donot compile when no RegularExpressions are available */ |
| |
| if(status==NULL || U_FAILURE(*status)){ |
| return; |
| } |
| |
| int32_t capacity = src->fLength + 1; |
| char* buf = NULL; |
| int32_t bufLen = 0; |
| 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)){ |
| printAttribute("translate", UnicodeString(buf, bufLen, "UTF-8"), bufLen); |
| write_utf8_file(out,UnicodeString(">\n")); |
| } |
| }else if(getShowWarning()){ |
| fprintf(stderr, "Warning: Tranlate attribute for resource %s cannot be set. XLIFF prohibits it.\n", resName); |
| /* no translate attribute .. just close the tag */ |
| write_utf8_file(out,UnicodeString(">\n")); |
| } |
| }else{ |
| /* no translate attribute .. just close the tag */ |
| write_utf8_file(out,UnicodeString(">\n")); |
| } |
| |
| if(descLen > 0){ |
| write_tabs(out); |
| print(desc, descLen, "<!--", "-->", status); |
| } |
| |
| uprv_free(desc); |
| uprv_free(trans); |
| #else |
| |
| fprintf(stderr, "Warning: Could not output comments to XLIFF file. ICU has been built without RegularExpression support.\n"); |
| |
| #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(SResource *res, const char *container, const char *restype, const char *mimetype, const char *id, UErrorCode *status) |
| { |
| const char *resname = NULL; |
| char *sid = NULL; |
| |
| write_tabs(out); |
| |
| 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)); |
| |
| if (resname != NULL) { |
| printAttribute("resname", resname, (int32_t) uprv_strlen(resname)); |
| } |
| |
| if (mimetype != NULL) { |
| printAttribute("mime-type", mimetype, (int32_t) uprv_strlen(mimetype)); |
| } |
| |
| if (restype != NULL) { |
| printAttribute("restype", restype, (int32_t) uprv_strlen(restype)); |
| } |
| |
| tabCount += 1; |
| if (res->fComment.fLength > 0) { |
| /* printComments will print the closing ">\n" */ |
| printComments(&res->fComment, resname, TRUE, status); |
| } else { |
| write_utf8_file(out, UnicodeString(">\n")); |
| } |
| |
| return sid; |
| } |
| |
| /* Writing Functions */ |
| |
| static const char *trans_unit = "trans-unit"; |
| static const char *close_trans_unit = "</trans-unit>\n"; |
| static const char *source = "<source>"; |
| static const char *close_source = "</source>\n"; |
| static const char *group = "group"; |
| static const char *close_group = "</group>\n"; |
| |
| static const char *bin_unit = "bin-unit"; |
| static const char *close_bin_unit = "</bin-unit>\n"; |
| static const char *bin_source = "<bin-source>\n"; |
| static const char *close_bin_source = "</bin-source>\n"; |
| static const char *external_file = "<external-file"; |
| /*static const char *close_external_file = "</external-file>\n";*/ |
| static const char *internal_file = "<internal-file"; |
| static const char *close_internal_file = "</internal-file>\n"; |
| |
| 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(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->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(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->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(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->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(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->fCount; i += 1) { |
| char c[256] = {0}; |
| |
| itostr(c, i, 10, 0); |
| ivd = getID(sid, c, ivd); |
| 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")); |
| |
| tabCount += 1; |
| write_tabs(out); |
| write_utf8_file(out, UnicodeString(source)); |
| |
| write_utf8_file(out, UnicodeString(buf, len)); |
| |
| write_utf8_file(out, UnicodeString(close_source)); |
| tabCount -= 1; |
| write_tabs(out); |
| write_utf8_file(out, UnicodeString(close_trans_unit)); |
| |
| uprv_free(ivd); |
| ivd = NULL; |
| } |
| |
| tabCount -= 1; |
| write_tabs(out); |
| |
| write_utf8_file(out, UnicodeString(close_group)); |
| uprv_free(sid); |
| sid = NULL; |
| } |
| |
| static void |
| 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->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(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->fFileName !=NULL ? |
| uprv_strlen(res->fFileName) :0))); |
| const char* ext = NULL; |
| |
| char* f = NULL; |
| |
| fn[0]=0; |
| |
| if(res->fFileName != NULL){ |
| uprv_strcpy(fileName, res->fFileName); |
| f = uprv_strrchr(fileName, '\\'); |
| |
| if (f != NULL) { |
| f++; |
| } else { |
| f = fileName; |
| } |
| |
| ext = uprv_strrchr(fileName, '.'); |
| |
| if (ext == NULL) { |
| fprintf(stderr, "Error: %s is an unknown binary filename type.\n", fileName); |
| exit(U_ILLEGAL_ARGUMENT_ERROR); |
| } |
| |
| if(uprv_strcmp(ext, ".jpg")==0 || uprv_strcmp(ext, ".jpeg")==0 || uprv_strcmp(ext, ".gif")==0 ){ |
| m_type = "image"; |
| } else if(uprv_strcmp(ext, ".wav")==0 || uprv_strcmp(ext, ".au")==0 ){ |
| m_type = "audio"; |
| } else if(uprv_strcmp(ext, ".avi")==0 || uprv_strcmp(ext, ".mpg")==0 || uprv_strcmp(ext, ".mpeg")==0){ |
| m_type = "video"; |
| } else if(uprv_strcmp(ext, ".txt")==0 || uprv_strcmp(ext, ".text")==0){ |
| m_type = "text"; |
| } |
| |
| sid = printContainer(res, bin_unit, binary_restype, m_type, id, status); |
| |
| write_tabs(out); |
| |
| write_utf8_file(out, UnicodeString(bin_source)); |
| |
| tabCount+= 1; |
| write_tabs(out); |
| |
| write_utf8_file(out, UnicodeString(external_file)); |
| printAttribute("href", f, (int32_t)uprv_strlen(f)); |
| write_utf8_file(out, UnicodeString("/>\n")); |
| tabCount -= 1; |
| 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)); |
| } else { |
| char temp[256] = {0}; |
| uint32_t i = 0; |
| int32_t len=0; |
| |
| sid = printContainer(res, bin_unit, binary_restype, m_type, id, status); |
| |
| 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->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->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(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->fFirst; |
| i = 0; |
| |
| while (current != NULL) { |
| res_write_xml(current, sid, language, FALSE, status); |
| |
| if(U_FAILURE(*status)){ |
| return; |
| } |
| |
| i += 1; |
| current = current->fNext; |
| } |
| |
| tabCount -= 1; |
| write_tabs(out); |
| |
| write_utf8_file(out, UnicodeString(close_group)); |
| |
| uprv_free(sid); |
| sid = NULL; |
| } |
| |
| 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 (static_cast<StringResource *>(res), id, language, status); |
| return; |
| |
| case URES_ALIAS: |
| alias_write_xml (static_cast<AliasResource *>(res), id, language, status); |
| return; |
| |
| case URES_INT_VECTOR: |
| intvector_write_xml (static_cast<IntVectorResource *>(res), id, language, status); |
| return; |
| |
| case URES_BINARY: |
| bin_write_xml (static_cast<BinaryResource *>(res), id, language, status); |
| return; |
| |
| case URES_INT: |
| int_write_xml (static_cast<IntResource *>(res), id, language, status); |
| return; |
| |
| case URES_ARRAY: |
| array_write_xml (static_cast<ArrayResource *>(res), id, language, status); |
| return; |
| |
| case URES_TABLE: |
| table_write_xml (static_cast<TableResource *>(res), id, language, isTopLevel, status); |
| return; |
| |
| default: |
| break; |
| } |
| } |
| |
| *status = U_INTERNAL_PROGRAM_ERROR; |
| } |
| |
| void |
| bundle_write_xml(struct SRBRoot *bundle, const char *outputDir,const char* outputEnc, const char* filename, |
| char *writtenFilename, int writtenFilenameLen, |
| const char* language, const char* outFileName, UErrorCode *status) { |
| |
| char* xmlfileName = NULL; |
| char* outputFileName = NULL; |
| char* originalFileName = NULL; |
| const char* fileStart = "<file xml:space = \"preserve\" source-language = \""; |
| const char* file1 = "\" datatype = \"x-icu-resource-bundle\" "; |
| const char* file2 = "original = \""; |
| const char* file4 = "\" date = \""; |
| const char* fileEnd = "</file>\n"; |
| const char* headerStart = "<header>\n"; |
| const char* headerEnd = "</header>\n"; |
| const char* bodyStart = "<body>\n"; |
| const char* bodyEnd = "</body>\n"; |
| |
| const char *tool_start = "<tool"; |
| const char *tool_id = "genrb-" GENRB_VERSION "-icu-" U_ICU_VERSION; |
| const char *tool_name = "genrb"; |
| |
| char* temp = NULL; |
| char* lang = NULL; |
| const char* pos = NULL; |
| int32_t first, index; |
| time_t currTime; |
| char timeBuf[128]; |
| |
| outDir = outputDir; |
| |
| srBundle = bundle; |
| |
| pos = uprv_strrchr(filename, '\\'); |
| if(pos != NULL) { |
| first = (int32_t)(pos - filename + 1); |
| } else { |
| first = 0; |
| } |
| index = (int32_t)(uprv_strlen(filename) - uprv_strlen(textExt) - first); |
| originalFileName = (char *)uprv_malloc(sizeof(char)*index+1); |
| uprv_memset(originalFileName, 0, sizeof(char)*index+1); |
| uprv_strncpy(originalFileName, filename + first, index); |
| |
| if(uprv_strcmp(originalFileName, srBundle->fLocale) != 0) { |
| fprintf(stdout, "Warning: The file name is not same as the resource name!\n"); |
| } |
| |
| temp = originalFileName; |
| originalFileName = (char *)uprv_malloc(sizeof(char)* (uprv_strlen(temp)+uprv_strlen(textExt)) + 1); |
| uprv_memset(originalFileName, 0, sizeof(char)* (uprv_strlen(temp)+uprv_strlen(textExt)) + 1); |
| uprv_strcat(originalFileName, temp); |
| uprv_strcat(originalFileName, textExt); |
| uprv_free(temp); |
| temp = NULL; |
| |
| |
| if (language == NULL) { |
| /* lang = parseFilename(filename, lang); |
| if (lang == NULL) {*/ |
| /* now check if locale name is valid or not |
| * this is to cater for situation where |
| * pegasusServer.txt contains |
| * |
| * en{ |
| * .. |
| * } |
| */ |
| lang = parseFilename(srBundle->fLocale, lang); |
| /* |
| * Neither the file name nor the table name inside the |
| * txt file contain a valid country and language codes |
| * throw an error. |
| * pegasusServer.txt contains |
| * |
| * testelements{ |
| * .... |
| * } |
| */ |
| if(lang==NULL){ |
| fprintf(stderr, "Error: The file name and table name do not contain a valid language code. Please use -l option to specify it.\n"); |
| exit(U_ILLEGAL_ARGUMENT_ERROR); |
| } |
| /* }*/ |
| } else { |
| lang = (char *)uprv_malloc(sizeof(char)*uprv_strlen(language) +1); |
| uprv_memset(lang, 0, sizeof(char)*uprv_strlen(language) +1); |
| uprv_strcpy(lang, language); |
| } |
| |
| if(outFileName) { |
| outputFileName = (char *)uprv_malloc(sizeof(char)*uprv_strlen(outFileName) + 1); |
| uprv_memset(outputFileName, 0, sizeof(char)*uprv_strlen(outFileName) + 1); |
| uprv_strcpy(outputFileName,outFileName); |
| } else { |
| outputFileName = (char *)uprv_malloc(sizeof(char)*uprv_strlen(srBundle->fLocale) + 1); |
| uprv_memset(outputFileName, 0, sizeof(char)*uprv_strlen(srBundle->fLocale) + 1); |
| uprv_strcpy(outputFileName,srBundle->fLocale); |
| } |
| |
| if(outputDir) { |
| xmlfileName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(outputDir) + uprv_strlen(outputFileName) + uprv_strlen(xliffExt) + 1) +1); |
| uprv_memset(xmlfileName, 0, sizeof(char)*(uprv_strlen(outputDir)+ uprv_strlen(outputFileName) + uprv_strlen(xliffExt) + 1) +1); |
| } else { |
| xmlfileName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(outputFileName) + uprv_strlen(xliffExt)) +1); |
| uprv_memset(xmlfileName, 0, sizeof(char)*(uprv_strlen(outputFileName) + uprv_strlen(xliffExt)) +1); |
| } |
| |
| if(outputDir){ |
| uprv_strcpy(xmlfileName, outputDir); |
| if(outputDir[uprv_strlen(outputDir)-1] !=U_FILE_SEP_CHAR){ |
| uprv_strcat(xmlfileName,U_FILE_SEP_STRING); |
| } |
| } |
| uprv_strcat(xmlfileName,outputFileName); |
| uprv_strcat(xmlfileName,xliffExt); |
| |
| if (writtenFilename) { |
| uprv_strncpy(writtenFilename, xmlfileName, writtenFilenameLen); |
| } |
| |
| if (U_FAILURE(*status)) { |
| goto cleanup_bundle_write_xml; |
| } |
| |
| out= T_FileStream_open(xmlfileName,"w"); |
| |
| if(out==NULL){ |
| *status = U_FILE_ACCESS_ERROR; |
| goto cleanup_bundle_write_xml; |
| } |
| write_utf8_file(out, UnicodeString(xmlHeader)); |
| |
| if(outputEnc && *outputEnc!='\0'){ |
| /* store the output encoding */ |
| enc = outputEnc; |
| conv=ucnv_open(enc,status); |
| if(U_FAILURE(*status)){ |
| goto cleanup_bundle_write_xml; |
| } |
| } |
| write_utf8_file(out, UnicodeString(bundleStart)); |
| write_tabs(out); |
| write_utf8_file(out, UnicodeString(fileStart)); |
| /* check if lang and language are the same */ |
| if(language != NULL && uprv_strcmp(lang, srBundle->fLocale)!=0){ |
| fprintf(stderr,"Warning: The top level tag in the resource and language specified are not the same. Please check the input.\n"); |
| } |
| write_utf8_file(out, UnicodeString(lang)); |
| write_utf8_file(out, UnicodeString(file1)); |
| write_utf8_file(out, UnicodeString(file2)); |
| write_utf8_file(out, UnicodeString(originalFileName)); |
| write_utf8_file(out, UnicodeString(file4)); |
| |
| time(&currTime); |
| strftime(timeBuf, sizeof(timeBuf), "%Y-%m-%dT%H:%M:%SZ", gmtime(&currTime)); |
| write_utf8_file(out, UnicodeString(timeBuf)); |
| write_utf8_file(out, UnicodeString("\">\n")); |
| |
| tabCount += 1; |
| write_tabs(out); |
| write_utf8_file(out, UnicodeString(headerStart)); |
| |
| tabCount += 1; |
| write_tabs(out); |
| |
| write_utf8_file(out, UnicodeString(tool_start)); |
| printAttribute("tool-id", tool_id, (int32_t) uprv_strlen(tool_id)); |
| printAttribute("tool-name", tool_name, (int32_t) uprv_strlen(tool_name)); |
| write_utf8_file(out, UnicodeString("/>\n")); |
| |
| tabCount -= 1; |
| write_tabs(out); |
| |
| write_utf8_file(out, UnicodeString(headerEnd)); |
| |
| write_tabs(out); |
| tabCount += 1; |
| |
| write_utf8_file(out, UnicodeString(bodyStart)); |
| |
| |
| res_write_xml(bundle->fRoot, bundle->fLocale, lang, TRUE, status); |
| |
| tabCount -= 1; |
| write_tabs(out); |
| |
| write_utf8_file(out, UnicodeString(bodyEnd)); |
| tabCount--; |
| write_tabs(out); |
| write_utf8_file(out, UnicodeString(fileEnd)); |
| tabCount--; |
| write_tabs(out); |
| write_utf8_file(out, UnicodeString(bundleEnd)); |
| T_FileStream_close(out); |
| |
| ucnv_close(conv); |
| |
| cleanup_bundle_write_xml: |
| uprv_free(originalFileName); |
| uprv_free(lang); |
| if(xmlfileName != NULL) { |
| uprv_free(xmlfileName); |
| } |
| if(outputFileName != NULL){ |
| uprv_free(outputFileName); |
| } |
| } |
