← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/common/unormimp.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/common/unormimp.h
1
 
/*
2
 
*******************************************************************************
3
 
*
4
 
*   Copyright (C) 2001-2010, International Business Machines
5
 
*   Corporation and others.  All Rights Reserved.
6
 
*
7
 
*******************************************************************************
8
 
*   file name:  unormimp.h
9
 
*   encoding:   US-ASCII
10
 
*   tab size:   8 (not used)
11
 
*   indentation:4
12
 
*
13
 
*   created on: 2001may25
14
 
*   created by: Markus W. Scherer
15
 
*/
16
 
 
17
 
#ifndef __UNORMIMP_H__
18
 
#define __UNORMIMP_H__
19
 
 
20
 
#include "unicode/utypes.h"
21
 
 
22
 
#if !UCONFIG_NO_NORMALIZATION
23
 
 
24
 
#include "udataswp.h"
25
 
 
26
 
/*
27
 
 * The 2001-2010 implementation of the normalization code loads its data from
28
 
 * unorm.icu, which is generated with the gennorm tool.
29
 
 * The format of that file is described at the end of this file.
30
 
 */
31
 
 
32
 
/* norm32 value constants */
33
 
enum {
34
 
    /* quick check flags 0..3 set mean "no" for their forms */
35
 
    _NORM_QC_NFC=0x11,          /* no|maybe */
36
 
    _NORM_QC_NFKC=0x22,         /* no|maybe */
37
 
    _NORM_QC_NFD=4,             /* no */
38
 
    _NORM_QC_NFKD=8,            /* no */
39
 
 
40
 
    _NORM_QC_ANY_NO=0xf,
41
 
 
42
 
    /* quick check flags 4..5 mean "maybe" for their forms; test flags>=_NORM_QC_MAYBE */
43
 
    _NORM_QC_MAYBE=0x10,
44
 
    _NORM_QC_ANY_MAYBE=0x30,
45
 
 
46
 
    _NORM_QC_MASK=0x3f,
47
 
 
48
 
    _NORM_COMBINES_FWD=0x40,
49
 
    _NORM_COMBINES_BACK=0x80,
50
 
    _NORM_COMBINES_ANY=0xc0,
51
 
 
52
 
    _NORM_CC_SHIFT=8,           /* UnicodeData.txt combining class in bits 15..8 */
53
 
    _NORM_CC_MASK=0xff00,
54
 
 
55
 
    _NORM_EXTRA_SHIFT=16,               /* 16 bits for the index to UChars and other extra data */
56
 
    _NORM_EXTRA_INDEX_TOP=0xfc00,       /* start of surrogate specials after shift */
57
 
 
58
 
    _NORM_EXTRA_SURROGATE_MASK=0x3ff,
59
 
    _NORM_EXTRA_SURROGATE_TOP=0x3f0,    /* hangul etc. */
60
 
 
61
 
    _NORM_EXTRA_HANGUL=_NORM_EXTRA_SURROGATE_TOP,
62
 
    _NORM_EXTRA_JAMO_L,
63
 
    _NORM_EXTRA_JAMO_V,
64
 
    _NORM_EXTRA_JAMO_T
65
 
};
66
 
 
67
 
/* norm32 value constants using >16 bits */
68
 
#define _NORM_MIN_SPECIAL       0xfc000000
69
 
#define _NORM_SURROGATES_TOP    0xfff00000
70
 
#define _NORM_MIN_HANGUL        0xfff00000
71
 
#define _NORM_MIN_JAMO_V        0xfff20000
72
 
#define _NORM_JAMO_V_TOP        0xfff30000
73
 
 
74
 
/* value constants for auxTrie */
75
 
enum {
76
 
    _NORM_AUX_COMP_EX_SHIFT=10,
77
 
    _NORM_AUX_UNSAFE_SHIFT=11,
78
 
    _NORM_AUX_NFC_SKIPPABLE_F_SHIFT=12
79
 
};
80
 
 
81
 
#define _NORM_AUX_MAX_FNC           ((int32_t)1<<_NORM_AUX_COMP_EX_SHIFT)
82
 
 
83
 
