--- /dev/null
+/*
+*******************************************************************************
+*
+* Copyright (C) 2003-2006, International Business Machines
+* Corporation and others. All Rights Reserved.
+*
+*******************************************************************************
+* file name: pkgitems.cpp
+* encoding: US-ASCII
+* tab size: 8 (not used)
+* indentation:4
+*
+* created on: 2005sep18
+* created by: Markus W. Scherer
+*
+* Companion file to package.cpp. Deals with details of ICU data item formats.
+* Used for item dependencies.
+* Contains adapted code from uresdata.c and ucnv_bld.c (swapper code from 2003).
+*/
+
+#include "unicode/utypes.h"
+#include "unicode/ures.h"
+#include "unicode/putil.h"
+#include "unicode/udata.h"
+#include "cstring.h"
+#include "ucmndata.h"
+#include "udataswp.h"
+#include "swapimpl.h"
+#include "toolutil.h"
+#include "package.h"
+#include "pkg_imp.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* item formats in common */
+
+#include "uresdata.h"
+#include "ucnv_bld.h"
+#include "ucnv_io.h"
+
+// general definitions ----------------------------------------------------- ***
+
+#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+
+U_CDECL_BEGIN
+
+static void U_CALLCONV
+printError(void *context, const char *fmt, va_list args) {
+ vfprintf((FILE *)context, fmt, args);
+}
+
+U_CDECL_END
+
+typedef void CheckDependency(void *context, const char *itemName, const char *targetName);
+
+// check a dependency ------------------------------------------------------ ***
+
+/*
+ * assemble the target item name from the source item name, an ID
+ * and a suffix
+ */
+static void
+checkIDSuffix(const char *itemName, const char *id, int32_t idLength, const char *suffix,
+ CheckDependency check, void *context,
+ UErrorCode *pErrorCode) {
+ char target[200];
+ const char *itemID;
+ int32_t treeLength, suffixLength, targetLength;
+
+ // get the item basename
+ itemID=strrchr(itemName, '/');
+ if(itemID!=NULL) {
+ ++itemID;
+ } else {
+ itemID=itemName;
+ }
+
+ // build the target string
+ treeLength=(int32_t)(itemID-itemName);
+ if(idLength<0) {
+ idLength=(int32_t)strlen(id);
+ }
+ suffixLength=(int32_t)strlen(suffix);
+ targetLength=treeLength+idLength+suffixLength;
+ if(targetLength>=(int32_t)sizeof(target)) {
+ fprintf(stderr, "icupkg/checkIDSuffix(%s) alias target item name length %ld too long\n",
+ itemName, (long)targetLength);
+ *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
+ return;
+ }
+
+ memcpy(target, itemName, treeLength);
+ memcpy(target+treeLength, id, idLength);
+ memcpy(target+treeLength+idLength, suffix, suffixLength+1); // +1 includes the terminating NUL
+
+ check(context, itemName, target);
+}
+
+/* assemble the target item name from the item's parent item name */
+static void
+checkParent(const char *itemName, CheckDependency check, void *context,
+ UErrorCode *pErrorCode) {
+ const char *itemID, *parent, *parentLimit, *suffix;
+ int32_t parentLength;
+
+ // get the item basename
+ itemID=strrchr(itemName, '/');
+ if(itemID!=NULL) {
+ ++itemID;
+ } else {
+ itemID=itemName;
+ }
+
+ // get the item suffix
+ suffix=strrchr(itemID, '.');
+ if(suffix==NULL) {
+ // empty suffix, point to the end of the string
+ suffix=strrchr(itemID, 0);
+ }
+
+ // get the position of the last '_'
+ for(parentLimit=suffix; parentLimit>itemID && *--parentLimit!='_';) {}
+
+ if(parentLimit!=itemID) {
+ // get the parent item name by truncating the last part of this item's name */
+ parent=itemID;
+ parentLength=(int32_t)(parentLimit-itemID);
+ } else {
+ // no '_' in the item name: the parent is the root bundle
+ parent="root";
+ parentLength=4;
+ if((suffix-itemID)==parentLength && 0==memcmp(itemID, parent, parentLength)) {
+ // the item itself is "root", which does not depend on a parent
+ return;
+ }
+ }
+ checkIDSuffix(itemName, parent, parentLength, suffix, check, context, pErrorCode);
+}
+
+// get dependencies from resource bundles ---------------------------------- ***
+
+static const char *const gAliasKey="%%ALIAS";
+enum { gAliasKeyLength=7 };
+
+/*
+ * Enumerate one resource item and its children and extract dependencies from
+ * aliases.
+ * Code adapted from ures_preflightResource() and ures_swapResource().
+ */
+static void
+ures_enumDependencies(const UDataSwapper *ds,
+ const char *itemName,
+ const Resource *inBundle, int32_t length,
+ Resource res, const char *inKey, int32_t depth,
+ CheckDependency check, void *context,
+ UErrorCode *pErrorCode) {
+ const Resource *p;
+ int32_t offset;
+
+ if(res==0 || RES_GET_TYPE(res)==URES_INT) {
+ /* empty string or integer, nothing to do */
+ return;
+ }
+
+ /* all other types use an offset to point to their data */
+ offset=(int32_t)RES_GET_OFFSET(res);
+ if(0<=length && length<=offset) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) resource offset exceeds bundle length %d\n",
+ itemName, res, length);
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+ return;
+ }
+ p=inBundle+offset;
+
+ switch(RES_GET_TYPE(res)) {
+ /* strings and aliases have physically the same value layout */
+ case URES_STRING:
+ // we ignore all strings except top-level strings with a %%ALIAS key
+ if(depth!=1) {
+ break;
+ } else {
+ char key[8];
+ int32_t keyLength;
+
+ keyLength=(int32_t)strlen(inKey);
+ if(keyLength!=gAliasKeyLength) {
+ break;
+ }
+ ds->swapInvChars(ds, inKey, gAliasKeyLength+1, key, pErrorCode);
+ if(U_FAILURE(*pErrorCode)) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) string key contains variant characters\n",
+ itemName, res);
+ return;
+ }
+ if(0!=strcmp(key, gAliasKey)) {
+ break;
+ }
+ }
+ // for the top-level %%ALIAS string fall through to URES_ALIAS
+ case URES_ALIAS:
+ {
+ char localeID[32];
+ const uint16_t *p16;
+ int32_t i, stringLength;
+ uint16_t u16, ored16;
+
+ stringLength=udata_readInt32(ds, (int32_t)*p);
+
+ /* top=offset+1+(string length +1)/2 rounded up */
+ offset+=1+((stringLength+1)+1)/2;
+ if(offset>length) {
+ break; // the resource does not fit into the bundle, print error below
+ }
+
+ // extract the locale ID from alias strings like
+ // locale_ID/key1/key2/key3
+ // locale_ID
+ if(U_IS_BIG_ENDIAN==ds->inIsBigEndian) {
+ u16=0x2f; // slash in local endianness
+ } else {
+ u16=0x2f00; // slash in opposite endianness
+ }
+ p16=(const uint16_t *)(p+1); // Unicode string contents
+
+ // search for the first slash
+ for(i=0; i<stringLength && p16[i]!=u16; ++i) {}
+
+ if(RES_GET_TYPE(res)==URES_ALIAS) {
+ // ignore aliases with an initial slash:
+ // /ICUDATA/... and /pkgname/... go to a different package
+ // /LOCALE/... are for dynamic sideways fallbacks and don't go to a fixed bundle
+ if(i==0) {
+ break; // initial slash ('/')
+ }
+
+ // ignore the intra-bundle path starting from the first slash ('/')
+ stringLength=i;
+ } else /* URES_STRING */ {
+ // the whole string should only consist of a locale ID
+ if(i!=stringLength) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) %%ALIAS contains a '/'\n",
+ itemName, res);
+ *pErrorCode=U_UNSUPPORTED_ERROR;
+ return;
+ }
+ }
+
+ // convert the Unicode string to char * and
+ // check that it has a bundle path but no package
+ if(stringLength>=(int32_t)sizeof(localeID)) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) alias locale ID length %ld too long\n",
+ itemName, res, stringLength);
+ *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
+ return;
+ }
+
+ // convert the alias Unicode string to US-ASCII
+ ored16=0;
+ if(U_IS_BIG_ENDIAN==ds->inIsBigEndian) {
+ for(i=0; i<stringLength; ++i) {
+ u16=p16[i];
+ ored16|=u16;
+ localeID[i]=(char)u16;
+ }
+ } else {
+ for(i=0; i<stringLength; ++i) {
+ u16=p16[i];
+ ored16|=u16;
+ localeID[i]=(char)(u16>>8);
+ }
+ ored16=(uint16_t)((ored16<<8)|(ored16>>8));
+ }
+ localeID[stringLength]=0;
+ if(ored16>0x7f) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) alias string contains non-ASCII characters\n",
+ itemName, res);
+ *pErrorCode=U_INVALID_CHAR_FOUND;
+ return;
+ }
+
+ if(U_CHARSET_FAMILY==U_EBCDIC_FAMILY) {
+ // swap to EBCDIC
+ // our swapper is probably not the right one, but
+ // the function uses it only for printing errors
+ uprv_ebcdicFromAscii(ds, localeID, stringLength, localeID, pErrorCode);
+ if(U_FAILURE(*pErrorCode)) {
+ return;
+ }
+ }
+#if U_CHARSET_FAMILY!=U_ASCII_FAMILY && U_CHARSET_FAMILY!=U_EBCDIC_FAMILY
+# error Unknown U_CHARSET_FAMILY value!
+#endif
+
+ checkIDSuffix(itemName, localeID, -1, ".res", check, context, pErrorCode);
+ }
+ break;
+ case URES_TABLE:
+ case URES_TABLE32:
+ {
+ const uint16_t *pKey16;
+ const int32_t *pKey32;
+
+ Resource item;
+ int32_t i, count;
+
+ if(RES_GET_TYPE(res)==URES_TABLE) {
+ /* get table item count */
+ pKey16=(const uint16_t *)p;
+ count=ds->readUInt16(*pKey16++);
+
+ pKey32=NULL;
+
+ /* top=((1+ table item count)/2 rounded up)+(table item count) */
+ offset+=((1+count)+1)/2;
+ } else {
+ /* get table item count */
+ pKey32=(const int32_t *)p;
+ count=udata_readInt32(ds, *pKey32++);
+
+ pKey16=NULL;
+
+ /* top=(1+ table item count)+(table item count) */
+ offset+=1+count;
+ }
+
+ p=inBundle+offset; /* pointer to table resources */
+ offset+=count;
+
+ if(offset>length) {
+ break; // the resource does not fit into the bundle, print error below
+ }
+
+ /* recurse */
+ for(i=0; i<count; ++i) {
+ item=ds->readUInt32(*p++);
+ ures_enumDependencies(
+ ds, itemName, inBundle, length, item,
+ ((const char *)inBundle)+
+ (pKey16!=NULL ?
+ ds->readUInt16(pKey16[i]) :
+ udata_readInt32(ds, pKey32[i])),
+ depth+1,
+ check, context,
+ pErrorCode);
+ if(U_FAILURE(*pErrorCode)) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s table res=%08x)[%d].recurse(%08x) failed\n",
+ itemName, res, i, item);
+ break;
+ }
+ }
+ }
+ break;
+ case URES_ARRAY:
+ {
+ Resource item;
+ int32_t i, count;
+
+ /* top=offset+1+(array length) */
+ count=udata_readInt32(ds, (int32_t)*p++);
+ offset+=1+count;
+
+ if(offset>length) {
+ break; // the resource does not fit into the bundle, print error below
+ }
+
+ /* recurse */
+ for(i=0; i<count; ++i) {
+ item=ds->readUInt32(*p++);
+ ures_enumDependencies(
+ ds, itemName, inBundle, length,
+ item, NULL, depth+1,
+ check, context,
+ pErrorCode);
+ if(U_FAILURE(*pErrorCode)) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s array res=%08x)[%d].recurse(%08x) failed\n",
+ itemName, res, i, item);
+ break;
+ }
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ if(U_FAILURE(*pErrorCode)) {
+ /* nothing to do */
+ } else if(0<=length && length<offset) {
+ udata_printError(ds, "icupkg/ures_enumDependencies(%s res=%08x) resource limit exceeds bundle length %d\n",
+ itemName, res, length);
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+ }
+}
+
+/* code adapted from ures_swap() */
+static void
+ures_enumDependencies(const UDataSwapper *ds,
+ const char *itemName, const UDataInfo *pInfo,
+ const uint8_t *inBytes, int32_t length,
+ CheckDependency check, void *context,
+ UErrorCode *pErrorCode) {
+ const Resource *inBundle;
+ Resource rootRes;
+
+ /* the following integers count Resource item offsets (4 bytes each), not bytes */
+ int32_t bundleLength;
+
+ /* check format version */
+ if(pInfo->formatVersion[0]!=1) {
+ fprintf(stderr, "icupkg: .res format version %02x not supported\n",
+ pInfo->formatVersion[0]);
+ exit(U_UNSUPPORTED_ERROR);
+ }
+
+ /* a resource bundle must contain at least one resource item */
+ bundleLength=length/4;
+
+ /* formatVersion 1.1 must have a root item and at least 5 indexes */
+ if( bundleLength<
+ (pInfo->formatVersion[1]==0 ? 1 : 1+5)
+ ) {
+ fprintf(stderr, "icupkg: too few bytes (%d after header) for a resource bundle\n",
+ length);
+ exit(U_INDEX_OUTOFBOUNDS_ERROR);
+ }
+
+ inBundle=(const Resource *)inBytes;
+ rootRes=ds->readUInt32(*inBundle);
+
+ ures_enumDependencies(
+ ds, itemName, inBundle, bundleLength,
+ rootRes, NULL, 0,
+ check, context,
+ pErrorCode);
+
+ /*
+ * if the bundle attributes are present and the nofallback flag is not set,
+ * then add the parent bundle as a dependency
+ */
+ if(pInfo->formatVersion[1]>=1) {
+ int32_t indexes[URES_INDEX_TOP];
+ const int32_t *inIndexes;
+
+ inIndexes=(const int32_t *)inBundle+1;
+ indexes[URES_INDEX_LENGTH]=udata_readInt32(ds, inIndexes[URES_INDEX_LENGTH]);
+ if(indexes[URES_INDEX_LENGTH]>URES_INDEX_ATTRIBUTES) {
+ indexes[URES_INDEX_ATTRIBUTES]=udata_readInt32(ds, inIndexes[URES_INDEX_ATTRIBUTES]);
+ if(0==(indexes[URES_INDEX_ATTRIBUTES]&URES_ATT_NO_FALLBACK)) {
+ /* this bundle participates in locale fallback */
+ checkParent(itemName, check, context, pErrorCode);
+ }
+ }
+ }
+}
+
+// get dependencies from conversion tables --------------------------------- ***
+
+/* code adapted from ucnv_swap() */
+static void
+ucnv_enumDependencies(const UDataSwapper *ds,
+ const char *itemName, const UDataInfo *pInfo,
+ const uint8_t *inBytes, int32_t length,
+ CheckDependency check, void *context,
+ UErrorCode *pErrorCode) {
+ uint32_t staticDataSize;
+
+ const UConverterStaticData *inStaticData;
+
+ const _MBCSHeader *inMBCSHeader;
+ uint8_t outputType;
+
+ /* check format version */
+ if(!(
+ pInfo->formatVersion[0]==6 &&
+ pInfo->formatVersion[1]>=2
+ )) {
+ fprintf(stderr, "icupkg/ucnv_enumDependencies(): .cnv format version %02x.%02x not supported\n",
+ pInfo->formatVersion[0], pInfo->formatVersion[1]);
+ exit(U_UNSUPPORTED_ERROR);
+ }
+
+ /* read the initial UConverterStaticData structure after the UDataInfo header */
+ inStaticData=(const UConverterStaticData *)inBytes;
+
+ if( length<(int32_t)sizeof(UConverterStaticData) ||
+ (uint32_t)length<(staticDataSize=ds->readUInt32(inStaticData->structSize))
+ ) {
+ udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after header) for an ICU .cnv conversion table\n",
+ length);
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+ return;
+ }
+
+ inBytes+=staticDataSize;
+ length-=(int32_t)staticDataSize;
+
+ /* check for supported conversionType values */
+ if(inStaticData->conversionType==UCNV_MBCS) {
+ /* MBCS data */
+ uint32_t mbcsHeaderFlags;
+ int32_t extOffset;
+
+ inMBCSHeader=(const _MBCSHeader *)inBytes;
+
+ if(length<(int32_t)sizeof(_MBCSHeader)) {
+ udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table\n",
+ length);
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+ return;
+ }
+ if(!(inMBCSHeader->version[0]==4 && inMBCSHeader->version[1]>=1)) {
+ udata_printError(ds, "icupkg/ucnv_enumDependencies(): unsupported _MBCSHeader.version %d.%d\n",
+ inMBCSHeader->version[0], inMBCSHeader->version[1]);
+ *pErrorCode=U_UNSUPPORTED_ERROR;
+ return;
+ }
+
+ mbcsHeaderFlags=ds->readUInt32(inMBCSHeader->flags);
+ extOffset=(int32_t)(mbcsHeaderFlags>>8);
+ outputType=(uint8_t)mbcsHeaderFlags;
+
+ if(outputType==MBCS_OUTPUT_EXT_ONLY) {
+ /*
+ * extension-only file,
+ * contains a base name instead of normal base table data
+ */
+ char baseName[32];
+ int32_t baseNameLength;
+
+ /* there is extension data after the base data, see ucnv_ext.h */
+ if(length<(extOffset+UCNV_EXT_INDEXES_MIN_LENGTH*4)) {
+ udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table with extension data\n",
+ length);
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+ return;
+ }
+
+ /* swap the base name, between the header and the extension data */
+ baseNameLength=(int32_t)strlen((const char *)(inMBCSHeader+1));
+ if(baseNameLength>=(int32_t)sizeof(baseName)) {
+ udata_printError(ds, "icupkg/ucnv_enumDependencies(%s): base name length %ld too long\n",
+ itemName, baseNameLength);
+ *pErrorCode=U_UNSUPPORTED_ERROR;
+ return;
+ }
+ ds->swapInvChars(ds, inMBCSHeader+1, baseNameLength+1, baseName, pErrorCode);
+
+ checkIDSuffix(itemName, baseName, -1, ".cnv", check, context, pErrorCode);
+ }
+ }
+}
+
+// ICU data formats -------------------------------------------------------- ***
+
+static const struct {
+ uint8_t dataFormat[4];
+} dataFormats[]={
+ { { 0x52, 0x65, 0x73, 0x42 } }, /* dataFormat="ResB" */
+ { { 0x63, 0x6e, 0x76, 0x74 } }, /* dataFormat="cnvt" */
+ { { 0x43, 0x76, 0x41, 0x6c } } /* dataFormat="CvAl" */
+};
+
+enum {
+ FMT_RES,
+ FMT_CNV,
+ FMT_ALIAS,
+ FMT_COUNT
+};
+
+static int32_t
+getDataFormat(const uint8_t dataFormat[4]) {
+ int32_t i;
+
+ for(i=0; i<FMT_COUNT; ++i) {
+ if(0==memcmp(dataFormats[i].dataFormat, dataFormat, 4)) {
+ return i;
+ }
+ }
+ return -1;
+}
+
+// enumerate dependencies of a package item -------------------------------- ***
+
+U_NAMESPACE_BEGIN
+
+void
+Package::enumDependencies(Item *pItem) {
+ const UDataInfo *pInfo;
+ const uint8_t *inBytes;
+ int32_t format, length, infoLength, itemHeaderLength;
+ UErrorCode errorCode;
+
+ errorCode=U_ZERO_ERROR;
+ pInfo=getDataInfo(pItem->data,pItem->length, infoLength, itemHeaderLength, &errorCode);
+ if(U_FAILURE(errorCode)) {
+ return; // should not occur because readFile() checks headers
+ }
+
+ // find the data format and call the corresponding function, if any
+ format=getDataFormat(pInfo->dataFormat);
+ if(format>=0) {
+ UDataSwapper *ds;
+
+ // TODO: share/cache swappers
+ ds=udata_openSwapper((UBool)pInfo->isBigEndian, pInfo->charsetFamily, U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &errorCode);
+ if(U_FAILURE(errorCode)) {
+ fprintf(stderr, "icupkg: udata_openSwapper(\"%s\") failed - %s\n",
+ pItem->name, u_errorName(errorCode));
+ exit(errorCode);
+ }
+
+ ds->printError=printError;
+ ds->printErrorContext=stderr;
+
+ inBytes=pItem->data+itemHeaderLength;
+ length=pItem->length-itemHeaderLength;
+
+ switch(format) {
+ case FMT_RES:
+ ures_enumDependencies(ds, pItem->name, pInfo, inBytes, length, checkDependency, this, &errorCode);
+ break;
+ case FMT_CNV:
+ ucnv_enumDependencies(ds, pItem->name, pInfo, inBytes, length, checkDependency, this, &errorCode);
+ break;
+ default:
+ break;
+ }
+
+ udata_closeSwapper(ds);
+
+ if(U_FAILURE(errorCode)) {
+ exit(errorCode);
+ }
+ }
+}
+U_NAMESPACE_END
projects / apple / icu.git / blobdiff