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