[apple/icu.git] / icuSources / tools / toolutil / pkgitems.cpp

/*
*******************************************************************************
*
*   Copyright (C) 2003-2014, 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 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 "uinvchar.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 ----------------------------------------------------- ***

U_CDECL_BEGIN

static void U_CALLCONV
printError(void *context, const char *fmt, va_list args) {
    vfprintf((FILE *)context, fmt, args);
}

U_CDECL_END

// a data item in native-platform form ------------------------------------- ***

U_NAMESPACE_BEGIN

class NativeItem {
public:
    NativeItem() : pItem(NULL), pInfo(NULL), bytes(NULL), swapped(NULL), length(0) {}
    NativeItem(const Item *item, UDataSwapFn *swap) : swapped(NULL) {
        setItem(item, swap);
    }
    ~NativeItem() {
        delete [] swapped;
    }
    const UDataInfo *getDataInfo() const {
        return pInfo;
    }
    const uint8_t *getBytes() const {
        return bytes;
    }
    int32_t getLength() const {
        return length;
    }

    void setItem(const Item *item, UDataSwapFn *swap) {
        pItem=item;
        int32_t infoLength, itemHeaderLength;
        UErrorCode errorCode=U_ZERO_ERROR;
        pInfo=::getDataInfo(pItem->data, pItem->length, infoLength, itemHeaderLength, &errorCode);
        if(U_FAILURE(errorCode)) {
            exit(errorCode); // should succeed because readFile() checks headers
        }
        length=pItem->length-itemHeaderLength;

        if(pInfo->isBigEndian==U_IS_BIG_ENDIAN && pInfo->charsetFamily==U_CHARSET_FAMILY) {
            bytes=pItem->data+itemHeaderLength;
        } else {
            UDataSwapper *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;

            swapped=new uint8_t[pItem->length];
            if(swapped==NULL) {
                fprintf(stderr, "icupkg: unable to allocate memory for swapping \"%s\"\n", pItem->name);
                exit(U_MEMORY_ALLOCATION_ERROR);
            }
            swap(ds, pItem->data, pItem->length, swapped, &errorCode);
            pInfo=::getDataInfo(swapped, pItem->length, infoLength, itemHeaderLength, &errorCode);
            bytes=swapped+itemHeaderLength;
            udata_closeSwapper(ds);
        }
    }

private:
    const Item *pItem;
    const UDataInfo *pInfo;
    const uint8_t *bytes;
    uint8_t *swapped;
    int32_t length;
};

// check a dependency ------------------------------------------------------ ***

/*
 * assemble the target item name from the source item name, an ID
 * and a suffix
 */
static void 
makeTargetName(const char *itemName, const char *id, int32_t idLength, const char *suffix,
               char *target, int32_t capacity,
               UErrorCode *pErrorCode) {
    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>=capacity) {
        fprintf(stderr, "icupkg/makeTargetName(%s) 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
}

static void 
checkIDSuffix(const char *itemName, const char *id, int32_t idLength, const char *suffix,
              CheckDependency check, void *context,
              UErrorCode *pErrorCode) {
    char target[200];
    makeTargetName(itemName, id, idLength, suffix, target, (int32_t)sizeof(target), pErrorCode);
    if(U_SUCCESS(*pErrorCode)) {
        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 UChar SLASH=0x2f;

/*
 * Check for the alias from the string or alias resource res.
 */
static void
checkAlias(const char *itemName,
           Resource res, const UChar *alias, int32_t length, UBool useResSuffix,
           CheckDependency check, void *context, UErrorCode *pErrorCode) {
    int32_t i;

    if(!uprv_isInvariantUString(alias, length)) {
        fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) alias string contains non-invariant characters\n",
                        itemName, res);
        *pErrorCode=U_INVALID_CHAR_FOUND;
        return;
    }

    // extract the locale ID from alias strings like
    // locale_ID/key1/key2/key3
    // locale_ID

    // search for the first slash
    for(i=0; i<length && alias[i]!=SLASH; ++i) {}

    if(res_getPublicType(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) {
            return; // initial slash ('/')
        }

        // ignore the intra-bundle path starting from the first slash ('/')
        length=i;
    } else /* URES_STRING */ {
        // the whole string should only consist of a locale ID
        if(i!=length) {
            fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) %%ALIAS contains a '/'\n",
                            itemName, res);
            *pErrorCode=U_UNSUPPORTED_ERROR;
            return;
        }
    }

    // convert the Unicode string to char *
    char localeID[32];
    if(length>=(int32_t)sizeof(localeID)) {
        fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) alias locale ID length %ld too long\n",
                        itemName, res, (long)length);
        *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
        return;
    }
    u_UCharsToChars(alias, localeID, length);
    localeID[length]=0;

    checkIDSuffix(itemName, localeID, -1, (useResSuffix ? ".res" : ""), check, context, pErrorCode);
}

/*
 * Enumerate one resource item and its children and extract dependencies from
 * aliases.
 */
