[apple/icu.git] / icuSources / samples / uresb / uresb.c

/*
*******************************************************************************
*
*   © 2016 and later: Unicode, Inc. and others.
*   License & terms of use: http://www.unicode.org/copyright.html#License
*
*******************************************************************************
*******************************************************************************
*
*   Copyright (C) 1999-2007, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  uresb.c
*   encoding:   UTF-8
*   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;
    }

}
Commit	Line	Data
b75a7d8f A	1	/*
	2	*******************************************************************************
	3	*
f3c0d7a5 A	4	* © 2016 and later: Unicode, Inc. and others.
	5	* License & terms of use: http://www.unicode.org/copyright.html#License
	6	*
	7	*******************************************************************************
	8	*******************************************************************************
	9	*
46f4442e	10	* Copyright (C) 1999-2007, International Business Machines
b75a7d8f A	11	* Corporation and others. All Rights Reserved.
	12	*
	13	*******************************************************************************
	14	* file name: uresb.c
f3c0d7a5	15	* encoding: UTF-8
b75a7d8f A	16	* tab size: 8 (not used)
	17	* indentation:4
	18	*
	19	* created on: 2000sep6
	20	* created by: Vladimir Weinstein
	21	*/
	22
	23	/******************************************************************************
	24	* This program prints out resource bundles - example for
	25	* ICU workshop
	26	* TODO: make a complete i18n layout for this program.
	27	******************************************************************************/
	28
374ca955	29	#include "unicode/putil.h"
b75a7d8f A	30	#include "unicode/ures.h"
	31	#include "unicode/ustdio.h"
	32	#include "unicode/uloc.h"
	33	#include "unicode/ustring.h"
	34	#include "uoptions.h"
	35	#include "toolutil.h"
	36
	37	#include <string.h>
	38	#include <stdlib.h>
	39	#ifdef WIN32
	40	#include <direct.h>
	41	#else
	42	#include <unistd.h>
	43	#endif
	44
	45	#define URESB_DEFAULTTRUNC 40
	46
	47	static char *currdir = NULL;
	48	/*--locale sr_YU and --encoding cp855
	49	* are interesting on Win32
	50	*/
	51
	52	static const char *locale = NULL;
	53	static const char *encoding = NULL;
	54	static const char *resPath = NULL;
	55	static const int32_t indentsize = 4;
	56	static UFILE *outerr = NULL;
	57	static int32_t truncsize = URESB_DEFAULTTRUNC;
	58	static UBool trunc = FALSE;
	59
	60	const UChar baderror[] = { 0x0042, 0x0041, 0x0044, 0x0000 };
	61
	62	const UChar *getErrorName(UErrorCode errorNumber);
	63	void reportError(UErrorCode *status);
	64	static UChar quotedString(const UChar string);
	65	void printOutBundle(UFILE out, UResourceBundle resource, int32_t indent, UErrorCode *status);
	66	void printIndent(UFILE *out, int32_t indent);
46f4442e	67	void printHex(UFILE out, const int8_t what);
b75a7d8f A	68
	69	static UOption options[]={
	70	UOPTION_HELP_H,
	71	UOPTION_HELP_QUESTION_MARK,
	72	{ "locale", NULL, NULL, NULL, 'l', UOPT_REQUIRES_ARG, 0 },
	73	UOPTION_ENCODING,
	74	{ "path", NULL, NULL, NULL, 'p', UOPT_OPTIONAL_ARG, 0 },
	75	{ "truncate", NULL, NULL, NULL, 't', UOPT_OPTIONAL_ARG, 0 },
	76	UOPTION_VERBOSE
	77	};
	78
	79	static UBool VERBOSE = FALSE;
	80
	81	extern int
	82	main(int argc, char* argv[]) {
	83
	84	UResourceBundle *bundle = NULL;
	85	UErrorCode status = U_ZERO_ERROR;
	86	UFILE *out = NULL;
	87	int32_t i = 0;
	88	const char* arg;
	89	char resPathBuffer[1024];
	90	#ifdef WIN32
	91	currdir = _getcwd(NULL, 0);
	92	#else
	93	currdir = getcwd(NULL, 0);
	94	#endif
	95
	96	argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);
	97
	98	/* error handling, printing usage message */
	99	if(argc<0) {
	100	fprintf(stderr,
	101	"error in command line argument \"%s\"\n",
	102	argv[-argc]);
	103	}