#define _NORM_AUX_FNC_MASK          (uint32_t)(_NORM_AUX_MAX_FNC-1)
84
 
#define _NORM_AUX_COMP_EX_MASK      ((uint32_t)1<<_NORM_AUX_COMP_EX_SHIFT)
85
 
#define _NORM_AUX_UNSAFE_MASK       ((uint32_t)1<<_NORM_AUX_UNSAFE_SHIFT)
86
 
#define _NORM_AUX_NFC_SKIP_F_MASK   ((uint32_t)1<<_NORM_AUX_NFC_SKIPPABLE_F_SHIFT)
87
 
 
88
 
/* canonStartSets[0..31] contains indexes for what is in the array */
89
 
enum {
90
 
    _NORM_SET_INDEX_CANON_SETS_LENGTH,      /* number of uint16_t in canonical starter sets */
91
 
    _NORM_SET_INDEX_CANON_BMP_TABLE_LENGTH, /* number of uint16_t in the BMP search table (contains pairs) */
92
 
    _NORM_SET_INDEX_CANON_SUPP_TABLE_LENGTH,/* number of uint16_t in the supplementary search table (contains triplets) */
93
 
 
94
 
    /* from formatVersion 2.3: */
95
 
    _NORM_SET_INDEX_NX_CJK_COMPAT_OFFSET,   /* uint16_t offset from canonStartSets[0] to the
96
 
                                               exclusion set for CJK compatibility characters */
97
 
    _NORM_SET_INDEX_NX_UNICODE32_OFFSET,    /* uint16_t offset from canonStartSets[0] to the
98
 
                                               exclusion set for Unicode 3.2 characters */
99
 
    _NORM_SET_INDEX_NX_RESERVED_OFFSET,     /* uint16_t offset from canonStartSets[0] to the
100
 
                                               end of the previous exclusion set */
101
 
 
102
 
    _NORM_SET_INDEX_TOP=32                  /* changing this requires a new formatVersion */
103
 
};
104
 
 
105
 
/* more constants for canonical starter sets */
106
 
 
107
 
/* 14 bit indexes to canonical USerializedSets */
108
 
#define _NORM_MAX_CANON_SETS            0x4000
109
 
 
110
 
/* single-code point BMP sets are encoded directly in the search table except if result=0x4000..0x7fff */
111
 
#define _NORM_CANON_SET_BMP_MASK        0xc000
112
 
#define _NORM_CANON_SET_BMP_IS_INDEX    0x4000
113
 
 
114
 
/* indexes[] value names */
115
 
enum {
116
 
    _NORM_INDEX_TRIE_SIZE,              /* number of bytes in normalization trie */
117
 
    _NORM_INDEX_UCHAR_COUNT,            /* number of UChars in extra data */
118
 
 
119
 
    _NORM_INDEX_COMBINE_DATA_COUNT,     /* number of uint16_t words for combining data */
120
 
    _NORM_INDEX_COMBINE_FWD_COUNT,      /* number of code points that combine forward */
121
 
    _NORM_INDEX_COMBINE_BOTH_COUNT,     /* number of code points that combine forward and backward */
122
 
    _NORM_INDEX_COMBINE_BACK_COUNT,     /* number of code points that combine backward */
123
 
 
124
 
    _NORM_INDEX_MIN_NFC_NO_MAYBE,       /* first code point with quick check NFC NO/MAYBE */
125
 
    _NORM_INDEX_MIN_NFKC_NO_MAYBE,      /* first code point with quick check NFKC NO/MAYBE */
126
 
    _NORM_INDEX_MIN_NFD_NO_MAYBE,       /* first code point with quick check NFD NO/MAYBE */
127
 
    _NORM_INDEX_MIN_NFKD_NO_MAYBE,      /* first code point with quick check NFKD NO/MAYBE */
128
 
 
129
 
    _NORM_INDEX_FCD_TRIE_SIZE,          /* number of bytes in FCD trie */
130
 
 
131
 
