782 lines
26 KiB
C
782 lines
26 KiB
C
/*
|
|
*******************************************************************************
|
|
*
|
|
* Copyright (C) 1999-2006, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
*******************************************************************************
|
|
* file name: derb.c
|
|
* encoding: US-ASCII
|
|
* tab size: 8 (not used)
|
|
* indentation:4
|
|
*
|
|
* created on: 2000sep6
|
|
* created by: Vladimir Weinstein as an ICU workshop example
|
|
* maintained by: Yves Arrouye <yves@realnames.com>
|
|
*/
|
|
|
|
#include "unicode/ucnv.h"
|
|
#include "unicode/ustring.h"
|
|
#include "unicode/putil.h"
|
|
|
|
#include "uresimp.h"
|
|
#include "cmemory.h"
|
|
#include "cstring.h"
|
|
#include "uoptions.h"
|
|
#include "toolutil.h"
|
|
#include "ustrfmt.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
#if defined(U_WINDOWS) || defined(U_CYGWIN)
|
|
#include <io.h>
|
|
#include <fcntl.h>
|
|
#define USE_FILENO_BINARY_MODE 1
|
|
/* Windows likes to rename Unix-like functions */
|
|
#ifndef fileno
|
|
#define fileno _fileno
|
|
#endif
|
|
#ifndef setmode
|
|
#define setmode _setmode
|
|
#endif
|
|
#ifndef O_BINARY
|
|
#define O_BINARY _O_BINARY
|
|
#endif
|
|
#endif
|
|
|
|
#define DERB_VERSION "1.0"
|
|
|
|
#define DERB_DEFAULT_TRUNC 80
|
|
|
|
static UConverter *defaultConverter = 0;
|
|
|
|
static const int32_t indentsize = 4;
|
|
static int32_t truncsize = DERB_DEFAULT_TRUNC;
|
|
static UBool trunc = FALSE;
|
|
|
|
static const char *getEncodingName(const char *encoding);
|
|
static void reportError(const char *pname, UErrorCode *status, const char *when);
|
|
static UChar *quotedString(const UChar *string);
|
|
static void printOutBundle(FILE *out, UConverter *converter, UResourceBundle *resource, int32_t indent, const char *pname, UErrorCode *status);
|
|
static void printString(FILE *out, UConverter *converter, const UChar *str, int32_t len);
|
|
static void printCString(FILE *out, UConverter *converter, const char *str, int32_t len);
|
|
static void printIndent(FILE *out, UConverter *converter, int32_t indent);
|
|
static void printHex(FILE *out, UConverter *converter, uint8_t what);
|
|
|
|
static UOption options[]={
|
|
UOPTION_HELP_H,
|
|
UOPTION_HELP_QUESTION_MARK,
|
|
/* 2 */ UOPTION_ENCODING,
|
|
/* 3 */ { "to-stdout", NULL, NULL, NULL, 'c', UOPT_NO_ARG, 0 } ,
|
|
/* 4 */ { "truncate", NULL, NULL, NULL, 't', UOPT_OPTIONAL_ARG, 0 },
|
|
/* 5 */ UOPTION_VERBOSE,
|
|
/* 6 */ UOPTION_DESTDIR,
|
|
/* 7 */ UOPTION_SOURCEDIR,
|
|
/* 8 */ { "bom", NULL, NULL, NULL, 0, UOPT_NO_ARG, 0 },
|
|
/* 9 */ UOPTION_ICUDATADIR,
|
|
/* 10 */ UOPTION_VERSION,
|
|
/* 11 */ { "suppressAliases", NULL, NULL, NULL, 'A', UOPT_NO_ARG, 0 }
|
|
};
|
|
|
|
static UBool verbose = FALSE;
|
|
static UBool suppressAliases = FALSE;
|
|
|
|
extern int
|
|
main(int argc, char* argv[]) {
|
|
const char *encoding = NULL;
|
|
const char *outputDir = NULL; /* NULL = no output directory, use current */
|
|
const char *inputDir = ".";
|
|
int tostdout = 0;
|
|
int prbom = 0;
|
|
|
|
const char *pname;
|
|
|
|
UResourceBundle *bundle = NULL;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
int32_t i = 0;
|
|
|
|
UConverter *converter;
|
|
|
|
const char* arg;
|
|
|
|
/* Get the name of tool. */
|
|
pname = uprv_strrchr(*argv, U_FILE_SEP_CHAR);
|
|
#if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
|
|
if (!pname) {
|
|
pname = uprv_strrchr(*argv, U_FILE_ALT_SEP_CHAR);
|
|
}
|
|
#endif
|
|
if (!pname) {
|
|
pname = *argv;
|
|
} else {
|
|
++pname;
|
|
}
|
|
|
|
/* error handling, printing usage message */
|
|
argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);
|
|
|
|
/* error handling, printing usage message */
|
|
if(argc<0) {
|
|
fprintf(stderr,
|
|
"%s: error in command line argument \"%s\"\n", pname,
|
|
argv[-argc]);
|
|
}
|
|
if(argc<0 || options[0].doesOccur || options[1].doesOccur) {
|
|
fprintf(argc < 0 ? stderr : stdout,
|
|
"%csage: %s [ -h, -?, --help ] [ -V, --version ]\n"
|
|
" [ -v, --verbose ] [ -e, --encoding encoding ] [ --bom ]\n"
|
|
" [ -t, --truncate [ size ] ]\n"
|
|
" [ -s, --sourcedir source ] [ -d, --destdir destination ]\n"
|
|
" [ -i, --icudatadir directory ] [ -c, --to-stdout ]\n"
|
|
" [ -A, --suppressAliases]\n"
|
|
" bundle ...\n", argc < 0 ? 'u' : 'U',
|
|
pname);
|
|
return argc<0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
|
|
}
|
|
|
|
if(options[10].doesOccur) {
|
|
fprintf(stderr,
|
|
"%s version %s (ICU version %s).\n"
|
|
"%s\n",
|
|
pname, DERB_VERSION, U_ICU_VERSION, U_COPYRIGHT_STRING);
|
|
return U_ZERO_ERROR;
|
|
}
|
|
if(options[2].doesOccur) {
|
|
encoding = options[2].value;
|
|
}
|
|
|
|
if (options[3].doesOccur) {
|
|
tostdout = 1;
|
|
}
|
|
|
|
if(options[4].doesOccur) {
|
|
trunc = TRUE;
|
|
if(options[4].value != NULL) {
|
|
truncsize = atoi(options[4].value); /* user defined printable size */
|
|
} else {
|
|
truncsize = DERB_DEFAULT_TRUNC; /* we'll use default omitting size */
|
|
}
|
|
} else {
|
|
trunc = FALSE;
|
|
}
|
|
|
|
if(options[5].doesOccur) {
|
|
verbose = TRUE;
|
|
}
|
|
|
|
if (options[6].doesOccur) {
|
|
outputDir = options[6].value;
|
|
}
|
|
|
|
if(options[7].doesOccur) {
|
|
inputDir = options[7].value; /* we'll use users resources */
|
|
}
|
|
|
|
if (options[8].doesOccur) {
|
|
prbom = 1;
|
|
}
|
|
|
|
if (options[9].doesOccur) {
|
|
u_setDataDirectory(options[9].value);
|
|
}
|
|
|
|
if (options[11].doesOccur) {
|
|
suppressAliases = TRUE;
|
|
}
|
|
|
|
converter = ucnv_open(encoding, &status);
|
|
if (U_FAILURE(status)) {
|
|
fprintf(stderr, "%s: couldn't create %s converter for encoding\n", pname, encoding ? encoding : ucnv_getDefaultName());
|
|
return 2;
|
|
}
|
|
ucnv_setFromUCallBack(converter, UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_C, 0, 0, &status);
|
|
if (U_FAILURE(status)) {
|
|
fprintf(stderr, "%s: couldn't configure converter for encoding\n", pname);
|
|
return 3;
|
|
}
|
|
|
|
defaultConverter = ucnv_open(0, &status);
|
|
if (U_FAILURE(status)) {
|
|
fprintf(stderr, "%s: couldn't create %s converter for encoding\n", ucnv_getDefaultName(), pname);
|
|
return 2;
|
|
}
|
|
|
|
for (i = 1; i < argc; ++i) {
|
|
static const UChar sp[] = { 0x0020 }; /* " " */
|
|
char infile[4096]; /* XXX Sloppy. */
|
|
char locale[64];
|
|
const char *thename = 0, *p, *q;
|
|
UBool fromICUData = FALSE;
|
|
|
|
arg = getLongPathname(argv[i]);
|
|
|
|
if (verbose) {
|
|
printf("processing bundle \"%s\"\n", argv[i]);
|
|
}
|
|
|
|
p = uprv_strrchr(arg, U_FILE_SEP_CHAR);
|
|
#if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
|
|
if (p == NULL) {
|
|
p = uprv_strrchr(arg, U_FILE_ALT_SEP_CHAR);
|
|
}
|
|
#endif
|
|
if (!p) {
|
|
p = arg;
|
|
} else {
|
|
p++;
|
|
}
|
|
q = uprv_strrchr(p, '.');
|
|
if (!q) {
|
|
for (q = p; *q; ++q)
|
|
;
|
|
}
|
|
uprv_strncpy(locale, p, q - p);
|
|
locale[q - p] = 0;
|
|
|
|
if (!(fromICUData = !uprv_strcmp(inputDir, "-"))) {
|
|
UBool absfilename = *arg == U_FILE_SEP_CHAR;
|
|
#ifdef U_WINDOWS
|
|
if (!absfilename) {
|
|
absfilename = (uprv_strlen(arg) > 2 && isalpha(arg[0])
|
|
&& arg[1] == ':' && arg[2] == U_FILE_SEP_CHAR);
|
|
}
|
|
#endif
|
|
if (absfilename) {
|
|
thename = arg;
|
|
} else {
|
|
q = uprv_strrchr(arg, U_FILE_SEP_CHAR);
|
|
#if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
|
|
if (q == NULL) {
|
|
q = uprv_strrchr(arg, U_FILE_ALT_SEP_CHAR);
|
|
}
|
|
#endif
|
|
uprv_strcpy(infile, inputDir);
|
|
if(q != NULL) {
|
|
uprv_strcat(infile, U_FILE_SEP_STRING);
|
|
strncat(infile, arg, q-arg);
|
|
}
|
|
thename = infile;
|
|
}
|
|
}
|
|
status = U_ZERO_ERROR;
|
|
if (thename) {
|
|
bundle = ures_openDirect(thename, locale, &status);
|
|
} else {
|
|
bundle = ures_open(fromICUData ? 0 : inputDir, locale, &status);
|
|
}
|
|
if (status == U_ZERO_ERROR) {
|
|
FILE *out;
|
|
|
|
const char *filename = 0;
|
|
const char *ext = 0;
|
|
|
|
if (!locale || !tostdout) {
|
|
filename = uprv_strrchr(arg, U_FILE_SEP_CHAR);
|
|
|
|
#if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
|
|
if (!filename) {
|
|
filename = uprv_strrchr(arg, U_FILE_ALT_SEP_CHAR);
|
|
}
|
|
#endif
|
|
if (!filename) {
|
|
filename = arg;
|
|
} else {
|
|
++filename;
|
|
}
|
|
ext = uprv_strrchr(arg, '.');
|
|
if (!ext) {
|
|
ext = filename + uprv_strlen(filename);
|
|
}
|
|
}
|
|
|
|
if (tostdout) {
|
|
out = stdout;
|
|
#if defined(U_WINDOWS) || defined(U_CYGWIN)
|
|
if (setmode(fileno(out), O_BINARY) == -1) {
|
|
fprintf(stderr, "%s: couldn't set standard output to binary mode\n", pname);
|
|
return 4;
|
|
}
|
|
#endif
|
|
} else {
|
|
char thefile[4096], *tp;
|
|
int32_t len;
|
|
|
|
if (outputDir) {
|
|
uprv_strcpy(thefile, outputDir);
|
|
uprv_strcat(thefile, U_FILE_SEP_STRING);
|
|
} else {
|
|
*thefile = 0;
|
|
}
|
|
uprv_strcat(thefile, filename);
|
|
tp = thefile + uprv_strlen(thefile);
|
|
len = (int32_t)uprv_strlen(ext);
|
|
if (len) {
|
|
tp -= len - 1;
|
|
} else {
|
|
*tp++ = '.';
|
|
}
|
|
uprv_strcpy(tp, "txt");
|
|
|
|
out = fopen(thefile, "w");
|
|
if (!out) {
|
|
fprintf(stderr, "%s: couldn't create %s\n", pname, thefile);
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
if (prbom) { /* XXX: Should be done only for UTFs */
|
|
static const UChar bom[] = { 0xFEFF };
|
|
printString(out, converter, bom, (int32_t)(sizeof(bom)/sizeof(*bom)));
|
|
}
|
|
|
|
printCString(out, converter, "// -*- Coding: ", -1);
|
|
printCString(out, converter, encoding ? encoding : getEncodingName(ucnv_getDefaultName()), -1);
|
|
printCString(out, converter, "; -*-\n//\n", -1);
|
|
printCString(out, converter, "// This file was dumped by derb(8) from ", -1);
|
|
if (thename) {
|
|
printCString(out, converter, thename, -1);
|
|
} else if (fromICUData) {
|
|
printCString(out, converter, "the ICU internal ", -1);
|
|
printCString(out, converter, locale, -1);
|
|
printCString(out, converter, " locale", -1);
|
|
}
|
|
|
|
printCString(out, converter, "\n// derb(8) by Vladimir Weinstein and Yves Arrouye\n\n", -1);
|
|
|
|
if (locale) {
|
|
printCString(out, converter, locale, -1);
|
|
} else {
|
|
printCString(out, converter, filename, (int32_t)(ext - filename));
|
|
printString(out, converter, sp, (int32_t)(sizeof(sp)/sizeof(*sp)));
|
|
}
|
|
printOutBundle(out, converter, bundle, 0, pname, &status);
|
|
|
|
if (out != stdout) {
|
|
fclose(out);
|
|
}
|
|
}
|
|
else {
|
|
reportError(pname, &status, "opening resource file");
|
|
}
|
|
|
|
ures_close(bundle);
|
|
}
|
|
|
|
ucnv_close(defaultConverter);
|
|
ucnv_close(converter);
|
|
|
|
return 0;
|
|
}
|
|
|
|
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 *) uprv_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;
|
|
}
|
|
|
|
|
|
static void printString(FILE *out, UConverter *converter, const UChar *str, int32_t len) {
|
|
char buf[256];
|
|
const UChar *strEnd;
|
|
|
|
if (len < 0) {
|
|
len = u_strlen(str);
|
|
}
|
|
strEnd = str + len;
|
|
|
|
do {
|
|
UErrorCode err = U_ZERO_ERROR;
|
|
char *bufp = buf, *bufend = buf + sizeof(buf) - 1 ;
|
|
|
|
ucnv_fromUnicode(converter, &bufp, bufend, &str, strEnd, 0, 0, &err);
|
|
*bufp = 0;
|
|
|
|
fprintf(out, "%s", buf);
|
|
} while (str < strEnd);
|
|
}
|
|
|
|
static void printCString(FILE *out, UConverter *converter, const char *str, int32_t len) {
|
|
UChar buf[256];
|
|
const char *strEnd;
|
|
|
|
if (len < 0) {
|
|
len = (int32_t)uprv_strlen(str);
|
|
}
|
|
strEnd = str + len;
|
|
|
|
do {
|
|
UErrorCode err = U_ZERO_ERROR;
|
|
UChar *bufp = buf, *bufend = buf + (sizeof(buf)/sizeof(buf[0])) - 1 ;
|
|
|
|
ucnv_toUnicode(defaultConverter, &bufp, bufend, &str, strEnd, 0, 0, &err);
|
|
*bufp = 0;
|
|
|
|
printString(out, converter, buf, (int32_t)(bufp - buf));
|
|
} while (str < strEnd);
|
|
}
|
|
|
|
static void printIndent(FILE *out, UConverter *converter, int32_t indent) {
|
|
UChar inchar[256];
|
|
int32_t i = 0;
|
|
for(i = 0; i<indent; i++) {
|
|
inchar[i] = 0x0020;
|
|
}
|
|
inchar[indent] = 0;
|
|
|
|
printString(out, converter, inchar, indent);
|
|
}
|
|
|
|
static void printHex(FILE *out, UConverter *converter, uint8_t what) {
|
|
static const char map[] = "0123456789ABCDEF";
|
|
UChar hex[2];
|
|
|
|
hex[0] = map[what >> 4];
|
|
hex[1] = map[what & 0xf];
|
|
|
|
printString(out, converter, hex, (int32_t)(sizeof(hex)/sizeof(*hex)));
|
|
}
|
|
static const UChar *
|
|
derb_getString(const ResourceData *pResData, const Resource res, int32_t *pLength) {
|
|
if(res!=RES_BOGUS) {
|
|
int32_t *p=(int32_t *)RES_GET_POINTER(pResData->pRoot, res);
|
|
if (pLength) {
|
|
*pLength=*p;
|
|
}
|
|
return (UChar *)++p;
|
|
} else {
|
|
if (pLength) {
|
|
*pLength=0;
|
|
}
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static const char *
|
|
derb_getTableKey(const Resource *pRoot, const Resource res, uint16_t indexS) {
|
|
uint16_t *p=(uint16_t *)RES_GET_POINTER(pRoot, res);
|
|
if(indexS<*p) {
|
|
return ((const char *)(pRoot)+(p[indexS+1])); /*RES_GET_KEY(pRoot, p[indexS+1]);*/
|
|
} else {
|
|
return NULL; /* indexS>itemCount */
|
|
}
|
|
}
|
|
|
|
static Resource
|
|
derb_getArrayItem(Resource *pRoot, Resource res, int32_t indexR) {
|
|
int32_t *p=(int32_t *)RES_GET_POINTER(pRoot, res);
|
|
if(indexR<*p) {
|
|
return ((Resource *)(p))[1+indexR];
|
|
} else {
|
|
return RES_BOGUS; /* indexR>itemCount */
|
|
}
|
|
}
|
|
|
|
static Resource
|
|
derb_getTableItem(const Resource *pRoot, const Resource res, uint16_t indexR) {
|
|
uint16_t *p=(uint16_t *)RES_GET_POINTER(pRoot, res);
|
|
uint16_t count=*p;
|
|
if(indexR<count) {
|
|
return ((Resource *)(p+1+count+(~count&1)))[indexR];
|
|
} else {
|
|
return RES_BOGUS; /* indexR>itemCount */
|
|
}
|
|
}
|
|
|
|
|
|
static void printOutAlias(FILE *out, UConverter *converter, UResourceBundle *parent, Resource r, const char *key, int32_t indent, const char *pname, UErrorCode *status) {
|
|
static const UChar cr[] = { '\n' };
|
|
int32_t len = 0;
|
|
const UChar* thestr = derb_getString(&(parent->fResData), r, &len);
|
|
UChar *string = quotedString(thestr);
|
|
if(trunc && len > truncsize) {
|
|
char msg[128];
|
|
printIndent(out, converter, indent);
|
|
sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
|
|
(long)len, (long)truncsize/2);
|
|
printCString(out, converter, msg, -1);
|
|
len = truncsize;
|
|
}
|
|
if(U_SUCCESS(*status)) {
|
|
static const UChar openStr[] = { 0x003A, 0x0061, 0x006C, 0x0069, 0x0061, 0x0073, 0x0020, 0x007B, 0x0020, 0x0022 }; /* ":alias { \"" */
|
|
static const UChar closeStr[] = { 0x0022, 0x0020, 0x007D, 0x0020 }; /* "\" } " */
|
|
printIndent(out, converter, indent);
|
|
if(key != NULL) {
|
|
printCString(out, converter, key, -1);
|
|
}
|
|
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
|
|
printString(out, converter, string, len);
|
|
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
|
|
if(verbose) {
|
|
printCString(out, converter, " // ALIAS", -1);
|
|
}
|
|
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
|
|
} else {
|
|
reportError(pname, status, "getting binary value");
|
|
}
|
|
}
|
|
|
|
static void printOutBundle(FILE *out, UConverter *converter, UResourceBundle *resource, int32_t indent, const char *pname, UErrorCode *status)
|
|
{
|
|
static const UChar cr[] = { '\n' };
|
|
|
|
/* int32_t noOfElements = ures_getSize(resource);*/
|
|
int32_t i = 0;
|
|
const char *key = ures_getKey(resource);
|
|
|
|
switch(ures_getType(resource)) {
|
|
case RES_STRING :
|
|
{
|
|
int32_t len=0;
|
|
const UChar* thestr = ures_getString(resource, &len, status);
|
|
UChar *string = quotedString(thestr);
|
|
|
|
/* TODO: String truncation */
|
|
if(trunc && len > truncsize) {
|
|
char msg[128];
|
|
printIndent(out, converter, indent);
|
|
sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
|
|
(long)len, (long)(truncsize/2));
|
|
printCString(out, converter, msg, -1);
|
|
len = truncsize/2;
|
|
}
|
|
printIndent(out, converter, indent);
|
|
if(key != NULL) {
|
|
static const UChar openStr[] = { 0x0020, 0x007B, 0x0020, 0x0022 }; /* " { \"" */
|
|
static const UChar closeStr[] = { 0x0022, 0x0020, 0x007D }; /* "\" }" */
|
|
printCString(out, converter, key, (int32_t)uprv_strlen(key));
|
|
printString(out, converter, openStr, (int32_t)(sizeof(openStr)/sizeof(*openStr)));
|
|
printString(out, converter, string, len);
|
|
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
|
|
} else {
|
|
static const UChar openStr[] = { 0x0022 }; /* "\"" */
|
|
static const UChar closeStr[] = { 0x0022, 0x002C }; /* "\"," */
|
|
|
|
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
|
|
printString(out, converter, string, (int32_t)(u_strlen(string)));
|
|
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
|
|
}
|
|
|
|
if(verbose) {
|
|
printCString(out, converter, "// STRING", -1);
|
|
}
|
|
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
|
|
|
|
uprv_free(string);
|
|
}
|
|
break;
|
|
|
|
case RES_INT :
|
|
{
|
|
static const UChar openStr[] = { 0x003A, 0x0069, 0x006E, 0x0074, 0x0020, 0x007B, 0x0020 }; /* ":int { " */
|
|
static const UChar closeStr[] = { 0x0020, 0x007D }; /* " }" */
|
|
UChar num[20];
|
|
|
|
printIndent(out, converter, indent);
|
|
if(key != NULL) {
|
|
printCString(out, converter, key, -1);
|
|
}
|
|
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
|
|
uprv_itou(num, 20, ures_getInt(resource, status), 10, 0);
|
|
printString(out, converter, num, u_strlen(num));
|
|
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
|
|
|
|
if(verbose) {
|
|
printCString(out, converter, "// INT", -1);
|
|
}
|
|
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
|
|
break;
|
|
}
|
|
case RES_BINARY :
|
|
{
|
|
int32_t len = 0;
|
|
const int8_t *data = (const int8_t *)ures_getBinary(resource, &len, status);
|
|
if(trunc && len > truncsize) {
|
|
char msg[128];
|
|
printIndent(out, converter, indent);
|
|
sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
|
|
(long)len, (long)(truncsize/2));
|
|
printCString(out, converter, msg, -1);
|
|
len = truncsize;
|
|
}
|
|
if(U_SUCCESS(*status)) {
|
|
static const UChar openStr[] = { 0x003A, 0x0062, 0x0069, 0x006E, 0x0061, 0x0072, 0x0079, 0x0020, 0x007B, 0x0020 }; /* ":binary { " */
|
|
static const UChar closeStr[] = { 0x0020, 0x007D, 0x0020 }; /* " } " */
|
|
printIndent(out, converter, indent);
|
|
if(key != NULL) {
|
|
printCString(out, converter, key, -1);
|
|
}
|
|
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
|
|
for(i = 0; i<len; i++) {
|
|
printHex(out, converter, *data++);
|
|
}
|
|
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
|
|
if(verbose) {
|
|
printCString(out, converter, " // BINARY", -1);
|
|
}
|
|
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
|
|
} else {
|
|
reportError(pname, status, "getting binary value");
|
|
}
|
|
}
|
|
break;
|
|
case RES_INT_VECTOR :
|
|
{
|
|
int32_t len = 0;
|
|
const int32_t *data = ures_getIntVector(resource, &len, status);
|
|
if(U_SUCCESS(*status)) {
|
|
static const UChar openStr[] = { 0x003A, 0x0069, 0x006E, 0x0074, 0x0076, 0x0065, 0x0063, 0x0074, 0x006F, 0x0072, 0x0020, 0x007B, 0x0020 }; /* ":intvector { " */
|
|
static const UChar closeStr[] = { 0x0020, 0x007D, 0x0020 }; /* " } " */
|
|
UChar num[20];
|
|
|
|
printIndent(out, converter, indent);
|
|
if(key != NULL) {
|
|
printCString(out, converter, key, -1);
|
|
}
|
|
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
|
|
for(i = 0; i < len - 1; i++) {
|
|
int32_t numLen = uprv_itou(num, 20, data[i], 10, 0);
|
|
num[numLen++] = 0x002C; /* ',' */
|
|
num[numLen++] = 0x0020; /* ' ' */
|
|
num[numLen] = 0;
|
|
printString(out, converter, num, u_strlen(num));
|
|
}
|
|
if(len > 0) {
|
|
uprv_itou(num, 20, data[len - 1], 10, 0);
|
|
printString(out, converter, num, u_strlen(num));
|
|
}
|
|
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
|
|
if(verbose) {
|
|
printCString(out, converter, "// INTVECTOR", -1);
|
|
}
|
|
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
|
|
} else {
|
|
reportError(pname, status, "getting int vector");
|
|
}
|
|
}
|
|
break;
|
|
case RES_TABLE :
|
|
case RES_ARRAY :
|
|
{
|
|
static const UChar openStr[] = { 0x007B }; /* "{" */
|
|
static const UChar closeStr[] = { 0x007D, '\n' }; /* "}\n" */
|
|
|
|
UResourceBundle *t = NULL;
|
|
ures_resetIterator(resource);
|
|
printIndent(out, converter, indent);
|
|
if(key != NULL) {
|
|
printCString(out, converter, key, -1);
|
|
}
|
|
printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
|
|
if(verbose) {
|
|
if(ures_getType(resource) == RES_TABLE) {
|
|
printCString(out, converter, "// TABLE", -1);
|
|
} else {
|
|
printCString(out, converter, "// ARRAY", -1);
|
|
}
|
|
}
|
|
printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
|
|
|
|
if(suppressAliases == FALSE) {
|
|
while(U_SUCCESS(*status) && ures_hasNext(resource)) {
|
|
t = ures_getNextResource(resource, t, status);
|
|
if(U_SUCCESS(*status)) {
|
|
printOutBundle(out, converter, t, indent+indentsize, pname, status);
|
|
} else {
|
|
reportError(pname, status, "While processing table");
|
|
*status = U_ZERO_ERROR;
|
|
}
|
|
}
|
|
} else { /* we have to use low level access to do this */
|
|
Resource r = RES_BOGUS;
|
|
for(i = 0; i < ures_getSize(resource); i++) {
|
|
/* need to know if it's an alias */
|
|
if(ures_getType(resource) == RES_TABLE) {
|
|
r = derb_getTableItem(resource->fResData.pRoot, resource->fRes, (int16_t)i);
|
|
key = derb_getTableKey(resource->fResData.pRoot, resource->fRes, (int16_t)i);
|
|
} else {
|
|
r = derb_getArrayItem(resource->fResData.pRoot, resource->fRes, i);
|
|
}
|
|
if(U_SUCCESS(*status)) {
|
|
if(RES_GET_TYPE(r) == RES_ALIAS) {
|
|
printOutAlias(out, converter, resource, r, key, indent+indentsize, pname, status);
|
|
} else {
|
|
t = ures_getByIndex(resource, i, t, status);
|
|
printOutBundle(out, converter, t, indent+indentsize, pname, status);
|
|
}
|
|
} else {
|
|
reportError(pname, status, "While processing table");
|
|
*status = U_ZERO_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
printIndent(out, converter, indent);
|
|
printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
|
|
ures_close(t);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
static const char *getEncodingName(const char *encoding) {
|
|
UErrorCode err;
|
|
const char *enc;
|
|
|
|
err = U_ZERO_ERROR;
|
|
if (!(enc = ucnv_getStandardName(encoding, "MIME", &err))) {
|
|
err = U_ZERO_ERROR;
|
|
if (!(enc = ucnv_getStandardName(encoding, "IANA", &err))) {
|
|
;
|
|
}
|
|
}
|
|
|
|
return enc;
|
|
}
|
|
|
|
static void reportError(const char *pname, UErrorCode *status, const char *when) {
|
|
fprintf(stderr, "%s: error %d while %s: %s\n", pname, *status, when, u_errorName(*status));
|
|
}
|
|
|
|
/*
|
|
* Local Variables:
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*/
|
|
|
|
|