| /* | |
| ******************************************************************************* | |
| * | |
| * Copyright (C) 1999-2007, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ******************************************************************************* | |
| * file name: uresb.c | |
| * encoding: US-ASCII | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2000sep6 | |
| * created by: Vladimir Weinstein | |
| */ | |
| /****************************************************************************** | |
| * This program prints out resource bundles - example for | |
| * ICU workshop | |
| * TODO: make a complete i18n layout for this program. | |
| ******************************************************************************/ | |
| #include "unicode/putil.h" | |
| #include "unicode/ures.h" | |
| #include "unicode/ustdio.h" | |
| #include "unicode/uloc.h" | |
| #include "unicode/ustring.h" | |
| #include "uoptions.h" | |
| #include "toolutil.h" | |
| #include <string.h> | |
| #include <stdlib.h> | |
| #ifdef WIN32 | |
| #include <direct.h> | |
| #else | |
| #include <unistd.h> | |
| #endif | |
| #define URESB_DEFAULTTRUNC 40 | |
| static char *currdir = NULL; | |
| /*--locale sr_YU and --encoding cp855 | |
| * are interesting on Win32 | |
| */ | |
| static const char *locale = NULL; | |
| static const char *encoding = NULL; | |
| static const char *resPath = NULL; | |
| static const int32_t indentsize = 4; | |
| static UFILE *outerr = NULL; | |
| static int32_t truncsize = URESB_DEFAULTTRUNC; | |
| static UBool trunc = FALSE; | |
| const UChar baderror[] = { 0x0042, 0x0041, 0x0044, 0x0000 }; | |
| const UChar *getErrorName(UErrorCode errorNumber); | |
| void reportError(UErrorCode *status); | |
| static UChar *quotedString(const UChar *string); | |
| void printOutBundle(UFILE *out, UResourceBundle *resource, int32_t indent, UErrorCode *status); | |
| void printIndent(UFILE *out, int32_t indent); | |
| void printHex(UFILE *out, const int8_t *what); | |
| static UOption options[]={ | |
| UOPTION_HELP_H, | |
| UOPTION_HELP_QUESTION_MARK, | |
| { "locale", NULL, NULL, NULL, 'l', UOPT_REQUIRES_ARG, 0 }, | |
| UOPTION_ENCODING, | |
| { "path", NULL, NULL, NULL, 'p', UOPT_OPTIONAL_ARG, 0 }, | |
| { "truncate", NULL, NULL, NULL, 't', UOPT_OPTIONAL_ARG, 0 }, | |
| UOPTION_VERBOSE | |
| }; | |
| static UBool VERBOSE = FALSE; | |
| extern int | |
| main(int argc, char* argv[]) { | |
| UResourceBundle *bundle = NULL; | |
| UErrorCode status = U_ZERO_ERROR; | |
| UFILE *out = NULL; | |
| int32_t i = 0; | |
| const char* arg; | |
| char resPathBuffer[1024]; | |
| #ifdef WIN32 | |
| currdir = _getcwd(NULL, 0); | |
| #else | |
| currdir = getcwd(NULL, 0); | |
| #endif | |
| argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options); | |
| /* error handling, printing usage message */ | |
| if(argc<0) { | |
| fprintf(stderr, | |
| "error in command line argument \"%s\"\n", | |
| argv[-argc]); | |
| } | |
| if(argc<2 || options[0].doesOccur || options[1].doesOccur) { | |
| fprintf(stderr, | |
| "usage: %s [-options] locale(s)\n", | |
| argv[0]); | |
| return argc<0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR; | |
| } | |
| if(options[2].doesOccur) { | |
| locale = options[2].value; | |
| } else { | |
| locale = 0; | |
| } | |
| if(options[3].doesOccur) { | |
| encoding = options[3].value; | |
| } else { | |
| encoding = NULL; | |
| } | |
| if(options[4].doesOccur) { | |
| if(options[4].value != NULL) { | |
| resPath = options[4].value; /* we'll use users resources */ | |
| } else { | |
| resPath = NULL; /* we'll use ICU system resources for dumping */ | |
| } | |
| } else { | |
| strcpy(resPathBuffer, currdir); | |
| /*strcat(resPathBuffer, U_FILE_SEP_STRING); | |
| strcat(resPathBuffer, "uresb");*/ | |
| resPath = resPathBuffer; /* we'll just dump uresb samples resources */ | |
| } | |
| if(options[5].doesOccur) { | |
| trunc = TRUE; | |
| if(options[5].value != NULL) { | |
| truncsize = atoi(options[5].value); /* user defined printable size */ | |
| } else { | |
| truncsize = URESB_DEFAULTTRUNC; /* we'll use default omitting size */ | |
| } | |
| } else { | |
| trunc = FALSE; | |
| } | |
| if(options[6].doesOccur) { | |
| VERBOSE = TRUE; | |
| } | |
| outerr = u_finit(stderr, locale, encoding); | |
| out = u_finit(stdout, locale, encoding); | |
| for(i = 1; i < argc; ++i) { | |
| status = U_ZERO_ERROR; | |
| arg = getLongPathname(argv[i]); | |
| u_fprintf(out, "uresb: processing file \"%s\" in path \"%s\"\n", arg, resPath); | |
| bundle = ures_open(resPath, arg, &status); | |
| if(U_SUCCESS(status)) { | |
| u_fprintf(out, "%s\n", arg); | |
| printOutBundle(out, bundle, 0, &status); | |
| } else { | |
| reportError(&status); | |
| } | |
| ures_close(bundle); | |
| } | |
| u_fclose(out); | |
| u_fclose(outerr); | |
| return 0; | |
| } | |
| void printIndent(UFILE *out, int32_t indent) { | |
| char inchar[256]; | |
| int32_t i = 0; | |
| for(i = 0; i<indent; i++) { | |
| inchar[i] = ' '; | |
| } | |
| inchar[indent] = '\0'; | |
| u_fprintf(out, "%s", inchar); | |
| } | |
| void printHex(UFILE *out, const int8_t *what) { | |
| u_fprintf(out, "%02X", (uint8_t)*what); | |
| } | |
| static UChar *quotedString(const UChar *string) { | |
| int len = u_strlen(string); | |
| int alen = len; | |
| const UChar *sp; | |
| UChar *newstr, *np; | |
| for (sp = string; *sp; ++sp) { | |
| switch (*sp) { | |
| case '\n': | |
| case 0x0022: | |
| ++alen; | |
| break; | |
| } | |
| } | |
| newstr = (UChar *) malloc((1 + alen) * sizeof(*newstr)); | |
| for (sp = string, np = newstr; *sp; ++sp) { | |
| switch (*sp) { | |
| case '\n': | |
| *np++ = 0x005C; | |
| *np++ = 0x006E; | |
| break; | |
| case 0x0022: | |
| *np++ = 0x005C; | |
| default: | |
| *np++ = *sp; | |
| break; | |
| } | |
| } | |
| *np = 0; | |
| return newstr; | |
| } | |
| void printOutBundle(UFILE *out, UResourceBundle *resource, int32_t indent, UErrorCode *status) { | |
| int32_t i = 0; | |
| const char *key = ures_getKey(resource); | |
| switch(ures_getType(resource)) { | |
| case URES_STRING : | |
| { | |
| int32_t len=0; | |
| const UChar*thestr = ures_getString(resource, &len, status); | |
| UChar *string = quotedString(thestr); | |
| /* TODO: String truncation */ | |
| /* | |
| if(trunc && len > truncsize) { | |
| printIndent(out, indent); | |
| u_fprintf(out, "// WARNING: this string, size %d is truncated to %d\n", len, truncsize/2); | |
| len = truncsize/2; | |
| } | |
| */ | |
| printIndent(out, indent); | |
| if(key != NULL) { | |
| u_fprintf(out, "%s { \"%S\" } ", key, string); | |
| } else { | |
| u_fprintf(out, "\"%S\",", string); | |
| } | |
| if(VERBOSE) { | |
| u_fprintf(out, " // STRING"); | |
| } | |
| u_fprintf(out, "\n"); | |
| free(string); | |
| } | |
| break; | |
| case URES_INT : | |
| printIndent(out, indent); | |
| if(key != NULL) { | |
| u_fprintf(out, "%s", key); | |
| } | |
| u_fprintf(out, ":int { %li } ", ures_getInt(resource, status)); | |
| if(VERBOSE) { | |
| u_fprintf(out, " // INT"); | |
| } | |
| u_fprintf(out, "\n"); | |
| break; | |
| case URES_BINARY : | |
| { | |
| int32_t len = 0; | |
| const int8_t *data = (const int8_t *)ures_getBinary(resource, &len, status); | |
| if(trunc && len > truncsize) { | |
| printIndent(out, indent); | |
| u_fprintf(out, "// WARNING: this resource, size %li is truncated to %li\n", len, truncsize/2); | |
| len = truncsize/2; | |
| } | |
| if(U_SUCCESS(*status)) { | |
| printIndent(out, indent); | |
| if(key != NULL) { | |
| u_fprintf(out, "%s", key); | |
| } | |
| u_fprintf(out, ":binary { "); | |
| for(i = 0; i<len; i++) { | |
| printHex(out, data++); | |
| } | |
| u_fprintf(out, " }"); | |
| if(VERBOSE) { | |
| u_fprintf(out, " // BINARY"); | |
| } | |
| u_fprintf(out, "\n"); | |
| } else { | |
| reportError(status); | |
| } | |
| } | |
| break; | |
| case URES_INT_VECTOR : | |
| { | |
| int32_t len = 0; | |
| const int32_t *data = ures_getIntVector(resource, &len, status); | |
| if(U_SUCCESS(*status)) { | |
| printIndent(out, indent); | |
| if(key != NULL) { | |
| u_fprintf(out, "%s", key); | |
| } | |
| u_fprintf(out, ":intvector { "); | |
| for(i = 0; i<len-1; i++) { | |
| u_fprintf(out, "%d, ", data[i]); | |
| } | |
| if(len > 0) { | |
| u_fprintf(out, "%d ", data[len-1]); | |
| } | |
| u_fprintf(out, "}"); | |
| if(VERBOSE) { | |
| u_fprintf(out, " // INTVECTOR"); | |
| } | |
| u_fprintf(out, "\n"); | |
| } else { | |
| reportError(status); | |
| } | |
| } | |
| break; | |
| case URES_TABLE : | |
| case URES_ARRAY : | |
| { | |
| UResourceBundle *t = NULL; | |
| ures_resetIterator(resource); | |
| printIndent(out, indent); | |
| if(key != NULL) { | |
| u_fprintf(out, "%s ", key); | |
| } | |
| u_fprintf(out, "{"); | |
| if(VERBOSE) { | |
| if(ures_getType(resource) == URES_TABLE) { | |
| u_fprintf(out, " // TABLE"); | |
| } else { | |
| u_fprintf(out, " // ARRAY"); | |
| } | |
| } | |
| u_fprintf(out, "\n"); | |
| while(ures_hasNext(resource)) { | |
| t = ures_getNextResource(resource, t, status); | |
| printOutBundle(out, t, indent+indentsize, status); | |
| } | |
| printIndent(out, indent); | |
| u_fprintf(out, "}\n"); | |
| ures_close(t); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| void reportError(UErrorCode *status) { | |
| u_fprintf(outerr, "Error %d(%s) : %U happened!\n", *status, u_errorName(*status), getErrorName(*status)); | |
| } | |
| const UChar *getErrorName(UErrorCode errorNumber) { | |
| UErrorCode status = U_ZERO_ERROR; | |
| int32_t len = 0; | |
| UResourceBundle *error = ures_open(currdir, locale, &status); | |
| UResourceBundle *errorcodes = ures_getByKey(error, "errorcodes", NULL, &status); | |
| const UChar *result = ures_getStringByIndex(errorcodes, errorNumber, &len, &status); | |
| ures_close(errorcodes); | |
| ures_close(error); | |
| if(U_SUCCESS(status)) { | |
| return result; | |
| } else { | |
| return baderror; | |
| } | |
| } |