73c04bcf	104	if(argc<2 \|\| options[0].doesOccur \|\| options[1].doesOccur) {
b75a7d8f	105	fprintf(stderr,
73c04bcf	106	"usage: %s [-options] locale(s)\n",
b75a7d8f A	107	argv[0]);
	108	return argc<0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
	109	}
	110
	111	if(options[2].doesOccur) {
	112	locale = options[2].value;
	113	} else {
	114	locale = 0;
	115	}
	116
	117	if(options[3].doesOccur) {
	118	encoding = options[3].value;
	119	} else {
	120	encoding = NULL;
	121	}
	122
	123	if(options[4].doesOccur) {
	124	if(options[4].value != NULL) {
	125	resPath = options[4].value; /* we'll use users resources */
	126	} else {
	127	resPath = NULL; /* we'll use ICU system resources for dumping */
	128	}
	129	} else {
	130	strcpy(resPathBuffer, currdir);
73c04bcf A	131	/*strcat(resPathBuffer, U_FILE_SEP_STRING);
73c04bcf A	132	strcat(resPathBuffer, "uresb");*/
b75a7d8f A	133	resPath = resPathBuffer; /* we'll just dump uresb samples resources */
	134	}
	135
	136	if(options[5].doesOccur) {
	137	trunc = TRUE;
	138	if(options[5].value != NULL) {
	139	truncsize = atoi(options[5].value); /* user defined printable size */
	140	} else {
	141	truncsize = URESB_DEFAULTTRUNC; /* we'll use default omitting size */
	142	}
	143	} else {
	144	trunc = FALSE;
	145	}
	146
	147	if(options[6].doesOccur) {
73c04bcf	148	VERBOSE = TRUE;
b75a7d8f A	149	}
	150
	151	outerr = u_finit(stderr, locale, encoding);
	152	out = u_finit(stdout, locale, encoding);
	153
	154	for(i = 1; i < argc; ++i) {
	155	status = U_ZERO_ERROR;
	156	arg = getLongPathname(argv[i]);
	157
73c04bcf	158	u_fprintf(out, "uresb: processing file \"%s\" in path \"%s\"\n", arg, resPath);
b75a7d8f A	159	bundle = ures_open(resPath, arg, &status);
	160	if(U_SUCCESS(status)) {
	161	u_fprintf(out, "%s\n", arg);
	162	printOutBundle(out, bundle, 0, &status);
	163	} else {
	164	reportError(&status);
	165	}
	166
	167	ures_close(bundle);
	168	}
	169
	170
	171
	172	u_fclose(out);
	173	u_fclose(outerr);
	174	return 0;
	175	}
	176
	177	void printIndent(UFILE *out, int32_t indent) {
	178	char inchar[256];
	179	int32_t i = 0;
	180	for(i = 0; i<indent; i++) {
	181	inchar[i] = ' ';
	182	}
	183	inchar[indent] = '\0';
	184	u_fprintf(out, "%s", inchar);
	185	}
	186