static void
ures_enumDependencies(const char *itemName,
                      const ResourceData *pResData,
                      Resource res, const char *inKey, const char *parentKey, int32_t depth,
                      CheckDependency check, void *context,
                      Package *pkg,
                      UErrorCode *pErrorCode) {
    switch(res_getPublicType(res)) {
    case URES_STRING:
        {
            UBool useResSuffix = TRUE;
            // Check for %%ALIAS
            if(depth==1 && inKey!=NULL) {
                if(0!=strcmp(inKey, "%%ALIAS")) {
                    break;
                }
            }
            // Check for %%DEPENDENCY
            else if(depth==2 && parentKey!=NULL) {
                if(0!=strcmp(parentKey, "%%DEPENDENCY")) {
                    break;
                }
                useResSuffix = FALSE;
            } else {
                // we ignore all other strings
                break;
            }
            int32_t length;
            const UChar *alias=res_getString(pResData, res, &length);
            checkAlias(itemName, res, alias, length, useResSuffix, check, context, pErrorCode);
        }
        break;
    case URES_ALIAS:
        {
            int32_t length;
            const UChar *alias=res_getAlias(pResData, res, &length);
            checkAlias(itemName, res, alias, length, TRUE, check, context, pErrorCode);
        }
        break;
    case URES_TABLE:
        {
            /* recurse */
            int32_t count=res_countArrayItems(pResData, res);
            for(int32_t i=0; i<count; ++i) {
                const char *itemKey;
                Resource item=res_getTableItemByIndex(pResData, res, i, &itemKey);
                ures_enumDependencies(
                        itemName, pResData,
                        item, itemKey,
                        inKey, depth+1,
                        check, context,
                        pkg,
                        pErrorCode);
                if(U_FAILURE(*pErrorCode)) {
                    fprintf(stderr, "icupkg/ures_enumDependencies(%s table res=%08x)[%d].recurse(%s: %08x) failed\n",
                                    itemName, res, i, itemKey, item);
                    break;
                }
            }
        }
        break;
    case URES_ARRAY:
        {
            /* recurse */
            int32_t count=res_countArrayItems(pResData, res);
            for(int32_t i=0; i<count; ++i) {
                Resource item=res_getArrayItem(pResData, res, i);
                ures_enumDependencies(
                        itemName, pResData,
                        item, NULL,
                        inKey, depth+1,
                        check, context,
                        pkg,
                        pErrorCode);
                if(U_FAILURE(*pErrorCode)) {
                    fprintf(stderr, "icupkg/ures_enumDependencies(%s array res=%08x)[%d].recurse(%08x) failed\n",
                                    itemName, res, i, item);
                    break;
                }
            }
        }
        break;
    default:
        break;
    }
}

