icuSources/tools/icupkg/icupkg.cpp

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 2005-2012, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  icupkg.cpp
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2005jul29
  14 *   created by: Markus W. Scherer
  15 *
  16 *   This tool operates on ICU data (.dat package) files.
  17 *   It takes one as input, or creates an empty one, and can remove, add, and
  18 *   extract data pieces according to command-line options.
  19 *   At the same time, it swaps each piece to a consistent set of platform
  20 *   properties as desired.
  21 *   Useful as an install-time tool for shipping only one flavor of ICU data
  22 *   and preparing data files for the target platform.
  23 *   Also for customizing ICU data (pruning, augmenting, replacing) and for
  24 *   taking it apart.
  25 *   Subsumes functionality and implementation code from
  26 *   gencmn, decmn, and icuswap tools.
  27 *   Will not work with data DLLs (shared libraries).
  28 */
  29
  30 #include "unicode/utypes.h"
  31 #include "unicode/putil.h"
  32 #include "cstring.h"
  33 #include "toolutil.h"
  34 #include "uoptions.h"
  35 #include "uparse.h"
  36 #include "filestrm.h"
  37 #include "package.h"
  38 #include "pkg_icu.h"
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43
  44 U_NAMESPACE_USE
  45
  46 // TODO: add --matchmode=regex for using the ICU regex engine for item name pattern matching?
  47
  48 // general definitions ----------------------------------------------------- ***
  49
  50 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  51
  52 // main() ------------------------------------------------------------------ ***
  53
  54 static void
  55 printUsage(const char *pname, UBool isHelp) {
  56     FILE *where=isHelp ? stdout : stderr;
  57
  58     fprintf(where,
  59             "%csage: %s [-h|-?|--help ] [-tl|-tb|-te] [-c] [-C comment]\n"
  60             "\t[-a list] [-r list] [-x list] [-l [-o outputListFileName]]\n"
  61             "\t[-s path] [-d path] [-w] [-m mode]\n"
  62             "\tinfilename [outfilename]\n",
  63             isHelp ? 'U' : 'u', pname);
  64     if(isHelp) {
  65         fprintf(where,
  66             "\n"
  67             "Read the input ICU .dat package file, modify it according to the options,\n"
  68             "swap it to the desired platform properties (charset & endianness),\n"
  69             "and optionally write the resulting ICU .dat package to the output file.\n"
  70             "Items are removed, then added, then extracted and listed.\n"
  71             "An ICU .dat package is written if items are removed or added,\n"
  72             "or if the input and output filenames differ,\n"
  73             "or if the --writepkg (-w) option is set.\n");
  74         fprintf(where,
  75             "\n"
  76             "If the input filename is \"new\" then an empty package is created.\n"
  77             "If the output filename is missing, then it is automatically generated\n"
  78             "from the input filename: If the input filename ends with an l, b, or e\n"
  79             "matching its platform properties, then the output filename will\n"
  80             "contain the letter from the -t (--type) option.\n");
  81         fprintf(where,
  82             "\n"
  83             "This tool can also be used to just swap a single ICU data file, replacing the\n"
  84             "former icuswap tool. For this mode, provide the infilename (and optional\n"
  85             "outfilename) for a non-package ICU data file.\n"
  86             "Allowed options include -t, -w, -s and -d.\n"
  87             "The filenames can be absolute, or relative to the source/dest dir paths.\n"
  88             "Other options are not allowed in this mode.\n");
  89         fprintf(where,
  90             "\n"
  91             "Options:\n"
  92             "\t(Only the last occurrence of an option is used.)\n"
  93             "\n"
  94             "\t-h or -? or --help    print this message and exit\n");
  95         fprintf(where,
  96             "\n"
  97             "\t-tl or --type l   output for little-endian/ASCII charset family\n"
  98             "\t-tb or --type b   output for big-endian/ASCII charset family\n"
  99             "\t-te or --type e   output for big-endian/EBCDIC charset family\n"
 100             "\t                  The output type defaults to the input type.\n"
 101             "\n"
 102             "\t-c or --copyright include the ICU copyright notice\n"
 103             "\t-C comment or --comment comment   include a comment string\n");
 104         fprintf(where,
 105             "\n"
 106             "\t-a list or --add list      add items to the package\n"
 107             "\t-r list or --remove list   remove items from the package\n"
 108             "\t-x list or --extract list  extract items from the package\n"
 109             "\tThe list can be a single item's filename,\n"
 110             "\tor a .txt filename with a list of item filenames,\n"
 111             "\tor an ICU .dat package filename.\n");
 112         fprintf(where,
 113             "\n"
 114             "\t-w or --writepkg  write the output package even if no items are removed\n"
 115             "\t                  or added (e.g., for only swapping the data)\n");
 116         fprintf(where,
 117             "\n"
 118             "\t-m mode or --matchmode mode  set the matching mode for item names with\n"
 119             "\t                             wildcards\n"
 120             "\t        noslash: the '*' wildcard does not match the '/' tree separator\n");
 121         /*
 122          * Usage text columns, starting after the initial TAB.
 123          *      1         2         3         4         5         6         7         8
 124          *     901234567890123456789012345678901234567890123456789012345678901234567890
 125          */
 126         fprintf(where,
 127             "\n"
 128             "\tList file syntax: Items are listed on one or more lines and separated\n"
 129             "\tby whitespace (space+tab).\n"
 130             "\tComments begin with # and are ignored. Empty lines are ignored.\n"
 131             "\tLines where the first non-whitespace character is one of %s\n"
 132             "\tare also ignored, to reserve for future syntax.\n",
 133             U_PKG_RESERVED_CHARS);
 134         fprintf(where,
 135             "\tItems for removal or extraction may contain a single '*' wildcard\n"
 136             "\tcharacter. The '*' matches zero or more characters.\n"
 137             "\tIf --matchmode noslash (-m noslash) is set, then the '*'\n"
 138             "\tdoes not match '/'.\n");
 139         fprintf(where,
 140             "\n"
 141             "\tItems must be listed relative to the package, and the --sourcedir or\n"
 142             "\tthe --destdir path will be prepended.\n"
 143             "\tThe paths are only prepended to item filenames while adding or\n"
 144             "\textracting items, not to ICU .dat package or list filenames.\n"
 145             "\t\n"
 146             "\tPaths may contain '/' instead of the platform's\n"
 147             "\tfile separator character, and are converted as appropriate.\n");
 148         fprintf(where,
 149             "\n"
 150             "\t-s path or --sourcedir path  directory for the --add items\n"
 151             "\t-d path or --destdir path    directory for the --extract items\n"
 152             "\n"
 153             "\t-l or --list                 list the package items to stdout or to output list file\n"
 154             "\t                             (after modifying the package)\n");
 155     }
 156 }
 157
 158 static UOption options[]={
 159     UOPTION_HELP_H,
 160     UOPTION_HELP_QUESTION_MARK,
 161     UOPTION_DEF("type", 't', UOPT_REQUIRES_ARG),
 162
 163     UOPTION_COPYRIGHT,
 164     UOPTION_DEF("comment", 'C', UOPT_REQUIRES_ARG),
 165
 166     UOPTION_SOURCEDIR,
 167     UOPTION_DESTDIR,
 168
 169     UOPTION_DEF("writepkg", 'w', UOPT_NO_ARG),
 170
 171     UOPTION_DEF("matchmode", 'm', UOPT_REQUIRES_ARG),
 172
 173     UOPTION_DEF("add", 'a', UOPT_REQUIRES_ARG),
 174     UOPTION_DEF("remove", 'r', UOPT_REQUIRES_ARG),
 175     UOPTION_DEF("extract", 'x', UOPT_REQUIRES_ARG),
 176
 177     UOPTION_DEF("list", 'l', UOPT_NO_ARG),
 178
 179     UOPTION_DEF("outlist", 'o', UOPT_REQUIRES_ARG)
 180 };
 181
 182 enum {
 183     OPT_HELP_H,
 184     OPT_HELP_QUESTION_MARK,
 185     OPT_OUT_TYPE,
 186
 187     OPT_COPYRIGHT,
 188     OPT_COMMENT,
 189
 190     OPT_SOURCEDIR,
 191     OPT_DESTDIR,
 192
 193     OPT_WRITEPKG,
 194
 195     OPT_MATCHMODE,
 196
 197     OPT_ADD_LIST,
 198     OPT_REMOVE_LIST,
 199     OPT_EXTRACT_LIST,
 200
 201     OPT_LIST_ITEMS,
 202
 203     OPT_LIST_FILE,
 204
 205     OPT_COUNT
 206 };
 207
 208 static UBool
 209 isPackageName(const char *filename) {
 210     int32_t len;
 211
 212     len=(int32_t)strlen(filename)-4; /* -4: subtract the length of ".dat" */
 213     return (UBool)(len>0 && 0==strcmp(filename+len, ".dat"));
 214 }
 215 /*
 216 This line is required by MinGW because it incorrectly globs the arguments.
 217 So when \* is used, it turns into a list of files instead of a literal "*"
 218 */
 219 int _CRT_glob = 0;
 220
 221 extern int
 222 main(int argc, char *argv[]) {
 223     const char *pname, *sourcePath, *destPath, *inFilename, *outFilename, *outComment;
 224     char outType;
 225     UBool isHelp, isModified, isPackage;
 226     int result = 0;
 227
 228     Package *pkg, *listPkg, *addListPkg;
 229
 230     U_MAIN_INIT_ARGS(argc, argv);
 231
 232     /* get the program basename */
 233     pname=findBasename(argv[0]);
 234
 235     argc=u_parseArgs(argc, argv, LENGTHOF(options), options);
 236     isHelp=options[OPT_HELP_H].doesOccur || options[OPT_HELP_QUESTION_MARK].doesOccur;
 237     if(isHelp) {
 238         printUsage(pname, TRUE);
 239         return U_ZERO_ERROR;
 240     }
 241     if(argc<2 || 3<argc) {
 242         printUsage(pname, FALSE);
 243         return U_ILLEGAL_ARGUMENT_ERROR;
 244     }
 245
 246     pkg=new Package;
 247     if(pkg==NULL) {
 248         fprintf(stderr, "icupkg: not enough memory\n");
 249         return U_MEMORY_ALLOCATION_ERROR;
 250     }
 251     isModified=FALSE;
 252
 253     if(options[OPT_SOURCEDIR].doesOccur) {
 254         sourcePath=options[OPT_SOURCEDIR].value;
 255     } else {
 256         // work relative to the current working directory
 257         sourcePath=NULL;
 258     }
 259     if(options[OPT_DESTDIR].doesOccur) {
 260         destPath=options[OPT_DESTDIR].value;
 261     } else {
 262         // work relative to the current working directory
 263         destPath=NULL;
 264     }
 265
 266     if(0==strcmp(argv[1], "new")) {
 267         inFilename=NULL;
 268         isPackage=TRUE;
 269     } else {
 270         inFilename=argv[1];
 271         if(isPackageName(inFilename)) {
 272             pkg->readPackage(inFilename);
 273             isPackage=TRUE;
 274         } else {
 275             /* swap a single file (icuswap replacement) rather than work on a package */
 276             pkg->addFile(sourcePath, inFilename);
 277             isPackage=FALSE;
 278         }
 279     }
 280
 281     if(argc>=3) {
 282         outFilename=argv[2];
 283         if(0!=strcmp(argv[1], argv[2])) {
 284             isModified=TRUE;
 285         }
 286     } else if(isPackage) {
 287         outFilename=NULL;
 288     } else /* !isPackage */ {
 289         outFilename=inFilename;
 290         isModified=(UBool)(sourcePath!=destPath);
 291     }
 292
 293     /* parse the output type option */
 294     if(options[OPT_OUT_TYPE].doesOccur) {
 295         const char *type=options[OPT_OUT_TYPE].value;
 296         if(type[0]==0 || type[1]!=0) {
 297             /* the type must be exactly one letter */
 298             printUsage(pname, FALSE);
 299             return U_ILLEGAL_ARGUMENT_ERROR;
 300         }
 301         outType=type[0];
 302         switch(outType) {
 303         case 'l':
 304         case 'b':
 305         case 'e':
 306             break;
 307         default:
 308             printUsage(pname, FALSE);
 309             return U_ILLEGAL_ARGUMENT_ERROR;
 310         }
 311
 312         /*
 313          * Set the isModified flag if the output type differs from the
 314          * input package type.
 315          * If we swap a single file, just assume that we are modifying it.
 316          * The Package class does not give us access to the item and its type.
 317          */
 318         isModified|=(UBool)(!isPackage || outType!=pkg->getInType());
 319     } else if(isPackage) {
 320         outType=pkg->getInType(); // default to input type
 321     } else /* !isPackage: swap single file */ {
 322         outType=0; /* tells extractItem() to not swap */
 323     }
 324
 325     if(options[OPT_WRITEPKG].doesOccur) {
 326         isModified=TRUE;
 327     }
 328
 329     if(!isPackage) {
 330         /*
 331          * icuswap tool replacement: Only swap a single file.
 332          * Check that irrelevant options are not set.
 333          */
 334         if( options[OPT_COMMENT].doesOccur ||
 335             options[OPT_COPYRIGHT].doesOccur ||
 336             options[OPT_MATCHMODE].doesOccur ||
 337             options[OPT_REMOVE_LIST].doesOccur ||
 338             options[OPT_ADD_LIST].doesOccur ||
 339             options[OPT_EXTRACT_LIST].doesOccur ||
 340             options[OPT_LIST_ITEMS].doesOccur
 341         ) {
 342             printUsage(pname, FALSE);
 343             return U_ILLEGAL_ARGUMENT_ERROR;
 344         }
 345         if(isModified) {
 346             pkg->extractItem(destPath, outFilename, 0, outType);
 347         }
 348
 349         delete pkg;
 350         return result;
 351     }
 352
 353     /* Work with a package. */
 354
 355     if(options[OPT_COMMENT].doesOccur) {
 356         outComment=options[OPT_COMMENT].value;
 357     } else if(options[OPT_COPYRIGHT].doesOccur) {
 358         outComment=U_COPYRIGHT_STRING;
 359     } else {
 360         outComment=NULL;
 361     }
 362
 363     if(options[OPT_MATCHMODE].doesOccur) {
 364         if(0==strcmp(options[OPT_MATCHMODE].value, "noslash")) {
 365             pkg->setMatchMode(Package::MATCH_NOSLASH);
 366         } else {
 367             printUsage(pname, FALSE);
 368             return U_ILLEGAL_ARGUMENT_ERROR;
 369         }
 370     }
 371
 372     /* remove items */
 373     if(options[OPT_REMOVE_LIST].doesOccur) {
 374         listPkg=new Package();
 375         if(listPkg==NULL) {
 376             fprintf(stderr, "icupkg: not enough memory\n");
 377             exit(U_MEMORY_ALLOCATION_ERROR);
 378         }
 379         if(readList(NULL, options[OPT_REMOVE_LIST].value, FALSE, listPkg)) {
 380             pkg->removeItems(*listPkg);
 381             delete listPkg;
 382             isModified=TRUE;
 383         } else {
 384             printUsage(pname, FALSE);
 385             return U_ILLEGAL_ARGUMENT_ERROR;
 386         }
 387     }
 388
 389     /*
 390      * add items
 391      * use a separate Package so that its memory and items stay around
 392      * as long as the main Package
 393      */
 394     addListPkg=NULL;
 395     if(options[OPT_ADD_LIST].doesOccur) {
 396         addListPkg=new Package();
 397         if(addListPkg==NULL) {
 398             fprintf(stderr, "icupkg: not enough memory\n");
 399             exit(U_MEMORY_ALLOCATION_ERROR);
 400         }
 401         if(readList(sourcePath, options[OPT_ADD_LIST].value, TRUE, addListPkg)) {
 402             pkg->addItems(*addListPkg);
 403             // delete addListPkg; deferred until after writePackage()
 404             isModified=TRUE;
 405         } else {
 406             printUsage(pname, FALSE);
 407             return U_ILLEGAL_ARGUMENT_ERROR;
 408         }
 409     }
 410
 411     /* extract items */
 412     if(options[OPT_EXTRACT_LIST].doesOccur) {
 413         listPkg=new Package();
 414         if(listPkg==NULL) {
 415             fprintf(stderr, "icupkg: not enough memory\n");
 416             exit(U_MEMORY_ALLOCATION_ERROR);
 417         }
 418         if(readList(NULL, options[OPT_EXTRACT_LIST].value, FALSE, listPkg)) {
 419             pkg->extractItems(destPath, *listPkg, outType);
 420             delete listPkg;
 421         } else {
 422             printUsage(pname, FALSE);
 423             return U_ILLEGAL_ARGUMENT_ERROR;
 424         }
 425     }
 426
 427     /* list items */
 428     if(options[OPT_LIST_ITEMS].doesOccur) {
 429         int32_t i;
 430         if (options[OPT_LIST_FILE].doesOccur) {
 431             FileStream *out;
 432             out = T_FileStream_open(options[OPT_LIST_FILE].value, "w");
 433             if (out != NULL) {
 434                 for(i=0; i<pkg->getItemCount(); ++i) {
 435                     T_FileStream_writeLine(out, pkg->getItem(i)->name);
 436                     T_FileStream_writeLine(out, "\n");
 437                 }
 438                 T_FileStream_close(out);
 439             } else {
 440                 return U_ILLEGAL_ARGUMENT_ERROR;
 441             }
 442         } else {
 443             for(i=0; i<pkg->getItemCount(); ++i) {
 444                 fprintf(stdout, "%s\n", pkg->getItem(i)->name);
 445             }
 446         }
 447     }
 448
 449     /* check dependencies between items */
 450     if(!pkg->checkDependencies()) {
 451         /* some dependencies are not fulfilled */
 452         return U_MISSING_RESOURCE_ERROR;
 453     }
 454
 455     /* write the output .dat package if there are any modifications */
 456     if(isModified) {
 457         char outFilenameBuffer[1024]; // for auto-generated output filename, if necessary
 458
 459         if(outFilename==NULL || outFilename[0]==0) {
 460             if(inFilename==NULL || inFilename[0]==0) {
 461                 fprintf(stderr, "icupkg: unable to auto-generate an output filename if there is no input filename\n");
 462                 exit(U_ILLEGAL_ARGUMENT_ERROR);
 463             }
 464
 465             /*
 466              * auto-generate a filename:
 467              * copy the inFilename,
 468              * and if the last basename character matches the input file's type,
 469              * then replace it with the output file's type
 470              */
 471             char suffix[6]="?.dat";
 472             char *s;
 473
 474             suffix[0]=pkg->getInType();
 475             strcpy(outFilenameBuffer, inFilename);
 476             s=strchr(outFilenameBuffer, 0);
 477             if((s-outFilenameBuffer)>5 && 0==memcmp(s-5, suffix, 5)) {
 478                 *(s-5)=outType;
 479             }
 480             outFilename=outFilenameBuffer;
 481         }
 482         result = writePackageDatFile(outFilename, outComment, NULL, NULL, pkg, outType);
 483     }
 484
 485     delete addListPkg;
 486     delete pkg;
 487     return result;
 488 }
 489
 490 /*
 491  * Hey, Emacs, please set the following:
 492  *
 493  * Local Variables:
 494  * indent-tabs-mode: nil
 495  * End:
 496  *
 497  */