1 /*
2 *******************************************************************************
3 *
4 * Copyright (C) 2002-2014, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 *******************************************************************************
8 * file name: uprops.cpp
9 * encoding: US-ASCII
10 * tab size: 8 (not used)
11 * indentation:4
12 *
13 * created on: 2002feb24
14 * created by: Markus W. Scherer
15 *
16 * Implementations for mostly non-core Unicode character properties
17 * stored in uprops.icu.
18 *
19 * With the APIs implemented here, almost all properties files and
20 * their associated implementation files are used from this file,
21 * including those for normalization and case mappings.
22 */
23
24 #include "unicode/utypes.h"
25 #include "unicode/uchar.h"
26 #include "unicode/unorm2.h"
27 #include "unicode/uscript.h"
28 #include "unicode/ustring.h"
29 #include "cstring.h"
30 #include "normalizer2impl.h"
31 #include "umutex.h"
32 #include "ubidi_props.h"
33 #include "uprops.h"
34 #include "ucase.h"
35 #include "ustr_imp.h"
36
37 U_NAMESPACE_USE
38
39 #define GET_BIDI_PROPS() ubidi_getSingleton()
40
41 /* general properties API functions ----------------------------------------- */
42
43 struct BinaryProperty;
44
45 typedef UBool BinaryPropertyContains(const BinaryProperty &prop, UChar32 c, UProperty which);
46
47 struct BinaryProperty {
48 int32_t column; // SRC_PROPSVEC column, or "source" if mask==0
49 uint32_t mask;
50 BinaryPropertyContains *contains;
51 };
52
defaultContains(const BinaryProperty & prop,UChar32 c,UProperty)53 static UBool defaultContains(const BinaryProperty &prop, UChar32 c, UProperty /*which*/) {
54 /* systematic, directly stored properties */
55 return (u_getUnicodeProperties(c, prop.column)&prop.mask)!=0;
56 }
57
caseBinaryPropertyContains(const BinaryProperty &,UChar32 c,UProperty which)58 static UBool caseBinaryPropertyContains(const BinaryProperty &/*prop*/, UChar32 c, UProperty which) {
59 return ucase_hasBinaryProperty(c, which);
60 }
61
isBidiControl(const BinaryProperty &,UChar32 c,UProperty)62 static UBool isBidiControl(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
63 return ubidi_isBidiControl(GET_BIDI_PROPS(), c);
64 }
65
isMirrored(const BinaryProperty &,UChar32 c,UProperty)66 static UBool isMirrored(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
67 return ubidi_isMirrored(GET_BIDI_PROPS(), c);
68 }
69
isJoinControl(const BinaryProperty &,UChar32 c,UProperty)70 static UBool isJoinControl(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
71 return ubidi_isJoinControl(GET_BIDI_PROPS(), c);
72 }
73
74 #if UCONFIG_NO_NORMALIZATION
hasFullCompositionExclusion(const BinaryProperty &,UChar32,UProperty)75 static UBool hasFullCompositionExclusion(const BinaryProperty &, UChar32, UProperty) {
76 return FALSE;
77 }
78 #else
hasFullCompositionExclusion(const BinaryProperty &,UChar32 c,UProperty)79 static UBool hasFullCompositionExclusion(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
80 // By definition, Full_Composition_Exclusion is the same as NFC_QC=No.
81 UErrorCode errorCode=U_ZERO_ERROR;
82 const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode);
83 return U_SUCCESS(errorCode) && impl->isCompNo(impl->getNorm16(c));
84 }
85 #endif
86
87 // UCHAR_NF*_INERT properties
88 #if UCONFIG_NO_NORMALIZATION
isNormInert(const BinaryProperty &,UChar32,UProperty)89 static UBool isNormInert(const BinaryProperty &, UChar32, UProperty) {
90 return FALSE;
91 }
92 #else
isNormInert(const BinaryProperty &,UChar32 c,UProperty which)93 static UBool isNormInert(const BinaryProperty &/*prop*/, UChar32 c, UProperty which) {
94 UErrorCode errorCode=U_ZERO_ERROR;
95 const Normalizer2 *norm2=Normalizer2Factory::getInstance(
96 (UNormalizationMode)(which-UCHAR_NFD_INERT+UNORM_NFD), errorCode);
97 return U_SUCCESS(errorCode) && norm2->isInert(c);
98 }
99 #endif
100
101 #if UCONFIG_NO_NORMALIZATION
changesWhenCasefolded(const BinaryProperty &,UChar32,UProperty)102 static UBool changesWhenCasefolded(const BinaryProperty &, UChar32, UProperty) {
103 return FALSE;
104 }
105 #else
changesWhenCasefolded(const BinaryProperty &,UChar32 c,UProperty)106 static UBool changesWhenCasefolded(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
107 UnicodeString nfd;
108 UErrorCode errorCode=U_ZERO_ERROR;
109 const Normalizer2 *nfcNorm2=Normalizer2::getNFCInstance(errorCode);
110 if(U_FAILURE(errorCode)) {
111 return FALSE;
112 }
113 if(nfcNorm2->getDecomposition(c, nfd)) {
114 /* c has a decomposition */
115 if(nfd.length()==1) {
116 c=nfd[0]; /* single BMP code point */
117 } else if(nfd.length()<=U16_MAX_LENGTH &&
118 nfd.length()==U16_LENGTH(c=nfd.char32At(0))
119 ) {
120 /* single supplementary code point */
121 } else {
122 c=U_SENTINEL;
123 }
124 } else if(c<0) {
125 return FALSE; /* protect against bad input */
126 }
127 if(c>=0) {
128 /* single code point */
129 const UCaseProps *csp=ucase_getSingleton();
130 const UChar *resultString;
131 return (UBool)(ucase_toFullFolding(csp, c, &resultString, U_FOLD_CASE_DEFAULT)>=0);
132 } else {
133 /* guess some large but stack-friendly capacity */
134 UChar dest[2*UCASE_MAX_STRING_LENGTH];
135 int32_t destLength;
136 destLength=u_strFoldCase(dest, UPRV_LENGTHOF(dest),
137 nfd.getBuffer(), nfd.length(),
138 U_FOLD_CASE_DEFAULT, &errorCode);
139 return (UBool)(U_SUCCESS(errorCode) &&
140 0!=u_strCompare(nfd.getBuffer(), nfd.length(),
141 dest, destLength, FALSE));
142 }
143 }
144 #endif
145
146 #if UCONFIG_NO_NORMALIZATION
changesWhenNFKC_Casefolded(const BinaryProperty &,UChar32,UProperty)147 static UBool changesWhenNFKC_Casefolded(const BinaryProperty &, UChar32, UProperty) {
148 return FALSE;
149 }
150 #else
changesWhenNFKC_Casefolded(const BinaryProperty &,UChar32 c,UProperty)151 static UBool changesWhenNFKC_Casefolded(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
152 UErrorCode errorCode=U_ZERO_ERROR;
153 const Normalizer2Impl *kcf=Normalizer2Factory::getNFKC_CFImpl(errorCode);
154 if(U_FAILURE(errorCode)) {
155 return FALSE;
156 }
157 UnicodeString src(c);
158 UnicodeString dest;
159 {
160 // The ReorderingBuffer must be in a block because its destructor
161 // needs to release dest's buffer before we look at its contents.
162 ReorderingBuffer buffer(*kcf, dest);
163 // Small destCapacity for NFKC_CF(c).
164 if(buffer.init(5, errorCode)) {
165 const UChar *srcArray=src.getBuffer();
166 kcf->compose(srcArray, srcArray+src.length(), FALSE,
167 TRUE, buffer, errorCode);
168 }
169 }
170 return U_SUCCESS(errorCode) && dest!=src;
171 }
172 #endif
173
174 #if UCONFIG_NO_NORMALIZATION
isCanonSegmentStarter(const BinaryProperty &,UChar32,UProperty)175 static UBool isCanonSegmentStarter(const BinaryProperty &, UChar32, UProperty) {
176 return FALSE;
177 }
178 #else
isCanonSegmentStarter(const BinaryProperty &,UChar32 c,UProperty)179 static UBool isCanonSegmentStarter(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
180 UErrorCode errorCode=U_ZERO_ERROR;
181 const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode);
182 return
183 U_SUCCESS(errorCode) && impl->ensureCanonIterData(errorCode) &&
184 impl->isCanonSegmentStarter(c);
185 }
186 #endif
187
isPOSIX_alnum(const BinaryProperty &,UChar32 c,UProperty)188 static UBool isPOSIX_alnum(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
189 return u_isalnumPOSIX(c);
190 }
191
isPOSIX_blank(const BinaryProperty &,UChar32 c,UProperty)192 static UBool isPOSIX_blank(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
193 return u_isblank(c);
194 }
195
isPOSIX_graph(const BinaryProperty &,UChar32 c,UProperty)196 static UBool isPOSIX_graph(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
197 return u_isgraphPOSIX(c);
198 }
199
isPOSIX_print(const BinaryProperty &,UChar32 c,UProperty)200 static UBool isPOSIX_print(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
201 return u_isprintPOSIX(c);
202 }
203
isPOSIX_xdigit(const BinaryProperty &,UChar32 c,UProperty)204 static UBool isPOSIX_xdigit(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
205 return u_isxdigit(c);
206 }
207
208 static const BinaryProperty binProps[UCHAR_BINARY_LIMIT]={
209 /*
210 * column and mask values for binary properties from u_getUnicodeProperties().
211 * Must be in order of corresponding UProperty,
212 * and there must be exactly one entry per binary UProperty.
213 *
214 * Properties with mask==0 are handled in code.
215 * For them, column is the UPropertySource value.
216 */
217 { 1, U_MASK(UPROPS_ALPHABETIC), defaultContains },
218 { 1, U_MASK(UPROPS_ASCII_HEX_DIGIT), defaultContains },
219 { UPROPS_SRC_BIDI, 0, isBidiControl },
220 { UPROPS_SRC_BIDI, 0, isMirrored },
221 { 1, U_MASK(UPROPS_DASH), defaultContains },
222 { 1, U_MASK(UPROPS_DEFAULT_IGNORABLE_CODE_POINT), defaultContains },
223 { 1, U_MASK(UPROPS_DEPRECATED), defaultContains },
224 { 1, U_MASK(UPROPS_DIACRITIC), defaultContains },
225 { 1, U_MASK(UPROPS_EXTENDER), defaultContains },
226 { UPROPS_SRC_NFC, 0, hasFullCompositionExclusion },
227 { 1, U_MASK(UPROPS_GRAPHEME_BASE), defaultContains },
228 { 1, U_MASK(UPROPS_GRAPHEME_EXTEND), defaultContains },
229 { 1, U_MASK(UPROPS_GRAPHEME_LINK), defaultContains },
230 { 1, U_MASK(UPROPS_HEX_DIGIT), defaultContains },
231 { 1, U_MASK(UPROPS_HYPHEN), defaultContains },
232 { 1, U_MASK(UPROPS_ID_CONTINUE), defaultContains },
233 { 1, U_MASK(UPROPS_ID_START), defaultContains },
234 { 1, U_MASK(UPROPS_IDEOGRAPHIC), defaultContains },
235 { 1, U_MASK(UPROPS_IDS_BINARY_OPERATOR), defaultContains },
236 { 1, U_MASK(UPROPS_IDS_TRINARY_OPERATOR), defaultContains },
237 { UPROPS_SRC_BIDI, 0, isJoinControl },
238 { 1, U_MASK(UPROPS_LOGICAL_ORDER_EXCEPTION), defaultContains },
239 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_LOWERCASE
240 { 1, U_MASK(UPROPS_MATH), defaultContains },
241 { 1, U_MASK(UPROPS_NONCHARACTER_CODE_POINT), defaultContains },
242 { 1, U_MASK(UPROPS_QUOTATION_MARK), defaultContains },
243 { 1, U_MASK(UPROPS_RADICAL), defaultContains },
244 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_SOFT_DOTTED
245 { 1, U_MASK(UPROPS_TERMINAL_PUNCTUATION), defaultContains },
246 { 1, U_MASK(UPROPS_UNIFIED_IDEOGRAPH), defaultContains },
247 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_UPPERCASE
248 { 1, U_MASK(UPROPS_WHITE_SPACE), defaultContains },
249 { 1, U_MASK(UPROPS_XID_CONTINUE), defaultContains },
250 { 1, U_MASK(UPROPS_XID_START), defaultContains },
251 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CASE_SENSITIVE
252 { 1, U_MASK(UPROPS_S_TERM), defaultContains },
253 { 1, U_MASK(UPROPS_VARIATION_SELECTOR), defaultContains },
254 { UPROPS_SRC_NFC, 0, isNormInert }, // UCHAR_NFD_INERT
255 { UPROPS_SRC_NFKC, 0, isNormInert }, // UCHAR_NFKD_INERT
256 { UPROPS_SRC_NFC, 0, isNormInert }, // UCHAR_NFC_INERT
257 { UPROPS_SRC_NFKC, 0, isNormInert }, // UCHAR_NFKC_INERT
258 { UPROPS_SRC_NFC_CANON_ITER, 0, isCanonSegmentStarter },
259 { 1, U_MASK(UPROPS_PATTERN_SYNTAX), defaultContains },
260 { 1, U_MASK(UPROPS_PATTERN_WHITE_SPACE), defaultContains },
261 { UPROPS_SRC_CHAR_AND_PROPSVEC, 0, isPOSIX_alnum },
262 { UPROPS_SRC_CHAR, 0, isPOSIX_blank },
263 { UPROPS_SRC_CHAR, 0, isPOSIX_graph },
264 { UPROPS_SRC_CHAR, 0, isPOSIX_print },
265 { UPROPS_SRC_CHAR, 0, isPOSIX_xdigit },
266 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CASED
267 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CASE_IGNORABLE
268 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_LOWERCASED
269 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_UPPERCASED
270 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_TITLECASED
271 { UPROPS_SRC_CASE_AND_NORM, 0, changesWhenCasefolded },
272 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_CASEMAPPED
273 { UPROPS_SRC_NFKC_CF, 0, changesWhenNFKC_Casefolded }
274 };
275
276 U_CAPI UBool U_EXPORT2
u_hasBinaryProperty(UChar32 c,UProperty which)277 u_hasBinaryProperty(UChar32 c, UProperty which) {
278 /* c is range-checked in the functions that are called from here */
279 if(which<UCHAR_BINARY_START || UCHAR_BINARY_LIMIT<=which) {
280 /* not a known binary property */
281 return FALSE;
282 } else {
283 const BinaryProperty &prop=binProps[which];
284 return prop.contains(prop, c, which);
285 }
286 }
287
288 struct IntProperty;
289
290 typedef int32_t IntPropertyGetValue(const IntProperty &prop, UChar32 c, UProperty which);
291 typedef int32_t IntPropertyGetMaxValue(const IntProperty &prop, UProperty which);
292
293 struct IntProperty {
294 int32_t column; // SRC_PROPSVEC column, or "source" if mask==0
295 uint32_t mask;
296 int32_t shift; // =maxValue if getMaxValueFromShift() is used
297 IntPropertyGetValue *getValue;
298 IntPropertyGetMaxValue *getMaxValue;
299 };
300
defaultGetValue(const IntProperty & prop,UChar32 c,UProperty)301 static int32_t defaultGetValue(const IntProperty &prop, UChar32 c, UProperty /*which*/) {
302 /* systematic, directly stored properties */
303 return (int32_t)(u_getUnicodeProperties(c, prop.column)&prop.mask)>>prop.shift;
304 }
305
defaultGetMaxValue(const IntProperty & prop,UProperty)306 static int32_t defaultGetMaxValue(const IntProperty &prop, UProperty /*which*/) {
307 return (uprv_getMaxValues(prop.column)&prop.mask)>>prop.shift;
308 }
309
getMaxValueFromShift(const IntProperty & prop,UProperty)310 static int32_t getMaxValueFromShift(const IntProperty &prop, UProperty /*which*/) {
311 return prop.shift;
312 }
313
getBiDiClass(const IntProperty &,UChar32 c,UProperty)314 static int32_t getBiDiClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
315 return (int32_t)u_charDirection(c);
316 }
317
getBiDiPairedBracketType(const IntProperty &,UChar32 c,UProperty)318 static int32_t getBiDiPairedBracketType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
319 return (int32_t)ubidi_getPairedBracketType(GET_BIDI_PROPS(), c);
320 }
321
biDiGetMaxValue(const IntProperty &,UProperty which)322 static int32_t biDiGetMaxValue(const IntProperty &/*prop*/, UProperty which) {
323 return ubidi_getMaxValue(GET_BIDI_PROPS(), which);
324 }
325
326 #if UCONFIG_NO_NORMALIZATION
getCombiningClass(const IntProperty &,UChar32,UProperty)327 static int32_t getCombiningClass(const IntProperty &, UChar32, UProperty) {
328 return 0;
329 }
330 #else
getCombiningClass(const IntProperty &,UChar32 c,UProperty)331 static int32_t getCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
332 return u_getCombiningClass(c);
333 }
334 #endif
335
getGeneralCategory(const IntProperty &,UChar32 c,UProperty)336 static int32_t getGeneralCategory(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
337 return (int32_t)u_charType(c);
338 }
339
getJoiningGroup(const IntProperty &,UChar32 c,UProperty)340 static int32_t getJoiningGroup(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
341 return ubidi_getJoiningGroup(GET_BIDI_PROPS(), c);
342 }
343
getJoiningType(const IntProperty &,UChar32 c,UProperty)344 static int32_t getJoiningType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
345 return ubidi_getJoiningType(GET_BIDI_PROPS(), c);
346 }
347
getNumericType(const IntProperty &,UChar32 c,UProperty)348 static int32_t getNumericType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
349 int32_t ntv=(int32_t)GET_NUMERIC_TYPE_VALUE(u_getMainProperties(c));
350 return UPROPS_NTV_GET_TYPE(ntv);
351 }
352
getScript(const IntProperty &,UChar32 c,UProperty)353 static int32_t getScript(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
354 UErrorCode errorCode=U_ZERO_ERROR;
355 return (int32_t)uscript_getScript(c, &errorCode);
356 }
357
358 /*
359 * Map some of the Grapheme Cluster Break values to Hangul Syllable Types.
360 * Hangul_Syllable_Type is fully redundant with a subset of Grapheme_Cluster_Break.
361 */
362 static const UHangulSyllableType gcbToHst[]={
363 U_HST_NOT_APPLICABLE, /* U_GCB_OTHER */
364 U_HST_NOT_APPLICABLE, /* U_GCB_CONTROL */
365 U_HST_NOT_APPLICABLE, /* U_GCB_CR */
366 U_HST_NOT_APPLICABLE, /* U_GCB_EXTEND */
367 U_HST_LEADING_JAMO, /* U_GCB_L */
368 U_HST_NOT_APPLICABLE, /* U_GCB_LF */
369 U_HST_LV_SYLLABLE, /* U_GCB_LV */
370 U_HST_LVT_SYLLABLE, /* U_GCB_LVT */
371 U_HST_TRAILING_JAMO, /* U_GCB_T */
372 U_HST_VOWEL_JAMO /* U_GCB_V */
373 /*
374 * Omit GCB values beyond what we need for hst.
375 * The code below checks for the array length.
376 */
377 };
378
getHangulSyllableType(const IntProperty &,UChar32 c,UProperty)379 static int32_t getHangulSyllableType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
380 /* see comments on gcbToHst[] above */
381 int32_t gcb=(int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT;
382 if(gcb<UPRV_LENGTHOF(gcbToHst)) {
383 return gcbToHst[gcb];
384 } else {
385 return U_HST_NOT_APPLICABLE;
386 }
387 }
388
389 #if UCONFIG_NO_NORMALIZATION
getNormQuickCheck(const IntProperty &,UChar32,UProperty)390 static int32_t getNormQuickCheck(const IntProperty &, UChar32, UProperty) {
391 return 0;
392 }
393 #else
getNormQuickCheck(const IntProperty &,UChar32 c,UProperty which)394 static int32_t getNormQuickCheck(const IntProperty &/*prop*/, UChar32 c, UProperty which) {
395 return (int32_t)unorm_getQuickCheck(c, (UNormalizationMode)(which-UCHAR_NFD_QUICK_CHECK+UNORM_NFD));
396 }
397 #endif
398
399 #if UCONFIG_NO_NORMALIZATION
getLeadCombiningClass(const IntProperty &,UChar32,UProperty)400 static int32_t getLeadCombiningClass(const IntProperty &, UChar32, UProperty) {
401 return 0;
402 }
403 #else
getLeadCombiningClass(const IntProperty &,UChar32 c,UProperty)404 static int32_t getLeadCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
405 return unorm_getFCD16(c)>>8;
406 }
407 #endif
408
409 #if UCONFIG_NO_NORMALIZATION
getTrailCombiningClass(const IntProperty &,UChar32,UProperty)410 static int32_t getTrailCombiningClass(const IntProperty &, UChar32, UProperty) {
411 return 0;
412 }
413 #else
getTrailCombiningClass(const IntProperty &,UChar32 c,UProperty)414 static int32_t getTrailCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
415 return unorm_getFCD16(c)&0xff;
416 }
417 #endif
418
419 static const IntProperty intProps[UCHAR_INT_LIMIT-UCHAR_INT_START]={
420 /*
421 * column, mask and shift values for int-value properties from u_getUnicodeProperties().
422 * Must be in order of corresponding UProperty,
423 * and there must be exactly one entry per int UProperty.
424 *
425 * Properties with mask==0 are handled in code.
426 * For them, column is the UPropertySource value.
427 */
428 { UPROPS_SRC_BIDI, 0, 0, getBiDiClass, biDiGetMaxValue },
429 { 0, UPROPS_BLOCK_MASK, UPROPS_BLOCK_SHIFT, defaultGetValue, defaultGetMaxValue },
430 { UPROPS_SRC_NFC, 0, 0xff, getCombiningClass, getMaxValueFromShift },
431 { 2, UPROPS_DT_MASK, 0, defaultGetValue, defaultGetMaxValue },
432 { 0, UPROPS_EA_MASK, UPROPS_EA_SHIFT, defaultGetValue, defaultGetMaxValue },
433 { UPROPS_SRC_CHAR, 0, (int32_t)U_CHAR_CATEGORY_COUNT-1,getGeneralCategory, getMaxValueFromShift },
434 { UPROPS_SRC_BIDI, 0, 0, getJoiningGroup, biDiGetMaxValue },
435 { UPROPS_SRC_BIDI, 0, 0, getJoiningType, biDiGetMaxValue },
436 { 2, UPROPS_LB_MASK, UPROPS_LB_SHIFT, defaultGetValue, defaultGetMaxValue },
437 { UPROPS_SRC_CHAR, 0, (int32_t)U_NT_COUNT-1, getNumericType, getMaxValueFromShift },
438 { 0, UPROPS_SCRIPT_MASK, 0, getScript, defaultGetMaxValue },
439 { UPROPS_SRC_PROPSVEC, 0, (int32_t)U_HST_COUNT-1, getHangulSyllableType, getMaxValueFromShift },
440 // UCHAR_NFD_QUICK_CHECK: max=1=YES -- never "maybe", only "no" or "yes"
441 { UPROPS_SRC_NFC, 0, (int32_t)UNORM_YES, getNormQuickCheck, getMaxValueFromShift },
442 // UCHAR_NFKD_QUICK_CHECK: max=1=YES -- never "maybe", only "no" or "yes"
443 { UPROPS_SRC_NFKC, 0, (int32_t)UNORM_YES, getNormQuickCheck, getMaxValueFromShift },
444 // UCHAR_NFC_QUICK_CHECK: max=2=MAYBE
445 { UPROPS_SRC_NFC, 0, (int32_t)UNORM_MAYBE, getNormQuickCheck, getMaxValueFromShift },
446 // UCHAR_NFKC_QUICK_CHECK: max=2=MAYBE
447 { UPROPS_SRC_NFKC, 0, (int32_t)UNORM_MAYBE, getNormQuickCheck, getMaxValueFromShift },
448 { UPROPS_SRC_NFC, 0, 0xff, getLeadCombiningClass, getMaxValueFromShift },
449 { UPROPS_SRC_NFC, 0, 0xff, getTrailCombiningClass, getMaxValueFromShift },
450 { 2, UPROPS_GCB_MASK, UPROPS_GCB_SHIFT, defaultGetValue, defaultGetMaxValue },
451 { 2, UPROPS_SB_MASK, UPROPS_SB_SHIFT, defaultGetValue, defaultGetMaxValue },
452 { 2, UPROPS_WB_MASK, UPROPS_WB_SHIFT, defaultGetValue, defaultGetMaxValue },
453 { UPROPS_SRC_BIDI, 0, 0, getBiDiPairedBracketType, biDiGetMaxValue },
454 };
455
456 U_CAPI int32_t U_EXPORT2
u_getIntPropertyValue(UChar32 c,UProperty which)457 u_getIntPropertyValue(UChar32 c, UProperty which) {
458 if(which<UCHAR_INT_START) {
459 if(UCHAR_BINARY_START<=which && which<UCHAR_BINARY_LIMIT) {
460 const BinaryProperty &prop=binProps[which];
461 return prop.contains(prop, c, which);
462 }
463 } else if(which<UCHAR_INT_LIMIT) {
464 const IntProperty &prop=intProps[which-UCHAR_INT_START];
465 return prop.getValue(prop, c, which);
466 } else if(which==UCHAR_GENERAL_CATEGORY_MASK) {
467 return U_MASK(u_charType(c));
468 }
469 return 0; // undefined
470 }
471
472 U_CAPI int32_t U_EXPORT2
u_getIntPropertyMinValue(UProperty)473 u_getIntPropertyMinValue(UProperty /*which*/) {
474 return 0; /* all binary/enum/int properties have a minimum value of 0 */
475 }
476
477 U_CAPI int32_t U_EXPORT2
u_getIntPropertyMaxValue(UProperty which)478 u_getIntPropertyMaxValue(UProperty which) {
479 if(which<UCHAR_INT_START) {
480 if(UCHAR_BINARY_START<=which && which<UCHAR_BINARY_LIMIT) {
481 return 1; // maximum TRUE for all binary properties
482 }
483 } else if(which<UCHAR_INT_LIMIT) {
484 const IntProperty &prop=intProps[which-UCHAR_INT_START];
485 return prop.getMaxValue(prop, which);
486 }
487 return -1; // undefined
488 }
489
490 U_CFUNC UPropertySource U_EXPORT2
uprops_getSource(UProperty which)491 uprops_getSource(UProperty which) {
492 if(which<UCHAR_BINARY_START) {
493 return UPROPS_SRC_NONE; /* undefined */
494 } else if(which<UCHAR_BINARY_LIMIT) {
495 const BinaryProperty &prop=binProps[which];
496 if(prop.mask!=0) {
497 return UPROPS_SRC_PROPSVEC;
498 } else {
499 return (UPropertySource)prop.column;
500 }
501 } else if(which<UCHAR_INT_START) {
502 return UPROPS_SRC_NONE; /* undefined */
503 } else if(which<UCHAR_INT_LIMIT) {
504 const IntProperty &prop=intProps[which-UCHAR_INT_START];
505 if(prop.mask!=0) {
506 return UPROPS_SRC_PROPSVEC;
507 } else {
508 return (UPropertySource)prop.column;
509 }
510 } else if(which<UCHAR_STRING_START) {
511 switch(which) {
512 case UCHAR_GENERAL_CATEGORY_MASK:
513 case UCHAR_NUMERIC_VALUE:
514 return UPROPS_SRC_CHAR;
515
516 default:
517 return UPROPS_SRC_NONE;
518 }
519 } else if(which<UCHAR_STRING_LIMIT) {
520 switch(which) {
521 case UCHAR_AGE:
522 return UPROPS_SRC_PROPSVEC;
523
524 case UCHAR_BIDI_MIRRORING_GLYPH:
525 return UPROPS_SRC_BIDI;
526
527 case UCHAR_CASE_FOLDING:
528 case UCHAR_LOWERCASE_MAPPING:
529 case UCHAR_SIMPLE_CASE_FOLDING:
530 case UCHAR_SIMPLE_LOWERCASE_MAPPING:
531 case UCHAR_SIMPLE_TITLECASE_MAPPING:
532 case UCHAR_SIMPLE_UPPERCASE_MAPPING:
533 case UCHAR_TITLECASE_MAPPING:
534 case UCHAR_UPPERCASE_MAPPING:
535 return UPROPS_SRC_CASE;
536
537 case UCHAR_ISO_COMMENT:
538 case UCHAR_NAME:
539 case UCHAR_UNICODE_1_NAME:
540 return UPROPS_SRC_NAMES;
541
542 default:
543 return UPROPS_SRC_NONE;
544 }
545 } else {
546 switch(which) {
547 case UCHAR_SCRIPT_EXTENSIONS:
548 return UPROPS_SRC_PROPSVEC;
549 default:
550 return UPROPS_SRC_NONE; /* undefined */
551 }
552 }
553 }
554
555 #if !UCONFIG_NO_NORMALIZATION
556
557 U_CAPI int32_t U_EXPORT2
u_getFC_NFKC_Closure(UChar32 c,UChar * dest,int32_t destCapacity,UErrorCode * pErrorCode)558 u_getFC_NFKC_Closure(UChar32 c, UChar *dest, int32_t destCapacity, UErrorCode *pErrorCode) {
559 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
560 return 0;
561 }
562 if(destCapacity<0 || (dest==NULL && destCapacity>0)) {
563 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
564 return 0;
565 }
566 // Compute the FC_NFKC_Closure on the fly:
567 // We have the API for complete coverage of Unicode properties, although
568 // this value by itself is not useful via API.
569 // (What could be useful is a custom normalization table that combines
570 // case folding and NFKC.)
571 // For the derivation, see Unicode's DerivedNormalizationProps.txt.
572 const Normalizer2 *nfkc=Normalizer2::getNFKCInstance(*pErrorCode);
573 const UCaseProps *csp=ucase_getSingleton();
574 if(U_FAILURE(*pErrorCode)) {
575 return 0;
576 }
577 // first: b = NFKC(Fold(a))
578 UnicodeString folded1String;
579 const UChar *folded1;
580 int32_t folded1Length=ucase_toFullFolding(csp, c, &folded1, U_FOLD_CASE_DEFAULT);
581 if(folded1Length<0) {
582 const Normalizer2Impl *nfkcImpl=Normalizer2Factory::getImpl(nfkc);
583 if(nfkcImpl->getCompQuickCheck(nfkcImpl->getNorm16(c))!=UNORM_NO) {
584 return u_terminateUChars(dest, destCapacity, 0, pErrorCode); // c does not change at all under CaseFolding+NFKC
585 }
586 folded1String.setTo(c);
587 } else {
588 if(folded1Length>UCASE_MAX_STRING_LENGTH) {
589 folded1String.setTo(folded1Length);
590 } else {
591 folded1String.setTo(FALSE, folded1, folded1Length);
592 }
593 }
594 UnicodeString kc1=nfkc->normalize(folded1String, *pErrorCode);
595 // second: c = NFKC(Fold(b))
596 UnicodeString folded2String(kc1);
597 UnicodeString kc2=nfkc->normalize(folded2String.foldCase(), *pErrorCode);
598 // if (c != b) add the mapping from a to c
599 if(U_FAILURE(*pErrorCode) || kc1==kc2) {
600 return u_terminateUChars(dest, destCapacity, 0, pErrorCode);
601 } else {
602 return kc2.extract(dest, destCapacity, *pErrorCode);
603 }
604 }
605
606 #endif
607