static void
ures_enumDependencies(const char *itemName, const UDataInfo *pInfo,
                      const uint8_t *inBytes, int32_t length,
                      CheckDependency check, void *context,
                      Package *pkg,
                      UErrorCode *pErrorCode) {
    ResourceData resData;

    res_read(&resData, pInfo, inBytes, length, pErrorCode);
    if(U_FAILURE(*pErrorCode)) {
        fprintf(stderr, "icupkg: .res format version %02x.%02x not supported, or bundle malformed\n",
                        pInfo->formatVersion[0], pInfo->formatVersion[1]);
        exit(U_UNSUPPORTED_ERROR);
    }

    /*
     * if the bundle attributes are present and the nofallback flag is not set,
     * then add the parent bundle as a dependency
     */
    if(pInfo->formatVersion[0]>1 || (pInfo->formatVersion[0]==1 && pInfo->formatVersion[1]>=1)) {
        if(!resData.noFallback) {
            /* this bundle participates in locale fallback */
            checkParent(itemName, check, context, pErrorCode);
        }
    }

    icu::NativeItem nativePool;

    if(resData.usesPoolBundle) {
        char poolName[200];
        makeTargetName(itemName, "pool", 4, ".res", poolName, (int32_t)sizeof(poolName), pErrorCode);
        if(U_FAILURE(*pErrorCode)) {
            return;
        }
        check(context, itemName, poolName);
        int32_t index=pkg->findItem(poolName);
        if(index<0) {
            // We cannot work with a bundle if its pool resource is missing.
            // check() already printed a complaint.
            return;
        }
        // TODO: Cache the native version in the Item itself.
        nativePool.setItem(pkg->getItem(index), ures_swap);
        const UDataInfo *poolInfo=nativePool.getDataInfo();
        if(poolInfo->formatVersion[0]<=1) {
            fprintf(stderr, "icupkg: %s is not a pool bundle\n", poolName);
            return;
        }
        const int32_t *poolIndexes=(const int32_t *)nativePool.getBytes()+1;
        int32_t poolIndexLength=poolIndexes[URES_INDEX_LENGTH]&0xff;
        if(!(poolIndexLength>URES_INDEX_POOL_CHECKSUM &&
             (poolIndexes[URES_INDEX_ATTRIBUTES]&URES_ATT_IS_POOL_BUNDLE))
        ) {
            fprintf(stderr, "icupkg: %s is not a pool bundle\n", poolName);
            return;
        }
        if(resData.pRoot[1+URES_INDEX_POOL_CHECKSUM]==poolIndexes[URES_INDEX_POOL_CHECKSUM]) {
            resData.poolBundleKeys=(const char *)(poolIndexes+poolIndexLength);
        } else {
            fprintf(stderr, "icupkg: %s has mismatched checksum for %s\n", poolName, itemName);
            return;
        }
    }

    ures_enumDependencies(
        itemName, &resData,
        resData.rootRes, NULL, NULL, 0,
        check, context,
        pkg,
        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 mbcsHeaderLength, mbcsHeaderFlags, mbcsHeaderOptions;
        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) {
            mbcsHeaderLength=MBCS_HEADER_V4_LENGTH;
        } else if(inMBCSHeader->version[0]==5 && inMBCSHeader->version[1]>=3 &&
                  ((mbcsHeaderOptions=ds->readUInt32(inMBCSHeader->options))&
                   MBCS_OPT_UNKNOWN_INCOMPATIBLE_MASK)==0
        ) {
            mbcsHeaderLength=mbcsHeaderOptions&MBCS_OPT_LENGTH_MASK;
        } else {
            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 */
            const char *inBaseName=(const char *)inBytes+mbcsHeaderLength*4;
            baseNameLength=(int32_t)strlen(inBaseName);
            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, inBaseName, 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 -------------------------------- ***

void
Package::enumDependencies(Item *pItem, void *context, CheckDependency check) {
    int32_t infoLength, itemHeaderLength;
    UErrorCode errorCode=U_ZERO_ERROR;
    const UDataInfo *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
    int32_t format=getDataFormat(pInfo->dataFormat);
    if(format>=0) {
        switch(format) {
        case FMT_RES:
            {
                /*
                 * Swap the resource bundle (if necessary) so that we can use
                 * the normal runtime uresdata.c code to read it.
                 * We do not want to duplicate that code, especially not together with on-the-fly swapping.
                 */
                NativeItem nrb(pItem, ures_swap);
                ures_enumDependencies(pItem->name, nrb.getDataInfo(), nrb.getBytes(), nrb.getLength(), check, context, this, &errorCode);
                break;
            }
        case FMT_CNV:
            {
                // TODO: share/cache swappers
                UDataSwapper *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;

                const uint8_t *inBytes=pItem->data+itemHeaderLength;
                int32_t length=pItem->length-itemHeaderLength;

                ucnv_enumDependencies(ds, pItem->name, pInfo, inBytes, length, check, context, &errorCode);
                udata_closeSwapper(ds);
                break;
            }
        default:
            break;
        }

        if(U_FAILURE(errorCode)) {
            exit(errorCode);
        }
    }
}

U_NAMESPACE_END
Commit	Line	Data
73c04bcf A	1	/*
	2	*******************************************************************************
	3	*
b331163b	4	* Copyright (C) 2003-2014, International Business Machines
73c04bcf A	5	* Corporation and others. All Rights Reserved.
	6	*
	7	*******************************************************************************
	8	* file name: pkgitems.cpp
	9	* encoding: US-ASCII
	10	* tab size: 8 (not used)
	11	* indentation:4
	12	*
	13	* created on: 2005sep18
	14	* created by: Markus W. Scherer
	15	*
	16	* Companion file to package.cpp. Deals with details of ICU data item formats.
	17	* Used for item dependencies.
729e4ab9	18	* Contains adapted code from ucnv_bld.c (swapper code from 2003).
73c04bcf A	19	*/
	20
	21	#include "unicode/utypes.h"
	22	#include "unicode/ures.h"
	23	#include "unicode/putil.h"
	24	#include "unicode/udata.h"
	25	#include "cstring.h"
729e4ab9	26	#include "uinvchar.h"
73c04bcf A	27	#include "ucmndata.h"
	28	#include "udataswp.h"
	29	#include "swapimpl.h"
	30	#include "toolutil.h"
	31	#include "package.h"
	32	#include "pkg_imp.h"
	33
	34	#include <stdio.h>
	35	#include <stdlib.h>
	36	#include <string.h>
	37
	38	/* item formats in common */
	39
	40	#include "uresdata.h"
	41	#include "ucnv_bld.h"
	42	#include "ucnv_io.h"
	43
	44	// general definitions ----------------------------------------------------- ***
	45
73c04bcf A	46	U_CDECL_BEGIN
	47
	48	static void U_CALLCONV
	49	printError(void context, const char fmt, va_list args) {
	50	vfprintf((FILE *)context, fmt, args);
	51	}
	52
	53	U_CDECL_END
	54
729e4ab9 A	55	// a data item in native-platform form ------------------------------------- ***
	56
	57	U_NAMESPACE_BEGIN
	58
	59	class NativeItem {
	60	public:
	61	NativeItem() : pItem(NULL), pInfo(NULL), bytes(NULL), swapped(NULL), length(0) {}
	62	NativeItem(const Item item, UDataSwapFn swap) : swapped(NULL) {
	63	setItem(item, swap);
	64	}
	65	~NativeItem() {
	66	delete [] swapped;
	67	}
	68	const UDataInfo *getDataInfo() const {
	69	return pInfo;
	70	}
	71	const uint8_t *getBytes() const {
	72	return bytes;
	73	}
	74	int32_t getLength() const {
	75	return length;
	76	}
	77
	78	void setItem(const Item item, UDataSwapFn swap) {
	79	pItem=item;
	80	int32_t infoLength, itemHeaderLength;
	81	UErrorCode errorCode=U_ZERO_ERROR;
	82	pInfo=::getDataInfo(pItem->data, pItem->length, infoLength, itemHeaderLength, &errorCode);
	83	if(U_FAILURE(errorCode)) {
	84	exit(errorCode); // should succeed because readFile() checks headers
	85	}
	86	length=pItem->length-itemHeaderLength;
	87
	88	if(pInfo->isBigEndian==U_IS_BIG_ENDIAN && pInfo->charsetFamily==U_CHARSET_FAMILY) {
	89	bytes=pItem->data+itemHeaderLength;
	90	} else {
	91	UDataSwapper *ds=udata_openSwapper((UBool)pInfo->isBigEndian, pInfo->charsetFamily, U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &errorCode);
	92	if(U_FAILURE(errorCode)) {
	93	fprintf(stderr, "icupkg: udata_openSwapper(\"%s\") failed - %s\n",
	94	pItem->name, u_errorName(errorCode));
	95	exit(errorCode);
	96	}
	97
	98	ds->printError=printError;
	99	ds->printErrorContext=stderr;
	100
	101	swapped=new uint8_t[pItem->length];
	102	if(swapped==NULL) {
	103	fprintf(stderr, "icupkg: unable to allocate memory for swapping \"%s\"\n", pItem->name);
	104	exit(U_MEMORY_ALLOCATION_ERROR);
	105	}
	106	swap(ds, pItem->data, pItem->length, swapped, &errorCode);
	107	pInfo=::getDataInfo(swapped, pItem->length, infoLength, itemHeaderLength, &errorCode);
	108	bytes=swapped+itemHeaderLength;
	109	udata_closeSwapper(ds);
	110	}
	111	}
	112
	113	private:
	114	const Item *pItem;
	115	const UDataInfo *pInfo;
	116	const uint8_t *bytes;
	117	uint8_t *swapped;
	118	int32_t length;
119	};
120
73c04bcf A	121	// check a dependency ------------------------------------------------------ ***
	122
	123	/*
	124	* assemble the target item name from the source item name, an ID
	125	* and a suffix
	126	*/
	127	static void
729e4ab9 A	128	makeTargetName(const char itemName, const char id, int32_t idLength, const char *suffix,
	129	char *target, int32_t capacity,
	130	UErrorCode *pErrorCode) {
73c04bcf A	131	const char *itemID;
	132	int32_t treeLength, suffixLength, targetLength;
	133
	134	// get the item basename
	135	itemID=strrchr(itemName, '/');
	136	if(itemID!=NULL) {
	137	++itemID;
	138	} else {
	139	itemID=itemName;
	140	}
	141
	142	// build the target string
	143	treeLength=(int32_t)(itemID-itemName);
	144	if(idLength<0) {
	145	idLength=(int32_t)strlen(id);
	146	}
	147	suffixLength=(int32_t)strlen(suffix);
	148	targetLength=treeLength+idLength+suffixLength;
729e4ab9 A	149	if(targetLength>=capacity) {
729e4ab9 A	150	fprintf(stderr, "icupkg/makeTargetName(%s) target item name length %ld too long\n",
73c04bcf A	151	itemName, (long)targetLength);
	152	*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
	153	return;
	154	}
	155
	156	memcpy(target, itemName, treeLength);
	157	memcpy(target+treeLength, id, idLength);
	158	memcpy(target+treeLength+idLength, suffix, suffixLength+1); // +1 includes the terminating NUL
729e4ab9	159	}
73c04bcf	160
729e4ab9 A	161	static void
	162	checkIDSuffix(const char itemName, const char id, int32_t idLength, const char *suffix,
	163	CheckDependency check, void *context,
	164	UErrorCode *pErrorCode) {
	165	char target[200];
	166	makeTargetName(itemName, id, idLength, suffix, target, (int32_t)sizeof(target), pErrorCode);
	167	if(U_SUCCESS(*pErrorCode)) {
	168	check(context, itemName, target);
	169	}
73c04bcf A	170	}
	171
	172	/* assemble the target item name from the item's parent item name */
	173	static void
	174	checkParent(const char itemName, CheckDependency check, void context,
	175	UErrorCode *pErrorCode) {
	176	const char itemID, parent, parentLimit, suffix;
	177	int32_t parentLength;
	178
	179	// get the item basename
	180	itemID=strrchr(itemName, '/');
	181	if(itemID!=NULL) {
	182	++itemID;
	183	} else {
	184	itemID=itemName;
	185	}
	186
	187	// get the item suffix
	188	suffix=strrchr(itemID, '.');
	189	if(suffix==NULL) {
	190	// empty suffix, point to the end of the string
	191	suffix=strrchr(itemID, 0);
	192	}
	193
	194	// get the position of the last '_'
	195	for(parentLimit=suffix; parentLimit>itemID && *--parentLimit!='_';) {}
	196
	197	if(parentLimit!=itemID) {
	198	// get the parent item name by truncating the last part of this item's name */
	199	parent=itemID;
	200	parentLength=(int32_t)(parentLimit-itemID);
	201	} else {
	202	// no '_' in the item name: the parent is the root bundle
	203	parent="root";
	204	parentLength=4;
	205	if((suffix-itemID)==parentLength && 0==memcmp(itemID, parent, parentLength)) {
	206	// the item itself is "root", which does not depend on a parent
	207	return;
	208	}
	209	}
	210	checkIDSuffix(itemName, parent, parentLength, suffix, check, context, pErrorCode);
	211	}
	212
	213	// get dependencies from resource bundles ---------------------------------- ***
	214
729e4ab9	215	static const UChar SLASH=0x2f;
73c04bcf A	216
73c04bcf A	217	/*
729e4ab9	218	* Check for the alias from the string or alias resource res.
73c04bcf A	219	*/
73c04bcf A	220	static void
729e4ab9 A	221	checkAlias(const char *itemName,
	222	Resource res, const UChar *alias, int32_t length, UBool useResSuffix,
	223	CheckDependency check, void context, UErrorCode pErrorCode) {
	224	int32_t i;
73c04bcf	225
729e4ab9 A	226	if(!uprv_isInvariantUString(alias, length)) {
	227	fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) alias string contains non-invariant characters\n",
	228	itemName, res);
	229	*pErrorCode=U_INVALID_CHAR_FOUND;
73c04bcf A	230	return;
	231	}
	232
729e4ab9 A	233	// extract the locale ID from alias strings like
	234	// locale_ID/key1/key2/key3
	235	// locale_ID
73c04bcf	236
729e4ab9 A	237	// search for the first slash
729e4ab9 A	238	for(i=0; i<length && alias[i]!=SLASH; ++i) {}
73c04bcf	239
729e4ab9 A	240	if(res_getPublicType(res)==URES_ALIAS) {
	241	// ignore aliases with an initial slash:
	242	// /ICUDATA/... and /pkgname/... go to a different package
	243	// /LOCALE/... are for dynamic sideways fallbacks and don't go to a fixed bundle
	244	if(i==0) {
	245	return; // initial slash ('/')
73c04bcf	246	}
46f4442e	247
729e4ab9 A	248	// ignore the intra-bundle path starting from the first slash ('/')
	249	length=i;
	250	} else /* URES_STRING */ {
	251	// the whole string should only consist of a locale ID
	252	if(i!=length) {
	253	fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) %%ALIAS contains a '/'\n",
	254	itemName, res);
	255	*pErrorCode=U_UNSUPPORTED_ERROR;
	256	return;
46f4442e	257	}
729e4ab9	258	}
73c04bcf	259
729e4ab9 A	260	// convert the Unicode string to char *
	261	char localeID[32];
	262	if(length>=(int32_t)sizeof(localeID)) {
	263	fprintf(stderr, "icupkg/ures_enumDependencies(%s res=%08x) alias locale ID length %ld too long\n",
	264	itemName, res, (long)length);
	265	*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
	266	return;
	267	}
	268	u_UCharsToChars(alias, localeID, length);
	269	localeID[length]=0;
