Index: icu46/source/common/propname.h |
=================================================================== |
--- icu46/source/common/propname.h (revision 0) |
+++ icu46/source/common/propname.h (revision 0) |
@@ -0,0 +1,515 @@ |
+/* |
+********************************************************************** |
+* 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 |
Property changes on: icu46/source/common/propname.h |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |