]> git.saurik.com Git - apple/icu.git/blob - icuSources/samples/uresb/uresb.c
projects / apple / icu.git / blob
? search:


f8d7cd66c2c8340f67d0982c81e0221ca6f05c76
[apple/icu.git] / icuSources / samples / uresb / uresb.c
1 /*
2 *******************************************************************************
3 *
4 * © 2016 and later: Unicode, Inc. and others.
5 * License & terms of use: http://www.unicode.org/copyright.html#License
6 *
7 *******************************************************************************
8 *******************************************************************************
9 *
10 * Copyright (C) 1999-2007, International Business Machines
11 * Corporation and others. All Rights Reserved.
12 *
13 *******************************************************************************
14 * file name: uresb.c
15 * encoding: UTF-8
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
29 #include "unicode/putil.h"
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);
67 void printHex(UFILE *out, const int8_t *what);
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 }
104 if(argc<2 || options[0].doesOccur || options[1].doesOccur) {
105 fprintf(stderr,
106 "usage: %s [-options] locale(s)\n",
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);
131 /*strcat(resPathBuffer, U_FILE_SEP_STRING);
132 strcat(resPathBuffer, "uresb");*/
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) {
148 VERBOSE = TRUE;
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
158 u_fprintf(out, "uresb: processing file \"%s\" in path \"%s\"\n", arg, resPath);
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
187 void printHex(UFILE *out, const int8_t *what) {
188 u_fprintf(out, "%02X", (uint8_t)*what);
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) {
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) {
248 u_fprintf(out, "%s { \"%S\" } ", key, string);
249 } else {
250 u_fprintf(out, "\"%S\",", string);
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) {
363 u_fprintf(outerr, "Error %d(%s) : %U happened!\n", *status, u_errorName(*status), getErrorName(*status));
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 }
mirror of ICU