73c04bcf	270
729e4ab9 A	271	checkIDSuffix(itemName, localeID, -1, (useResSuffix ? ".res" : ""), check, context, pErrorCode);
729e4ab9 A	272	}
73c04bcf	273
729e4ab9 A	274	/*
	275	* Enumerate one resource item and its children and extract dependencies from
	276	* aliases.
	277	*/
	278	static void
	279	ures_enumDependencies(const char *itemName,
	280	const ResourceData *pResData,
	281	Resource res, const char inKey, const char parentKey, int32_t depth,
	282	CheckDependency check, void *context,
	283	Package *pkg,
	284	UErrorCode *pErrorCode) {
	285	switch(res_getPublicType(res)) {
	286	case URES_STRING:
	287	{
	288	UBool useResSuffix = TRUE;
	289	// Check for %%ALIAS
	290	if(depth==1 && inKey!=NULL) {
	291	if(0!=strcmp(inKey, "%%ALIAS")) {
	292	break;
73c04bcf A	293	}
73c04bcf A	294	}
729e4ab9 A	295	// Check for %%DEPENDENCY
	296	else if(depth==2 && parentKey!=NULL) {
	297	if(0!=strcmp(parentKey, "%%DEPENDENCY")) {
	298	break;
73c04bcf	299	}
729e4ab9	300	useResSuffix = FALSE;
73c04bcf	301	} else {
729e4ab9 A	302	// we ignore all other strings
729e4ab9 A	303	break;
73c04bcf	304	}
729e4ab9 A	305	int32_t length;
	306	const UChar *alias=res_getString(pResData, res, &length);
	307	checkAlias(itemName, res, alias, length, useResSuffix, check, context, pErrorCode);
	308	}
	309	break;
	310	case URES_ALIAS:
	311	{
	312	int32_t length;
	313	const UChar *alias=res_getAlias(pResData, res, &length);
	314	checkAlias(itemName, res, alias, length, TRUE, check, context, pErrorCode);
73c04bcf A	315	}
	316	break;
	317	case URES_TABLE:
73c04bcf	318	{
73c04bcf	319	/* recurse */
729e4ab9 A	320	int32_t count=res_countArrayItems(pResData, res);
	321	for(int32_t i=0; i<count; ++i) {
	322	const char *itemKey;
	323	Resource item=res_getTableItemByIndex(pResData, res, i, &itemKey);
73c04bcf	324	ures_enumDependencies(
729e4ab9 A	325	itemName, pResData,
729e4ab9 A	326	item, itemKey,
46f4442e	327	inKey, depth+1,
73c04bcf	328	check, context,
729e4ab9	329	pkg,
73c04bcf A	330	pErrorCode);
73c04bcf A	331	if(U_FAILURE(*pErrorCode)) {
729e4ab9 A	332	fprintf(stderr, "icupkg/ures_enumDependencies(%s table res=%08x)[%d].recurse(%s: %08x) failed\n",
729e4ab9 A	333	itemName, res, i, itemKey, item);
73c04bcf A	334	break;
	335	}
	336	}
	337	}
	338	break;
	339	case URES_ARRAY:
	340	{
73c04bcf	341	/* recurse */
729e4ab9 A	342	int32_t count=res_countArrayItems(pResData, res);
	343	for(int32_t i=0; i<count; ++i) {
	344	Resource item=res_getArrayItem(pResData, res, i);
73c04bcf	345	ures_enumDependencies(
729e4ab9 A	346	itemName, pResData,
	347	item, NULL,
	348	inKey, depth+1,
73c04bcf	349	check, context,
729e4ab9	350	pkg,
73c04bcf A	351	pErrorCode);
73c04bcf A	352	if(U_FAILURE(*pErrorCode)) {
729e4ab9 A	353	fprintf(stderr, "icupkg/ures_enumDependencies(%s array res=%08x)[%d].recurse(%08x) failed\n",
729e4ab9 A	354	itemName, res, i, item);
73c04bcf A	355	break;
	356	}
	357	}
	358	}
	359	break;
	360	default:
	361	break;
	362	}
73c04bcf A	363	}
73c04bcf A	364
73c04bcf	365	static void
729e4ab9	366	ures_enumDependencies(const char itemName, const UDataInfo pInfo,
73c04bcf A	367	const uint8_t *inBytes, int32_t length,
73c04bcf A	368	CheckDependency check, void *context,
729e4ab9	369	Package *pkg,
73c04bcf	370	UErrorCode *pErrorCode) {
729e4ab9	371	ResourceData resData;
73c04bcf	372
729e4ab9 A	373	res_read(&resData, pInfo, inBytes, length, pErrorCode);
	374	if(U_FAILURE(*pErrorCode)) {
	375	fprintf(stderr, "icupkg: .res format version %02x.%02x not supported, or bundle malformed\n",
	376	pInfo->formatVersion[0], pInfo->formatVersion[1]);
73c04bcf A	377	exit(U_UNSUPPORTED_ERROR);
	378	}
	379
73c04bcf A	380	/*
	381	* if the bundle attributes are present and the nofallback flag is not set,
	382	* then add the parent bundle as a dependency
	383	*/
729e4ab9 A	384	if(pInfo->formatVersion[0]>1 \|\| (pInfo->formatVersion[0]==1 && pInfo->formatVersion[1]>=1)) {
	385	if(!resData.noFallback) {
	386	/* this bundle participates in locale fallback */
	387	checkParent(itemName, check, context, pErrorCode);
73c04bcf A	388	}
73c04bcf A	389	}
729e4ab9	390
4388f060	391	icu::NativeItem nativePool;
729e4ab9 A	392
	393	if(resData.usesPoolBundle) {
	394	char poolName[200];
	395	makeTargetName(itemName, "pool", 4, ".res", poolName, (int32_t)sizeof(poolName), pErrorCode);
	396	if(U_FAILURE(*pErrorCode)) {
	397	return;
	398	}
	399	check(context, itemName, poolName);
	400	int32_t index=pkg->findItem(poolName);
	401	if(index<0) {
	402	// We cannot work with a bundle if its pool resource is missing.
	403	// check() already printed a complaint.
	404	return;
	405	}
	406	// TODO: Cache the native version in the Item itself.
	407	nativePool.setItem(pkg->getItem(index), ures_swap);
	408	const UDataInfo *poolInfo=nativePool.getDataInfo();
	409	if(poolInfo->formatVersion[0]<=1) {
	410	fprintf(stderr, "icupkg: %s is not a pool bundle\n", poolName);
	411	return;
	412	}
	413	const int32_t poolIndexes=(const int32_t )nativePool.getBytes()+1;
	414	int32_t poolIndexLength=poolIndexes[URES_INDEX_LENGTH]&0xff;
	415	if(!(poolIndexLength>URES_INDEX_POOL_CHECKSUM &&
	416	(poolIndexes[URES_INDEX_ATTRIBUTES]&URES_ATT_IS_POOL_BUNDLE))
	417	) {
	418	fprintf(stderr, "icupkg: %s is not a pool bundle\n", poolName);
	419	return;
	420	}
	421	if(resData.pRoot[1+URES_INDEX_POOL_CHECKSUM]==poolIndexes[URES_INDEX_POOL_CHECKSUM]) {
	422	resData.poolBundleKeys=(const char *)(poolIndexes+poolIndexLength);
	423	} else {
	424	fprintf(stderr, "icupkg: %s has mismatched checksum for %s\n", poolName, itemName);
	425	return;
	426	}
	427	}
	428
	429	ures_enumDependencies(
	430	itemName, &resData,
	431	resData.rootRes, NULL, NULL, 0,
	432	check, context,
	433	pkg,
	434	pErrorCode);
73c04bcf A	435	}
	436
	437	// get dependencies from conversion tables --------------------------------- ***
	438
	439	/* code adapted from ucnv_swap() */
	440	static void
	441	ucnv_enumDependencies(const UDataSwapper *ds,
	442	const char itemName, const UDataInfo pInfo,
	443	const uint8_t *inBytes, int32_t length,
	444	CheckDependency check, void *context,
	445	UErrorCode *pErrorCode) {
	446	uint32_t staticDataSize;
	447
	448	const UConverterStaticData *inStaticData;
	449
	450	const _MBCSHeader *inMBCSHeader;
	451	uint8_t outputType;
	452
	453	/* check format version */
	454	if(!(
	455	pInfo->formatVersion[0]==6 &&
	456	pInfo->formatVersion[1]>=2
	457	)) {
	458	fprintf(stderr, "icupkg/ucnv_enumDependencies(): .cnv format version %02x.%02x not supported\n",
	459	pInfo->formatVersion[0], pInfo->formatVersion[1]);
	460	exit(U_UNSUPPORTED_ERROR);
	461	}
	462
	463	/* read the initial UConverterStaticData structure after the UDataInfo header */
	464	inStaticData=(const UConverterStaticData *)inBytes;
	465
	466	if( length<(int32_t)sizeof(UConverterStaticData) \|\|
	467	(uint32_t)length<(staticDataSize=ds->readUInt32(inStaticData->structSize))
	468	) {
	469	udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after header) for an ICU .cnv conversion table\n",
	470	length);
	471	*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	472	return;
	473	}
	474
	475	inBytes+=staticDataSize;
	476	length-=(int32_t)staticDataSize;
	477
	478	/* check for supported conversionType values */
	479	if(inStaticData->conversionType==UCNV_MBCS) {
	480	/* MBCS data */
46f4442e	481	uint32_t mbcsHeaderLength, mbcsHeaderFlags, mbcsHeaderOptions;
73c04bcf A	482	int32_t extOffset;
	483
	484	inMBCSHeader=(const _MBCSHeader *)inBytes;
	485
	486	if(length<(int32_t)sizeof(_MBCSHeader)) {
	487	udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table\n",
	488	length);
	489	*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	490	return;
	491	}
