The Tor Browser / file comparison

comparison: intl/icu/source/tools/genrb/derb.c

intl/icu/source/tools/genrb/derb.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:529bb6e26450
1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 1999-2013, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: derb.c
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2000sep6
14 * created by: Vladimir Weinstein as an ICU workshop example
15 * maintained by: Yves Arrouye <yves@realnames.com>
16 */
17
18 #include "unicode/ucnv.h"
19 #include "unicode/ustring.h"
20 #include "unicode/putil.h"
21 #include "unicode/ustdio.h"
22
23 #include "uresimp.h"
24 #include "cmemory.h"
25 #include "cstring.h"
26 #include "uoptions.h"
27 #include "toolutil.h"
28 #include "ustrfmt.h"
29
30 #if !UCONFIG_NO_FORMATTING
31
32 #define DERB_VERSION "1.1"
33
34 #define DERB_DEFAULT_TRUNC 80
35
36 static const int32_t indentsize = 4;
37 static int32_t truncsize = DERB_DEFAULT_TRUNC;
38 static UBool opt_truncate = FALSE;
39
40 static const char *getEncodingName(const char *encoding);
41 static void reportError(const char *pname, UErrorCode *status, const char *when);
42 static UChar *quotedString(const UChar *string);
43 static void printOutBundle(UFILE *out, UConverter *converter, UResourceBundle *resource, int32_t indent, const char *pname, UErrorCode *status);
44 static void printString(UFILE *out, UConverter *converter, const UChar *str, int32_t len);
45 static void printCString(UFILE *out, UConverter *converter, const char *str, int32_t len);
46 static void printIndent(UFILE *out, UConverter *converter, int32_t indent);
47 static void printHex(UFILE *out, UConverter *converter, uint8_t what);
48
49 static UOption options[]={
50 UOPTION_HELP_H,
51 UOPTION_HELP_QUESTION_MARK,
52 /* 2 */ UOPTION_ENCODING,
53 /* 3 */ { "to-stdout", NULL, NULL, NULL, 'c', UOPT_NO_ARG, 0 } ,
54 /* 4 */ { "truncate", NULL, NULL, NULL, 't', UOPT_OPTIONAL_ARG, 0 },
55 /* 5 */ UOPTION_VERBOSE,
56 /* 6 */ UOPTION_DESTDIR,
57 /* 7 */ UOPTION_SOURCEDIR,
58 /* 8 */ { "bom", NULL, NULL, NULL, 0, UOPT_NO_ARG, 0 },
59 /* 9 */ UOPTION_ICUDATADIR,
60 /* 10 */ UOPTION_VERSION,
61 /* 11 */ { "suppressAliases", NULL, NULL, NULL, 'A', UOPT_NO_ARG, 0 },
62 };
63
64 static UBool verbose = FALSE;
65 static UBool suppressAliases = FALSE;
66 static UFILE *ustderr = NULL;
67
68 extern int
69 main(int argc, char* argv[]) {
70 const char *encoding = NULL;
71 const char *outputDir = NULL; /* NULL = no output directory, use current */
72 const char *inputDir = ".";
73 int tostdout = 0;
74 int prbom = 0;
75
76 const char *pname;
77
78 UResourceBundle *bundle = NULL;
79 UErrorCode status = U_ZERO_ERROR;
80 int32_t i = 0;
81
82 UConverter *converter = NULL; // not used
83
84 const char* arg;
85
86 /* Get the name of tool. */
87 pname = uprv_strrchr(*argv, U_FILE_SEP_CHAR);
88 #if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
89 if (!pname) {
90 pname = uprv_strrchr(*argv, U_FILE_ALT_SEP_CHAR);
91 }
92 #endif
93 if (!pname) {
94 pname = *argv;
95 } else {
96 ++pname;
97 }
98
99 /* error handling, printing usage message */
100 argc=u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);
101
102 /* error handling, printing usage message */
103 if(argc<0) {
104 fprintf(stderr,
105 "%s: error in command line argument \"%s\"\n", pname,
106 argv[-argc]);
107 }
108 if(argc<0 || options[0].doesOccur || options[1].doesOccur) {
109 fprintf(argc < 0 ? stderr : stdout,
110 "%csage: %s [ -h, -?, --help ] [ -V, --version ]\n"
111 " [ -v, --verbose ] [ -e, --encoding encoding ] [ --bom ]\n"
112 " [ -t, --truncate [ size ] ]\n"
113 " [ -s, --sourcedir source ] [ -d, --destdir destination ]\n"
114 " [ -i, --icudatadir directory ] [ -c, --to-stdout ]\n"
115 " [ -A, --suppressAliases]\n"
116 " bundle ...\n", argc < 0 ? 'u' : 'U',
117 pname);
118 return argc<0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
119 }
120
121 if(options[10].doesOccur) {
122 fprintf(stderr,
123 "%s version %s (ICU version %s).\n"
124 "%s\n",
125 pname, DERB_VERSION, U_ICU_VERSION, U_COPYRIGHT_STRING);
126 return U_ZERO_ERROR;
127 }
128 if(options[2].doesOccur) {
129 encoding = options[2].value;
130 }
131
132 if (options[3].doesOccur) {
133 if(options[2].doesOccur) {
134 fprintf(stderr, "%s: Error: don't specify an encoding (-e) when writing to stdout (-c).\n", pname);
135 return 3;
136 }
137 tostdout = 1;
138 }
139
140 if(options[4].doesOccur) {
141 opt_truncate = TRUE;
142 if(options[4].value != NULL) {
143 truncsize = atoi(options[4].value); /* user defined printable size */
144 } else {
145 truncsize = DERB_DEFAULT_TRUNC; /* we'll use default omitting size */
146 }
147 } else {
148 opt_truncate = FALSE;
149 }
150
151 if(options[5].doesOccur) {
152 verbose = TRUE;
153 }
154
155 if (options[6].doesOccur) {
156 outputDir = options[6].value;
157 }
158
159 if(options[7].doesOccur) {
160 inputDir = options[7].value; /* we'll use users resources */
161 }
162
163 if (options[8].doesOccur) {
164 prbom = 1;
165 }
166
167 if (options[9].doesOccur) {
168 u_setDataDirectory(options[9].value);
169 }
170
171 if (options[11].doesOccur) {
172 suppressAliases = TRUE;
173 }
174
175 fflush(stderr); // use ustderr now.
176 ustderr = u_finit(stderr, NULL, NULL);
177
178 for (i = 1; i < argc; ++i) {
179 static const UChar sp[] = { 0x0020 }; /* " " */
180 char infile[4096]; /* XXX Sloppy. */
181 char locale[64];
182 const char *thename = 0, *p, *q;
183 UBool fromICUData = FALSE;
184
185 arg = getLongPathname(argv[i]);
186
187 if (verbose) {
188 u_fprintf(ustderr, "processing bundle \"%s\"\n", argv[i]);
189 }
190
191 p = uprv_strrchr(arg, U_FILE_SEP_CHAR);
192 #if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
193 if (p == NULL) {
194 p = uprv_strrchr(arg, U_FILE_ALT_SEP_CHAR);
195 }
196 #endif
197 if (!p) {
198 p = arg;
199 } else {
200 p++;
201 }
202 q = uprv_strrchr(p, '.');
203 if (!q) {
204 for (q = p; *q; ++q)
205 ;
206 }
207 uprv_strncpy(locale, p, q - p);
208 locale[q - p] = 0;
209
210 if (!(fromICUData = !uprv_strcmp(inputDir, "-"))) {
211 UBool absfilename = *arg == U_FILE_SEP_CHAR;
212 #if U_PLATFORM_HAS_WIN32_API
213 if (!absfilename) {
214 absfilename = (uprv_strlen(arg) > 2 && isalpha(arg[0])
215 && arg[1] == ':' && arg[2] == U_FILE_SEP_CHAR);
216 }
217 #endif
218 if (absfilename) {
219 thename = arg;
220 } else {
221 q = uprv_strrchr(arg, U_FILE_SEP_CHAR);
222 #if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
223 if (q == NULL) {
224 q = uprv_strrchr(arg, U_FILE_ALT_SEP_CHAR);
225 }
226 #endif
227 uprv_strcpy(infile, inputDir);
228 if(q != NULL) {
229 uprv_strcat(infile, U_FILE_SEP_STRING);
230 strncat(infile, arg, q-arg);
231 }
232 thename = infile;
233 }
234 }
235 status = U_ZERO_ERROR;
236 if (thename) {
237 bundle = ures_openDirect(thename, locale, &status);
238 } else {
239 bundle = ures_open(fromICUData ? 0 : inputDir, locale, &status);
240 }
241 if (status == U_ZERO_ERROR) {
242 UFILE *out = NULL;
243
244 const char *filename = 0;
245 const char *ext = 0;
246
247 if (!locale[0] || !tostdout) {
248 filename = uprv_strrchr(arg, U_FILE_SEP_CHAR);
249
250 #if U_FILE_SEP_CHAR != U_FILE_ALT_SEP_CHAR
251 if (!filename) {
252 filename = uprv_strrchr(arg, U_FILE_ALT_SEP_CHAR);
253 }
254 #endif
255 if (!filename) {
256 filename = arg;
257 } else {
258 ++filename;
259 }
260 ext = uprv_strrchr(arg, '.');
261 if (!ext) {
262 ext = filename + uprv_strlen(filename);
263 }
264 }
265
266 if (tostdout) {
267 out = u_get_stdout();
268 } else {
269 char thefile[4096], *tp;
270 int32_t len;
271
272 if (outputDir) {
273 uprv_strcpy(thefile, outputDir);
274 uprv_strcat(thefile, U_FILE_SEP_STRING);
275 } else {
276 *thefile = 0;
277 }
278 uprv_strcat(thefile, filename);
279 tp = thefile + uprv_strlen(thefile);
280 len = (int32_t)uprv_strlen(ext);
281 if (len) {
282 tp -= len - 1;
283 } else {
284 *tp++ = '.';
285 }
286 uprv_strcpy(tp, "txt");
287
288 out = u_fopen(thefile, "w", NULL, encoding);
289 if (!out) {
290 u_fprintf(ustderr, "%s: couldn't create %s\n", pname, thefile);
291 u_fclose(ustderr);
292 return 4;
293 }
294 }
295
296 // now, set the callback.
297 ucnv_setFromUCallBack(u_fgetConverter(out), UCNV_FROM_U_CALLBACK_ESCAPE, UCNV_ESCAPE_C, 0, 0, &status);
298 if (U_FAILURE(status)) {
299 u_fprintf(ustderr, "%s: couldn't configure converter for encoding\n", pname);
300 u_fclose(ustderr);
301 if(!tostdout) {
302 u_fclose(out);
303 }
304 return 3;
305 }
306
307 if (prbom) { /* XXX: Should be done only for UTFs */
308 u_fputc(0xFEFF, out);
309 }
310 u_fprintf(out, "// -*- Coding: %s; -*-\n//\n", encoding ? encoding : getEncodingName(ucnv_getDefaultName()));
311 u_fprintf(out, "// This file was dumped by derb(8) from ");
312 if (thename) {
313 u_fprintf(out, "%s", thename);
314 } else if (fromICUData) {
315 u_fprintf(out, "the ICU internal %s locale", locale);
316 }
317
318 u_fprintf(out, "\n// derb(8) by Vladimir Weinstein and Yves Arrouye\n\n");
319
320 if (locale[0]) {
321 u_fprintf(out, "%s", locale);
322 } else {
323 u_fprintf(out, "%.*s%.*S", (int32_t)(ext - filename), filename, (int32_t)(sizeof(sp)/sizeof(*sp)), sp);
324 }
325 printOutBundle(out, converter, bundle, 0, pname, &status);
326
327 if (!tostdout) {
328 u_fclose(out);
329 }
330 }
331 else {
332 reportError(pname, &status, "opening resource file");
333 }
334
335 ures_close(bundle);
336 }
337
338 ucnv_close(converter);
339
340 return 0;
341 }
342
343 static UChar *quotedString(const UChar *string) {
344 int len = u_strlen(string);
345 int alen = len;
346 const UChar *sp;
347 UChar *newstr, *np;
348
349 for (sp = string; *sp; ++sp) {
350 switch (*sp) {
351 case '\n':
352 case 0x0022:
353 ++alen;
354 break;
355 }
356 }
357
358 newstr = (UChar *) uprv_malloc((1 + alen) * sizeof(*newstr));
359 for (sp = string, np = newstr; *sp; ++sp) {
360 switch (*sp) {
361 case '\n':
362 *np++ = 0x005C;
363 *np++ = 0x006E;
364 break;
365
366 case 0x0022:
367 *np++ = 0x005C;
368
369 default:
370 *np++ = *sp;
371 break;
372 }
373 }
374 *np = 0;
375
376 return newstr;
377 }
378
379
380 static void printString(UFILE *out, UConverter *converter, const UChar *str, int32_t len) {
381 u_file_write(str, len, out);
382 }
383
384 static void printCString(UFILE *out, UConverter *converter, const char *str, int32_t len) {
385 if(len==-1) {
386 u_fprintf(out, "%s", str);
387 } else {
388 u_fprintf(out, "%.*s", len, str);
389 }
390 }
391
392 static void printIndent(UFILE *out, UConverter *converter, int32_t indent) {
393 UChar inchar[256];
394 int32_t i = 0;
395 for(i = 0; i<indent; i++) {
396 inchar[i] = 0x0020;
397 }
398 inchar[indent] = 0;
399
400 printString(out, converter, inchar, indent);
401 }
402
403 static void printHex(UFILE *out, UConverter *converter, uint8_t what) {
404 static const char map[] = "0123456789ABCDEF";
405 UChar hex[2];
406
407 hex[0] = map[what >> 4];
408 hex[1] = map[what & 0xf];
409
410 printString(out, converter, hex, (int32_t)(sizeof(hex)/sizeof(*hex)));
411 }
412
413 static void printOutAlias(UFILE *out, UConverter *converter, UResourceBundle *parent, Resource r, const char *key, int32_t indent, const char *pname, UErrorCode *status) {
414 static const UChar cr[] = { '\n' };
415 int32_t len = 0;
416 const UChar* thestr = res_getAlias(&(parent->fResData), r, &len);
417 UChar *string = quotedString(thestr);
418 if(opt_truncate && len > truncsize) {
419 char msg[128];
420 printIndent(out, converter, indent);
421 sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
422 (long)len, (long)truncsize/2);
423 printCString(out, converter, msg, -1);
424 len = truncsize;
425 }
426 if(U_SUCCESS(*status)) {
427 static const UChar openStr[] = { 0x003A, 0x0061, 0x006C, 0x0069, 0x0061, 0x0073, 0x0020, 0x007B, 0x0020, 0x0022 }; /* ":alias { \"" */
428 static const UChar closeStr[] = { 0x0022, 0x0020, 0x007D, 0x0020 }; /* "\" } " */
429 printIndent(out, converter, indent);
430 if(key != NULL) {
431 printCString(out, converter, key, -1);
432 }
433 printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
434 printString(out, converter, string, len);
435 printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
436 if(verbose) {
437 printCString(out, converter, " // ALIAS", -1);
438 }
439 printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
440 } else {
441 reportError(pname, status, "getting binary value");
442 }
443 uprv_free(string);
444 }
445
446 static void printOutBundle(UFILE *out, UConverter *converter, UResourceBundle *resource, int32_t indent, const char *pname, UErrorCode *status)
447 {
448 static const UChar cr[] = { '\n' };
449
450 /* int32_t noOfElements = ures_getSize(resource);*/
451 int32_t i = 0;
452 const char *key = ures_getKey(resource);
453
454 switch(ures_getType(resource)) {
455 case URES_STRING :
456 {
457 int32_t len=0;
458 const UChar* thestr = ures_getString(resource, &len, status);
459 UChar *string = quotedString(thestr);
460
461 /* TODO: String truncation */
462 if(opt_truncate && len > truncsize) {
463 char msg[128];
464 printIndent(out, converter, indent);
465 sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
466 (long)len, (long)(truncsize/2));
467 printCString(out, converter, msg, -1);
468 len = truncsize/2;
469 }
470 printIndent(out, converter, indent);
471 if(key != NULL) {
472 static const UChar openStr[] = { 0x0020, 0x007B, 0x0020, 0x0022 }; /* " { \"" */
473 static const UChar closeStr[] = { 0x0022, 0x0020, 0x007D }; /* "\" }" */
474 printCString(out, converter, key, (int32_t)uprv_strlen(key));
475 printString(out, converter, openStr, (int32_t)(sizeof(openStr)/sizeof(*openStr)));
476 printString(out, converter, string, len);
477 printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
478 } else {
479 static const UChar openStr[] = { 0x0022 }; /* "\"" */
480 static const UChar closeStr[] = { 0x0022, 0x002C }; /* "\"," */
481
482 printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
483 printString(out, converter, string, (int32_t)(u_strlen(string)));
484 printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
485 }
486
487 if(verbose) {
488 printCString(out, converter, "// STRING", -1);
489 }
490 printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
491
492 uprv_free(string);
493 }
494 break;
495
496 case URES_INT :
497 {
498 static const UChar openStr[] = { 0x003A, 0x0069, 0x006E, 0x0074, 0x0020, 0x007B, 0x0020 }; /* ":int { " */
499 static const UChar closeStr[] = { 0x0020, 0x007D }; /* " }" */
500 UChar num[20];
501
502 printIndent(out, converter, indent);
503 if(key != NULL) {
504 printCString(out, converter, key, -1);
505 }
506 printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
507 uprv_itou(num, 20, ures_getInt(resource, status), 10, 0);
508 printString(out, converter, num, u_strlen(num));
509 printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
510
511 if(verbose) {
512 printCString(out, converter, "// INT", -1);
513 }
514 printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
515 break;
516 }
517 case URES_BINARY :
518 {
519 int32_t len = 0;
520 const int8_t *data = (const int8_t *)ures_getBinary(resource, &len, status);
521 if(opt_truncate && len > truncsize) {
522 char msg[128];
523 printIndent(out, converter, indent);
524 sprintf(msg, "// WARNING: this resource, size %li is truncated to %li\n",
525 (long)len, (long)(truncsize/2));
526 printCString(out, converter, msg, -1);
527 len = truncsize;
528 }
529 if(U_SUCCESS(*status)) {
530 static const UChar openStr[] = { 0x003A, 0x0062, 0x0069, 0x006E, 0x0061, 0x0072, 0x0079, 0x0020, 0x007B, 0x0020 }; /* ":binary { " */
531 static const UChar closeStr[] = { 0x0020, 0x007D, 0x0020 }; /* " } " */
532 printIndent(out, converter, indent);
533 if(key != NULL) {
534 printCString(out, converter, key, -1);
535 }
536 printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
537 for(i = 0; i<len; i++) {
538 printHex(out, converter, *data++);
539 }
540 printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
541 if(verbose) {
542 printCString(out, converter, " // BINARY", -1);
543 }
544 printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
545 } else {
546 reportError(pname, status, "getting binary value");
547 }
548 }
549 break;
550 case URES_INT_VECTOR :
551 {
552 int32_t len = 0;
553 const int32_t *data = ures_getIntVector(resource, &len, status);
554 if(U_SUCCESS(*status)) {
555 static const UChar openStr[] = { 0x003A, 0x0069, 0x006E, 0x0074, 0x0076, 0x0065, 0x0063, 0x0074, 0x006F, 0x0072, 0x0020, 0x007B, 0x0020 }; /* ":intvector { " */
556 static const UChar closeStr[] = { 0x0020, 0x007D, 0x0020 }; /* " } " */
557 UChar num[20];
558
559 printIndent(out, converter, indent);
560 if(key != NULL) {
561 printCString(out, converter, key, -1);
562 }
563 printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
564 for(i = 0; i < len - 1; i++) {
565 int32_t numLen = uprv_itou(num, 20, data[i], 10, 0);
566 num[numLen++] = 0x002C; /* ',' */
567 num[numLen++] = 0x0020; /* ' ' */
568 num[numLen] = 0;
569 printString(out, converter, num, u_strlen(num));
570 }
571 if(len > 0) {
572 uprv_itou(num, 20, data[len - 1], 10, 0);
573 printString(out, converter, num, u_strlen(num));
574 }
575 printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
576 if(verbose) {
577 printCString(out, converter, "// INTVECTOR", -1);
578 }
579 printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
580 } else {
581 reportError(pname, status, "getting int vector");
582 }
583 }
584 break;
585 case URES_TABLE :
586 case URES_ARRAY :
587 {
588 static const UChar openStr[] = { 0x007B }; /* "{" */
589 static const UChar closeStr[] = { 0x007D, '\n' }; /* "}\n" */
590
591 UResourceBundle *t = NULL;
592 ures_resetIterator(resource);
593 printIndent(out, converter, indent);
594 if(key != NULL) {
595 printCString(out, converter, key, -1);
596 }
597 printString(out, converter, openStr, (int32_t)(sizeof(openStr) / sizeof(*openStr)));
598 if(verbose) {
599 if(ures_getType(resource) == URES_TABLE) {
600 printCString(out, converter, "// TABLE", -1);
601 } else {
602 printCString(out, converter, "// ARRAY", -1);
603 }
604 }
605 printString(out, converter, cr, (int32_t)(sizeof(cr) / sizeof(*cr)));
606
607 if(suppressAliases == FALSE) {
608 while(U_SUCCESS(*status) && ures_hasNext(resource)) {
609 t = ures_getNextResource(resource, t, status);
610 if(U_SUCCESS(*status)) {
611 printOutBundle(out, converter, t, indent+indentsize, pname, status);
612 } else {
613 reportError(pname, status, "While processing table");
614 *status = U_ZERO_ERROR;
615 }
616 }
617 } else { /* we have to use low level access to do this */
618 Resource r;
619 int32_t resSize = ures_getSize(resource);
620 UBool isTable = (UBool)(ures_getType(resource) == URES_TABLE);
621 for(i = 0; i < resSize; i++) {
622 /* need to know if it's an alias */
623 if(isTable) {
624 r = res_getTableItemByIndex(&resource->fResData, resource->fRes, i, &key);
625 } else {
626 r = res_getArrayItem(&resource->fResData, resource->fRes, i);
627 }
628 if(U_SUCCESS(*status)) {
629 if(res_getPublicType(r) == URES_ALIAS) {
630 printOutAlias(out, converter, resource, r, key, indent+indentsize, pname, status);
631 } else {
632 t = ures_getByIndex(resource, i, t, status);
633 printOutBundle(out, converter, t, indent+indentsize, pname, status);
634 }
635 } else {
636 reportError(pname, status, "While processing table");
637 *status = U_ZERO_ERROR;
638 }
639 }
640 }
641
642 printIndent(out, converter, indent);
643 printString(out, converter, closeStr, (int32_t)(sizeof(closeStr) / sizeof(*closeStr)));
644 ures_close(t);
645 }
646 break;
647 default:
648 break;
649 }
650
651 }
652
653 static const char *getEncodingName(const char *encoding) {
654 UErrorCode err;
655 const char *enc;
656
657 err = U_ZERO_ERROR;
658 if (!(enc = ucnv_getStandardName(encoding, "MIME", &err))) {
659 err = U_ZERO_ERROR;
660 if (!(enc = ucnv_getStandardName(encoding, "IANA", &err))) {
661 ;
662 }
663 }
664
665 return enc;
666 }
667
668 static void reportError(const char *pname, UErrorCode *status, const char *when) {
669 u_fprintf(ustderr, "%s: error %d while %s: %s\n", pname, *status, when, u_errorName(*status));
670 }
671
672 #else
673 extern int
674 main(int argc, char* argv[]) {
675 /* Changing stdio.h ustdio.h requires that formatting not be disabled. */
676 return 3;
677 }
678 #endif /* !UCONFIG_NO_FORMATTING */
679
680 /*
681 * Local Variables:
682 * indent-tabs-mode: nil
683 * End:
684 */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial