1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
4 *******************************************************************************
6 * Copyright (C) 2002-2015, International Business Machines
7 * Corporation and others. All Rights Reserved.
9 *******************************************************************************
13 * Modification History:
15 * Date Name Description
16 * 10/01/02 Ram Creation.
17 * 02/07/08 Spieth Correct XLIFF generation on EBCDIC platform
19 *******************************************************************************
22 // Safer use of UnicodeString.
23 #ifndef UNISTR_FROM_CHAR_EXPLICIT
24 # define UNISTR_FROM_CHAR_EXPLICIT explicit
27 // Less important, but still a good idea.
28 #ifndef UNISTR_FROM_STRING_EXPLICIT
29 # define UNISTR_FROM_STRING_EXPLICIT explicit
34 #include "unicode/ures.h"
38 #include "unicode/ucnv.h"
43 #include "unicode/ustring.h"
44 #include "unicode/uchar.h"
47 #include "unicode/unistr.h"
48 #include "unicode/utf8.h"
49 #include "unicode/utf16.h"
54 static int tabCount = 0;
56 static FileStream* out=NULL;
57 static struct SRBRoot* srBundle ;
58 static const char* outDir = NULL;
59 static const char* enc ="";
60 static UConverter* conv = NULL;
62 const char* const* ISOLanguages;
63 const char* const* ISOCountries;
64 const char* textExt = ".txt";
65 const char* xliffExt = ".xlf";
67 static int32_t write_utf8_file(FileStream* fileStream, UnicodeString outString)
69 UErrorCode status = U_ZERO_ERROR;
72 // preflight to get the destination buffer size
76 outString.getBuffer(),
80 // allocate the buffer
81 char* dest = (char*)uprv_malloc(len);
82 status = U_ZERO_ERROR;
88 outString.getBuffer(),
92 // write data to out file
93 int32_t ret = T_FileStream_write(fileStream, dest, len);
98 /*write indentation for formatting*/
99 static void write_tabs(FileStream* os){
101 for(;i<=tabCount;i++){
102 write_utf8_file(os,UnicodeString(" "));
106 /*get ID for each element. ID is globally unique.*/
107 static char* getID(const char* id, const char* curKey, char* result) {
109 result = (char *)uprv_malloc(sizeof(char)*uprv_strlen(id) + 1);
110 uprv_memset(result, 0, sizeof(char)*uprv_strlen(id) + 1);
111 uprv_strcpy(result, id);
113 result = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(id) + 1 + uprv_strlen(curKey)) + 1);
114 uprv_memset(result, 0, sizeof(char)*(uprv_strlen(id) + 1 + uprv_strlen(curKey)) + 1);
116 uprv_strcpy(result, id);
117 uprv_strcat(result, "_");
119 uprv_strcat(result, curKey);
124 /*compute CRC for binary code*/
125 /* The code is from http://www.theorem.com/java/CRC32.java
126 * Calculates the CRC32 - 32 bit Cyclical Redundancy Check
127 * <P> This check is used in numerous systems to verify the integrity
128 * of information. It's also used as a hashing function. Unlike a regular
129 * checksum, it's sensitive to the order of the characters.
130 * It produces a 32 bit
132 * @author Michael Lecuyer (mjl@theorem.com)
133 * @version 1.1 August 11, 1998
136 /* ICU is not endian portable, because ICU data generated on big endian machines can be
137 * ported to big endian machines but not to little endian machines and vice versa. The
138 * conversion is not portable across platforms with different endianess.
141 uint32_t computeCRC(const char *ptr, uint32_t len, uint32_t lastcrc){
151 #define CRC32_POLYNOMIAL 0xEDB88320
154 for (i = 0; i <= 255; i++) {
156 for (j = 8; j > 0; j--) {
157 if ((crc2 & 1) == 1) {
158 crc2 = (crc2 >> 1) ^ CRC32_POLYNOMIAL;
168 temp1 = (uint32_t)crc>>8;
169 temp2 = crc_ta[(crc^*ptr) & 0xFF];
176 static void strnrepchr(char* src, int32_t srcLen, char s, char r){
178 for(i=0;i<srcLen;i++){
184 /* Parse the filename, and get its language information.
185 * If it fails to get the language information from the filename,
186 * use "en" as the default value for language
188 static char* parseFilename(const char* id, char* /*lang*/) {
189 int idLen = (int) uprv_strlen(id);
190 char* localeID = (char*) uprv_malloc(idLen);
192 int canonCapacity = 0;
196 UErrorCode status = U_ZERO_ERROR;
197 const char *ext = uprv_strchr(id, '.');
200 pos = (int) (ext - id);
204 uprv_memcpy(localeID, id, pos);
205 localeID[pos]=0; /* NUL terminate the string */
207 canonCapacity =pos*3;
208 canon = (char*) uprv_malloc(canonCapacity);
209 canonLen = uloc_canonicalize(localeID, canon, canonCapacity, &status);
211 if(U_FAILURE(status)){
212 fprintf(stderr, "Could not canonicalize the locale ID: %s. Error: %s\n", localeID, u_errorName(status));
215 strnrepchr(canon, canonLen, '_', '-');
219 static const char* xmlHeader = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
221 static const char* bundleStart = "<xliff version = \"1.2\" "
222 "xmlns='urn:oasis:names:tc:xliff:document:1.2' "
223 "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
224 "xsi:schemaLocation='urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd'>\n";
226 static const char* bundleStart = "<xliff version = \"1.1\" "
227 "xmlns='urn:oasis:names:tc:xliff:document:1.1' "
228 "xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' "
229 "xsi:schemaLocation='urn:oasis:names:tc:xliff:document:1.1 http://www.oasis-open.org/committees/xliff/documents/xliff-core-1.1.xsd'>\n";
231 static const char* bundleEnd = "</xliff>\n";
233 void res_write_xml(struct SResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status);
235 static char* convertAndEscape(char** pDest, int32_t destCap, int32_t* destLength,
236 const UChar* src, int32_t srcLen, UErrorCode* status){
243 if(status==NULL || U_FAILURE(*status) || pDest==NULL || srcLen==0 || src == NULL){
247 if(dest==NULL || destCap <=0){
248 destCap = srcLen * 8;
249 dest = (char*) uprv_malloc(sizeof(char) * destCap);
251 *status=U_MEMORY_ALLOCATION_ERROR;
258 while(srcIndex<srcLen){
259 U16_NEXT(src, srcIndex, srcLen, c);
261 if (U16_IS_LEAD(c) || U16_IS_TRAIL(c)) {
262 *status = U_ILLEGAL_CHAR_FOUND;
263 fprintf(stderr, "Illegal Surrogate! \n");
268 if((destLen+U8_LENGTH(c)) < destCap){
274 uprv_strcpy(dest+( destLen),"\x26\x61\x6d\x70\x3b"); /* &*/
275 destLen+=(int32_t)uprv_strlen("\x26\x61\x6d\x70\x3b");
278 uprv_strcpy(dest+(destLen),"\x26\x6c\x74\x3b"); /* <*/
279 destLen+=(int32_t)uprv_strlen("\x26\x6c\x74\x3b");
282 uprv_strcpy(dest+(destLen),"\x26\x67\x74\x3b"); /* >*/
283 destLen+=(int32_t)uprv_strlen("\x26\x67\x74\x3b");
286 uprv_strcpy(dest+(destLen),"\x26\x71\x75\x6f\x74\x3b"); /* "*/
287 destLen+=(int32_t)uprv_strlen("\x26\x71\x75\x6f\x74\x3b");
290 uprv_strcpy(dest+(destLen),"\x26\x61\x70\x6f\x73\x3b"); /* ' */
291 destLen+=(int32_t)uprv_strlen("\x26\x61\x70\x6f\x73\x3b");
294 /* Disallow C0 controls except TAB, CR, LF*/
327 *status = U_ILLEGAL_CHAR_FOUND;
328 fprintf(stderr, "Illegal Character \\u%04X!\n",(int)c);
332 dest[destLen++]=(char)c;
335 UBool isError = FALSE;
336 U8_APPEND((unsigned char*)dest,destLen,destCap,c,isError);
338 *status = U_ILLEGAL_CHAR_FOUND;
339 fprintf(stderr, "Illegal Character \\U%08X!\n",(int)c);
347 temp = (char*) uprv_malloc(sizeof(char)*destCap);
349 *status=U_MEMORY_ALLOCATION_ERROR;
353 uprv_memmove(temp,dest,destLen);
361 *destLength = destLen;
365 #define ASTERISK 0x002A
369 #define AT_SIGN 0x0040
372 trim(char **src, int32_t *len){
376 if(src == NULL || *src == NULL){
380 /* trim from the end */
381 for( i=(*len-1); i>= 0; i--){
399 print(UChar* src, int32_t srcLen,const char *tagStart,const char *tagEnd, UErrorCode *status){
400 int32_t bufCapacity = srcLen*4;
404 if(U_FAILURE(*status)){
408 buf = (char*) (uprv_malloc(bufCapacity));
410 fprintf(stderr, "Could not allocate memory!!");
411 exit(U_MEMORY_ALLOCATION_ERROR);
413 buf = convertAndEscape(&buf, bufCapacity, &bufLen, src, srcLen,status);
414 if(U_SUCCESS(*status)){
416 write_utf8_file(out,UnicodeString(tagStart));
417 write_utf8_file(out,UnicodeString(buf, bufLen, "UTF-8"));
418 write_utf8_file(out,UnicodeString(tagEnd));
419 write_utf8_file(out,UnicodeString("\n"));
424 printNoteElements(const UString *src, UErrorCode *status){
426 #if UCONFIG_NO_REGULAR_EXPRESSIONS==0 /* donot compile when no RegularExpressions are available */
428 int32_t capacity = 0;
437 capacity = src->fLength;
438 note = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity);
440 count = getCount(src->fChars,src->fLength, UPC_NOTE, status);
441 if(U_FAILURE(*status)){
445 for(i=0; i < count; i++){
446 noteLen = getAt(src->fChars,src->fLength, ¬e, capacity, i, UPC_NOTE, status);
447 if(U_FAILURE(*status)){
453 print(note, noteLen,"<note>", "</note>", status);
459 fprintf(stderr, "Warning: Could not output comments to XLIFF file. ICU has been built without RegularExpression support.\n");
461 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
465 static void printAttribute(const char *name, const char *value, int32_t /*len*/)
467 write_utf8_file(out, UnicodeString(" "));
468 write_utf8_file(out, UnicodeString(name));
469 write_utf8_file(out, UnicodeString(" = \""));
470 write_utf8_file(out, UnicodeString(value));
471 write_utf8_file(out, UnicodeString("\""));
474 static void printAttribute(const char *name, const UnicodeString value, int32_t /*len*/)
476 write_utf8_file(out, UnicodeString(" "));
477 write_utf8_file(out, UnicodeString(name));
478 write_utf8_file(out, UnicodeString(" = \""));
479 write_utf8_file(out, value);
480 write_utf8_file(out, UnicodeString("\""));
484 printComments(struct UString *src, const char *resName, UBool printTranslate, UErrorCode *status){
486 #if UCONFIG_NO_REGULAR_EXPRESSIONS==0 /* donot compile when no RegularExpressions are available */
488 if(status==NULL || U_FAILURE(*status)){
492 int32_t capacity = src->fLength + 1;
495 UChar* desc = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity);
496 UChar* trans = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * capacity);
498 int32_t descLen = 0, transLen=0;
499 if(desc==NULL || trans==NULL){
500 *status = U_MEMORY_ALLOCATION_ERROR;
505 // TODO: make src const, stop modifying it in-place, make printContainer() take const resource, etc.
506 src->fLength = removeCmtText(src->fChars, src->fLength, status);
507 descLen = getDescription(src->fChars,src->fLength, &desc, capacity, status);
508 transLen = getTranslate(src->fChars,src->fLength, &trans, capacity, status);
510 /* first print translate attribute */
513 /* print translate attribute */
514 buf = convertAndEscape(&buf, 0, &bufLen, trans, transLen, status);
515 if(U_SUCCESS(*status)){
516 printAttribute("translate", UnicodeString(buf, bufLen, "UTF-8"), bufLen);
517 write_utf8_file(out,UnicodeString(">\n"));
519 }else if(getShowWarning()){
520 fprintf(stderr, "Warning: Tranlate attribute for resource %s cannot be set. XLIFF prohibits it.\n", resName);
521 /* no translate attribute .. just close the tag */
522 write_utf8_file(out,UnicodeString(">\n"));
525 /* no translate attribute .. just close the tag */
526 write_utf8_file(out,UnicodeString(">\n"));
531 print(desc, descLen, "<!--", "-->", status);
538 fprintf(stderr, "Warning: Could not output comments to XLIFF file. ICU has been built without RegularExpression support.\n");
540 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
545 * Print out a containing element, like:
546 * <trans-unit id = "blah" resname = "blah" restype = "x-id-alias" translate = "no">
547 * <group id "calendar_gregorian" resname = "gregorian" restype = "x-icu-array">
549 static char *printContainer(SResource *res, const char *container, const char *restype, const char *mimetype, const char *id, UErrorCode *status)
551 const char *resname = NULL;
556 resname = res->getKeyString(srBundle);
557 if (resname != NULL && *resname != 0) {
558 sid = getID(id, resname, sid);
560 sid = getID(id, NULL, sid);
563 write_utf8_file(out, UnicodeString("<"));
564 write_utf8_file(out, UnicodeString(container));
565 printAttribute("id", sid, (int32_t) uprv_strlen(sid));
567 if (resname != NULL) {
568 printAttribute("resname", resname, (int32_t) uprv_strlen(resname));
571 if (mimetype != NULL) {
572 printAttribute("mime-type", mimetype, (int32_t) uprv_strlen(mimetype));
575 if (restype != NULL) {
576 printAttribute("restype", restype, (int32_t) uprv_strlen(restype));
580 if (res->fComment.fLength > 0) {
581 /* printComments will print the closing ">\n" */
582 printComments(&res->fComment, resname, TRUE, status);
584 write_utf8_file(out, UnicodeString(">\n"));
590 /* Writing Functions */
592 static const char *trans_unit = "trans-unit";
593 static const char *close_trans_unit = "</trans-unit>\n";
594 static const char *source = "<source>";
595 static const char *close_source = "</source>\n";
596 static const char *group = "group";
597 static const char *close_group = "</group>\n";
599 static const char *bin_unit = "bin-unit";
600 static const char *close_bin_unit = "</bin-unit>\n";
601 static const char *bin_source = "<bin-source>\n";
602 static const char *close_bin_source = "</bin-source>\n";
603 static const char *external_file = "<external-file";
604 /*static const char *close_external_file = "</external-file>\n";*/
605 static const char *internal_file = "<internal-file";
606 static const char *close_internal_file = "</internal-file>\n";
608 static const char *application_mimetype = "application"; /* add "/octet-stream"? */
610 static const char *alias_restype = "x-icu-alias";
611 static const char *array_restype = "x-icu-array";
612 static const char *binary_restype = "x-icu-binary";
613 static const char *integer_restype = "x-icu-integer";
614 static const char *intvector_restype = "x-icu-intvector";
615 static const char *table_restype = "x-icu-table";
618 string_write_xml(StringResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
624 if(status==NULL || U_FAILURE(*status)){
628 sid = printContainer(res, trans_unit, NULL, NULL, id, status);
632 write_utf8_file(out, UnicodeString(source));
634 buf = convertAndEscape(&buf, 0, &bufLen, res->getBuffer(), res->length(), status);
636 if (U_FAILURE(*status)) {
640 write_utf8_file(out, UnicodeString(buf, bufLen, "UTF-8"));
641 write_utf8_file(out, UnicodeString(close_source));
643 printNoteElements(&res->fComment, status);
648 write_utf8_file(out, UnicodeString(close_trans_unit));
655 alias_write_xml(AliasResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
660 sid = printContainer(res, trans_unit, alias_restype, NULL, id, status);
664 write_utf8_file(out, UnicodeString(source));
666 buf = convertAndEscape(&buf, 0, &bufLen, res->getBuffer(), res->length(), status);
668 if(U_FAILURE(*status)){
671 write_utf8_file(out, UnicodeString(buf, bufLen, "UTF-8"));
672 write_utf8_file(out, UnicodeString(close_source));
674 printNoteElements(&res->fComment, status);
679 write_utf8_file(out, UnicodeString(close_trans_unit));
686 array_write_xml(ArrayResource *res, const char* id, const char* language, UErrorCode *status) {
690 struct SResource *current = NULL;
692 sid = printContainer(res, group, array_restype, NULL, id, status);
694 current = res->fFirst;
696 while (current != NULL) {
700 itostr(c, index, 10, 0);
702 subId = getID(sid, c, subId);
704 res_write_xml(current, subId, language, FALSE, status);
708 if(U_FAILURE(*status)){
712 current = current->fNext;
717 write_utf8_file(out, UnicodeString(close_group));
723 intvector_write_xml(IntVectorResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
728 char buf[256] = {'0'};
730 sid = printContainer(res, group, intvector_restype, NULL, id, status);
732 for(i = 0; i < res->fCount; i += 1) {
736 ivd = getID(sid, c, ivd);
737 len = itostr(buf, res->fArray[i], 10, 0);
740 write_utf8_file(out, UnicodeString("<"));
741 write_utf8_file(out, UnicodeString(trans_unit));
743 printAttribute("id", ivd, (int32_t)uprv_strlen(ivd));
744 printAttribute("restype", integer_restype, (int32_t) strlen(integer_restype));
746 write_utf8_file(out, UnicodeString(">\n"));
750 write_utf8_file(out, UnicodeString(source));
752 write_utf8_file(out, UnicodeString(buf, len));
754 write_utf8_file(out, UnicodeString(close_source));
757 write_utf8_file(out, UnicodeString(close_trans_unit));
766 write_utf8_file(out, UnicodeString(close_group));
772 int_write_xml(IntResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
777 sid = printContainer(res, trans_unit, integer_restype, NULL, id, status);
781 write_utf8_file(out, UnicodeString(source));
783 len = itostr(buf, res->fValue, 10, 0);
784 write_utf8_file(out, UnicodeString(buf, len));
786 write_utf8_file(out, UnicodeString(close_source));
788 printNoteElements(&res->fComment, status);
793 write_utf8_file(out, UnicodeString(close_trans_unit));
800 bin_write_xml(BinaryResource *res, const char* id, const char* /*language*/, UErrorCode *status) {
801 const char* m_type = application_mimetype;
803 uint32_t crc = 0xFFFFFFFF;
805 char fileName[1024] ={0};
806 int32_t tLen = ( outDir == NULL) ? 0 :(int32_t)uprv_strlen(outDir);
807 char* fn = (char*) uprv_malloc(sizeof(char) * (tLen+1024 +
808 (res->fFileName !=NULL ?
809 uprv_strlen(res->fFileName) :0)));
810 const char* ext = NULL;
816 if(res->fFileName != NULL){
817 uprv_strcpy(fileName, res->fFileName);
818 f = uprv_strrchr(fileName, '\\');
826 ext = uprv_strrchr(fileName, '.');
829 fprintf(stderr, "Error: %s is an unknown binary filename type.\n", fileName);
830 exit(U_ILLEGAL_ARGUMENT_ERROR);
833 if(uprv_strcmp(ext, ".jpg")==0 || uprv_strcmp(ext, ".jpeg")==0 || uprv_strcmp(ext, ".gif")==0 ){
835 } else if(uprv_strcmp(ext, ".wav")==0 || uprv_strcmp(ext, ".au")==0 ){
837 } else if(uprv_strcmp(ext, ".avi")==0 || uprv_strcmp(ext, ".mpg")==0 || uprv_strcmp(ext, ".mpeg")==0){
839 } else if(uprv_strcmp(ext, ".txt")==0 || uprv_strcmp(ext, ".text")==0){
843 sid = printContainer(res, bin_unit, binary_restype, m_type, id, status);
847 write_utf8_file(out, UnicodeString(bin_source));
852 write_utf8_file(out, UnicodeString(external_file));
853 printAttribute("href", f, (int32_t)uprv_strlen(f));
854 write_utf8_file(out, UnicodeString("/>\n"));
858 write_utf8_file(out, UnicodeString(close_bin_source));
860 printNoteElements(&res->fComment, status);
863 write_utf8_file(out, UnicodeString(close_bin_unit));
865 char temp[256] = {0};
869 sid = printContainer(res, bin_unit, binary_restype, m_type, id, status);
872 write_utf8_file(out, UnicodeString(bin_source));
877 write_utf8_file(out, UnicodeString(internal_file));
878 printAttribute("form", application_mimetype, (int32_t) uprv_strlen(application_mimetype));
880 while(i <res->fLength){
881 len = itostr(temp, res->fData[i], 16, 2);
882 crc = computeCRC(temp, len, crc);
886 len = itostr(temp, crc, 10, 0);
887 printAttribute("crc", temp, len);
889 write_utf8_file(out, UnicodeString(">"));
892 while(i <res->fLength){
893 len = itostr(temp, res->fData[i], 16, 2);
894 write_utf8_file(out, UnicodeString(temp));
898 write_utf8_file(out, UnicodeString(close_internal_file));
903 write_utf8_file(out, UnicodeString(close_bin_source));
904 printNoteElements(&res->fComment, status);
908 write_utf8_file(out, UnicodeString(close_bin_unit));
920 table_write_xml(TableResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status) {
924 struct SResource *current = NULL;
927 if (U_FAILURE(*status)) {
931 sid = printContainer(res, group, table_restype, NULL, id, status);
937 current = res->fFirst;
940 while (current != NULL) {
941 res_write_xml(current, sid, language, FALSE, status);
943 if(U_FAILURE(*status)){
948 current = current->fNext;
954 write_utf8_file(out, UnicodeString(close_group));
961 res_write_xml(struct SResource *res, const char* id, const char* language, UBool isTopLevel, UErrorCode *status) {
963 if (U_FAILURE(*status)) {
968 switch (res->fType) {
970 string_write_xml (static_cast<StringResource *>(res), id, language, status);
974 alias_write_xml (static_cast<AliasResource *>(res), id, language, status);
977 case URES_INT_VECTOR:
978 intvector_write_xml (static_cast<IntVectorResource *>(res), id, language, status);
982 bin_write_xml (static_cast<BinaryResource *>(res), id, language, status);
986 int_write_xml (static_cast<IntResource *>(res), id, language, status);
990 array_write_xml (static_cast<ArrayResource *>(res), id, language, status);
994 table_write_xml (static_cast<TableResource *>(res), id, language, isTopLevel, status);
1002 *status = U_INTERNAL_PROGRAM_ERROR;
1006 bundle_write_xml(struct SRBRoot *bundle, const char *outputDir,const char* outputEnc, const char* filename,
1007 char *writtenFilename, int writtenFilenameLen,
1008 const char* language, const char* outFileName, UErrorCode *status) {
1010 char* xmlfileName = NULL;
1011 char* outputFileName = NULL;
1012 char* originalFileName = NULL;
1013 const char* fileStart = "<file xml:space = \"preserve\" source-language = \"";
1014 const char* file1 = "\" datatype = \"x-icu-resource-bundle\" ";
1015 const char* file2 = "original = \"";
1016 const char* file4 = "\" date = \"";
1017 const char* fileEnd = "</file>\n";
1018 const char* headerStart = "<header>\n";
1019 const char* headerEnd = "</header>\n";
1020 const char* bodyStart = "<body>\n";
1021 const char* bodyEnd = "</body>\n";
1023 const char *tool_start = "<tool";
1024 const char *tool_id = "genrb-" GENRB_VERSION "-icu-" U_ICU_VERSION;
1025 const char *tool_name = "genrb";
1029 const char* pos = NULL;
1030 int32_t first, index;
1038 pos = uprv_strrchr(filename, '\\');
1040 first = (int32_t)(pos - filename + 1);
1044 index = (int32_t)(uprv_strlen(filename) - uprv_strlen(textExt) - first);
1045 originalFileName = (char *)uprv_malloc(sizeof(char)*index+1);
1046 uprv_memset(originalFileName, 0, sizeof(char)*index+1);
1047 uprv_strncpy(originalFileName, filename + first, index);
1049 if(uprv_strcmp(originalFileName, srBundle->fLocale) != 0) {
1050 fprintf(stdout, "Warning: The file name is not same as the resource name!\n");
1053 temp = originalFileName;
1054 originalFileName = (char *)uprv_malloc(sizeof(char)* (uprv_strlen(temp)+uprv_strlen(textExt)) + 1);
1055 uprv_memset(originalFileName, 0, sizeof(char)* (uprv_strlen(temp)+uprv_strlen(textExt)) + 1);
1056 uprv_strcat(originalFileName, temp);
1057 uprv_strcat(originalFileName, textExt);
1062 if (language == NULL) {
1063 /* lang = parseFilename(filename, lang);
1064 if (lang == NULL) {*/
1065 /* now check if locale name is valid or not
1066 * this is to cater for situation where
1067 * pegasusServer.txt contains
1073 lang = parseFilename(srBundle->fLocale, lang);
1075 * Neither the file name nor the table name inside the
1076 * txt file contain a valid country and language codes
1078 * pegasusServer.txt contains
1085 fprintf(stderr, "Error: The file name and table name do not contain a valid language code. Please use -l option to specify it.\n");
1086 exit(U_ILLEGAL_ARGUMENT_ERROR);
1090 lang = (char *)uprv_malloc(sizeof(char)*uprv_strlen(language) +1);
1091 uprv_memset(lang, 0, sizeof(char)*uprv_strlen(language) +1);
1092 uprv_strcpy(lang, language);
1096 outputFileName = (char *)uprv_malloc(sizeof(char)*uprv_strlen(outFileName) + 1);
1097 uprv_memset(outputFileName, 0, sizeof(char)*uprv_strlen(outFileName) + 1);
1098 uprv_strcpy(outputFileName,outFileName);
1100 outputFileName = (char *)uprv_malloc(sizeof(char)*uprv_strlen(srBundle->fLocale) + 1);
1101 uprv_memset(outputFileName, 0, sizeof(char)*uprv_strlen(srBundle->fLocale) + 1);
1102 uprv_strcpy(outputFileName,srBundle->fLocale);
1106 xmlfileName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(outputDir) + uprv_strlen(outputFileName) + uprv_strlen(xliffExt) + 1) +1);
1107 uprv_memset(xmlfileName, 0, sizeof(char)*(uprv_strlen(outputDir)+ uprv_strlen(outputFileName) + uprv_strlen(xliffExt) + 1) +1);
1109 xmlfileName = (char *)uprv_malloc(sizeof(char)*(uprv_strlen(outputFileName) + uprv_strlen(xliffExt)) +1);
1110 uprv_memset(xmlfileName, 0, sizeof(char)*(uprv_strlen(outputFileName) + uprv_strlen(xliffExt)) +1);
1114 uprv_strcpy(xmlfileName, outputDir);
1115 if(outputDir[uprv_strlen(outputDir)-1] !=U_FILE_SEP_CHAR){
1116 uprv_strcat(xmlfileName,U_FILE_SEP_STRING);
1119 uprv_strcat(xmlfileName,outputFileName);
1120 uprv_strcat(xmlfileName,xliffExt);
1122 if (writtenFilename) {
1123 uprv_strncpy(writtenFilename, xmlfileName, writtenFilenameLen);
1126 if (U_FAILURE(*status)) {
1127 goto cleanup_bundle_write_xml;
1130 out= T_FileStream_open(xmlfileName,"w");
1133 *status = U_FILE_ACCESS_ERROR;
1134 goto cleanup_bundle_write_xml;
1136 write_utf8_file(out, UnicodeString(xmlHeader));
1138 if(outputEnc && *outputEnc!='\0'){
1139 /* store the output encoding */
1141 conv=ucnv_open(enc,status);
1142 if(U_FAILURE(*status)){
1143 goto cleanup_bundle_write_xml;
1146 write_utf8_file(out, UnicodeString(bundleStart));
1148 write_utf8_file(out, UnicodeString(fileStart));
1149 /* check if lang and language are the same */
1150 if(language != NULL && uprv_strcmp(lang, srBundle->fLocale)!=0){
1151 fprintf(stderr,"Warning: The top level tag in the resource and language specified are not the same. Please check the input.\n");
1153 write_utf8_file(out, UnicodeString(lang));
1154 write_utf8_file(out, UnicodeString(file1));
1155 write_utf8_file(out, UnicodeString(file2));
1156 write_utf8_file(out, UnicodeString(originalFileName));
1157 write_utf8_file(out, UnicodeString(file4));
1160 strftime(timeBuf, sizeof(timeBuf), "%Y-%m-%dT%H:%M:%SZ", gmtime(&currTime));
1161 write_utf8_file(out, UnicodeString(timeBuf));
1162 write_utf8_file(out, UnicodeString("\">\n"));
1166 write_utf8_file(out, UnicodeString(headerStart));
1171 write_utf8_file(out, UnicodeString(tool_start));
1172 printAttribute("tool-id", tool_id, (int32_t) uprv_strlen(tool_id));
1173 printAttribute("tool-name", tool_name, (int32_t) uprv_strlen(tool_name));
1174 write_utf8_file(out, UnicodeString("/>\n"));
1179 write_utf8_file(out, UnicodeString(headerEnd));
1184 write_utf8_file(out, UnicodeString(bodyStart));
1187 res_write_xml(bundle->fRoot, bundle->fLocale, lang, TRUE, status);
1192 write_utf8_file(out, UnicodeString(bodyEnd));
1195 write_utf8_file(out, UnicodeString(fileEnd));
1198 write_utf8_file(out, UnicodeString(bundleEnd));
1199 T_FileStream_close(out);
1203 cleanup_bundle_write_xml:
1204 uprv_free(originalFileName);
1206 if(xmlfileName != NULL) {
1207 uprv_free(xmlfileName);
1209 if(outputFileName != NULL){
1210 uprv_free(outputFileName);