46f4442e A	492	if(inMBCSHeader->version[0]==4 && inMBCSHeader->version[1]>=1) {
	493	mbcsHeaderLength=MBCS_HEADER_V4_LENGTH;
	494	} else if(inMBCSHeader->version[0]==5 && inMBCSHeader->version[1]>=3 &&
	495	((mbcsHeaderOptions=ds->readUInt32(inMBCSHeader->options))&
	496	MBCS_OPT_UNKNOWN_INCOMPATIBLE_MASK)==0
	497	) {
	498	mbcsHeaderLength=mbcsHeaderOptions&MBCS_OPT_LENGTH_MASK;
	499	} else {
73c04bcf A	500	udata_printError(ds, "icupkg/ucnv_enumDependencies(): unsupported _MBCSHeader.version %d.%d\n",
	501	inMBCSHeader->version[0], inMBCSHeader->version[1]);
	502	*pErrorCode=U_UNSUPPORTED_ERROR;
	503	return;
	504	}
	505
	506	mbcsHeaderFlags=ds->readUInt32(inMBCSHeader->flags);
	507	extOffset=(int32_t)(mbcsHeaderFlags>>8);
	508	outputType=(uint8_t)mbcsHeaderFlags;
	509
	510	if(outputType==MBCS_OUTPUT_EXT_ONLY) {
	511	/*
	512	* extension-only file,
	513	* contains a base name instead of normal base table data
	514	*/
	515	char baseName[32];
	516	int32_t baseNameLength;
	517
	518	/* there is extension data after the base data, see ucnv_ext.h */
	519	if(length<(extOffset+UCNV_EXT_INDEXES_MIN_LENGTH*4)) {
	520	udata_printError(ds, "icupkg/ucnv_enumDependencies(): too few bytes (%d after headers) for an ICU MBCS .cnv conversion table with extension data\n",
	521	length);
	522	*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
	523	return;
	524	}
	525
	526	/* swap the base name, between the header and the extension data */
46f4442e A	527	const char inBaseName=(const char )inBytes+mbcsHeaderLength*4;
46f4442e A	528	baseNameLength=(int32_t)strlen(inBaseName);
73c04bcf A	529	if(baseNameLength>=(int32_t)sizeof(baseName)) {
	530	udata_printError(ds, "icupkg/ucnv_enumDependencies(%s): base name length %ld too long\n",
	531	itemName, baseNameLength);
	532	*pErrorCode=U_UNSUPPORTED_ERROR;
	533	return;
	534	}
46f4442e	535	ds->swapInvChars(ds, inBaseName, baseNameLength+1, baseName, pErrorCode);
73c04bcf A	536
	537	checkIDSuffix(itemName, baseName, -1, ".cnv", check, context, pErrorCode);
	538	}
	539	}
	540	}
	541
	542	// ICU data formats -------------------------------------------------------- ***
	543
	544	static const struct {
	545	uint8_t dataFormat[4];
	546	} dataFormats[]={
	547	{ { 0x52, 0x65, 0x73, 0x42 } }, /* dataFormat="ResB" */
	548	{ { 0x63, 0x6e, 0x76, 0x74 } }, /* dataFormat="cnvt" */
	549	{ { 0x43, 0x76, 0x41, 0x6c } } /* dataFormat="CvAl" */
	550	};
	551
	552	enum {
	553	FMT_RES,
	554	FMT_CNV,
	555	FMT_ALIAS,
	556	FMT_COUNT
	557	};
	558
	559	static int32_t
	560	getDataFormat(const uint8_t dataFormat[4]) {
	561	int32_t i;
	562
	563	for(i=0; i<FMT_COUNT; ++i) {
	564	if(0==memcmp(dataFormats[i].dataFormat, dataFormat, 4)) {
	565	return i;
	566	}
	567	}
	568	return -1;
	569	}
	570
	571	// enumerate dependencies of a package item -------------------------------- ***
	572
