com.ibm.icu.impl.ICUResourceBundleReader Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of vaadin-client-compiler-deps Show documentation
Show all versions of vaadin-client-compiler-deps Show documentation
Vaadin is a web application framework for Rich Internet Applications (RIA).
Vaadin enables easy development and maintenance of fast and
secure rich web
applications with a stunning look and feel and a wide browser support.
It features a server-side architecture with the majority of the logic
running
on the server. Ajax technology is used at the browser-side to ensure a
rich
and interactive user experience.
/*
*******************************************************************************
* Copyright (C) 2004-2011, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
package com.ibm.icu.impl;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import com.ibm.icu.util.ULocale;
import com.ibm.icu.util.UResourceBundle;
import com.ibm.icu.util.VersionInfo;
/**
* This class reads the *.res resource bundle format
*
* (For the latest version of the file format documentation see
* ICU4C's source/common/uresdata.h file.)
*
* File format for .res resource bundle files (formatVersion=2, ICU 4.4)
*
* New in formatVersion 2 compared with 1.3: -------------
*
* Three new resource types -- String-v2, Table16 and Array16 -- have their
* values stored in a new array of 16-bit units between the table key strings
* and the start of the other resources.
*
* genrb eliminates duplicates among Unicode string-v2 values.
* Multiple Unicode strings may use the same offset and string data,
* or a short string may point to the suffix of a longer string. ("Suffix sharing")
* For example, one string "abc" may be reused for another string "bc" by pointing
* to the second character. (Short strings-v2 are NUL-terminated
* and not preceded by an explicit length value.)
*
* It is allowed for all resource types to share values.
* The swapper code (ures_swap()) has been modified so that it swaps each item
* exactly once.
*
* A resource bundle may use a special pool bundle. Some or all of the table key strings
* of the using-bundle are omitted, and the key string offsets for such key strings refer
* to offsets in the pool bundle.
* The using-bundle's and the pool-bundle's indexes[URES_INDEX_POOL_CHECKSUM] values
* must match.
* Two bits in indexes[URES_INDEX_ATTRIBUTES] indicate whether a resource bundle
* is or uses a pool bundle.
*
* Table key strings must be compared in ASCII order, even if they are not
* stored in ASCII.
*
* New in formatVersion 1.3 compared with 1.2: -------------
*
* genrb eliminates duplicates among key strings.
* Multiple table items may share one key string, or one item may point
* to the suffix of another's key string. ("Suffix sharing")
* For example, one key "abc" may be reused for another key "bc" by pointing
* to the second character. (Key strings are NUL-terminated.)
*
* -------------
*
* An ICU4C resource bundle file (.res) is a binary, memory-mappable file
* with nested, hierarchical data structures.
* It physically contains the following:
*
* Resource root; -- 32-bit Resource item, root item for this bundle's tree;
* currently, the root item must be a table or table32 resource item
* int32_t indexes[indexes[0]]; -- array of indexes for friendly
* reading and swapping; see URES_INDEX_* above
* new in formatVersion 1.1 (ICU 2.8)
* char keys[]; -- characters for key strings
* (formatVersion 1.0: up to 65k of characters; 1.1: <2G)
* (minus the space for root and indexes[]),
* which consist of invariant characters (ASCII/EBCDIC) and are NUL-terminated;
* padded to multiple of 4 bytes for 4-alignment of the following data
* uint16_t 16BitUnits[]; -- resources that are stored entirely as sequences of 16-bit units
* (new in formatVersion 2/ICU 4.4)
* data is indexed by the offset values in 16-bit resource types,
* with offset 0 pointing to the beginning of this array;
* there is a 0 at offset 0, for empty resources;
* padded to multiple of 4 bytes for 4-alignment of the following data
* data; -- data directly and indirectly indexed by the root item;
* the structure is determined by walking the tree
*
* Each resource bundle item has a 32-bit Resource handle (see typedef above)
* which contains the item type number in its upper 4 bits (31..28) and either
* an offset or a direct value in its lower 28 bits (27..0).
* The order of items is undefined and only determined by walking the tree.
* Leaves of the tree may be stored first or last or anywhere in between,
* and it is in theory possible to have unreferenced holes in the file.
*
* 16-bit-unit values:
* Starting with formatVersion 2/ICU 4.4, some resources are stored in a special
* array of 16-bit units. Each resource value is a sequence of 16-bit units,
* with no per-resource padding to a 4-byte boundary.
* 16-bit container types (Table16 and Array16) contain Resource16 values
* which are offsets to String-v2 resources in the same 16-bit-units array.
*
* Direct values:
* - Empty Unicode strings have an offset value of 0 in the Resource handle itself.
* - Starting with formatVersion 2/ICU 4.4, an offset value of 0 for
* _any_ resource type indicates an empty value.
* - Integer values are 28-bit values stored in the Resource handle itself;
* the interpretation of unsigned vs. signed integers is up to the application.
*
* All other types and values use 28-bit offsets to point to the item's data.
* The offset is an index to the first 32-bit word of the value, relative to the
* start of the resource data (i.e., the root item handle is at offset 0).
* To get byte offsets, the offset is multiplied by 4 (or shifted left by 2 bits).
* All resource item values are 4-aligned.
*
* New in formatVersion 2/ICU 4.4: Some types use offsets into the 16-bit-units array,
* indexing 16-bit units in that array.
*
* The structures (memory layouts) for the values for each item type are listed
* in the table below.
*
* Nested, hierarchical structures: -------------
*
* Table items contain key-value pairs where the keys are offsets to char * key strings.
* The values of these pairs are either Resource handles or
* offsets into the 16-bit-units array, depending on the table type.
*
* Array items are simple vectors of Resource handles,
* or of offsets into the 16-bit-units array, depending on the array type.
*
* Table key string offsets: -------
*
* Key string offsets are relative to the start of the resource data (of the root handle),
* i.e., the first string has an offset of 4+sizeof(indexes).
* (After the 4-byte root handle and after the indexes array.)
*
* If the resource bundle uses a pool bundle, then some key strings are stored
* in the pool bundle rather than in the local bundle itself.
* - In a Table or Table16, the 16-bit key string offset is local if it is
* less than indexes[URES_INDEX_KEYS_TOP]<<2.
* Otherwise, subtract indexes[URES_INDEX_KEYS_TOP]<<2 to get the offset into
* the pool bundle key strings.
* - In a Table32, the 32-bit key string offset is local if it is non-negative.
* Otherwise, reset bit 31 to get the pool key string offset.
*
* Unlike the local offset, the pool key offset is relative to
* the start of the key strings, not to the start of the bundle.
*
* An alias item is special (and new in ICU 2.4): --------------
*
* Its memory layout is just like for a UnicodeString, but at runtime it resolves to
* another resource bundle's item according to the path in the string.
* This is used to share items across bundles that are in different lookup/fallback
* chains (e.g., large collation data among zh_TW and zh_HK).
* This saves space (for large items) and maintenance effort (less duplication of data).
*
* --------------------------------------------------------------------------
*
* Resource types:
*
* Most resources have their values stored at four-byte offsets from the start
* of the resource data. These values are at least 4-aligned.
* Some resource values are stored directly in the offset field of the Resource itself.
* See UResType in unicode/ures.h for enumeration constants for Resource types.
*
* Some resources have their values stored as sequences of 16-bit units,
* at 2-byte offsets from the start of a contiguous 16-bit-unit array between
* the table key strings and the other resources. (new in formatVersion 2/ICU 4.4)
* At offset 0 of that array is a 16-bit zero value for empty 16-bit resources.
* Resource16 values in Table16 and Array16 are 16-bit offsets to String-v2
* resources, with the offsets relative to the start of the 16-bit-units array.
*
* Type Name Memory layout of values
* (in parentheses: scalar, non-offset values)
*
* 0 Unicode String: int32_t length, UChar[length], (UChar)0, (padding)
* or (empty string ("") if offset==0)
* 1 Binary: int32_t length, uint8_t[length], (padding)
* - the start of the bytes is 16-aligned -
* 2 Table: uint16_t count, uint16_t keyStringOffsets[count], (uint16_t padding), Resource[count]
* 3 Alias: (physically same value layout as string, new in ICU 2.4)
* 4 Table32: int32_t count, int32_t keyStringOffsets[count], Resource[count]
* (new in formatVersion 1.1/ICU 2.8)
* 5 Table16: uint16_t count, uint16_t keyStringOffsets[count], Resource16[count]
* (stored in the 16-bit-units array; new in formatVersion 2/ICU 4.4)
* 6 Unicode String-v2:UChar[length], (UChar)0; length determined by the first UChar:
* - if first is not a trail surrogate, then the length is implicit
* and u_strlen() needs to be called
* - if first<0xdfef then length=first&0x3ff (and skip first)
* - if first<0xdfff then length=((first-0xdfef)<<16) | second UChar
* - if first==0xdfff then length=((second UChar)<<16) | third UChar
* (stored in the 16-bit-units array; new in formatVersion 2/ICU 4.4)
* 7 Integer: (28-bit offset is integer value)
* 8 Array: int32_t count, Resource[count]
* 9 Array16: uint16_t count, Resource16[count]
* (stored in the 16-bit-units array; new in formatVersion 2/ICU 4.4)
* 14 Integer Vector: int32_t length, int32_t[length]
* 15 Reserved: This value denotes special purpose resources and is for internal use.
*
* Note that there are 3 types with data vector values:
* - Vectors of 8-bit bytes stored as type Binary.
* - Vectors of 16-bit words stored as type Unicode String or Unicode String-v2
* (no value restrictions, all values 0..ffff allowed!).
* - Vectors of 32-bit words stored as type Integer Vector.
*/
public final class ICUResourceBundleReader implements ICUBinary.Authenticate {
/**
* File format version that this class understands.
* "ResB"
*/
private static final byte DATA_FORMAT_ID[] = {(byte)0x52, (byte)0x65,
(byte)0x73, (byte)0x42};
/* indexes[] value names; indexes are generally 32-bit (Resource) indexes */
private static final int URES_INDEX_LENGTH = 0; /* contains URES_INDEX_TOP==the length of indexes[];
* formatVersion==1: all bits contain the length of indexes[]
* but the length is much less than 0xff;
* formatVersion>1:
* only bits 7..0 contain the length of indexes[],
* bits 31..8 are reserved and set to 0 */
private static final int URES_INDEX_KEYS_TOP = 1; /* contains the top of the key strings, */
/* same as the bottom of resources or UTF-16 strings, rounded up */
//ivate static final int URES_INDEX_RESOURCES_TOP = 2; /* contains the top of all resources */
private static final int URES_INDEX_BUNDLE_TOP = 3; /* contains the top of the bundle, */
/* in case it were ever different from [2] */
//ivate static final int URES_INDEX_MAX_TABLE_LENGTH = 4; /* max. length of any table */
private static final int URES_INDEX_ATTRIBUTES = 5; /* attributes bit set, see URES_ATT_* (new in formatVersion 1.2) */
private static final int URES_INDEX_16BIT_TOP = 6; /* top of the 16-bit units (UTF-16 string v2 UChars, URES_TABLE16, URES_ARRAY16),
* rounded up (new in formatVersion 2.0, ICU 4.4) */
private static final int URES_INDEX_POOL_CHECKSUM = 7; /* checksum of the pool bundle (new in formatVersion 2.0, ICU 4.4) */
//ivate static final int URES_INDEX_TOP = 8;
/*
* Nofallback attribute, attribute bit 0 in indexes[URES_INDEX_ATTRIBUTES].
* New in formatVersion 1.2 (ICU 3.6).
*
* If set, then this resource bundle is a standalone bundle.
* If not set, then the bundle participates in locale fallback, eventually
* all the way to the root bundle.
* If indexes[] is missing or too short, then the attribute cannot be determined
* reliably. Dependency checking should ignore such bundles, and loading should
* use fallbacks.
*/
private static final int URES_ATT_NO_FALLBACK = 1;
/*
* Attributes for bundles that are, or use, a pool bundle.
* A pool bundle provides key strings that are shared among several other bundles
* to reduce their total size.
* New in formatVersion 2 (ICU 4.4).
*/
private static final int URES_ATT_IS_POOL_BUNDLE = 2;
private static final int URES_ATT_USES_POOL_BUNDLE = 4;
private static final boolean DEBUG = false;
private byte[] /* formatVersion, */ dataVersion;
// See the ResourceData struct in ICU4C/source/common/uresdata.h.
private String s16BitUnits;
private byte[] poolBundleKeys;
private String poolBundleKeysAsString;
private int rootRes;
private int localKeyLimit;
private boolean noFallback; /* see URES_ATT_NO_FALLBACK */
private boolean isPoolBundle;
private boolean usesPoolBundle;
// Fields specific to the Java port.
private int[] indexes;
private byte[] keyStrings;
private String keyStringsAsString; // null except if isPoolBundle
private byte[] resourceBytes;
private int resourceBottom; // File offset where the mixed-type resources start.
private static ReaderCache CACHE = new ReaderCache();
private static final ICUResourceBundleReader NULL_READER = new ICUResourceBundleReader();
private static class ReaderInfo {
final String baseName;
final String localeID;
final ClassLoader loader;
ReaderInfo(String baseName, String localeID, ClassLoader loader) {
this.baseName = (baseName == null) ? "" : baseName;
this.localeID = (localeID == null) ? "" : localeID;
this.loader = loader;
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof ReaderInfo)) {
return false;
}
ReaderInfo info = (ReaderInfo)obj;
return this.baseName.equals(info.baseName)
&& this.localeID.equals(info.localeID)
&& this.loader.equals(info.loader);
}
public int hashCode() {
return baseName.hashCode() ^ localeID.hashCode() ^ loader.hashCode();
}
}
private static class ReaderCache extends SoftCache {
/* (non-Javadoc)
* @see com.ibm.icu.impl.CacheBase#createInstance(java.lang.Object, java.lang.Object)
*/
@Override
protected ICUResourceBundleReader createInstance(ReaderInfo key, ReaderInfo data) {
String fullName = ICUResourceBundleReader.getFullName(data.baseName, data.localeID);
InputStream stream = ICUData.getStream(data.loader, fullName);
if (stream == null) {
return NULL_READER;
}
return new ICUResourceBundleReader(stream, data.baseName, data.localeID, data.loader);
}
}
/*
* Sole constructor, just used for NULL_READER
*/
private ICUResourceBundleReader() {
}
private ICUResourceBundleReader(InputStream stream, String baseName, String localeID, ClassLoader loader) {
BufferedInputStream bs = new BufferedInputStream(stream);
try {
if (DEBUG) {
System.out.println("The InputStream class is: " + stream.getClass().getName());
System.out.println("The BufferedInputStream class is: " + bs.getClass().getName());
System.out.println("The bytes avialable in stream before reading the header: " + bs.available());
}
dataVersion = ICUBinary.readHeader(bs, DATA_FORMAT_ID, this);
if (DEBUG) System.out.println("The bytes available in stream after reading the header: " + bs.available());
readData(bs);
stream.close();
} catch (IOException ex) {
String fullName = ICUResourceBundleReader.getFullName(baseName, localeID);
throw new RuntimeException("Data file " + fullName + " is corrupt - " + ex.getMessage());
}
// set pool bundle keys if necessary
if (usesPoolBundle) {
ICUResourceBundleReader poolBundleReader = getReader(baseName, "pool", loader);
if (!poolBundleReader.isPoolBundle) {
throw new IllegalStateException("pool.res is not a pool bundle");
}
if (poolBundleReader.indexes[URES_INDEX_POOL_CHECKSUM] != indexes[URES_INDEX_POOL_CHECKSUM]) {
throw new IllegalStateException("pool.res has a different checksum than this bundle");
}
poolBundleKeys = poolBundleReader.keyStrings;
poolBundleKeysAsString = poolBundleReader.keyStringsAsString;
}
}
static ICUResourceBundleReader getReader(String baseName, String localeID, ClassLoader root) {
ReaderInfo info = new ReaderInfo(baseName, localeID, root);
ICUResourceBundleReader reader = CACHE.getInstance(info, info);
if (reader == NULL_READER) {
return null;
}
return reader;
}
// See res_init() in ICU4C/source/common/uresdata.c.
private void readData(InputStream stream) throws IOException {
DataInputStream ds = new DataInputStream(stream);
if(DEBUG) System.out.println("The DataInputStream class is: " + ds.getClass().getName());
if(DEBUG) System.out.println("The available bytes in the stream before reading the data: "+ds.available());
rootRes = ds.readInt();
// read the variable-length indexes[] array
int indexes0 = ds.readInt();
int indexLength = indexes0 & 0xff;
indexes = new int[indexLength];
indexes[URES_INDEX_LENGTH] = indexes0;
for(int i=1; i URES_INDEX_ATTRIBUTES) {
// determine if this resource bundle falls back to a parent bundle
// along normal locale ID fallback
int att = indexes[URES_INDEX_ATTRIBUTES];
noFallback = (att & URES_ATT_NO_FALLBACK) != 0;
isPoolBundle = (att & URES_ATT_IS_POOL_BUNDLE) != 0;
usesPoolBundle = (att & URES_ATT_USES_POOL_BUNDLE) != 0;
}
int length = indexes[URES_INDEX_BUNDLE_TOP]*4;
if(DEBUG) System.out.println("The number of bytes in the bundle: "+length);
// Read the local key strings.
// The keyStrings include NUL characters corresponding to the bytes
// up to the end of the indexes.
if(indexes[URES_INDEX_KEYS_TOP] > (1 + indexLength)) {
int keysBottom = (1 + indexLength) << 2;
int keysTop = indexes[URES_INDEX_KEYS_TOP] << 2;
resourceBottom = keysTop;
if(isPoolBundle) {
// Shift the key strings down:
// Pool bundle key strings are used with a 0-based index,
// unlike regular bundles' key strings for which indexes
// are based on the start of the bundle data.
keysTop -= keysBottom;
keysBottom = 0;
} else {
localKeyLimit = keysTop;
}
keyStrings = new byte[keysTop];
ds.readFully(keyStrings, keysBottom, keysTop - keysBottom);
if(isPoolBundle) {
// Overwrite trailing padding bytes so that the conversion works.
while(keysBottom < keysTop && keyStrings[keysTop - 1] == (byte)0xaa) {
keyStrings[--keysTop] = 0;
}
keyStringsAsString = new String(keyStrings, "US-ASCII");
}
}
// Read the array of 16-bit units.
// We are not using
// new String(keys, "UTF-16BE")
// because the 16-bit units may not be well-formed Unicode.
if( indexLength > URES_INDEX_16BIT_TOP &&
indexes[URES_INDEX_16BIT_TOP] > indexes[URES_INDEX_KEYS_TOP]
) {
int num16BitUnits = (indexes[URES_INDEX_16BIT_TOP] -
indexes[URES_INDEX_KEYS_TOP]) * 2;
char[] c16BitUnits = new char[num16BitUnits];
// Note: Calling readFully() to read data into byte[] and copy
// the data to char[] is faster than calling readChar() one by one
// for large data
byte[] c16BitUnitsBytes = new byte[num16BitUnits * 2];
ds.readFully(c16BitUnitsBytes);
for (int i = 0; i < num16BitUnits; i++) {
c16BitUnits[i] = (char)((c16BitUnitsBytes[i*2] << 8) | (c16BitUnitsBytes[i*2 + 1] & 0xFF));
}
s16BitUnits = new String(c16BitUnits);
resourceBottom = indexes[URES_INDEX_16BIT_TOP] << 2;
} else {
s16BitUnits = "\0";
}
// Read the block of bytes for the mixed-type resources.
resourceBytes = new byte[length - resourceBottom];
ds.readFully(resourceBytes);
}
VersionInfo getVersion(){
return VersionInfo.getInstance(dataVersion[0],dataVersion[1],dataVersion[2],dataVersion[3]);
}
public boolean isDataVersionAcceptable(byte version[]){
// while ICU4C can read formatVersion 1.0 and up,
// ICU4J requires 1.1 as a minimum
// formatVersion = version;
return ((version[0] == 1 && version[1] >= 1) || version[0] == 2);
}
int getRootResource() {
return rootRes;
}
boolean getNoFallback() {
return noFallback;
}
boolean getUsesPoolBundle() {
return usesPoolBundle;
}
static int RES_GET_TYPE(int res) {
return res >>> 28;
}
private static int RES_GET_OFFSET(int res) {
return res & 0x0fffffff;
}
private int getResourceByteOffset(int offset) {
return (offset << 2) - resourceBottom;
}
/* get signed and unsigned integer values directly from the Resource handle */
static int RES_GET_INT(int res) {
return (res << 4) >> 4;
}
static int RES_GET_UINT(int res) {
return res & 0x0fffffff;
}
static boolean URES_IS_TABLE(int type) {
return type==UResourceBundle.TABLE || type==ICUResourceBundle.TABLE16 || type==ICUResourceBundle.TABLE32;
}
private static byte[] emptyBytes = new byte[0];
private static ByteBuffer emptyByteBuffer = ByteBuffer.allocate(0).asReadOnlyBuffer();
private static char[] emptyChars = new char[0];
private static int[] emptyInts = new int[0];
private static String emptyString = "";
private char getChar(int offset) {
return (char)((resourceBytes[offset] << 8) | (resourceBytes[offset + 1] & 0xff));
}
private char[] getChars(int offset, int count) {
char[] chars = new char[count];
for(int i = 0; i < count; offset += 2, ++i) {
chars[i] = (char)(((int)resourceBytes[offset] << 8) | (resourceBytes[offset + 1] & 0xff));
}
return chars;
}
private int getInt(int offset) {
return (resourceBytes[offset] << 24) |
((resourceBytes[offset+1] & 0xff) << 16) |
((resourceBytes[offset+2] & 0xff) << 8) |
((resourceBytes[offset+3] & 0xff));
}
private int[] getInts(int offset, int count) {
int[] ints = new int[count];
for(int i = 0; i < count; offset += 4, ++i) {
ints[i] = (resourceBytes[offset] << 24) |
((resourceBytes[offset+1] & 0xff) << 16) |
((resourceBytes[offset+2] & 0xff) << 8) |
((resourceBytes[offset+3] & 0xff));
}
return ints;
}
private char[] getTable16KeyOffsets(int offset) {
int length = s16BitUnits.charAt(offset++);
if(length > 0) {
return s16BitUnits.substring(offset, offset + length).toCharArray();
} else {
return emptyChars;
}
}
private char[] getTableKeyOffsets(int offset) {
int length = getChar(offset);
if(length > 0) {
return getChars(offset + 2, length);
} else {
return emptyChars;
}
}
private int[] getTable32KeyOffsets(int offset) {
int length = getInt(offset);
if(length > 0) {
return getInts(offset + 4, length);
} else {
return emptyInts;
}
}
/** Refers to ASCII key string bytes, for key string matching. */
private static final class ByteSequence {
private byte[] bytes;
private int offset;
public ByteSequence(byte[] bytes, int offset) {
this.bytes = bytes;
this.offset = offset;
}
public byte charAt(int index) {
return bytes[offset + index];
}
}
private String makeKeyStringFromBytes(int keyOffset) {
StringBuilder sb = new StringBuilder();
byte b;
while((b = keyStrings[keyOffset++]) != 0) {
sb.append((char)b);
}
return sb.toString();
}
private String makeKeyStringFromString(int keyOffset) {
int endOffset = keyOffset;
while(poolBundleKeysAsString.charAt(endOffset) != 0) {
++endOffset;
}
return poolBundleKeysAsString.substring(keyOffset, endOffset);
}
private ByteSequence RES_GET_KEY16(char keyOffset) {
if(keyOffset < localKeyLimit) {
return new ByteSequence(keyStrings, keyOffset);
} else {
return new ByteSequence(poolBundleKeys, keyOffset - localKeyLimit);
}
}
private String getKey16String(int keyOffset) {
if(keyOffset < localKeyLimit) {
return makeKeyStringFromBytes(keyOffset);
} else {
return makeKeyStringFromString(keyOffset - localKeyLimit);
}
}
private ByteSequence RES_GET_KEY32(int keyOffset) {
if(keyOffset >= 0) {
return new ByteSequence(keyStrings, keyOffset);
} else {
return new ByteSequence(poolBundleKeys, keyOffset & 0x7fffffff);
}
}
private String getKey32String(int keyOffset) {
if(keyOffset >= 0) {
return makeKeyStringFromBytes(keyOffset);
} else {
return makeKeyStringFromString(keyOffset & 0x7fffffff);
}
}
// Compare the length-specified input key with the
// NUL-terminated tableKey.
private static int compareKeys(CharSequence key, ByteSequence tableKey) {
int i;
for(i = 0; i < key.length(); ++i) {
int c2 = tableKey.charAt(i);
if(c2 == 0) {
return 1; // key > tableKey because key is longer.
}
int diff = (int)key.charAt(i) - c2;
if(diff != 0) {
return diff;
}
}
return -(int)tableKey.charAt(i);
}
private int compareKeys(CharSequence key, char keyOffset) {
return compareKeys(key, RES_GET_KEY16(keyOffset));
}
private int compareKeys32(CharSequence key, int keyOffset) {
return compareKeys(key, RES_GET_KEY32(keyOffset));
}
String getString(int res) {
int offset=RES_GET_OFFSET(res);
int length;
if(RES_GET_TYPE(res)==ICUResourceBundle.STRING_V2) {
int first = s16BitUnits.charAt(offset);
if((first&0xfffffc00)!=0xdc00) { // C: if(!U16_IS_TRAIL(first)) {
if(first==0) {
return emptyString;
}
int endOffset;
for(endOffset=offset+1; s16BitUnits.charAt(endOffset)!=0; ++endOffset) {}
return s16BitUnits.substring(offset, endOffset);
} else if(first<0xdfef) {
length=first&0x3ff;
++offset;
} else if(first<0xdfff) {
length=((first-0xdfef)<<16)|s16BitUnits.charAt(offset+1);
offset+=2;
} else {
length=((int)s16BitUnits.charAt(offset+1)<<16)|s16BitUnits.charAt(offset+2);
offset+=3;
}
return s16BitUnits.substring(offset, offset+length);
} else if(res==offset) /* RES_GET_TYPE(res)==URES_STRING */ {
if(res==0) {
return emptyString;
} else {
offset=getResourceByteOffset(offset);
length=getInt(offset);
return new String(getChars(offset+4, length));
}
} else {
return null;
}
}
String getAlias(int res) {
int offset=RES_GET_OFFSET(res);
int length;
if(RES_GET_TYPE(res)==ICUResourceBundle.ALIAS) {
if(offset==0) {
return emptyString;
} else {
offset=getResourceByteOffset(offset);
length=getInt(offset);
return new String(getChars(offset+4, length));
}
} else {
return null;
}
}
byte[] getBinary(int res, byte[] ba) {
int offset=RES_GET_OFFSET(res);
int length;
if(RES_GET_TYPE(res)==UResourceBundle.BINARY) {
if(offset==0) {
return emptyBytes;
} else {
offset=getResourceByteOffset(offset);
length=getInt(offset);
if(ba==null || ba.length!=length) {
ba=new byte[length];
}
System.arraycopy(resourceBytes, offset+4, ba, 0, length);
return ba;
}
} else {
return null;
}
}
ByteBuffer getBinary(int res) {
int offset=RES_GET_OFFSET(res);
int length;
if(RES_GET_TYPE(res)==UResourceBundle.BINARY) {
if(offset==0) {
// Don't just
// return emptyByteBuffer;
// in case it matters whether the buffer's mark is defined or undefined.
return emptyByteBuffer.duplicate();
} else {
offset=getResourceByteOffset(offset);
length=getInt(offset);
return ByteBuffer.wrap(resourceBytes, offset+4, length).slice().asReadOnlyBuffer();
}
} else {
return null;
}
}
int[] getIntVector(int res) {
int offset=RES_GET_OFFSET(res);
int length;
if(RES_GET_TYPE(res)==UResourceBundle.INT_VECTOR) {
if(offset==0) {
return emptyInts;
} else {
offset=getResourceByteOffset(offset);
length=getInt(offset);
return getInts(offset+4, length);
}
} else {
return null;
}
}
Container getArray(int res) {
int type=RES_GET_TYPE(res);
int offset=RES_GET_OFFSET(res);
switch(type) {
case UResourceBundle.ARRAY:
case ICUResourceBundle.ARRAY16:
if(offset==0) {
return new Container(this);
}
break;
default:
return null;
}
switch(type) {
case UResourceBundle.ARRAY:
return new Array(this, offset);
case ICUResourceBundle.ARRAY16:
return new Array16(this, offset);
default:
return null;
}
}
Table getTable(int res) {
int type=RES_GET_TYPE(res);
int offset=RES_GET_OFFSET(res);
switch(type) {
case UResourceBundle.TABLE:
case ICUResourceBundle.TABLE16:
case ICUResourceBundle.TABLE32:
if(offset==0) {
return new Table(this);
}
break;
default:
return null;
}
switch(type) {
case UResourceBundle.TABLE:
return new Table1632(this, offset);
case ICUResourceBundle.TABLE16:
return new Table16(this, offset);
case ICUResourceBundle.TABLE32:
return new Table32(this, offset);
default:
return null;
}
}
// Container value classes --------------------------------------------- ***
static class Container {
protected ICUResourceBundleReader reader;
protected int size;
protected int itemsOffset;
int getSize() {
return size;
}
int getContainerResource(int index) {
return ICUResourceBundle.RES_BOGUS;
}
protected int getContainer16Resource(int index) {
if (index < 0 || size <= index) {
return ICUResourceBundle.RES_BOGUS;
}
return (ICUResourceBundle.STRING_V2 << 28) |
reader.s16BitUnits.charAt(itemsOffset + index);
}
protected int getContainer32Resource(int index) {
if (index < 0 || size <= index) {
return ICUResourceBundle.RES_BOGUS;
}
return reader.getInt(itemsOffset + 4 * index);
}
Container(ICUResourceBundleReader reader) {
this.reader = reader;
}
}
private static final class Array extends Container {
int getContainerResource(int index) {
return getContainer32Resource(index);
}
Array(ICUResourceBundleReader reader, int offset) {
super(reader);
offset = reader.getResourceByteOffset(offset);
size = reader.getInt(offset);
itemsOffset = offset + 4;
}
}
private static final class Array16 extends Container {
int getContainerResource(int index) {
return getContainer16Resource(index);
}
Array16(ICUResourceBundleReader reader, int offset) {
super(reader);
size = reader.s16BitUnits.charAt(offset);
itemsOffset = offset + 1;
}
}
static class Table extends Container {
protected char[] keyOffsets;
protected int[] key32Offsets;
String getKey(int index) {
if (index < 0 || size <= index) {
return null;
}
return keyOffsets != null ?
reader.getKey16String(keyOffsets[index]) :
reader.getKey32String(key32Offsets[index]);
}
private static final int URESDATA_ITEM_NOT_FOUND = -1;
int findTableItem(CharSequence key) {
int mid, start, limit;
int result;
/* do a binary search for the key */
start=0;
limit=size;
while(start>> 1;
if (keyOffsets != null) {
result = reader.compareKeys(key, keyOffsets[mid]);
} else {
result = reader.compareKeys32(key, key32Offsets[mid]);
}
if (result < 0) {
limit = mid;
} else if (result > 0) {
start = mid + 1;
} else {
/* We found it! */
return mid;
}
}
return URESDATA_ITEM_NOT_FOUND; /* not found or table is empty. */
}
int getTableResource(String resKey) {
return getContainerResource(findTableItem(resKey));
}
Table(ICUResourceBundleReader reader) {
super(reader);
}
}
private static final class Table1632 extends Table {
int getContainerResource(int index) {
return getContainer32Resource(index);
}
Table1632(ICUResourceBundleReader reader, int offset) {
super(reader);
offset = reader.getResourceByteOffset(offset);
keyOffsets = reader.getTableKeyOffsets(offset);
size = keyOffsets.length;
itemsOffset = offset + 2 * ((size + 2) & ~1); // Skip padding for 4-alignment.
}
}
private static final class Table16 extends Table {
int getContainerResource(int index) {
return getContainer16Resource(index);
}
Table16(ICUResourceBundleReader reader, int offset) {
super(reader);
keyOffsets = reader.getTable16KeyOffsets(offset);
size = keyOffsets.length;
itemsOffset = offset + 1 + size;
}
}
private static final class Table32 extends Table {
int getContainerResource(int index) {
return getContainer32Resource(index);
}
Table32(ICUResourceBundleReader reader, int offset) {
super(reader);
offset = reader.getResourceByteOffset(offset);
key32Offsets = reader.getTable32KeyOffsets(offset);
size = key32Offsets.length;
itemsOffset = offset + 4 * (1 + size);
}
}
private static final String ICU_RESOURCE_SUFFIX = ".res";
/**
* Gets the full name of the resource with suffix.
*/
public static String getFullName(String baseName, String localeName) {
if (baseName == null || baseName.length() == 0) {
if (localeName.length() == 0) {
return localeName = ULocale.getDefault().toString();
}
return localeName + ICU_RESOURCE_SUFFIX;
} else {
if (baseName.indexOf('.') == -1) {
if (baseName.charAt(baseName.length() - 1) != '/') {
return baseName + "/" + localeName + ICU_RESOURCE_SUFFIX;
} else {
return baseName + localeName + ICU_RESOURCE_SUFFIX;
}
} else {
baseName = baseName.replace('.', '/');
if (localeName.length() == 0) {
return baseName + ICU_RESOURCE_SUFFIX;
} else {
return baseName + "_" + localeName + ICU_RESOURCE_SUFFIX;
}
}
}
}
}