| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 1999-2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: package.cpp |
| * encoding: UTF-8 |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 2005aug25 |
| * created by: Markus W. Scherer |
| * |
| * Read, modify, and write ICU .dat data package files. |
| * This is an integral part of the icupkg tool, moved to the toolutil library |
| * because parts of tool implementations tend to be later shared by |
| * other tools. |
| * Subsumes functionality and implementation code from |
| * gencmn, decmn, and icuswap tools. |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "unicode/putil.h" |
| #include "unicode/udata.h" |
| #include "cstring.h" |
| #include "uarrsort.h" |
| #include "ucmndata.h" |
| #include "udataswp.h" |
| #include "swapimpl.h" |
| #include "toolutil.h" |
| #include "package.h" |
| #include "cmemory.h" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| |
| static const int32_t kItemsChunk = 256; /* How much to increase the filesarray by each time */ |
| |
| // general definitions ----------------------------------------------------- *** |
| |
| /* UDataInfo cf. udata.h */ |
| static const UDataInfo dataInfo={ |
| (uint16_t)sizeof(UDataInfo), |
| 0, |
| |
| U_IS_BIG_ENDIAN, |
| U_CHARSET_FAMILY, |
| (uint8_t)sizeof(UChar), |
| 0, |
| |
| {0x43, 0x6d, 0x6e, 0x44}, /* dataFormat="CmnD" */ |
| {1, 0, 0, 0}, /* formatVersion */ |
| {3, 0, 0, 0} /* dataVersion */ |
| }; |
| |
| U_CDECL_BEGIN |
| static void U_CALLCONV |
| printPackageError(void *context, const char *fmt, va_list args) { |
| vfprintf((FILE *)context, fmt, args); |
| } |
| U_CDECL_END |
| |
| static uint16_t |
| readSwapUInt16(uint16_t x) { |
| return (uint16_t)((x<<8)|(x>>8)); |
| } |
| |
| // platform types ---------------------------------------------------------- *** |
| |
| static const char *types="lb?e"; |
| |
| enum { TYPE_L, TYPE_B, TYPE_LE, TYPE_E, TYPE_COUNT }; |
| |
| static inline int32_t |
| makeTypeEnum(uint8_t charset, UBool isBigEndian) { |
| return 2*(int32_t)charset+isBigEndian; |
| } |
| |
| static inline int32_t |
| makeTypeEnum(char type) { |
| return |
| type == 'l' ? TYPE_L : |
| type == 'b' ? TYPE_B : |
| type == 'e' ? TYPE_E : |
| -1; |
| } |
| |
| static inline char |
| makeTypeLetter(uint8_t charset, UBool isBigEndian) { |
| return types[makeTypeEnum(charset, isBigEndian)]; |
| } |
| |
| static inline char |
| makeTypeLetter(int32_t typeEnum) { |
| return types[typeEnum]; |
| } |
| |
| static void |
| makeTypeProps(char type, uint8_t &charset, UBool &isBigEndian) { |
| int32_t typeEnum=makeTypeEnum(type); |
| charset=(uint8_t)(typeEnum>>1); |
| isBigEndian=(UBool)(typeEnum&1); |
| } |
| |
| U_CFUNC const UDataInfo * |
| getDataInfo(const uint8_t *data, int32_t length, |
| int32_t &infoLength, int32_t &headerLength, |
| UErrorCode *pErrorCode) { |
| const DataHeader *pHeader; |
| const UDataInfo *pInfo; |
| |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return NULL; |
| } |
| if( data==NULL || |
| (length>=0 && length<(int32_t)sizeof(DataHeader)) |
| ) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } |
| |
| pHeader=(const DataHeader *)data; |
| pInfo=&pHeader->info; |
| if( (length>=0 && length<(int32_t)sizeof(DataHeader)) || |
| pHeader->dataHeader.magic1!=0xda || |
| pHeader->dataHeader.magic2!=0x27 || |
| pInfo->sizeofUChar!=2 |
| ) { |
| *pErrorCode=U_UNSUPPORTED_ERROR; |
| return NULL; |
| } |
| |
| if(pInfo->isBigEndian==U_IS_BIG_ENDIAN) { |
| headerLength=pHeader->dataHeader.headerSize; |
| infoLength=pInfo->size; |
| } else { |
| headerLength=readSwapUInt16(pHeader->dataHeader.headerSize); |
| infoLength=readSwapUInt16(pInfo->size); |
| } |
| |
| if( headerLength<(int32_t)sizeof(DataHeader) || |
| infoLength<(int32_t)sizeof(UDataInfo) || |
| headerLength<(int32_t)(sizeof(pHeader->dataHeader)+infoLength) || |
| (length>=0 && length<headerLength) |
| ) { |
| *pErrorCode=U_UNSUPPORTED_ERROR; |
| return NULL; |
| } |
| |
| return pInfo; |
| } |
| |
| static int32_t |
| getTypeEnumForInputData(const uint8_t *data, int32_t length, |
| UErrorCode *pErrorCode) { |
| const UDataInfo *pInfo; |
| int32_t infoLength, headerLength; |
| |
| /* getDataInfo() checks for illegal arguments */ |
| pInfo=getDataInfo(data, length, infoLength, headerLength, pErrorCode); |
| if(pInfo==NULL) { |
| return -1; |
| } |
| |
| return makeTypeEnum(pInfo->charsetFamily, (UBool)pInfo->isBigEndian); |
| } |
| |
| // file handling ----------------------------------------------------------- *** |
| |
| static void |
| extractPackageName(const char *filename, |
| char pkg[], int32_t capacity) { |
| const char *basename; |
| int32_t len; |
| |
| basename=findBasename(filename); |
| len=(int32_t)strlen(basename)-4; /* -4: subtract the length of ".dat" */ |
| |
| if(len<=0 || 0!=strcmp(basename+len, ".dat")) { |
| fprintf(stderr, "icupkg: \"%s\" is not recognized as a package filename (must end with .dat)\n", |
| basename); |
| exit(U_ILLEGAL_ARGUMENT_ERROR); |
| } |
| |
| if(len>=capacity) { |
| fprintf(stderr, "icupkg: the package name \"%s\" is too long (>=%ld)\n", |
| basename, (long)capacity); |
| exit(U_ILLEGAL_ARGUMENT_ERROR); |
| } |
| |
| memcpy(pkg, basename, len); |
| pkg[len]=0; |
| } |
| |
| static int32_t |
| getFileLength(FILE *f) { |
| int32_t length; |
| |
| fseek(f, 0, SEEK_END); |
| length=(int32_t)ftell(f); |
| fseek(f, 0, SEEK_SET); |
| return length; |
| } |
| |
| /* |
| * Turn tree separators and alternate file separators into normal file separators. |
| */ |
| static void |
| treeToPath(char *s) { |
| char *t; |
| |
| for(t=s; *t!=0; ++t) { |
| if(*t==U_TREE_ENTRY_SEP_CHAR || *t==U_FILE_ALT_SEP_CHAR) { |
| *t=U_FILE_SEP_CHAR; |
| } |
| } |
| } |
| |
| /* |
| * Turn file separators into tree separators. |
| */ |
| static void |
| pathToTree(char *s) { |
| char *t; |
| |
| for(t=s; *t!=0; ++t) { |
| if(*t==U_FILE_SEP_CHAR || *t==U_FILE_ALT_SEP_CHAR) { |
| *t=U_TREE_ENTRY_SEP_CHAR; |
| } |
| } |
| } |
| |
| /* |
| * Prepend the path (if any) to the name and run the name through treeToName(). |
| */ |
| static void |
| makeFullFilename(const char *path, const char *name, |
| char *filename, int32_t capacity) { |
| char *s; |
| |
| // prepend the path unless NULL or empty |
| if(path!=NULL && path[0]!=0) { |
| if((int32_t)(strlen(path)+1)>=capacity) { |
| fprintf(stderr, "pathname too long: \"%s\"\n", path); |
| exit(U_BUFFER_OVERFLOW_ERROR); |
| } |
| strcpy(filename, path); |
| |
| // make sure the path ends with a file separator |
| s=strchr(filename, 0); |
| if(*(s-1)!=U_FILE_SEP_CHAR && *(s-1)!=U_FILE_ALT_SEP_CHAR) { |
| *s++=U_FILE_SEP_CHAR; |
| } |
| } else { |
| s=filename; |
| } |
| |
| // turn the name into a filename, turn tree separators into file separators |
| if((int32_t)((s-filename)+strlen(name))>=capacity) { |
| fprintf(stderr, "path/filename too long: \"%s%s\"\n", filename, name); |
| exit(U_BUFFER_OVERFLOW_ERROR); |
| } |
| strcpy(s, name); |
| if (U_TREE_ENTRY_SEP_CHAR != U_FILE_SEP_CHAR || |
| U_FILE_ALT_SEP_CHAR != U_FILE_SEP_CHAR) { |
| treeToPath(s); |
| } |
| } |
| |
| static void |
| makeFullFilenameAndDirs(const char *path, const char *name, |
| char *filename, int32_t capacity) { |
| char *sep; |
| UErrorCode errorCode; |
| |
| makeFullFilename(path, name, filename, capacity); |
| |
| // make tree directories |
| errorCode=U_ZERO_ERROR; |
| sep=strchr(filename, 0)-strlen(name); |
| while((sep=strchr(sep, U_FILE_SEP_CHAR))!=NULL) { |
| if(sep!=filename) { |
| *sep=0; // truncate temporarily |
| uprv_mkdir(filename, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: unable to create tree directory \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| } |
| *sep++=U_FILE_SEP_CHAR; // restore file separator character |
| } |
| } |
| |
| static uint8_t * |
| readFile(const char *path, const char *name, int32_t &length, char &type) { |
| char filename[1024]; |
| FILE *file; |
| UErrorCode errorCode; |
| int32_t fileLength, typeEnum; |
| |
| makeFullFilename(path, name, filename, (int32_t)sizeof(filename)); |
| |
| /* open the input file, get its length, allocate memory for it, read the file */ |
| file=fopen(filename, "rb"); |
| if(file==NULL) { |
| fprintf(stderr, "icupkg: unable to open input file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| /* get the file length */ |
| fileLength=getFileLength(file); |
| if(ferror(file) || fileLength<=0) { |
| fprintf(stderr, "icupkg: empty input file \"%s\"\n", filename); |
| fclose(file); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| /* allocate the buffer, pad to multiple of 16 */ |
| length=(fileLength+0xf)&~0xf; |
| icu::LocalMemory<uint8_t> data((uint8_t *)uprv_malloc(length)); |
| if(data.isNull()) { |
| fclose(file); |
| fprintf(stderr, "icupkg: malloc error allocating %d bytes.\n", (int)length); |
| exit(U_MEMORY_ALLOCATION_ERROR); |
| } |
| |
| /* read the file */ |
| if(fileLength!=(int32_t)fread(data.getAlias(), 1, fileLength, file)) { |
| fprintf(stderr, "icupkg: error reading \"%s\"\n", filename); |
| fclose(file); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| /* pad the file to a multiple of 16 using the usual padding byte */ |
| if(fileLength<length) { |
| memset(data.getAlias()+fileLength, 0xaa, length-fileLength); |
| } |
| |
| fclose(file); |
| |
| // minimum check for ICU-format data |
| errorCode=U_ZERO_ERROR; |
| typeEnum=getTypeEnumForInputData(data.getAlias(), length, &errorCode); |
| if(typeEnum<0 || U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: not an ICU data file: \"%s\"\n", filename); |
| #if !UCONFIG_NO_LEGACY_CONVERSION |
| exit(U_INVALID_FORMAT_ERROR); |
| #else |
| fprintf(stderr, "U_INVALID_FORMAT_ERROR occurred but UCONFIG_NO_LEGACY_CONVERSION is on so this is expected.\n"); |
| exit(0); |
| #endif |
| } |
| type=makeTypeLetter(typeEnum); |
| |
| return data.orphan(); |
| } |
| |
| // .dat package file representation ---------------------------------------- *** |
| |
| U_CDECL_BEGIN |
| |
| static int32_t U_CALLCONV |
| compareItems(const void * /*context*/, const void *left, const void *right) { |
| U_NAMESPACE_USE |
| |
| return (int32_t)strcmp(((Item *)left)->name, ((Item *)right)->name); |
| } |
| |
| U_CDECL_END |
| |
| U_NAMESPACE_BEGIN |
| |
| Package::Package() |
| : doAutoPrefix(FALSE), prefixEndsWithType(FALSE) { |
| inPkgName[0]=0; |
| pkgPrefix[0]=0; |
| inData=NULL; |
| inLength=0; |
| inCharset=U_CHARSET_FAMILY; |
| inIsBigEndian=U_IS_BIG_ENDIAN; |
| |
| itemCount=0; |
| itemMax=0; |
| items=NULL; |
| |
| inStringTop=outStringTop=0; |
| |
| matchMode=0; |
| findPrefix=findSuffix=NULL; |
| findPrefixLength=findSuffixLength=0; |
| findNextIndex=-1; |
| |
| // create a header for an empty package |
| DataHeader *pHeader; |
| pHeader=(DataHeader *)header; |
| pHeader->dataHeader.magic1=0xda; |
| pHeader->dataHeader.magic2=0x27; |
| memcpy(&pHeader->info, &dataInfo, sizeof(dataInfo)); |
| headerLength=(int32_t)(4+sizeof(dataInfo)); |
| if(headerLength&0xf) { |
| /* NUL-pad the header to a multiple of 16 */ |
| int32_t length=(headerLength+0xf)&~0xf; |
| memset(header+headerLength, 0, length-headerLength); |
| headerLength=length; |
| } |
| pHeader->dataHeader.headerSize=(uint16_t)headerLength; |
| } |
| |
| Package::~Package() { |
| int32_t idx; |
| |
| uprv_free(inData); |
| |
| for(idx=0; idx<itemCount; ++idx) { |
| if(items[idx].isDataOwned) { |
| uprv_free(items[idx].data); |
| } |
| } |
| |
| uprv_free((void*)items); |
| } |
| |
| void |
| Package::setPrefix(const char *p) { |
| if(strlen(p)>=sizeof(pkgPrefix)) { |
| fprintf(stderr, "icupkg: --toc_prefix %s too long\n", p); |
| exit(U_ILLEGAL_ARGUMENT_ERROR); |
| } |
| strcpy(pkgPrefix, p); |
| } |
| |
| void |
| Package::readPackage(const char *filename) { |
| UDataSwapper *ds; |
| const UDataInfo *pInfo; |
| UErrorCode errorCode; |
| |
| const uint8_t *inBytes; |
| |
| int32_t length, offset, i; |
| int32_t itemLength, typeEnum; |
| char type; |
| |
| const UDataOffsetTOCEntry *inEntries; |
| |
| extractPackageName(filename, inPkgName, (int32_t)sizeof(inPkgName)); |
| |
| /* read the file */ |
| inData=readFile(NULL, filename, inLength, type); |
| length=inLength; |
| |
| /* |
| * swap the header - even if the swapping itself is a no-op |
| * because it tells us the header length |
| */ |
| errorCode=U_ZERO_ERROR; |
| makeTypeProps(type, inCharset, inIsBigEndian); |
| ds=udata_openSwapper(inIsBigEndian, inCharset, U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: udata_openSwapper(\"%s\") failed - %s\n", |
| filename, u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| |
| ds->printError=printPackageError; |
| ds->printErrorContext=stderr; |
| |
| headerLength=sizeof(header); |
| if(length<headerLength) { |
| headerLength=length; |
| } |
| headerLength=udata_swapDataHeader(ds, inData, headerLength, header, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| exit(errorCode); |
| } |
| |
| /* check data format and format version */ |
| pInfo=(const UDataInfo *)((const char *)inData+4); |
| if(!( |
| pInfo->dataFormat[0]==0x43 && /* dataFormat="CmnD" */ |
| pInfo->dataFormat[1]==0x6d && |
| pInfo->dataFormat[2]==0x6e && |
| pInfo->dataFormat[3]==0x44 && |
| pInfo->formatVersion[0]==1 |
| )) { |
| fprintf(stderr, "icupkg: data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as an ICU .dat package\n", |
| pInfo->dataFormat[0], pInfo->dataFormat[1], |
| pInfo->dataFormat[2], pInfo->dataFormat[3], |
| pInfo->formatVersion[0]); |
| exit(U_UNSUPPORTED_ERROR); |
| } |
| inIsBigEndian=(UBool)pInfo->isBigEndian; |
| inCharset=pInfo->charsetFamily; |
| |
| inBytes=(const uint8_t *)inData+headerLength; |
| inEntries=(const UDataOffsetTOCEntry *)(inBytes+4); |
| |
| /* check that the itemCount fits, then the ToC table, then at least the header of the last item */ |
| length-=headerLength; |
| if(length<4) { |
| /* itemCount does not fit */ |
| offset=0x7fffffff; |
| } else { |
| itemCount=udata_readInt32(ds, *(const int32_t *)inBytes); |
| setItemCapacity(itemCount); /* resize so there's space */ |
| if(itemCount==0) { |
| offset=4; |
| } else if(length<(4+8*itemCount)) { |
| /* ToC table does not fit */ |
| offset=0x7fffffff; |
| } else { |
| /* offset of the last item plus at least 20 bytes for its header */ |
| offset=20+(int32_t)ds->readUInt32(inEntries[itemCount-1].dataOffset); |
| } |
| } |
| if(length<offset) { |
| fprintf(stderr, "icupkg: too few bytes (%ld after header) for a .dat package\n", |
| (long)length); |
| exit(U_INDEX_OUTOFBOUNDS_ERROR); |
| } |
| /* do not modify the package length variable until the last item's length is set */ |
| |
| if(itemCount<=0) { |
| if(doAutoPrefix) { |
| fprintf(stderr, "icupkg: --auto_toc_prefix[_with_type] but the input package is empty\n"); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| } else { |
| char prefix[MAX_PKG_NAME_LENGTH+4]; |
| char *s, *inItemStrings; |
| |
| if(itemCount>itemMax) { |
| fprintf(stderr, "icupkg: too many items, maximum is %d\n", itemMax); |
| exit(U_BUFFER_OVERFLOW_ERROR); |
| } |
| |
| /* swap the item name strings */ |
| int32_t stringsOffset=4+8*itemCount; |
| itemLength=(int32_t)(ds->readUInt32(inEntries[0].dataOffset))-stringsOffset; |
| |
| // don't include padding bytes at the end of the item names |
| while(itemLength>0 && inBytes[stringsOffset+itemLength-1]!=0) { |
| --itemLength; |
| } |
| |
| if((inStringTop+itemLength)>STRING_STORE_SIZE) { |
| fprintf(stderr, "icupkg: total length of item name strings too long\n"); |
| exit(U_BUFFER_OVERFLOW_ERROR); |
| } |
| |
| inItemStrings=inStrings+inStringTop; |
| ds->swapInvChars(ds, inBytes+stringsOffset, itemLength, inItemStrings, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg failed to swap the input .dat package item name strings\n"); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| inStringTop+=itemLength; |
| |
| // reset the Item entries |
| memset(items, 0, itemCount*sizeof(Item)); |
| |
| /* |
| * Get the common prefix of the items. |
| * New-style ICU .dat packages use tree separators ('/') between package names, |
| * tree names, and item names, |
| * while old-style ICU .dat packages (before multi-tree support) |
| * use an underscore ('_') between package and item names. |
| */ |
| offset=(int32_t)ds->readUInt32(inEntries[0].nameOffset)-stringsOffset; |
| s=inItemStrings+offset; // name of the first entry |
| int32_t prefixLength; |
| if(doAutoPrefix) { |
| // Use the first entry's prefix. Must be a new-style package. |
| const char *prefixLimit=strchr(s, U_TREE_ENTRY_SEP_CHAR); |
| if(prefixLimit==NULL) { |
| fprintf(stderr, |
| "icupkg: --auto_toc_prefix[_with_type] but " |
| "the first entry \"%s\" does not contain a '%c'\n", |
| s, U_TREE_ENTRY_SEP_CHAR); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| prefixLength=(int32_t)(prefixLimit-s); |
| if(prefixLength==0 || prefixLength>=UPRV_LENGTHOF(pkgPrefix)) { |
| fprintf(stderr, |
| "icupkg: --auto_toc_prefix[_with_type] but " |
| "the prefix of the first entry \"%s\" is empty or too long\n", |
| s); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(prefixEndsWithType && s[prefixLength-1]!=type) { |
| fprintf(stderr, |
| "icupkg: --auto_toc_prefix_with_type but " |
| "the prefix of the first entry \"%s\" does not end with '%c'\n", |
| s, type); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| memcpy(pkgPrefix, s, prefixLength); |
| pkgPrefix[prefixLength]=0; |
| memcpy(prefix, s, ++prefixLength); // include the / |
| } else { |
| // Use the package basename as prefix. |
| int32_t inPkgNameLength= static_cast<int32_t>(strlen(inPkgName)); |
| memcpy(prefix, inPkgName, inPkgNameLength); |
| prefixLength=inPkgNameLength; |
| |
| if( (int32_t)strlen(s)>=(inPkgNameLength+2) && |
| 0==memcmp(s, inPkgName, inPkgNameLength) && |
| s[inPkgNameLength]=='_' |
| ) { |
| // old-style .dat package |
| prefix[prefixLength++]='_'; |
| } else { |
| // new-style .dat package |
| prefix[prefixLength++]=U_TREE_ENTRY_SEP_CHAR; |
| // if it turns out to not contain U_TREE_ENTRY_SEP_CHAR |
| // then the test in the loop below will fail |
| } |
| } |
| prefix[prefixLength]=0; |
| |
| /* read the ToC table */ |
| for(i=0; i<itemCount; ++i) { |
| // skip the package part of the item name, error if it does not match the actual package name |
| // or if nothing follows the package name |
| offset=(int32_t)ds->readUInt32(inEntries[i].nameOffset)-stringsOffset; |
| s=inItemStrings+offset; |
| if(0!=strncmp(s, prefix, prefixLength) || s[prefixLength]==0) { |
| fprintf(stderr, "icupkg: input .dat item name \"%s\" does not start with \"%s\"\n", |
| s, prefix); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| items[i].name=s+prefixLength; |
| |
| // set the item's data |
| items[i].data=(uint8_t *)inBytes+ds->readUInt32(inEntries[i].dataOffset); |
| if(i>0) { |
| items[i-1].length=(int32_t)(items[i].data-items[i-1].data); |
| |
| // set the previous item's platform type |
| typeEnum=getTypeEnumForInputData(items[i-1].data, items[i-1].length, &errorCode); |
| if(typeEnum<0 || U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: not an ICU data file: item \"%s\" in \"%s\"\n", items[i-1].name, filename); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| items[i-1].type=makeTypeLetter(typeEnum); |
| } |
| items[i].isDataOwned=FALSE; |
| } |
| // set the last item's length |
| items[itemCount-1].length=length-ds->readUInt32(inEntries[itemCount-1].dataOffset); |
| |
| // set the last item's platform type |
| typeEnum=getTypeEnumForInputData(items[itemCount-1].data, items[itemCount-1].length, &errorCode); |
| if(typeEnum<0 || U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: not an ICU data file: item \"%s\" in \"%s\"\n", items[itemCount-1].name, filename); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| items[itemCount-1].type=makeTypeLetter(typeEnum); |
| |
| if(type!=U_ICUDATA_TYPE_LETTER[0]) { |
| // sort the item names for the local charset |
| sortItems(); |
| } |
| } |
| |
| udata_closeSwapper(ds); |
| } |
| |
| char |
| Package::getInType() { |
| return makeTypeLetter(inCharset, inIsBigEndian); |
| } |
| |
| void |
| Package::writePackage(const char *filename, char outType, const char *comment) { |
| char prefix[MAX_PKG_NAME_LENGTH+4]; |
| UDataOffsetTOCEntry entry; |
| UDataSwapper *dsLocalToOut, *ds[TYPE_COUNT]; |
| FILE *file; |
| Item *pItem; |
| char *name; |
| UErrorCode errorCode; |
| int32_t i, length, prefixLength, maxItemLength, basenameOffset, offset, outInt32; |
| uint8_t outCharset; |
| UBool outIsBigEndian; |
| |
| extractPackageName(filename, prefix, MAX_PKG_NAME_LENGTH); |
| |
| // if there is an explicit comment, then use it, else use what's in the current header |
| if(comment!=NULL) { |
| /* get the header size minus the current comment */ |
| DataHeader *pHeader; |
| int32_t length; |
| |
| pHeader=(DataHeader *)header; |
| headerLength=4+pHeader->info.size; |
| length=(int32_t)strlen(comment); |
| if((int32_t)(headerLength+length)>=(int32_t)sizeof(header)) { |
| fprintf(stderr, "icupkg: comment too long\n"); |
| exit(U_BUFFER_OVERFLOW_ERROR); |
| } |
| memcpy(header+headerLength, comment, length+1); |
| headerLength+=length; |
| if(headerLength&0xf) { |
| /* NUL-pad the header to a multiple of 16 */ |
| length=(headerLength+0xf)&~0xf; |
| memset(header+headerLength, 0, length-headerLength); |
| headerLength=length; |
| } |
| pHeader->dataHeader.headerSize=(uint16_t)headerLength; |
| } |
| |
| makeTypeProps(outType, outCharset, outIsBigEndian); |
| |
| // open (TYPE_COUNT-2) swappers |
| // one is a no-op for local type==outType |
| // one type (TYPE_LE) is bogus |
| errorCode=U_ZERO_ERROR; |
| i=makeTypeEnum(outType); |
| ds[TYPE_B]= i==TYPE_B ? NULL : udata_openSwapper(TRUE, U_ASCII_FAMILY, outIsBigEndian, outCharset, &errorCode); |
| ds[TYPE_L]= i==TYPE_L ? NULL : udata_openSwapper(FALSE, U_ASCII_FAMILY, outIsBigEndian, outCharset, &errorCode); |
| ds[TYPE_LE]=NULL; |
| ds[TYPE_E]= i==TYPE_E ? NULL : udata_openSwapper(TRUE, U_EBCDIC_FAMILY, outIsBigEndian, outCharset, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: udata_openSwapper() failed - %s\n", u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| for(i=0; i<TYPE_COUNT; ++i) { |
| if(ds[i]!=NULL) { |
| ds[i]->printError=printPackageError; |
| ds[i]->printErrorContext=stderr; |
| } |
| } |
| |
| dsLocalToOut=ds[makeTypeEnum(U_CHARSET_FAMILY, U_IS_BIG_ENDIAN)]; |
| |
| // create the file and write its contents |
| file=fopen(filename, "wb"); |
| if(file==NULL) { |
| fprintf(stderr, "icupkg: unable to create file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| // swap and write the header |
| if(dsLocalToOut!=NULL) { |
| udata_swapDataHeader(dsLocalToOut, header, headerLength, header, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: udata_swapDataHeader(local to out) failed - %s\n", u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| } |
| length=(int32_t)fwrite(header, 1, headerLength, file); |
| if(length!=headerLength) { |
| fprintf(stderr, "icupkg: unable to write complete header to file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| // prepare and swap the package name with a tree separator |
| // for prepending to item names |
| if(pkgPrefix[0]==0) { |
| prefixLength=(int32_t)strlen(prefix); |
| } else { |
| prefixLength=(int32_t)strlen(pkgPrefix); |
| memcpy(prefix, pkgPrefix, prefixLength); |
| if(prefixEndsWithType) { |
| prefix[prefixLength-1]=outType; |
| } |
| } |
| prefix[prefixLength++]=U_TREE_ENTRY_SEP_CHAR; |
| prefix[prefixLength]=0; |
| if(dsLocalToOut!=NULL) { |
| dsLocalToOut->swapInvChars(dsLocalToOut, prefix, prefixLength, prefix, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: swapInvChars(output package name) failed - %s\n", u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| |
| // swap and sort the item names (sorting needs to be done in the output charset) |
| dsLocalToOut->swapInvChars(dsLocalToOut, inStrings, inStringTop, inStrings, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: swapInvChars(item names) failed - %s\n", u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| sortItems(); |
| } |
| |
| // create the output item names in sorted order, with the package name prepended to each |
| for(i=0; i<itemCount; ++i) { |
| length=(int32_t)strlen(items[i].name); |
| name=allocString(FALSE, length+prefixLength); |
| memcpy(name, prefix, prefixLength); |
| memcpy(name+prefixLength, items[i].name, length+1); |
| items[i].name=name; |
| } |
| |
| // calculate offsets for item names and items, pad to 16-align items |
| // align only the first item; each item's length is a multiple of 16 |
| basenameOffset=4+8*itemCount; |
| offset=basenameOffset+outStringTop; |
| if((length=(offset&15))!=0) { |
| length=16-length; |
| memset(allocString(FALSE, length-1), 0xaa, length); |
| offset+=length; |
| } |
| |
| // write the table of contents |
| // first the itemCount |
| outInt32=itemCount; |
| if(dsLocalToOut!=NULL) { |
| dsLocalToOut->swapArray32(dsLocalToOut, &outInt32, 4, &outInt32, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: swapArray32(item count) failed - %s\n", u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| } |
| length=(int32_t)fwrite(&outInt32, 1, 4, file); |
| if(length!=4) { |
| fprintf(stderr, "icupkg: unable to write complete item count to file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| // then write the item entries (and collect the maxItemLength) |
| maxItemLength=0; |
| for(i=0; i<itemCount; ++i) { |
| entry.nameOffset=(uint32_t)(basenameOffset+(items[i].name-outStrings)); |
| entry.dataOffset=(uint32_t)offset; |
| if(dsLocalToOut!=NULL) { |
| dsLocalToOut->swapArray32(dsLocalToOut, &entry, 8, &entry, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: swapArray32(item entry %ld) failed - %s\n", (long)i, u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| } |
| length=(int32_t)fwrite(&entry, 1, 8, file); |
| if(length!=8) { |
| fprintf(stderr, "icupkg: unable to write complete item entry %ld to file \"%s\"\n", (long)i, filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| length=items[i].length; |
| if(length>maxItemLength) { |
| maxItemLength=length; |
| } |
| offset+=length; |
| } |
| |
| // write the item names |
| length=(int32_t)fwrite(outStrings, 1, outStringTop, file); |
| if(length!=outStringTop) { |
| fprintf(stderr, "icupkg: unable to write complete item names to file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| // write the items |
| for(pItem=items, i=0; i<itemCount; ++pItem, ++i) { |
| int32_t type=makeTypeEnum(pItem->type); |
| if(ds[type]!=NULL) { |
| // swap each item from its platform properties to the desired ones |
| udata_swap( |
| ds[type], |
| pItem->data, pItem->length, pItem->data, |
| &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: udata_swap(item %ld) failed - %s\n", (long)i, u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| } |
| length=(int32_t)fwrite(pItem->data, 1, pItem->length, file); |
| if(length!=pItem->length) { |
| fprintf(stderr, "icupkg: unable to write complete item %ld to file \"%s\"\n", (long)i, filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| } |
| |
| if(ferror(file)) { |
| fprintf(stderr, "icupkg: unable to write complete file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| |
| fclose(file); |
| for(i=0; i<TYPE_COUNT; ++i) { |
| udata_closeSwapper(ds[i]); |
| } |
| } |
| |
| int32_t |
| Package::findItem(const char *name, int32_t length) const { |
| int32_t i, start, limit; |
| int result; |
| |
| /* do a binary search for the string */ |
| start=0; |
| limit=itemCount; |
| while(start<limit) { |
| i=(start+limit)/2; |
| if(length>=0) { |
| result=strncmp(name, items[i].name, length); |
| } else { |
| result=strcmp(name, items[i].name); |
| } |
| |
| if(result==0) { |
| /* found */ |
| if(length>=0) { |
| /* |
| * if we compared just prefixes, then we may need to back up |
| * to the first item with this prefix |
| */ |
| while(i>0 && 0==strncmp(name, items[i-1].name, length)) { |
| --i; |
| } |
| } |
| return i; |
| } else if(result<0) { |
| limit=i; |
| } else /* result>0 */ { |
| start=i+1; |
| } |
| } |
| |
| return ~start; /* not found, return binary-not of the insertion point */ |
| } |
| |
| void |
| Package::findItems(const char *pattern) { |
| const char *wild; |
| |
| if(pattern==NULL || *pattern==0) { |
| findNextIndex=-1; |
| return; |
| } |
| |
| findPrefix=pattern; |
| findSuffix=NULL; |
| findSuffixLength=0; |
| |
| wild=strchr(pattern, '*'); |
| if(wild==NULL) { |
| // no wildcard |
| findPrefixLength=(int32_t)strlen(pattern); |
| } else { |
| // one wildcard |
| findPrefixLength=(int32_t)(wild-pattern); |
| findSuffix=wild+1; |
| findSuffixLength=(int32_t)strlen(findSuffix); |
| if(NULL!=strchr(findSuffix, '*')) { |
| // two or more wildcards |
| fprintf(stderr, "icupkg: syntax error (more than one '*') in item pattern \"%s\"\n", pattern); |
| exit(U_PARSE_ERROR); |
| } |
| } |
| |
| if(findPrefixLength==0) { |
| findNextIndex=0; |
| } else { |
| findNextIndex=findItem(findPrefix, findPrefixLength); |
| } |
| } |
| |
| int32_t |
| Package::findNextItem() { |
| const char *name, *middle, *treeSep; |
| int32_t idx, nameLength, middleLength; |
| |
| if(findNextIndex<0) { |
| return -1; |
| } |
| |
| while(findNextIndex<itemCount) { |
| idx=findNextIndex++; |
| name=items[idx].name; |
| nameLength=(int32_t)strlen(name); |
| if(nameLength<(findPrefixLength+findSuffixLength)) { |
| // item name too short for prefix & suffix |
| continue; |
| } |
| if(findPrefixLength>0 && 0!=memcmp(findPrefix, name, findPrefixLength)) { |
| // left the range of names with this prefix |
| break; |
| } |
| middle=name+findPrefixLength; |
| middleLength=nameLength-findPrefixLength-findSuffixLength; |
| if(findSuffixLength>0 && 0!=memcmp(findSuffix, name+(nameLength-findSuffixLength), findSuffixLength)) { |
| // suffix does not match |
| continue; |
| } |
| // prefix & suffix match |
| |
| if(matchMode&MATCH_NOSLASH) { |
| treeSep=strchr(middle, U_TREE_ENTRY_SEP_CHAR); |
| if(treeSep!=NULL && (treeSep-middle)<middleLength) { |
| // the middle (matching the * wildcard) contains a tree separator / |
| continue; |
| } |
| } |
| |
| // found a matching item |
| return idx; |
| } |
| |
| // no more items |
| findNextIndex=-1; |
| return -1; |
| } |
| |
| void |
| Package::setMatchMode(uint32_t mode) { |
| matchMode=mode; |
| } |
| |
| void |
| Package::addItem(const char *name) { |
| addItem(name, NULL, 0, FALSE, U_ICUDATA_TYPE_LETTER[0]); |
| } |
| |
| void |
| Package::addItem(const char *name, uint8_t *data, int32_t length, UBool isDataOwned, char type) { |
| int32_t idx; |
| |
| idx=findItem(name); |
| if(idx<0) { |
| // new item, make space at the insertion point |
| ensureItemCapacity(); |
| // move the following items down |
| idx=~idx; |
| if(idx<itemCount) { |
| memmove(items+idx+1, items+idx, (itemCount-idx)*sizeof(Item)); |
| } |
| ++itemCount; |
| |
| // reset this Item entry |
| memset(items+idx, 0, sizeof(Item)); |
| |
| // copy the item's name |
| items[idx].name=allocString(TRUE, static_cast<int32_t>(strlen(name))); |
| strcpy(items[idx].name, name); |
| if (U_TREE_ENTRY_SEP_CHAR != U_FILE_SEP_CHAR || |
| U_FILE_ALT_SEP_CHAR != U_FILE_SEP_CHAR) { |
| pathToTree(items[idx].name); |
| } |
| } else { |
| // same-name item found, replace it |
| if(items[idx].isDataOwned) { |
| uprv_free(items[idx].data); |
| } |
| |
| // keep the item's name since it is the same |
| } |
| |
| // set the item's data |
| items[idx].data=data; |
| items[idx].length=length; |
| items[idx].isDataOwned=isDataOwned; |
| items[idx].type=type; |
| } |
| |
| void |
| Package::addFile(const char *filesPath, const char *name) { |
| uint8_t *data; |
| int32_t length; |
| char type; |
| |
| data=readFile(filesPath, name, length, type); |
| // readFile() exits the tool if it fails |
| addItem(name, data, length, TRUE, type); |
| } |
| |
| void |
| Package::addItems(const Package &listPkg) { |
| const Item *pItem; |
| int32_t i; |
| |
| for(pItem=listPkg.items, i=0; i<listPkg.itemCount; ++pItem, ++i) { |
| addItem(pItem->name, pItem->data, pItem->length, FALSE, pItem->type); |
| } |
| } |
| |
| void |
| Package::removeItem(int32_t idx) { |
| if(idx>=0) { |
| // remove the item |
| if(items[idx].isDataOwned) { |
| uprv_free(items[idx].data); |
| } |
| |
| // move the following items up |
| if((idx+1)<itemCount) { |
| memmove(items+idx, items+idx+1, (itemCount-(idx+1))*sizeof(Item)); |
| } |
| --itemCount; |
| |
| if(idx<=findNextIndex) { |
| --findNextIndex; |
| } |
| } |
| } |
| |
| void |
| Package::removeItems(const char *pattern) { |
| int32_t idx; |
| |
| findItems(pattern); |
| while((idx=findNextItem())>=0) { |
| removeItem(idx); |
| } |
| } |
| |
| void |
| Package::removeItems(const Package &listPkg) { |
| const Item *pItem; |
| int32_t i; |
| |
| for(pItem=listPkg.items, i=0; i<listPkg.itemCount; ++pItem, ++i) { |
| removeItems(pItem->name); |
| } |
| } |
| |
| void |
| Package::extractItem(const char *filesPath, const char *outName, int32_t idx, char outType) { |
| char filename[1024]; |
| UDataSwapper *ds; |
| FILE *file; |
| Item *pItem; |
| int32_t fileLength; |
| uint8_t itemCharset, outCharset; |
| UBool itemIsBigEndian, outIsBigEndian; |
| |
| if(idx<0 || itemCount<=idx) { |
| return; |
| } |
| pItem=items+idx; |
| |
| // swap the data to the outType |
| // outType==0: don't swap |
| if(outType!=0 && pItem->type!=outType) { |
| // open the swapper |
| UErrorCode errorCode=U_ZERO_ERROR; |
| makeTypeProps(pItem->type, itemCharset, itemIsBigEndian); |
| makeTypeProps(outType, outCharset, outIsBigEndian); |
| ds=udata_openSwapper(itemIsBigEndian, itemCharset, outIsBigEndian, outCharset, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: udata_openSwapper(item %ld) failed - %s\n", |
| (long)idx, u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| |
| ds->printError=printPackageError; |
| ds->printErrorContext=stderr; |
| |
| // swap the item from its platform properties to the desired ones |
| udata_swap(ds, pItem->data, pItem->length, pItem->data, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: udata_swap(item %ld) failed - %s\n", (long)idx, u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| udata_closeSwapper(ds); |
| pItem->type=outType; |
| } |
| |
| // create the file and write its contents |
| makeFullFilenameAndDirs(filesPath, outName, filename, (int32_t)sizeof(filename)); |
| file=fopen(filename, "wb"); |
| if(file==NULL) { |
| fprintf(stderr, "icupkg: unable to create file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| fileLength=(int32_t)fwrite(pItem->data, 1, pItem->length, file); |
| |
| if(ferror(file) || fileLength!=pItem->length) { |
| fprintf(stderr, "icupkg: unable to write complete file \"%s\"\n", filename); |
| exit(U_FILE_ACCESS_ERROR); |
| } |
| fclose(file); |
| } |
| |
| void |
| Package::extractItem(const char *filesPath, int32_t idx, char outType) { |
| extractItem(filesPath, items[idx].name, idx, outType); |
| } |
| |
| void |
| Package::extractItems(const char *filesPath, const char *pattern, char outType) { |
| int32_t idx; |
| |
| findItems(pattern); |
| while((idx=findNextItem())>=0) { |
| extractItem(filesPath, idx, outType); |
| } |
| } |
| |
| void |
| Package::extractItems(const char *filesPath, const Package &listPkg, char outType) { |
| const Item *pItem; |
| int32_t i; |
| |
| for(pItem=listPkg.items, i=0; i<listPkg.itemCount; ++pItem, ++i) { |
| extractItems(filesPath, pItem->name, outType); |
| } |
| } |
| |
| int32_t |
| Package::getItemCount() const { |
| return itemCount; |
| } |
| |
| const Item * |
| Package::getItem(int32_t idx) const { |
| if (0 <= idx && idx < itemCount) { |
| return &items[idx]; |
| } |
| return NULL; |
| } |
| |
| void |
| Package::checkDependency(void *context, const char *itemName, const char *targetName) { |
| // check dependency: make sure the target item is in the package |
| Package *me=(Package *)context; |
| if(me->findItem(targetName)<0) { |
| me->isMissingItems=TRUE; |
| fprintf(stderr, "Item %s depends on missing item %s\n", itemName, targetName); |
| } |
| } |
| |
| UBool |
| Package::checkDependencies() { |
| isMissingItems=FALSE; |
| enumDependencies(this, checkDependency); |
| return (UBool)!isMissingItems; |
| } |
| |
| void |
| Package::enumDependencies(void *context, CheckDependency check) { |
| int32_t i; |
| |
| for(i=0; i<itemCount; ++i) { |
| enumDependencies(items+i, context, check); |
| } |
| } |
| |
| char * |
| Package::allocString(UBool in, int32_t length) { |
| char *p; |
| int32_t top; |
| |
| if(in) { |
| top=inStringTop; |
| p=inStrings+top; |
| } else { |
| top=outStringTop; |
| p=outStrings+top; |
| } |
| top+=length+1; |
| |
| if(top>STRING_STORE_SIZE) { |
| fprintf(stderr, "icupkg: string storage overflow\n"); |
| exit(U_BUFFER_OVERFLOW_ERROR); |
| } |
| if(in) { |
| inStringTop=top; |
| } else { |
| outStringTop=top; |
| } |
| return p; |
| } |
| |
| void |
| Package::sortItems() { |
| UErrorCode errorCode=U_ZERO_ERROR; |
| uprv_sortArray(items, itemCount, (int32_t)sizeof(Item), compareItems, NULL, FALSE, &errorCode); |
| if(U_FAILURE(errorCode)) { |
| fprintf(stderr, "icupkg: sorting item names failed - %s\n", u_errorName(errorCode)); |
| exit(errorCode); |
| } |
| } |
| |
| void Package::setItemCapacity(int32_t max) |
| { |
| if(max<=itemMax) { |
| return; |
| } |
| Item *newItems = (Item*)uprv_malloc(max * sizeof(items[0])); |
| Item *oldItems = items; |
| if(newItems == NULL) { |
| fprintf(stderr, "icupkg: Out of memory trying to allocate %lu bytes for %d items\n", |
| (unsigned long)(max*sizeof(items[0])), max); |
| exit(U_MEMORY_ALLOCATION_ERROR); |
| } |
| if(items && itemCount>0) { |
| uprv_memcpy(newItems, items, (size_t)itemCount*sizeof(items[0])); |
| } |
| itemMax = max; |
| items = newItems; |
| uprv_free(oldItems); |
| } |
| |
| void Package::ensureItemCapacity() |
| { |
| if((itemCount+1)>itemMax) { |
| setItemCapacity(itemCount+kItemsChunk); |
| } |
| } |
| |
| U_NAMESPACE_END |
