1a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath/* 2a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath******************************************************************************* 3a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 4a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* Copyright (C) 2002-2012, International Business Machines 5a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* Corporation and others. All Rights Reserved. 6a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 7a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath******************************************************************************* 8a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 9a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* File wrtxml.cpp 10a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 11a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* Modification History: 12a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 13a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* Date Name Description 14a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 10/01/02 Ram Creation. 15a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 02/07/08 Spieth Correct XLIFF generation on EBCDIC platform 16a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath* 17a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath******************************************************************************* 183c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller*/ 19a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "reslist.h" 20a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "unewdata.h" 21a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "unicode/ures.h" 22a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "errmsg.h" 23a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "filestrm.h" 24a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "cstring.h" 25a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "unicode/ucnv.h" 263c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller#include "genrb.h" 273c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller#include "rle.h" 28a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "ucol_tok.h" 29a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "uhash.h" 303c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller#include "uresimp.h" 31a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "unicode/ustring.h" 32a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "unicode/uchar.h" 33a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "ustr.h" 34a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "prscmnts.h" 35a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "unicode/unistr.h" 363c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller#include "unicode/utf8.h" 37a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include "unicode/utf16.h" 38a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#include <time.h> 393c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 40a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan KamathU_NAMESPACE_USE 41a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 42a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic int tabCount = 0; 433c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 443c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fullerstatic FileStream* out=NULL; 453c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fullerstatic struct SRBRoot* srBundle ; 463c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fullerstatic const char* outDir = NULL; 47a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic const char* enc =""; 48a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic UConverter* conv = NULL; 49a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 503c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fullerconst char* const* ISOLanguages; 51a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathconst char* const* ISOCountries; 52a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathconst char* textExt = ".txt"; 53a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathconst char* xliffExt = ".xlf"; 54a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 55a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic int32_t write_utf8_file(FileStream* fileStream, UnicodeString outString) 56a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath{ 57a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath UErrorCode status = U_ZERO_ERROR; 58a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int32_t len = 0; 593c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 603c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller // preflight to get the destination buffer size 613c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller u_strToUTF8(NULL, 623c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 0, 633c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller &len, 643c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller outString.getBuffer(), 653c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller outString.length(), 663c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller &status); 673c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 68a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath // allocate the buffer 69a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath char* dest = (char*)uprv_malloc(len); 70a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath status = U_ZERO_ERROR; 71a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 72a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath // convert the data 73a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath u_strToUTF8(dest, 74a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath len, 75a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath &len, 763c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller outString.getBuffer(), 773c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller outString.length(), 783c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller &status); 793c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 80a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath // write data to out file 81a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int32_t ret = T_FileStream_write(fileStream, dest, len); 82a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_free(dest); 83a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath return (ret); 84a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath} 85a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 86a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath/*write indentation for formatting*/ 87a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic void write_tabs(FileStream* os){ 883c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller int i=0; 893c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller for(;i<=tabCount;i++){ 903c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller write_utf8_file(os,UnicodeString(" ")); 913c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller } 923c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller} 933c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 94a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath/*get ID for each element. ID is globally unique.*/ 95a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic char* getID(const char* id, const char* curKey, char* result) { 963c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller if(curKey == NULL) { 973c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller result = (char *)uprv_malloc(sizeof(char)*uprv_strlen(id) + 1); 98a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_memset(result, 0, sizeof(char)*uprv_strlen(id) + 1); 99a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_strcpy(result, id); 1003c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller } else { 1013c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller result = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(id) + 1 + uprv_strlen(curKey)) + 1); 102a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_memset(result, 0, sizeof(char)*(uprv_strlen(id) + 1 + uprv_strlen(curKey)) + 1); 103a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(id[0]!='\0'){ 1043c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller uprv_strcpy(result, id); 1053c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller uprv_strcat(result, "_"); 106a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 107a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_strcat(result, curKey); 1083c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller } 1093c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller return result; 110a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath} 111a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 1123c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller/*compute CRC for binary code*/ 1133c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller/* The code is from http://www.theorem.com/java/CRC32.java 1143c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * Calculates the CRC32 - 32 bit Cyclical Redundancy Check 1153c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * <P> This check is used in numerous systems to verify the integrity 1163c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * of information. It's also used as a hashing function. Unlike a regular 1173c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * checksum, it's sensitive to the order of the characters. 1183c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * It produces a 32 bit 1193c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * 1203c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * @author Michael Lecuyer (mjl@theorem.com) 1213c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * @version 1.1 August 11, 1998 1223c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller */ 1233c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 1243c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller/* ICU is not endian portable, because ICU data generated on big endian machines can be 1253c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * ported to big endian machines but not to little endian machines and vice versa. The 1263c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller * conversion is not portable across platforms with different endianess. 1273c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller */ 1283c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 1293c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fulleruint32_t computeCRC(char *ptr, uint32_t len, uint32_t lastcrc){ 1303c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller int32_t crc; 1313c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller uint32_t temp1; 1323c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller uint32_t temp2; 1333c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 1343c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller int32_t crc_ta[256]; 1353c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller int i = 0; 1363c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller int j = 0; 1373c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller uint32_t crc2 = 0; 1383c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 1393c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller#define CRC32_POLYNOMIAL 0xEDB88320 1403c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 1413c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller /*build crc table*/ 1423c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller for (i = 0; i <= 255; i++) { 1433c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller crc2 = i; 1443c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller for (j = 8; j > 0; j--) { 1453c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller if ((crc2 & 1) == 1) { 146a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath crc2 = (crc2 >> 1) ^ CRC32_POLYNOMIAL; 147a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } else { 148a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath crc2 >>= 1; 1493c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller } 1503c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller } 1513c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller crc_ta[i] = crc2; 152a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 1533c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 1543c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller crc = lastcrc; 155a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath while(len--!=0) { 156a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath temp1 = (uint32_t)crc>>8; 157a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath temp2 = crc_ta[(crc^*ptr) & 0xFF]; 158a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath crc = temp1^temp2; 159a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath ptr++; 160a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 1613c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller return(crc); 162a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath} 163a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 164a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic void strnrepchr(char* src, int32_t srcLen, char s, char r){ 165a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int32_t i = 0; 166a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath for(i=0;i<srcLen;i++){ 167a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(src[i]==s){ 168a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath src[i]=r; 169a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 170a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 171a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath} 172a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath/* Parse the filename, and get its language information. 173a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath * If it fails to get the language information from the filename, 174a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath * use "en" as the default value for language 175a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath */ 176a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic char* parseFilename(const char* id, char* /*lang*/) { 177a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int idLen = (int) uprv_strlen(id); 178a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath char* localeID = (char*) uprv_malloc(idLen); 179a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int pos = 0; 180a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int canonCapacity = 0; 181a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath char* canon = NULL; 182a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int canonLen = 0; 183a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath /*int i;*/ 184a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath UErrorCode status = U_ZERO_ERROR; 185a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath const char *ext = uprv_strchr(id, '.'); 186a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 187a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(ext != NULL){ 188a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath pos = (int) (ext - id); 189a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } else { 190a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath pos = idLen; 191a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 192a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_memcpy(localeID, id, pos); 1933c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller localeID[pos]=0; /* NUL terminate the string */ 1943c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 195a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath canonCapacity =pos*3; 196a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath canon = (char*) uprv_malloc(canonCapacity); 197a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath canonLen = uloc_canonicalize(localeID, canon, canonCapacity, &status); 198a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 199a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(U_FAILURE(status)){ 200a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath fprintf(stderr, "Could not canonicalize the locale ID: %s. Error: %s\n", localeID, u_errorName(status)); 201a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath exit(status); 202a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 203a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath strnrepchr(canon, canonLen, '_', '-'); 204a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath return canon; 205a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath} 206a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 207a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic const char* xmlHeader = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; 208a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#if 0 209a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic const char* bundleStart = "<xliff version = \"1.2\" " 210a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath "xmlns='urn:oasis:names:tc:xliff:document:1.2' " 211a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' " 212a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath "xsi:schemaLocation='urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd'>\n"; 2133c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller#else 214a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic const char* bundleStart = "<xliff version = \"1.1\" " 215a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath "xmlns='urn:oasis:names:tc:xliff:document:1.1' " 216a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' " 217a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath "xsi:schemaLocation='urn:oasis:names:tc:xliff:document:1.1 http://www.oasis-open.org/committees/xliff/documents/xliff-core-1.1.xsd'>\n"; 218a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath#endif 219a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic const char* bundleEnd = "</xliff>\n"; 220a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 221a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathvoid res_write_xml(struct SResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status); 2223c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 223a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamathstatic char* convertAndEscape(char** pDest, int32_t destCap, int32_t* destLength, 224a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath const UChar* src, int32_t srcLen, UErrorCode* status){ 225a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int32_t srcIndex=0; 226a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath char* dest=NULL; 227a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath char* temp=NULL; 228a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath int32_t destLen=0; 229a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath UChar32 c = 0; 230a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 231a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(status==NULL || U_FAILURE(*status) || pDest==NULL || srcLen==0 || src == NULL){ 232a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath return NULL; 233a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 2343c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller dest =*pDest; 2353c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller if(dest==NULL || destCap <=0){ 236a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath destCap = srcLen * 8; 237a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath dest = (char*) uprv_malloc(sizeof(char) * destCap); 238a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(dest==NULL){ 2393c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller *status=U_MEMORY_ALLOCATION_ERROR; 2403c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller return NULL; 2413c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller } 242a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 243a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 2443c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller dest[0]=0; 2453c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 2463c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller while(srcIndex<srcLen){ 2473c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller U16_NEXT(src, srcIndex, srcLen, c); 2483c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller 2493c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller if (U16_IS_LEAD(c) || U16_IS_TRAIL(c)) { 250a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath *status = U_ILLEGAL_CHAR_FOUND; 251a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath fprintf(stderr, "Illegal Surrogate! \n"); 252a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_free(dest); 253a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath return NULL; 2543c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller } 255a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 256a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if((destLen+U8_LENGTH(c)) < destCap){ 257a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 258a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath /* ASCII Range */ 259a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(c <=0x007F){ 260a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath switch(c) { 2613c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case '\x26': 262a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_strcpy(dest+( destLen),"\x26\x61\x6d\x70\x3b"); /* &*/ 263a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath destLen+=(int32_t)uprv_strlen("\x26\x61\x6d\x70\x3b"); 264a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath break; 265a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case '\x3c': 266a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_strcpy(dest+(destLen),"\x26\x6c\x74\x3b"); /* <*/ 267a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath destLen+=(int32_t)uprv_strlen("\x26\x6c\x74\x3b"); 268a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath break; 269a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case '\x3e': 270a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_strcpy(dest+(destLen),"\x26\x67\x74\x3b"); /* >*/ 271a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath destLen+=(int32_t)uprv_strlen("\x26\x67\x74\x3b"); 272a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath break; 273a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case '\x22': 274a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_strcpy(dest+(destLen),"\x26\x71\x75\x6f\x74\x3b"); /* "*/ 275a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath destLen+=(int32_t)uprv_strlen("\x26\x71\x75\x6f\x74\x3b"); 276a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath break; 277a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case '\x27': 278a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_strcpy(dest+(destLen),"\x26\x61\x70\x6f\x73\x3b"); /* ' */ 279a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath destLen+=(int32_t)uprv_strlen("\x26\x61\x70\x6f\x73\x3b"); 280a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath break; 281a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 282a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath /* Disallow C0 controls except TAB, CR, LF*/ 283a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x00: 2843c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x01: 2853c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x02: 2863c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x03: 2873c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x04: 2883c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x05: 2893c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x06: 2903c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x07: 2913c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x08: 2923c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller /*case 0x09:*/ 2933c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller /*case 0x0A: */ 2943c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x0B: 2953c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x0C: 2963c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller /*case 0x0D:*/ 2973c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x0E: 2983c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller case 0x0F: 299a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x10: 300a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x11: 301a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x12: 302a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x13: 303a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x14: 304a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x15: 305a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x16: 306a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x17: 307a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x18: 308a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x19: 309a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x1A: 310a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x1B: 311a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x1C: 312a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x1D: 313a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x1E: 314a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath case 0x1F: 315a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath *status = U_ILLEGAL_CHAR_FOUND; 316a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath fprintf(stderr, "Illegal Character \\u%04X!\n",(int)c); 317a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_free(dest); 318a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath return NULL; 319a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath default: 320a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath dest[destLen++]=(char)c; 321a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 322a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath }else{ 323a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath UBool isError = FALSE; 324a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath U8_APPEND((unsigned char*)dest,destLen,destCap,c,isError); 325a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(isError){ 326a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath *status = U_ILLEGAL_CHAR_FOUND; 327a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath fprintf(stderr, "Illegal Character \\U%08X!\n",(int)c); 328a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_free(dest); 329a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath return NULL; 330a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 331a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath } 332a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath }else{ 333a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath destCap += destLen; 334a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath 3353c938a3f6b61ce5e2dba0d039b03fe73b89fd26cNeil Fuller temp = (char*) uprv_malloc(sizeof(char)*destCap); 336a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath if(temp==NULL){ 337a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath *status=U_MEMORY_ALLOCATION_ERROR; 338a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath uprv_free(dest); 339a82f42bbeedd0b07f3892f3b0efaa8122dc8f264Narayan Kamath return NULL; 340 } 341 uprv_memmove(temp,dest,destLen); 342 destLen=0; 343 uprv_free(dest); 344 dest=temp; 345 temp=NULL; 346 } 347 348 } 349 *destLength = destLen; 350 return dest; 351} 352 353#define ASTERISK 0x002A 354#define SPACE 0x0020 355#define CR 0x000A 356#define LF 0x000D 357#define AT_SIGN 0x0040 358 359static void 360trim(char **src, int32_t *len){ 361 362 char *s = NULL; 363 int32_t i = 0; 364 if(src == NULL || *src == NULL){ 365 return; 366 } 367 s = *src; 368 /* trim from the end */ 369 for( i=(*len-1); i>= 0; i--){ 370 switch(s[i]){ 371 case ASTERISK: 372 case SPACE: 373 case CR: 374 case LF: 375 s[i] = 0; 376 continue; 377 default: 378 break; 379 } 380 break; 381 382 } 383 *len = i+1; 384} 385 386static void 387print(UChar* src, int32_t srcLen,const char *tagStart,const char *tagEnd, UErrorCode *status){ 388 int32_t bufCapacity = srcLen*4; 389 char *buf = NULL; 390 int32_t bufLen = 0; 391 392 if(U_FAILURE(*status)){ 393 return; 394 } 395 396 buf = (char*) (uprv_malloc(bufCapacity)); 397 if(buf==0){ 398 fprintf(stderr, "Could not allocate memory!!"); 399 exit(U_MEMORY_ALLOCATION_ERROR); 400 } 401 buf = convertAndEscape(&buf, bufCapacity, &bufLen, src, srcLen,status); 402 if(U_SUCCESS(*status)){ 403 trim(&buf,&bufLen); 404 write_utf8_file(out,UnicodeString(tagStart)); 405 write_utf8_file(out,UnicodeString(buf, bufLen, "UTF-8")); 406 write_utf8_file(out,UnicodeString(tagEnd)); 407 write_utf8_file(out,UnicodeString("\n")); 408 409 } 410} 411static void 412printNoteElements(struct UString *src, UErrorCode *status){ 413 414#if UCONFIG_NO_REGULAR_EXPRESSIONS==0 /* donot compile when no RegularExpressions are available */ 415 416 int32_t capacity = 0; 417 UChar* note = NULL; 418 int32_t noteLen = 0; 419 int32_t count = 0,i; 420 421 if(src == NULL){ 422 return; 423 } 424 425 capacity = src->fLength; 426 note = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity); 427 428 count = getCount(src->fChars,src->fLength, UPC_NOTE, status); 429 if(U_FAILURE(*status)){ 430 uprv_free(note); 431 return; 432 } 433 for(i=0; i < count; i++){ 434 noteLen = getAt(src->fChars,src->fLength, ¬e, capacity, i, UPC_NOTE, status); 435 if(U_FAILURE(*status)){ 436 uprv_free(note); 437 return; 438 } 439 if(noteLen > 0){ 440 write_tabs(out); 441 print(note, noteLen,"<note>", "</note>", status); 442 } 443 } 444 uprv_free(note); 445#else 446 447 fprintf(stderr, "Warning: Could not output comments to XLIFF file. ICU has been built without RegularExpression support.\n"); 448 449#endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */ 450 451} 452 453static void printAttribute(const char *name, const char *value, int32_t /*len*/) 454{ 455 write_utf8_file(out, UnicodeString(" ")); 456 write_utf8_file(out, UnicodeString(name)); 457 write_utf8_file(out, UnicodeString(" = \"")); 458 write_utf8_file(out, UnicodeString(value)); 459 write_utf8_file(out, UnicodeString("\"")); 460} 461 462static void printAttribute(const char *name, const UnicodeString value, int32_t /*len*/) 463{ 464 write_utf8_file(out, UnicodeString(" ")); 465 write_utf8_file(out, UnicodeString(name)); 466 write_utf8_file(out, UnicodeString(" = \"")); 467 write_utf8_file(out, value); 468 write_utf8_file(out, UnicodeString("\"")); 469} 470 471static void 472printComments(struct UString *src, const char *resName, UBool printTranslate, UErrorCode *status){ 473 474#if UCONFIG_NO_REGULAR_EXPRESSIONS==0 /* donot compile when no RegularExpressions are available */ 475 476 if(status==NULL || U_FAILURE(*status)){ 477 return; 478 } 479 480 int32_t capacity = src->fLength + 1; 481 char* buf = NULL; 482 int32_t bufLen = 0; 483 UChar* desc = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity); 484 UChar* trans = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity); 485 486 int32_t descLen = 0, transLen=0; 487 if(desc==NULL || trans==NULL){ 488 *status = U_MEMORY_ALLOCATION_ERROR; 489 uprv_free(desc); 490 uprv_free(trans); 491 return; 492 } 493 src->fLength = removeCmtText(src->fChars, src->fLength, status); 494 descLen = getDescription(src->fChars,src->fLength, &desc, capacity, status); 495 transLen = getTranslate(src->fChars,src->fLength, &trans, capacity, status); 496 497 /* first print translate attribute */ 498 if(transLen > 0){ 499 if(printTranslate){ 500 /* print translate attribute */ 501 buf = convertAndEscape(&buf, 0, &bufLen, trans, transLen, status); 502 if(U_SUCCESS(*status)){ 503 printAttribute("translate", UnicodeString(buf, bufLen, "UTF-8"), bufLen); 504 write_utf8_file(out,UnicodeString(">\n")); 505 } 506 }else if(getShowWarning()){ 507 fprintf(stderr, "Warning: Tranlate attribute for resource %s cannot be set. XLIFF prohibits it.\n", resName); 508 /* no translate attribute .. just close the tag */ 509 write_utf8_file(out,UnicodeString(">\n")); 510 } 511 }else{ 512 /* no translate attribute .. just close the tag */ 513 write_utf8_file(out,UnicodeString(">\n")); 514 } 515 516 if(descLen > 0){ 517 write_tabs(out); 518 print(desc, descLen, "<!--", "-->", status); 519 } 520 521 uprv_free(desc); 522 uprv_free(trans); 523#else 524 525 fprintf(stderr, "Warning: Could not output comments to XLIFF file. ICU has been built without RegularExpression support.\n"); 526 527#endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */ 528 529} 530 531/* 532 * Print out a containing element, like: 533 * <trans-unit id = "blah" resname = "blah" restype = "x-id-alias" translate = "no"> 534 * <group id "calendar_gregorian" resname = "gregorian" restype = "x-icu-array"> 535 */ 536static char *printContainer(struct SResource *res, const char *container, const char *restype, const char *mimetype, const char *id, UErrorCode *status) 537{ 538 char resKeyBuffer[8]; 539 const char *resname = NULL; 540 char *sid = NULL; 541 542 write_tabs(out); 543 544 resname = res_getKeyString(srBundle, res, resKeyBuffer); 545 if (resname != NULL && *resname != 0) { 546 sid = getID(id, resname, sid); 547 } else { 548 sid = getID(id, NULL, sid); 549 } 550 551 write_utf8_file(out, UnicodeString("<")); 552 write_utf8_file(out, UnicodeString(container)); 553 printAttribute("id", sid, (int32_t) uprv_strlen(sid)); 554 555 if (resname != NULL) { 556 printAttribute("resname", resname, (int32_t) uprv_strlen(resname)); 557 } 558 559 if (mimetype != NULL) { 560 printAttribute("mime-type", mimetype, (int32_t) uprv_strlen(mimetype)); 561 } 562 563 if (restype != NULL) { 564 printAttribute("restype", restype, (int32_t) uprv_strlen(restype)); 565 } 566 567 tabCount += 1; 568 if (res->fComment.fLength > 0) { 569 /* printComments will print the closing ">\n" */ 570 printComments(&res->fComment, resname, TRUE, status); 571 } else { 572 write_utf8_file(out, UnicodeString(">\n")); 573 } 574 575 return sid; 576} 577 578/* Writing Functions */ 579 580static const char *trans_unit = "trans-unit"; 581static const char *close_trans_unit = "</trans-unit>\n"; 582static const char *source = "<source>"; 583static const char *close_source = "</source>\n"; 584static const char *group = "group"; 585static const char *close_group = "</group>\n"; 586 587static const char *bin_unit = "bin-unit"; 588static const char *close_bin_unit = "</bin-unit>\n"; 589static const char *bin_source = "<bin-source>\n"; 590static const char *close_bin_source = "</bin-source>\n"; 591static const char *external_file = "<external-file"; 592/*static const char *close_external_file = "</external-file>\n";*/ 593static const char *internal_file = "<internal-file"; 594static const char *close_internal_file = "</internal-file>\n"; 595 596static const char *application_mimetype = "application"; /* add "/octet-stream"? */ 597 598static const char *alias_restype = "x-icu-alias"; 599static const char *array_restype = "x-icu-array"; 600static const char *binary_restype = "x-icu-binary"; 601static const char *integer_restype = "x-icu-integer"; 602static const char *intvector_restype = "x-icu-intvector"; 603static const char *table_restype = "x-icu-table"; 604 605static void 606string_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) { 607 608 char *sid = NULL; 609 char* buf = NULL; 610 int32_t bufLen = 0; 611 612 if(status==NULL || U_FAILURE(*status)){ 613 return; 614 } 615 616 sid = printContainer(res, trans_unit, NULL, NULL, id, status); 617 618 write_tabs(out); 619 620 write_utf8_file(out, UnicodeString(source)); 621 622 buf = convertAndEscape(&buf, 0, &bufLen, res->u.fString.fChars, res->u.fString.fLength, status); 623 624 if (U_FAILURE(*status)) { 625 return; 626 } 627 628 write_utf8_file(out, UnicodeString(buf, bufLen, "UTF-8")); 629 write_utf8_file(out, UnicodeString(close_source)); 630 631 printNoteElements(&res->fComment, status); 632 633 tabCount -= 1; 634 write_tabs(out); 635 636 write_utf8_file(out, UnicodeString(close_trans_unit)); 637 638 uprv_free(buf); 639 uprv_free(sid); 640} 641 642static void 643alias_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) { 644 char *sid = NULL; 645 char* buf = NULL; 646 int32_t bufLen=0; 647 648 sid = printContainer(res, trans_unit, alias_restype, NULL, id, status); 649 650 write_tabs(out); 651 652 write_utf8_file(out, UnicodeString(source)); 653 654 buf = convertAndEscape(&buf, 0, &bufLen, res->u.fString.fChars, res->u.fString.fLength, status); 655 656 if(U_FAILURE(*status)){ 657 return; 658 } 659 write_utf8_file(out, UnicodeString(buf, bufLen, "UTF-8")); 660 write_utf8_file(out, UnicodeString(close_source)); 661 662 printNoteElements(&res->fComment, status); 663 664 tabCount -= 1; 665 write_tabs(out); 666 667 write_utf8_file(out, UnicodeString(close_trans_unit)); 668 669 uprv_free(buf); 670 uprv_free(sid); 671} 672 673static void 674array_write_xml(struct SResource *res, const char* id, const char* language, UErrorCode *status) { 675 char* sid = NULL; 676 int index = 0; 677 678 struct SResource *current = NULL; 679 680 sid = printContainer(res, group, array_restype, NULL, id, status); 681 682 current = res->u.fArray.fFirst; 683 684 while (current != NULL) { 685 char c[256] = {0}; 686 char* subId = NULL; 687 688 itostr(c, index, 10, 0); 689 index += 1; 690 subId = getID(sid, c, subId); 691 692 res_write_xml(current, subId, language, FALSE, status); 693 uprv_free(subId); 694 subId = NULL; 695 696 if(U_FAILURE(*status)){ 697 return; 698 } 699 700 current = current->fNext; 701 } 702 703 tabCount -= 1; 704 write_tabs(out); 705 write_utf8_file(out, UnicodeString(close_group)); 706 707 uprv_free(sid); 708} 709 710static void 711intvector_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) { 712 char* sid = NULL; 713 char* ivd = NULL; 714 uint32_t i=0; 715 uint32_t len=0; 716 char buf[256] = {'0'}; 717 718 sid = printContainer(res, group, intvector_restype, NULL, id, status); 719 720 for(i = 0; i < res->u.fIntVector.fCount; i += 1) { 721 char c[256] = {0}; 722 723 itostr(c, i, 10, 0); 724 ivd = getID(sid, c, ivd); 725 len = itostr(buf, res->u.fIntVector.fArray[i], 10, 0); 726 727 write_tabs(out); 728 write_utf8_file(out, UnicodeString("<")); 729 write_utf8_file(out, UnicodeString(trans_unit)); 730 731 printAttribute("id", ivd, (int32_t)uprv_strlen(ivd)); 732 printAttribute("restype", integer_restype, (int32_t) strlen(integer_restype)); 733 734 write_utf8_file(out, UnicodeString(">\n")); 735 736 tabCount += 1; 737 write_tabs(out); 738 write_utf8_file(out, UnicodeString(source)); 739 740 write_utf8_file(out, UnicodeString(buf, len)); 741 742 write_utf8_file(out, UnicodeString(close_source)); 743 tabCount -= 1; 744 write_tabs(out); 745 write_utf8_file(out, UnicodeString(close_trans_unit)); 746 747 uprv_free(ivd); 748 ivd = NULL; 749 } 750 751 tabCount -= 1; 752 write_tabs(out); 753 754 write_utf8_file(out, UnicodeString(close_group)); 755 uprv_free(sid); 756 sid = NULL; 757} 758 759static void 760int_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) { 761 char* sid = NULL; 762 char buf[256] = {0}; 763 uint32_t len = 0; 764 765 sid = printContainer(res, trans_unit, integer_restype, NULL, id, status); 766 767 write_tabs(out); 768 769 write_utf8_file(out, UnicodeString(source)); 770 771 len = itostr(buf, res->u.fIntValue.fValue, 10, 0); 772 write_utf8_file(out, UnicodeString(buf, len)); 773 774 write_utf8_file(out, UnicodeString(close_source)); 775 776 printNoteElements(&res->fComment, status); 777 778 tabCount -= 1; 779 write_tabs(out); 780 781 write_utf8_file(out, UnicodeString(close_trans_unit)); 782 783 uprv_free(sid); 784 sid = NULL; 785} 786 787static void 788bin_write_xml(struct SResource *res, const char* id, const char* /*language*/, UErrorCode *status) { 789 const char* m_type = application_mimetype; 790 char* sid = NULL; 791 uint32_t crc = 0xFFFFFFFF; 792 793 char fileName[1024] ={0}; 794 int32_t tLen = ( outDir == NULL) ? 0 :(int32_t)uprv_strlen(outDir); 795 char* fn = (char*) uprv_malloc(sizeof(char) * (tLen+1024 + 796 (res->u.fBinaryValue.fFileName !=NULL ? 797 uprv_strlen(res->u.fBinaryValue.fFileName) :0))); 798 const char* ext = NULL; 799 800 char* f = NULL; 801 802 fn[0]=0; 803 804 if(res->u.fBinaryValue.fFileName != NULL){ 805 uprv_strcpy(fileName, res->u.fBinaryValue.fFileName); 806 f = uprv_strrchr(fileName, '\\'); 807 808 if (f != NULL) { 809 f++; 810 } else { 811 f = fileName; 812 } 813 814 ext = uprv_strrchr(fileName, '.'); 815 816 if (ext == NULL) { 817 fprintf(stderr, "Error: %s is an unknown binary filename type.\n", fileName); 818 exit(U_ILLEGAL_ARGUMENT_ERROR); 819 } 820 821 if(uprv_strcmp(ext, ".jpg")==0 || uprv_strcmp(ext, ".jpeg")==0 || uprv_strcmp(ext, ".gif")==0 ){ 822 m_type = "image"; 823 } else if(uprv_strcmp(ext, ".wav")==0 || uprv_strcmp(ext, ".au")==0 ){ 824 m_type = "audio"; 825 } else if(uprv_strcmp(ext, ".avi")==0 || uprv_strcmp(ext, ".mpg")==0 || uprv_strcmp(ext, ".mpeg")==0){ 826 m_type = "video"; 827 } else if(uprv_strcmp(ext, ".txt")==0 || uprv_strcmp(ext, ".text")==0){ 828 m_type = "text"; 829 } 830 831 sid = printContainer(res, bin_unit, binary_restype, m_type, id, status); 832 833 write_tabs(out); 834 835 write_utf8_file(out, UnicodeString(bin_source)); 836 837 tabCount+= 1; 838 write_tabs(out); 839 840 write_utf8_file(out, UnicodeString(external_file)); 841 printAttribute("href", f, (int32_t)uprv_strlen(f)); 842 write_utf8_file(out, UnicodeString("/>\n")); 843 tabCount -= 1; 844 write_tabs(out); 845 846 write_utf8_file(out, UnicodeString(close_bin_source)); 847 848 printNoteElements(&res->fComment, status); 849 tabCount -= 1; 850 write_tabs(out); 851 write_utf8_file(out, UnicodeString(close_bin_unit)); 852 } else { 853 char temp[256] = {0}; 854 uint32_t i = 0; 855 int32_t len=0; 856 857 sid = printContainer(res, bin_unit, binary_restype, m_type, id, status); 858 859 write_tabs(out); 860 write_utf8_file(out, UnicodeString(bin_source)); 861 862 tabCount += 1; 863 write_tabs(out); 864 865 write_utf8_file(out, UnicodeString(internal_file)); 866 printAttribute("form", application_mimetype, (int32_t) uprv_strlen(application_mimetype)); 867 868 while(i <res->u.fBinaryValue.fLength){ 869 len = itostr(temp, res->u.fBinaryValue.fData[i], 16, 2); 870 crc = computeCRC(temp, len, crc); 871 i++; 872 } 873 874 len = itostr(temp, crc, 10, 0); 875 printAttribute("crc", temp, len); 876 877 write_utf8_file(out, UnicodeString(">")); 878 879 i = 0; 880 while(i <res->u.fBinaryValue.fLength){ 881 len = itostr(temp, res->u.fBinaryValue.fData[i], 16, 2); 882 write_utf8_file(out, UnicodeString(temp)); 883 i += 1; 884 } 885 886 write_utf8_file(out, UnicodeString(close_internal_file)); 887 888 tabCount -= 2; 889 write_tabs(out); 890 891 write_utf8_file(out, UnicodeString(close_bin_source)); 892 printNoteElements(&res->fComment, status); 893 894 tabCount -= 1; 895 write_tabs(out); 896 write_utf8_file(out, UnicodeString(close_bin_unit)); 897 898 uprv_free(sid); 899 sid = NULL; 900 } 901 902 uprv_free(fn); 903} 904 905 906 907static void 908table_write_xml(struct SResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status) { 909 910 uint32_t i = 0; 911 912 struct SResource *current = NULL; 913 char* sid = NULL; 914 915 if (U_FAILURE(*status)) { 916 return ; 917 } 918 919 sid = printContainer(res, group, table_restype, NULL, id, status); 920 921 if(isTopLevel) { 922 sid[0] = '\0'; 923 } 924 925 current = res->u.fTable.fFirst; 926 i = 0; 927 928 while (current != NULL) { 929 res_write_xml(current, sid, language, FALSE, status); 930 931 if(U_FAILURE(*status)){ 932 return; 933 } 934 935 i += 1; 936 current = current->fNext; 937 } 938 939 tabCount -= 1; 940 write_tabs(out); 941 942 write_utf8_file(out, UnicodeString(close_group)); 943 944 uprv_free(sid); 945 sid = NULL; 946} 947 948void 949res_write_xml(struct SResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status) { 950 951 if (U_FAILURE(*status)) { 952 return ; 953 } 954 955 if (res != NULL) { 956 switch (res->fType) { 957 case URES_STRING: 958 string_write_xml (res, id, language, status); 959 return; 960 961 case URES_ALIAS: 962 alias_write_xml (res, id, language, status); 963 return; 964 965 case URES_INT_VECTOR: 966 intvector_write_xml (res, id, language, status); 967 return; 968 969 case URES_BINARY: 970 bin_write_xml (res, id, language, status); 971 return; 972 973 case URES_INT: 974 int_write_xml (res, id, language, status); 975 return; 976 977 case URES_ARRAY: 978 array_write_xml (res, id, language, status); 979 return; 980 981 case URES_TABLE: 982 table_write_xml (res, id, language, isTopLevel, status); 983 return; 984 985 default: 986 break; 987 } 988 } 989 990 *status = U_INTERNAL_PROGRAM_ERROR; 991} 992 993void 994bundle_write_xml(struct SRBRoot *bundle, const char *outputDir,const char* outputEnc, const char* filename, 995 char *writtenFilename, int writtenFilenameLen, 996 const char* language, const char* outFileName, UErrorCode *status) { 997 998 char* xmlfileName = NULL; 999 char* outputFileName = NULL; 1000 char* originalFileName = NULL; 1001 const char* fileStart = "<file xml:space = \"preserve\" source-language = \""; 1002 const char* file1 = "\" datatype = \"x-icu-resource-bundle\" "; 1003 const char* file2 = "original = \""; 1004 const char* file4 = "\" date = \""; 1005 const char* fileEnd = "</file>\n"; 1006 const char* headerStart = "<header>\n"; 1007 const char* headerEnd = "</header>\n"; 1008 const char* bodyStart = "<body>\n"; 1009 const char* bodyEnd = "</body>\n"; 1010 1011 const char *tool_start = "<tool"; 1012 const char *tool_id = "genrb-" GENRB_VERSION "-icu-" U_ICU_VERSION; 1013 const char *tool_name = "genrb"; 1014 1015 char* temp = NULL; 1016 char* lang = NULL; 1017 const char* pos = NULL; 1018 int32_t first, index; 1019 time_t currTime; 1020 char timeBuf[128]; 1021 1022 outDir = outputDir; 1023 1024 srBundle = bundle; 1025 1026 pos = uprv_strrchr(filename, '\\'); 1027 if(pos != NULL) { 1028 first = (int32_t)(pos - filename + 1); 1029 } else { 1030 first = 0; 1031 } 1032 index = (int32_t)(uprv_strlen(filename) - uprv_strlen(textExt) - first); 1033 originalFileName = (char *)uprv_malloc(sizeof(char)*index+1); 1034 uprv_memset(originalFileName, 0, sizeof(char)*index+1); 1035 uprv_strncpy(originalFileName, filename + first, index); 1036 1037 if(uprv_strcmp(originalFileName, srBundle->fLocale) != 0) { 1038 fprintf(stdout, "Warning: The file name is not same as the resource name!\n"); 1039 } 1040 1041 temp = originalFileName; 1042 originalFileName = (char *)uprv_malloc(sizeof(char)* (uprv_strlen(temp)+uprv_strlen(textExt)) + 1); 1043 uprv_memset(originalFileName, 0, sizeof(char)* (uprv_strlen(temp)+uprv_strlen(textExt)) + 1); 1044 uprv_strcat(originalFileName, temp); 1045 uprv_strcat(originalFileName, textExt); 1046 uprv_free(temp); 1047 temp = NULL; 1048 1049 1050 if (language == NULL) { 1051/* lang = parseFilename(filename, lang); 1052 if (lang == NULL) {*/ 1053 /* now check if locale name is valid or not 1054 * this is to cater for situation where 1055 * pegasusServer.txt contains 1056 * 1057 * en{ 1058 * .. 1059 * } 1060 */ 1061 lang = parseFilename(srBundle->fLocale, lang); 1062 /* 1063 * Neither the file name nor the table name inside the 1064 * txt file contain a valid country and language codes 1065 * throw an error. 1066 * pegasusServer.txt contains 1067 * 1068 * testelements{ 1069 * .... 1070 * } 1071 */ 1072 if(lang==NULL){ 1073 fprintf(stderr, "Error: The file name and table name do not contain a valid language code. Please use -l option to specify it.\n"); 1074 exit(U_ILLEGAL_ARGUMENT_ERROR); 1075 } 1076 /* }*/ 1077 } else { 1078 lang = (char *)uprv_malloc(sizeof(char)*uprv_strlen(language) +1); 1079 uprv_memset(lang, 0, sizeof(char)*uprv_strlen(language) +1); 1080 uprv_strcpy(lang, language); 1081 } 1082 1083 if(outFileName) { 1084 outputFileName = (char *)uprv_malloc(sizeof(char)*uprv_strlen(outFileName) + 1); 1085 uprv_memset(outputFileName, 0, sizeof(char)*uprv_strlen(outFileName) + 1); 1086 uprv_strcpy(outputFileName,outFileName); 1087 } else { 1088 outputFileName = (char *)uprv_malloc(sizeof(char)*uprv_strlen(srBundle->fLocale) + 1); 1089 uprv_memset(outputFileName, 0, sizeof(char)*uprv_strlen(srBundle->fLocale) + 1); 1090 uprv_strcpy(outputFileName,srBundle->fLocale); 1091 } 1092 1093 if(outputDir) { 1094 xmlfileName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(outputDir) + uprv_strlen(outputFileName) + uprv_strlen(xliffExt) + 1) +1); 1095 uprv_memset(xmlfileName, 0, sizeof(char)*(uprv_strlen(outputDir)+ uprv_strlen(outputFileName) + uprv_strlen(xliffExt) + 1) +1); 1096 } else { 1097 xmlfileName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(outputFileName) + uprv_strlen(xliffExt)) +1); 1098 uprv_memset(xmlfileName, 0, sizeof(char)*(uprv_strlen(outputFileName) + uprv_strlen(xliffExt)) +1); 1099 } 1100 1101 if(outputDir){ 1102 uprv_strcpy(xmlfileName, outputDir); 1103 if(outputDir[uprv_strlen(outputDir)-1] !=U_FILE_SEP_CHAR){ 1104 uprv_strcat(xmlfileName,U_FILE_SEP_STRING); 1105 } 1106 } 1107 uprv_strcat(xmlfileName,outputFileName); 1108 uprv_strcat(xmlfileName,xliffExt); 1109 1110 if (writtenFilename) { 1111 uprv_strncpy(writtenFilename, xmlfileName, writtenFilenameLen); 1112 } 1113 1114 if (U_FAILURE(*status)) { 1115 goto cleanup_bundle_write_xml; 1116 } 1117 1118 out= T_FileStream_open(xmlfileName,"w"); 1119 1120 if(out==NULL){ 1121 *status = U_FILE_ACCESS_ERROR; 1122 goto cleanup_bundle_write_xml; 1123 } 1124 write_utf8_file(out, xmlHeader); 1125 1126 if(outputEnc && *outputEnc!='\0'){ 1127 /* store the output encoding */ 1128 enc = outputEnc; 1129 conv=ucnv_open(enc,status); 1130 if(U_FAILURE(*status)){ 1131 goto cleanup_bundle_write_xml; 1132 } 1133 } 1134 write_utf8_file(out, bundleStart); 1135 write_tabs(out); 1136 write_utf8_file(out, fileStart); 1137 /* check if lang and language are the same */ 1138 if(language != NULL && uprv_strcmp(lang, srBundle->fLocale)!=0){ 1139 fprintf(stderr,"Warning: The top level tag in the resource and language specified are not the same. Please check the input.\n"); 1140 } 1141 write_utf8_file(out, UnicodeString(lang)); 1142 write_utf8_file(out, UnicodeString(file1)); 1143 write_utf8_file(out, UnicodeString(file2)); 1144 write_utf8_file(out, UnicodeString(originalFileName)); 1145 write_utf8_file(out, UnicodeString(file4)); 1146 1147 time(&currTime); 1148 strftime(timeBuf, sizeof(timeBuf), "%Y-%m-%dT%H:%M:%SZ", gmtime(&currTime)); 1149 write_utf8_file(out, UnicodeString(timeBuf)); 1150 write_utf8_file(out, UnicodeString("\">\n")); 1151 1152 tabCount += 1; 1153 write_tabs(out); 1154 write_utf8_file(out, headerStart); 1155 1156 tabCount += 1; 1157 write_tabs(out); 1158 1159 write_utf8_file(out, tool_start); 1160 printAttribute("tool-id", tool_id, (int32_t) uprv_strlen(tool_id)); 1161 printAttribute("tool-name", tool_name, (int32_t) uprv_strlen(tool_name)); 1162 write_utf8_file(out, UnicodeString("/>\n")); 1163 1164 tabCount -= 1; 1165 write_tabs(out); 1166 1167 write_utf8_file(out, UnicodeString(headerEnd)); 1168 1169 write_tabs(out); 1170 tabCount += 1; 1171 1172 write_utf8_file(out, UnicodeString(bodyStart)); 1173 1174 1175 res_write_xml(bundle->fRoot, bundle->fLocale, lang, TRUE, status); 1176 1177 tabCount -= 1; 1178 write_tabs(out); 1179 1180 write_utf8_file(out, UnicodeString(bodyEnd)); 1181 tabCount--; 1182 write_tabs(out); 1183 write_utf8_file(out, UnicodeString(fileEnd)); 1184 tabCount--; 1185 write_tabs(out); 1186 write_utf8_file(out, UnicodeString(bundleEnd)); 1187 T_FileStream_close(out); 1188 1189 ucnv_close(conv); 1190 1191cleanup_bundle_write_xml: 1192 uprv_free(originalFileName); 1193 uprv_free(lang); 1194 if(xmlfileName != NULL) { 1195 uprv_free(xmlfileName); 1196 } 1197 if(outputFileName != NULL){ 1198 uprv_free(outputFileName); 1199 } 1200} 1201