73c04bcf	573	void
46f4442e	574	Package::enumDependencies(Item pItem, void context, CheckDependency check) {
729e4ab9 A	575	int32_t infoLength, itemHeaderLength;
	576	UErrorCode errorCode=U_ZERO_ERROR;
	577	const UDataInfo *pInfo=getDataInfo(pItem->data, pItem->length, infoLength, itemHeaderLength, &errorCode);
73c04bcf A	578	if(U_FAILURE(errorCode)) {
	579	return; // should not occur because readFile() checks headers
	580	}
	581
	582	// find the data format and call the corresponding function, if any
729e4ab9	583	int32_t format=getDataFormat(pInfo->dataFormat);
73c04bcf	584	if(format>=0) {
73c04bcf A	585	switch(format) {
73c04bcf A	586	case FMT_RES:
729e4ab9 A	587	{
	588	/*
	589	* Swap the resource bundle (if necessary) so that we can use
	590	* the normal runtime uresdata.c code to read it.
	591	* We do not want to duplicate that code, especially not together with on-the-fly swapping.
	592	*/
	593	NativeItem nrb(pItem, ures_swap);
	594	ures_enumDependencies(pItem->name, nrb.getDataInfo(), nrb.getBytes(), nrb.getLength(), check, context, this, &errorCode);
	595	break;
	596	}
73c04bcf	597	case FMT_CNV:
729e4ab9 A	598	{
	599	// TODO: share/cache swappers
	600	UDataSwapper *ds=udata_openSwapper(
	601	(UBool)pInfo->isBigEndian, pInfo->charsetFamily,
	602	U_IS_BIG_ENDIAN, U_CHARSET_FAMILY,
	603	&errorCode);
	604	if(U_FAILURE(errorCode)) {
	605	fprintf(stderr, "icupkg: udata_openSwapper(\"%s\") failed - %s\n",
	606	pItem->name, u_errorName(errorCode));
	607	exit(errorCode);
	608	}
	609
	610	ds->printError=printError;
	611	ds->printErrorContext=stderr;
	612
	613	const uint8_t *inBytes=pItem->data+itemHeaderLength;
	614	int32_t length=pItem->length-itemHeaderLength;
	615
	616	ucnv_enumDependencies(ds, pItem->name, pInfo, inBytes, length, check, context, &errorCode);
	617	udata_closeSwapper(ds);
	618	break;
	619	}
73c04bcf A	620	default:
	621	break;
	622	}
	623
73c04bcf A	624	if(U_FAILURE(errorCode)) {
	625	exit(errorCode);
	626	}
	627	}
	628	}
729e4ab9	629
73c04bcf	630	U_NAMESPACE_END