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