icuSources/tools/genrb/derb.c

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