    _NORM_INDEX_AUX_TRIE_SIZE,          /* number of bytes in the auxiliary trie */
132
 
    _NORM_INDEX_CANON_SET_COUNT,        /* number of uint16_t in the array of serialized USet */
133
 
 
134
 
    _NORM_INDEX_TOP=32                  /* changing this requires a new formatVersion */
135
 
};
136
 
 
137
 
enum {
138
 
    /* FCD check: everything below this code point is known to have a 0 lead combining class */
139
 
    _NORM_MIN_WITH_LEAD_CC=0x300
140
 
};
141
 
 
142
 
enum {
143
 
    /**
144
 
     * Bit 7 of the length byte for a decomposition string in extra data is
145
 
     * a flag indicating whether the decomposition string is
146
 
     * preceded by a 16-bit word with the leading and trailing cc
147
 
     * of the decomposition (like for A-umlaut);
148
 
     * if not, then both cc's are zero (like for compatibility ideographs).
149
 
     */
150
 
    _NORM_DECOMP_FLAG_LENGTH_HAS_CC=0x80,
151
 
    /**
152
 
     * Bits 6..0 of the length byte contain the actual length.
153
 
     */
154
 
    _NORM_DECOMP_LENGTH_MASK=0x7f
155
 
};
156
 
 
157
 
/* Constants for options flags for normalization. @draft ICU 2.6 */
158
 
enum {
159
 
    /** Options bit 0, do not decompose Hangul syllables. @draft ICU 2.6 */
160
 
    UNORM_NX_HANGUL=1,
161
 
    /** Options bit 1, do not decompose CJK compatibility characters. @draft ICU 2.6 */
162
 
    UNORM_NX_CJK_COMPAT=2
163
 
};
164
 
 
165
 
/**
166
 
 * Swap unorm.icu. See udataswp.h.
167
 
 * @internal
168
 
 */
169
 
U_CAPI int32_t U_EXPORT2
170
 
unorm_swap(const UDataSwapper *ds,
171
 
           const void *inData, int32_t length, void *outData,
172
 
           UErrorCode *pErrorCode);
173
 
 
174
 
