/* ********************************************************************** * Copyright (c) 2002-2004, International Business Machines * Corporation and others. All Rights Reserved. ********************************************************************** * Author: Alan Liu * Created: October 30 2002 * Since: ICU 2.4 ********************************************************************** */ #ifndef PROPNAME_H #define PROPNAME_H #include "unicode/utypes.h" #include "unicode/uchar.h" #include "udataswp.h" #include "uprops.h" /* * This header defines the in-memory layout of the property names data * structure representing the UCD data files PropertyAliases.txt and * PropertyValueAliases.txt. It is used by: * propname.cpp - reads data * genpname - creates data */ /* low-level char * property name comparison -------------------------------- */ U_CDECL_BEGIN /** * \var uprv_comparePropertyNames * Unicode property names and property value names are compared "loosely". * * UCD.html 4.0.1 says: * For all property names, property value names, and for property values for * Enumerated, Binary, or Catalog properties, use the following * loose matching rule: * * LM3. Ignore case, whitespace, underscore ('_'), and hyphens. * * This function does just that, for (char *) name strings. * It is almost identical to ucnv_compareNames() but also ignores * C0 White_Space characters (U+0009..U+000d, and U+0085 on EBCDIC). * * @internal */ U_CAPI int32_t U_EXPORT2 uprv_compareASCIIPropertyNames(const char *name1, const char *name2); U_CAPI int32_t U_EXPORT2 uprv_compareEBCDICPropertyNames(const char *name1, const char *name2); #if U_CHARSET_FAMILY==U_ASCII_FAMILY # define uprv_comparePropertyNames uprv_compareASCIIPropertyNames #elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY # define uprv_comparePropertyNames uprv_compareEBCDICPropertyNames #else # error U_CHARSET_FAMILY is not valid #endif U_CDECL_END /* UDataMemory structure and signatures ------------------------------------- */ #define PNAME_DATA_NAME "pnames" #define PNAME_DATA_TYPE "icu" /* Fields in UDataInfo: */ /* PNAME_SIG[] is encoded as numeric literals for compatibility with the HP compiler */ #define PNAME_SIG_0 ((uint8_t)0x70) /* p */ #define PNAME_SIG_1 ((uint8_t)0x6E) /* n */ #define PNAME_SIG_2 ((uint8_t)0x61) /* a */ #define PNAME_SIG_3 ((uint8_t)0x6D) /* m */ #define PNAME_FORMAT_VERSION ((int8_t)1) /* formatVersion[0] */ /** * Swap pnames.icu. See udataswp.h. * @internal */ U_CAPI int32_t U_EXPORT2 upname_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outData, UErrorCode *pErrorCode); #ifdef XP_CPLUSPLUS class Builder; U_NAMESPACE_BEGIN /** * An offset from the start of the pnames data to a contained entity. * This must be a signed value, since negative offsets are used as an * end-of-list marker. Offsets to actual objects are non-zero. A * zero offset indicates an absent entry; this corresponds to aliases * marked "n/a" in the original Unicode data files. */ typedef int16_t Offset; /* must be signed */ #define MAX_OFFSET 0x7FFF /** * A generic value for a property or property value. Typically an * enum from uchar.h, but sometimes a non-enum value. It must be * large enough to accomodate the largest enum value, which as of this * writing is the largest general category mask. Need not be signed * but may be. Typically it doesn't matter, since the caller will * cast it to the proper type before use. Takes the special value * UCHAR_INVALID_CODE for invalid input. */ typedef int32_t EnumValue; /* ---------------------------------------------------------------------- */ /* ValueMap */ /** * For any top-level property that has named values (binary and * enumerated properties), there is a ValueMap object. This object * maps from enum values to two other maps. One goes from value enums * to value names. The other goes from value names to value enums. * * The value enum values may be contiguous or disjoint. If they are * contiguous then the enumToName_offset is nonzero, and the * ncEnumToName_offset is zero. Vice versa if the value enums are * disjoint. * * There are n of these objects, where n is the number of binary * properties + the number of enumerated properties. */ struct ValueMap { /* -- begin pnames data -- */ /* Enum=>name EnumToOffset / NonContiguousEnumToOffset objects. */ /* Exactly one of these will be nonzero. */ Offset enumToName_offset; Offset ncEnumToName_offset; Offset nameToEnum_offset; /* Name=>enum data */ /* -- end pnames data -- */ }; /* ---------------------------------------------------------------------- */ /* PropertyAliases class */ /** * A class encapsulating access to the memory-mapped data representing * property aliases and property value aliases (pnames). The class * MUST have no v-table and declares certain methods inline -- small * methods and methods that are called from only one point. * * The data members in this class correspond to the in-memory layout * of the header of the pnames data. */ class PropertyAliases { /* -- begin pnames data -- */ /* Enum=>name EnumToOffset object for binary and enumerated */ /* properties */ Offset enumToName_offset; /* Name=>enum data for binary & enumerated properties */ Offset nameToEnum_offset; /* Enum=>offset EnumToOffset object mapping enumerated properties */ /* to ValueMap objects */ Offset enumToValue_offset; /* The following are needed by external readers of this data. */ /* We don't use them ourselves. */ int16_t total_size; /* size in bytes excluding the udata header */ Offset valueMap_offset; /* offset to start of array */ int16_t valueMap_count; /* number of entries */ Offset nameGroupPool_offset; /* offset to start of array */ int16_t nameGroupPool_count; /* number of entries (not groups) */ Offset stringPool_offset; /* offset to start of pool */ int16_t stringPool_count; /* number of strings (not size in bytes) */ /* -- end pnames data -- */ friend class ::Builder; const ValueMap* getValueMap(EnumValue prop) const; const char* chooseNameInGroup(Offset offset, UPropertyNameChoice choice) const; public: inline const int8_t* getPointer(Offset o) const { return ((const int8_t*) this) + o; } inline const int8_t* getPointerNull(Offset o) const { return o ? getPointer(o) : NULL; } inline const char* getPropertyName(EnumValue prop, UPropertyNameChoice choice) const; inline EnumValue getPropertyEnum(const char* alias) const; inline const char* getPropertyValueName(EnumValue prop, EnumValue value, UPropertyNameChoice choice) const; inline EnumValue getPropertyValueEnum(EnumValue prop, const char* alias) const; static int32_t swap(const UDataSwapper *ds, const uint8_t *inBytes, int32_t length, uint8_t *outBytes, UErrorCode *pErrorCode); }; /* ---------------------------------------------------------------------- */ /* EnumToOffset */ /** * A generic map from enum values to Offsets. The enum values must be * contiguous, from enumStart to enumLimit. The Offset values may * point to anything. */ class EnumToOffset { /* -- begin pnames data -- */ EnumValue enumStart; EnumValue enumLimit; Offset _offsetArray; /* [array of enumLimit-enumStart] */ /* -- end pnames data -- */ friend class ::Builder; Offset* getOffsetArray() { return &_offsetArray; } const Offset* getOffsetArray() const { return &_offsetArray; } static int32_t getSize(int32_t n) { return sizeof(EnumToOffset) + sizeof(Offset) * (n - 1); } int32_t getSize() { return getSize(enumLimit - enumStart); } public: Offset getOffset(EnumValue enumProbe) const { if (enumProbe < enumStart || enumProbe >= enumLimit) { return 0; /* not found */ } const Offset* p = getOffsetArray(); return p[enumProbe - enumStart]; } static int32_t swap(const UDataSwapper *ds, const uint8_t *inBytes, int32_t length, uint8_t *outBytes, uint8_t *temp, int32_t pos, UErrorCode *pErrorCode); }; /* ---------------------------------------------------------------------- */ /* NonContiguousEnumToOffset */ /** * A generic map from enum values to Offsets. The enum values may be * disjoint. If they are contiguous, an EnumToOffset should be used * instead. The Offset values may point to anything. */ class NonContiguousEnumToOffset { /* -- begin pnames data -- */ int32_t count; EnumValue _enumArray; /* [array of count] */ /* Offset _offsetArray; // [array of count] after enumValue[count-1] */ /* -- end pnames data -- */ friend class ::Builder; EnumValue* getEnumArray() { return &_enumArray; } const EnumValue* getEnumArray() const { return &_enumArray; } Offset* getOffsetArray() { return (Offset*) (getEnumArray() + count); } const Offset* getOffsetArray() const { return (Offset*) (getEnumArray() + count); } static int32_t getSize(int32_t n) { return sizeof(int32_t) + (sizeof(EnumValue) + sizeof(Offset)) * n; } int32_t getSize() { return getSize(count); } public: Offset getOffset(EnumValue enumProbe) const { const EnumValue* e = getEnumArray(); const Offset* p = getOffsetArray(); /* linear search; binary later if warranted */ /* (binary is not faster for short lists) */ for (int32_t i=0; i<count; ++i) { if (e[i] < enumProbe) continue; if (e[i] > enumProbe) break; return p[i]; } return 0; /* not found */ } static int32_t swap(const UDataSwapper *ds, const uint8_t *inBytes, int32_t length, uint8_t *outBytes, uint8_t *temp, int32_t pos, UErrorCode *pErrorCode); }; /* ---------------------------------------------------------------------- */ /* NameToEnum */ /** * A map from names to enum values. */ class NameToEnum { /* -- begin pnames data -- */ int32_t count; /* number of entries */ EnumValue _enumArray; /* [array of count] EnumValues */ /* Offset _nameArray; // [array of count] offsets to names */ /* -- end pnames data -- */ friend class ::Builder; EnumValue* getEnumArray() { return &_enumArray; } const EnumValue* getEnumArray() const { return &_enumArray; } Offset* getNameArray() { return (Offset*) (getEnumArray() + count); } const Offset* getNameArray() const { return (Offset*) (getEnumArray() + count); } static int32_t getSize(int32_t n) { return sizeof(int32_t) + (sizeof(Offset) + sizeof(EnumValue)) * n; } int32_t getSize() { return getSize(count); } public: EnumValue getEnum(const char* alias, const PropertyAliases& data) const { const Offset* n = getNameArray(); const EnumValue* e = getEnumArray(); /* linear search; binary later if warranted */ /* (binary is not faster for short lists) */ for (int32_t i=0; i<count; ++i) { const char* name = (const char*) data.getPointer(n[i]); int32_t c = uprv_comparePropertyNames(alias, name); if (c > 0) continue; if (c < 0) break; return e[i]; } return UCHAR_INVALID_CODE; } static int32_t swap(const UDataSwapper *ds, const uint8_t *inBytes, int32_t length, uint8_t *outBytes, uint8_t *temp, int32_t pos, UErrorCode *pErrorCode); }; /*---------------------------------------------------------------------- * * In-memory layout. THIS IS NOT A STANDALONE DOCUMENT. It goes * together with above C++ declarations and gives an overview. * * See above for definitions of Offset and EnumValue. Also, refer to * above class declarations for the "bottom line" on data layout. * * Sizes: * '*_offset' is an Offset (see above) * 'count' members are typically int32_t (see above declarations) * 'enumArray' is an array of EnumValue (see above) * 'offsetArray' is an array of Offset (see above) * 'nameArray' is an array of Offset (see above) * 'enum*' is an EnumValue (see above) * '*Array [x n]' means that *Array has n elements * * References: * Instead of pointers, this flat data structure contains offsets. * All offsets are relative to the start of 'header'. A notation * is used to indicate what structure each offset points to: * 'foo (>x)' the offset(s) in foo point to structure x * * Structures: * Each structure is assigned a number, except for the header, * which is called 'header'. The numbers are not contiguous * for historical reasons. Some structures have sub-parts * that are denoted with a letter, e.g., "5a". * * BEGIN LAYOUT * ============ * header: * enumToName_offset (>0) * nameToEnum_offset (>2) * enumToValue_offset (>3) * (alignment padding build in to header) * * The header also contains the following, used by "external readers" * like ICU4J and icuswap. * * // The following are needed by external readers of this data. * // We don't use them ourselves. * int16_t total_size; // size in bytes excluding the udata header * Offset valueMap_offset; // offset to start of array * int16_t valueMap_count; // number of entries * Offset nameGroupPool_offset; // offset to start of array * int16_t nameGroupPool_count; // number of entries (not groups) * Offset stringPool_offset; // offset to start of pool * int16_t stringPool_count; // number of strings (not size in bytes) * * 0: # NonContiguousEnumToOffset obj for props => name groups * count * enumArray [x count] * offsetArray [x count] (>98) * * => pad to next 4-byte boundary * * (1: omitted -- no longer used) * * 2: # NameToEnum obj for binary & enumerated props * count * enumArray [x count] * nameArray [x count] (>99) * * => pad to next 4-byte boundary * * 3: # NonContiguousEnumToOffset obj for enumerated props => ValueMaps * count * enumArray [x count] * offsetArray [x count] (>4) * * => pad to next 4-byte boundary * * 4: # ValueMap array [x one for each enumerated prop i] * enumToName_offset (>5a +2*i) one of these two is NULL, one is not * ncEnumToName_offset (>5b +2*i) * nameToEnums_offset (>6 +2*i) * * => pad to next 4-byte boundary * * for each enumerated prop (either 5a or 5b): * * 5a: # EnumToOffset for enumerated prop's values => name groups * enumStart * enumLimit * offsetArray [x enumLimit - enumStart] (>98) * * => pad to next 4-byte boundary * * 5b: # NonContiguousEnumToOffset for enumerated prop's values => name groups * count * enumArray [x count] * offsetArray [x count] (>98) * * => pad to next 4-byte boundary * * 6: # NameToEnum for enumerated prop's values * count * enumArray [x count] * nameArray [x count] (>99) * * => pad to next 4-byte boundary * * 98: # name group pool {NGP} * [array of Offset values] (>99) * * 99: # string pool {SP} * [pool of nul-terminated char* strings] */ U_NAMESPACE_END #endif /* C++ */ #endif