46f4442e A	187	void printHex(UFILE out, const int8_t what) {
46f4442e A	188	u_fprintf(out, "%02X", (uint8_t)*what);
b75a7d8f A	189	}
	190
	191	static UChar quotedString(const UChar string) {
	192	int len = u_strlen(string);
	193	int alen = len;
	194	const UChar *sp;
	195	UChar newstr, np;
	196
	197	for (sp = string; *sp; ++sp) {
	198	switch (*sp) {
	199	case '\n':
	200	case 0x0022:
	201	++alen;
	202	break;
	203	}
	204	}
	205
	206	newstr = (UChar ) malloc((1 + alen) sizeof(*newstr));
	207	for (sp = string, np = newstr; *sp; ++sp) {
	208	switch (*sp) {
	209	case '\n':
	210	*np++ = 0x005C;
	211	*np++ = 0x006E;
	212	break;
	213
	214	case 0x0022:
	215	*np++ = 0x005C;
	216
	217	default:
	218	np++ = sp;
	219	break;
	220	}
	221	}
	222	*np = 0;
	223
	224	return newstr;
	225	}
	226
	227	void printOutBundle(UFILE out, UResourceBundle resource, int32_t indent, UErrorCode *status) {
b75a7d8f A	228	int32_t i = 0;
	229	const char *key = ures_getKey(resource);
	230
	231	switch(ures_getType(resource)) {
	232	case URES_STRING :
	233	{
	234	int32_t len=0;
	235	const UChar*thestr = ures_getString(resource, &len, status);
	236	UChar *string = quotedString(thestr);
	237
	238	/* TODO: String truncation */
	239	/*
	240	if(trunc && len > truncsize) {
	241	printIndent(out, indent);
	242	u_fprintf(out, "// WARNING: this string, size %d is truncated to %d\n", len, truncsize/2);
	243	len = truncsize/2;
	244	}
	245	*/
	246	printIndent(out, indent);
	247	if(key != NULL) {
374ca955	248	u_fprintf(out, "%s { \"%S\" } ", key, string);
b75a7d8f	249	} else {
374ca955	250	u_fprintf(out, "\"%S\",", string);
b75a7d8f A	251	}
	252	if(VERBOSE) {
	253	u_fprintf(out, " // STRING");
	254	}
	255	u_fprintf(out, "\n");
	256	free(string);
	257	}
	258	break;
	259	case URES_INT :
	260	printIndent(out, indent);
	261	if(key != NULL) {
	262	u_fprintf(out, "%s", key);
	263	}
	264	u_fprintf(out, ":int { %li } ", ures_getInt(resource, status));
	265
	266	if(VERBOSE) {
	267	u_fprintf(out, " // INT");
	268	}
	269	u_fprintf(out, "\n");
	270	break;
	271	case URES_BINARY :
	272	{
	273	int32_t len = 0;
	274	const int8_t data = (const int8_t )ures_getBinary(resource, &len, status);
	275	if(trunc && len > truncsize) {
	276	printIndent(out, indent);
	277	u_fprintf(out, "// WARNING: this resource, size %li is truncated to %li\n", len, truncsize/2);
	278	len = truncsize/2;
	279	}
	280	if(U_SUCCESS(*status)) {
	281	printIndent(out, indent);
	282	if(key != NULL) {
	283	u_fprintf(out, "%s", key);
	284	}
	285	u_fprintf(out, ":binary { ");
	286	for(i = 0; i<len; i++) {
	287	printHex(out, data++);
	288	}
	289	u_fprintf(out, " }");
	290	if(VERBOSE) {
	291	u_fprintf(out, " // BINARY");
	292	}
	293	u_fprintf(out, "\n");
	294
	295	} else {
	296	reportError(status);
	297	}
	298	}
	299	break;
	300	case URES_INT_VECTOR :
	301	{
	302	int32_t len = 0;
	303	const int32_t *data = ures_getIntVector(resource, &len, status);
	304	if(U_SUCCESS(*status)) {
	305	printIndent(out, indent);
	306	if(key != NULL) {
	307	u_fprintf(out, "%s", key);
	308	}
	309	u_fprintf(out, ":intvector { ");
	310	for(i = 0; i<len-1; i++) {
	311	u_fprintf(out, "%d, ", data[i]);
	312	}
	313	if(len > 0) {
	314	u_fprintf(out, "%d ", data[len-1]);
315	}
316	u_fprintf(out, "}");
317	if(VERBOSE) {
318	u_fprintf(out, " // INTVECTOR");
319	}
320	u_fprintf(out, "\n");
321
322	} else {
323	reportError(status);
324	}
325	}
326	break;
327	case URES_TABLE :
328	case URES_ARRAY :
329	{
330	UResourceBundle *t = NULL;
331	ures_resetIterator(resource);
332	printIndent(out, indent);
333	if(key != NULL) {
334	u_fprintf(out, "%s ", key);
335	}
336	u_fprintf(out, "{");
337	if(VERBOSE) {
338	if(ures_getType(resource) == URES_TABLE) {
339	u_fprintf(out, " // TABLE");
340	} else {
341	u_fprintf(out, " // ARRAY");
342	}
343	}
344	u_fprintf(out, "\n");
345
346	while(ures_hasNext(resource)) {
347	t = ures_getNextResource(resource, t, status);
348	printOutBundle(out, t, indent+indentsize, status);
349	}
350
351	printIndent(out, indent);
352	u_fprintf(out, "}\n");
353	ures_close(t);
354	}
355	break;
356	default:
357	break;
358	}
359
360	}
361
362	void reportError(UErrorCode *status) {
73c04bcf	363	u_fprintf(outerr, "Error %d(%s) : %U happened!\n", status, u_errorName(status), getErrorName(*status));
b75a7d8f A	364	}
	365
	366
	367	const UChar *getErrorName(UErrorCode errorNumber) {
	368	UErrorCode status = U_ZERO_ERROR;
	369	int32_t len = 0;
	370
	371	UResourceBundle *error = ures_open(currdir, locale, &status);
	372
	373	UResourceBundle *errorcodes = ures_getByKey(error, "errorcodes", NULL, &status);
	374
	375	const UChar *result = ures_getStringByIndex(errorcodes, errorNumber, &len, &status);
	376
	377	ures_close(errorcodes);
	378	ures_close(error);
	379
	380	if(U_SUCCESS(status)) {
	381	return result;
	382	} else {
	383	return baderror;
	384	}
	385
	386	}