/**
175
 
 * Description of the format of unorm.icu version 2.3.
176
 
 *
177
 
 * Main change from version 1 to version 2:
178
 
 * Use of new, common UTrie instead of normalization-specific tries.
179
 
 * Change to version 2.1: add third/auxiliary trie with associated data.
180
 
 * Change to version 2.2: add skippable (f) flag data (_NORM_AUX_NFC_SKIP_F_MASK).
181
 
 * Change to version 2.3: add serialized sets for normalization exclusions
182
 
 *                        stored inside canonStartSets[]
183
 
 *
184
 
 * For more details of how to use the data structures see the code
185
 
 * in unorm.cpp (runtime normalization code) and
186
 
 * in gennorm.c and gennorm/store.c (build-time data generation).
187
 
 *
188
 
 * For the serialized format of UTrie see utrie.c/UTrieHeader.
189
 
 *
190
 
 * - Overall partition
191
 
 *
192
 
 * unorm.dat customarily begins with a UDataInfo structure, see udata.h and .c.
193
 
 * After that there are the following structures:
194
 
 *
195
 
 * int32_t indexes[_NORM_INDEX_TOP];            -- _NORM_INDEX_TOP=32, see enum in this file
196
 
 *
197
 
 * UTrie normTrie;                              -- size in bytes=indexes[_NORM_INDEX_TRIE_SIZE]
198
 
 * 
199
 
 * uint16_t extraData[extraDataTop];            -- extraDataTop=indexes[_NORM_INDEX_UCHAR_COUNT]
200
 
 *                                                 extraData[0] contains the number of units for
201
 
 *                                                 FC_NFKC_Closure (formatVersion>=2.1)
202
 
 *
203
 
 * uint16_t combiningTable[combiningTableTop];  -- combiningTableTop=indexes[_NORM_INDEX_COMBINE_DATA_COUNT]
204
 
 *                                                 combiningTableTop may include one 16-bit padding unit
205
 
 *                                                 to make sure that fcdTrie is 32-bit-aligned
206
 
 *
207
 
 * UTrie fcdTrie;                               -- size in bytes=indexes[_NORM_INDEX_FCD_TRIE_SIZE]
208
 
 *
209
 
 * UTrie auxTrie;                               -- size in bytes=indexes[_NORM_INDEX_AUX_TRIE_SIZE]
210
 
 *
211
 
 * uint16_t canonStartSets[canonStartSetsTop]   -- canonStartSetsTop=indexes[_NORM_INDEX_CANON_SET_COUNT]
212
 
 *                                                 serialized USets and binary search tables, see below
213
 
 *
214
 
 *
215
 
 * The indexes array contains lengths and sizes of the following arrays and structures
216
 
 * as well as the following values:
217
 
 *  indexes[_NORM_INDEX_COMBINE_FWD_COUNT]=combineFwdTop
218
 
 *      -- one more than the highest combining index computed for forward-only-combining characters
219
 
 *  indexes[_NORM_INDEX_COMBINE_BOTH_COUNT]=combineBothTop-combineFwdTop
220
 
 *      -- number of combining indexes computed for both-ways-combining characters
221
 
 *  indexes[_NORM_INDEX_COMBINE_BACK_COUNT]=combineBackTop-combineBothTop
222
 
 *      -- number of combining indexes computed for backward-only-combining characters
223
 
 *
224
 
 *  indexes[_NORM_INDEX_MIN_NF*_NO_MAYBE] (where *={ C, D, KC, KD })
225
 
 *      -- first code point with a quick check NF* value of NO/MAYBE
226
 
 *
227
 
 *
228
 
 * - Tries
229
 
 *
230
 
 * The main structures are two UTrie tables ("compact arrays"),
231
 
 * each with one index array and one data array.
232
 
 * See utrie.h and utrie.c.
233
 
 *
234
 
 *
235
 
 * - Tries in unorm.dat
236
 
 *
237
 
 * The first trie (normTrie above)
238
 
 * provides data for the NF* quick checks and normalization.
239
 
 * The second trie (fcdTrie above) provides data just for FCD checks.
240
 
 *
241
 
 *
242
 
 * - norm32 data words from the first trie
243
 
 *
244
 
 * The norm32Table contains one 32-bit word "norm32" per code point.
245
 
 * It contains the following bit fields:
246
 
 * 31..16   extra data index, _NORM_EXTRA_SHIFT is used to shift this field down
247
 
 *          if this index is <_NORM_EXTRA_INDEX_TOP then it is an index into
248
 
 *              extraData[] where variable-length normalization data for this
249
 
 *              code point is found
250
 
 *          if this index is <_NORM_EXTRA_INDEX_TOP+_NORM_EXTRA_SURROGATE_TOP
251
 
 *              then this is a norm32 for a leading surrogate, and the index
252
 
 *              value is used together with the following trailing surrogate
253
 
 *              code unit in the second trie access
254
 
 *          if this index is >=_NORM_EXTRA_INDEX_TOP+_NORM_EXTRA_SURROGATE_TOP
255
 
 *              then this is a norm32 for a "special" character,
256
 
 *              i.e., the character is a Hangul syllable or a Jamo
257
 
 *              see _NORM_EXTRA_HANGUL etc.
258
 
 *          generally, instead of extracting this index from the norm32 and
259
 
 *              comparing it with the above constants,
260
 
 *              the normalization code compares the entire norm32 value
261
 
 *              with _NORM_MIN_SPECIAL, _NORM_SURROGATES_TOP, _NORM_MIN_HANGUL etc.
262
 
 *
263
 
 * 15..8    combining class (cc) according to UnicodeData.txt
264
 
 *
265
 
 *  7..6    _NORM_COMBINES_ANY flags, used in composition to see if a character
266
 
 *              combines with any following or preceding character(s)
267
 
 *              at all
268
 
 *     7    _NORM_COMBINES_BACK
269
 
 *     6    _NORM_COMBINES_FWD
270
 
 *
271
 
 *  5..0    quick check flags, set for "no" or "maybe", with separate flags for
272
 
 *              each normalization form
273
 
 *              the higher bits are "maybe" flags; for NF*D there are no such flags
274
 
 *              the lower bits are "no" flags for all forms, in the same order
275
 
 *              as the "maybe" flags,
276
 
 *              which is (MSB to LSB): NFKD NFD NFKC NFC
277
 
 *  5..4    _NORM_QC_ANY_MAYBE
278
 
 *  3..0    _NORM_QC_ANY_NO
279
 
 *              see further related constants
280
 
 *
281
 
 *
282
 
 * - Extra data per code point
283
 
 *
284
 
 * "Extra data" is referenced by the index in norm32.
285
 
 * It is variable-length data. It is only present, and only those parts
286
 
 * of it are, as needed for a given character.
287
 
 * The norm32 extra data index is added to the beginning of extraData[]
288
 
 * to get to a vector of 16-bit words with data at the following offsets:
289
 
 *
290
 
 * [-1]     Combining index for composition.
291
 
 *              Stored only if norm32&_NORM_COMBINES_ANY .
292
 
 * [0]      Lengths of the canonical and compatibility decomposition strings.
293
 
 *              Stored only if there are decompositions, i.e.,
294
 
 *              if norm32&(_NORM_QC_NFD|_NORM_QC_NFKD)
295
 
 *          High byte: length of NFKD, or 0 if none
296
 
 *          Low byte: length of NFD, or 0 if none
297
 
 *          Each length byte also has another flag:
298
 
 *              Bit 7 of a length byte is set if there are non-zero
299
 
 *              combining classes (cc's) associated with the respective
300
 
 *              decomposition. If this flag is set, then the decomposition
301
 
 *              is preceded by a 16-bit word that contains the
302
 
 *              leading and trailing cc's.
303
 
 *              Bits 6..0 of a length byte are the length of the
304
 
 *              decomposition string, not counting the cc word.
305
 
 * [1..n]   NFD
306
 
 * [n+1..]  NFKD
307
 
 *
308
 
 * Each of the two decompositions consists of up to two parts:
309
 
 * - The 16-bit words with the leading and trailing cc's.
310
 
 *   This is only stored if bit 7 of the corresponding length byte
311
 
 *   is set. In this case, at least one of the cc's is not zero.
312
 
 *   High byte: leading cc==cc of the first code point in the decomposition string
313
 
 *   Low byte: trailing cc==cc of the last code point in the decomposition string
314
 
 * - The decomposition string in UTF-16, with length code units.
315
 
 *
316
 
 *
317
 
 * - Combining indexes and combiningTable[]
318
 
 *
319
 
 * Combining indexes are stored at the [-1] offset of the extra data
320
 
 * if the character combines forward or backward with any other characters.
321
 
 * They are used for (re)composition in NF*C.
322
 
 * Values of combining indexes are arranged according to whether a character
323
 
 * combines forward, backward, or both ways:
324
 
 *    forward-only < both ways < backward-only
325
 
 *
326
 
 * The index values for forward-only and both-ways combining characters
327
 
 * are indexes into the combiningTable[].
328
 
 * The index values for backward-only combining characters are simply
329
 
 * incremented from the preceding index values to be unique.
330
 
 *
331
 
 * In the combiningTable[], a variable-length list
332
 
 * of variable-length (back-index, code point) pair entries is stored
333
 
 * for each forward-combining character.
334
 
 *
335
 
 * These back-indexes are the combining indexes of both-ways or backward-only
336
 
 * combining characters that the forward-combining character combines with.
337
 
 *
338
 
 * Each list is sorted in ascending order of back-indexes.
339
 
 * Each list is terminated with the last back-index having bit 15 set.
340
 
 *
341
 
 * Each pair (back-index, code point) takes up either 2 or 3
342
 
 * 16-bit words.
343
 
 * The first word of a list entry is the back-index, with its bit 15 set if
344
 
 * this is the last pair in the list.
345
 
 *
346
 
 * The second word contains flags in bits 15..13 that determine
347
 
 * if there is a third word and how the combined character is encoded:
348
 
 * 15   set if there is a third word in this list entry
349
 
 * 14   set if the result is a supplementary character
350
 
 * 13   set if the result itself combines forward
351
 
 *
352
 
 * According to these bits 15..14 of the second word,
353
 
 * the result character is encoded as follows:
354
 
 * 00 or 01 The result is <=0x1fff and stored in bits 12..0 of
355
 
 *          the second word.
356
 
 * 10       The result is 0x2000..0xffff and stored in the third word.
357
 
 *          Bits 12..0 of the second word are not used.
358
 
 * 11       The result is a supplementary character.
359
 
 *          Bits 9..0 of the leading surrogate are in bits 9..0 of
360
 
 *          the second word.
361
 
 *          Add 0xd800 to these bits to get the complete surrogate.
362
 
 *          Bits 12..10 of the second word are not used.
363
 
 *          The trailing surrogate is stored in the third word.
364
 
 *
365
 
 *
366
 
 * - FCD trie
367
 
 *
368
 
 * The FCD trie is very simple.
369
 
 * It is a folded trie with 16-bit data words.
370
 
 * In each word, the high byte contains the leading cc of the character,
371
 
 * and the low byte contains the trailing cc of the character.
372
 
 * These cc's are the cc's of the first and last code points in the
373
 
 * canonical decomposition of the character.
374
 
 *
375
 
 * Since all 16 bits are used for cc's, lead surrogates must be tested
376
 
 * by checking the code unit instead of the trie data.
377
 
 * This is done only if the 16-bit data word is not zero.
378
 
 * If the code unit is a leading surrogate and the data word is not zero,
379
 
 * then instead of cc's it contains the offset for the second trie lookup.
380
 
 *
381
 
 *
382
 
 * - Auxiliary trie and data
383
 
 *
384
 
 * The auxiliary 16-bit trie contains data for additional properties.
385
 
 * Bits
386
 
 * 15..13   reserved
387
 
 *     12   not NFC_Skippable (f) (formatVersion>=2.2)
388
 
 *     11   flag: not a safe starter for canonical closure
389
 
 *     10   composition exclusion
390
 
 *  9.. 0   index into extraData[] to FC_NFKC_Closure string
391
 
 *          (not for lead surrogate),
392
 
 *          or lead surrogate offset (for lead surrogate, if 9..0 not zero)
393
 
 *
394
 
 * - FC_NFKC_Closure strings in extraData[]
395
 
 *
396
 
 * Strings are either stored as a single code unit or as the length
397
 
 * followed by that many units.
398
 
 *   const UChar *s=extraData+(index from auxTrie data bits 9..0);
399
 
 *   int32_t length;
400
 
 *   if(*s<0xff00) {
401
 
 *     // s points to the single-unit string
402
 
 *     length=1;
403
 
 *   } else {
404
 
 *     length=*s&0xff;
405
 
 *     ++s;
406
 
 *   }
407
 
 *
408
 
 * Conditions for "NF* Skippable" from Mark Davis' com.ibm.text.UCD.NFSkippable:
409
 
 * (used in NormalizerTransliterator)
410
 
 *
411
 
 * A skippable character is
412
 
 * a) unassigned, or ALL of the following:
413
 
 * b) of combining class 0.
414
 
 * c) not decomposed by this normalization form.
415
 
 * AND if NFC or NFKC,
416
 
 * d) can never compose with a previous character.
417
 
 * e) can never compose with a following character.
418
 
 * f) can never change if another character is added.
419
 
 *    Example: a-breve might satisfy all but f, but if you
420
 
 *    add an ogonek it changes to a-ogonek + breve
421
 
 *
422
 
 * a)..e) must be tested from norm32.
423
 
 * Since f) is more complicated, the (not-)NFC_Skippable flag (f) is built
424
 
 * into the auxiliary trie.
425
 
 * The same bit is used for NFC and NFKC; (c) differs for them.
426
 
 * As usual, we build the "not skippable" flags so that unassigned
427
 
 * code points get a 0 bit.
428
 
 * This bit is only valid after (a)..(e) test FALSE; test NFD_NO before (f) as well.
429
 
 * Test Hangul LV syllables entirely in code.
430
 
 *
431
 
 *
432
 
 * - structure inside canonStartSets[]
433
 
 *
434
 
 * This array maps from code points c to sets of code points (USerializedSet).
435
 
 * The result sets are the code points whose canonical decompositions start
436
 
 * with c.
437
 
 *
438
 
 * canonStartSets[] contains the following sub-arrays:
439
 
 *
440
 
 * indexes[_NORM_SET_INDEX_TOP]
441
 
 *   - contains lengths of sub-arrays etc.
442
 
 *
443
 
 * startSets[indexes[_NORM_SET_INDEX_CANON_SETS_LENGTH]-_NORM_SET_INDEX_TOP]
444
 
 *   - contains serialized sets (USerializedSet) of canonical starters for
445
 
 *     enumerating canonically equivalent strings
446
 
 *     indexes[_NORM_SET_INDEX_CANON_SETS_LENGTH] includes _NORM_SET_INDEX_TOP
447
 
 *     for details about the structure see uset.c
448
 
 *
449
 
 * bmpTable[indexes[_NORM_SET_INDEX_CANON_BMP_TABLE_LENGTH]]
450
 
 *   - a sorted search table for BMP code points whose results are
451
 
 *     either indexes to USerializedSets or single code points for
452
 
 *     single-code point sets;
453
 
 *     each entry is a pair of { code point, result } with result=(binary) yy xxxxxx xxxxxxxx
454
 
 *     if yy==01 then there is a USerializedSet at canonStartSets+x
455
 
 *     else build a USerializedSet with result as the single code point
456
 
 *
457
 
 * suppTable[indexes[_NORM_SET_INDEX_CANON_SUPP_TABLE_LENGTH]]
458
 
 *   - a sorted search table for supplementary code points whose results are
459
 
 *     either indexes to USerializedSets or single code points for
460
 
 *     single-code point sets;
461
 
 *     each entry is a triplet of { high16(cp), low16(cp), result }
462
 
 *     each code point's high-word may contain extra data in bits 15..5:
463
 
 *     if the high word has bit 15 set, then build a set with a single code point
464
 
 *     which is (((high16(cp)&0x1f00)<<8)|result;
465
 
 *     else there is a USerializedSet at canonStartSets+result
466
 
 *
467
 
 * FormatVersion 2.3 adds 2 serialized sets for normalization exclusions.
468
 
 * They are stored in the data file so that the runtime normalization code need
469
 
 * not depend on other properties and their data and implementation files.
470
 
 * The _NORM_SET_INDEX_NX_..._OFFSET offsets in the canonStartSets index table
471
 
 * give the location for each set.
472
 
 * There is no set stored for UNORM_NX_HANGUL because it's trivial to create
473
 
 * without using properties.
474
 
 *
475
 
 * Set contents:
476
 
 *
477
 
 * _NORM_SET_INDEX_NX_CJK_COMPAT_OFFSET (for UNORM_NX_CJK_COMPAT)
478
 
 *     [[:Ideographic:]&[:NFD_QC=No:]]
479
 
 *     =[CJK Ideographs]&[has canonical decomposition]
480
 
 *
481
 
 * _NORM_SET_INDEX_NX_UNICODE32_OFFSET (for UNORM_UNICODE_3_2)
482
 
 *     [:^Age=3.2:]
483
 
 *     =set with all code points that were not designated by the specified Unicode version
484
 
 *
485
 
 * _NORM_SET_INDEX_NX_RESERVED_OFFSET
486
 
 *     This is an offset that points to where the next, future set would start.
487
 
 *     Currently it indicates where the previous set ends, and thus its length.
488
 
 *     The name for this enum constant may in the future be applied to different
489
 
 *     index slots. In order to get the limit of a set, use its index slot and
490
 
 *     the immediately following one regardless of that one's enum name.
491
 
 */
492
 
 
493
 
#endif /* #if !UCONFIG_NO_NORMALIZATION */
494
 
 
495
 
#endif