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