/*
********************************************************************************
-* Copyright (C) 1996-2003, International Business Machines
+* Copyright (C) 1996-2014, International Business Machines
* Corporation and others. All Rights Reserved.
********************************************************************************
*
#include "unicode/utypes.h"
#include "unicode/uchar.h"
+#include "unicode/uscript.h"
#include "unicode/udata.h"
-#include "unicode/uloc.h"
-#include "unicode/uiter.h"
-#include "unicode/uset.h"
-#include "umutex.h"
+#include "uassert.h"
#include "cmemory.h"
#include "ucln_cmn.h"
-#include "utrie.h"
-#include "ustr_imp.h"
+#include "utrie2.h"
+#include "udataswp.h"
#include "uprops.h"
+#include "ustr_imp.h"
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
-/* dynamically loaded Unicode character properties -------------------------- */
-
-/*
- * loaded uprops.dat -
- * for a description of the file format, see icu/source/tools/genprops/store.c
- */
-static const char DATA_NAME[] = "uprops";
-static const char DATA_TYPE[] = "icu";
-
-static UDataMemory *propsData=NULL;
-static UErrorCode dataErrorCode=U_ZERO_ERROR;
-
-static uint8_t formatVersion[4]={ 0, 0, 0, 0 };
-static UVersionInfo dataVersion={ 0, 0, 0, 0 };
-
-static UTrie propsTrie={ 0 }, propsVectorsTrie={ 0 };
-static const uint32_t *pData32=NULL, *props32Table=NULL, *exceptionsTable=NULL, *propsVectors=NULL;
-static const UChar *ucharsTable=NULL;
-static int32_t countPropsVectors=0, propsVectorsColumns=0;
-
-static int8_t havePropsData=0;
-
-/* index values loaded from uprops.dat */
-static int32_t indexes[UPROPS_INDEX_COUNT];
-
-/* if bit 15 is set, then the folding offset is in bits 14..0 of the 16-bit trie result */
-static int32_t U_CALLCONV
-getFoldingPropsOffset(uint32_t data) {
- if(data&0x8000) {
- return (int32_t)(data&0x7fff);
- } else {
- return 0;
- }
-}
-
-static UBool U_CALLCONV
-isAcceptable(void *context,
- const char *type, const char *name,
- const UDataInfo *pInfo) {
- if(
- pInfo->size>=20 &&
- pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
- pInfo->charsetFamily==U_CHARSET_FAMILY &&
- pInfo->dataFormat[0]==0x55 && /* dataFormat="UPro" */
- pInfo->dataFormat[1]==0x50 &&
- pInfo->dataFormat[2]==0x72 &&
- pInfo->dataFormat[3]==0x6f &&
- pInfo->formatVersion[0]==3 &&
- pInfo->formatVersion[2]==UTRIE_SHIFT &&
- pInfo->formatVersion[3]==UTRIE_INDEX_SHIFT
- ) {
- uprv_memcpy(formatVersion, pInfo->formatVersion, 4);
- uprv_memcpy(dataVersion, pInfo->dataVersion, 4);
- return TRUE;
- } else {
- return FALSE;
- }
-}
-
-UBool
-uchar_cleanup()
-{
- if (propsData) {
- udata_close(propsData);
- propsData=NULL;
- }
- pData32=NULL;
- props32Table=NULL;
- exceptionsTable=NULL;
- ucharsTable=NULL;
- propsVectors=NULL;
- countPropsVectors=0;
- dataErrorCode=U_ZERO_ERROR;
- havePropsData=FALSE;
-
- return TRUE;
-}
-
-static int8_t
-loadPropsData(void) {
- /* load Unicode character properties data from file if necessary */
-
- /*
- * This lazy intialization with double-checked locking (without mutex protection for
- * haveNormData==0) is transiently unsafe under certain circumstances.
- * Check the readme and use u_init() if necessary.
- */
- if(havePropsData==0) {
- UTrie trie={ 0 }, trie2={ 0 };
- UErrorCode errorCode=U_ZERO_ERROR;
- UDataMemory *data;
- const uint32_t *p=NULL;
- int32_t length;
-
- /* open the data outside the mutex block */
- data=udata_openChoice(NULL, DATA_TYPE, DATA_NAME, isAcceptable, NULL, &errorCode);
- dataErrorCode=errorCode;
- if(U_FAILURE(errorCode)) {
- return havePropsData=-1;
- }
-
- p=(const uint32_t *)udata_getMemory(data);
-
- /* unserialize the trie; it is directly after the int32_t indexes[UPROPS_INDEX_COUNT] */
- length=(int32_t)p[UPROPS_PROPS32_INDEX]*4;
- length=utrie_unserialize(&trie, (const uint8_t *)(p+UPROPS_INDEX_COUNT), length-64, &errorCode);
- if(U_FAILURE(errorCode)) {
- dataErrorCode=errorCode;
- udata_close(data);
- return havePropsData=-1;
- }
- trie.getFoldingOffset=getFoldingPropsOffset;
-
- /* unserialize the properties vectors trie, if any */
- if( p[UPROPS_ADDITIONAL_TRIE_INDEX]!=0 &&
- p[UPROPS_ADDITIONAL_VECTORS_INDEX]!=0
- ) {
- length=(int32_t)(p[UPROPS_ADDITIONAL_VECTORS_INDEX]-p[UPROPS_ADDITIONAL_TRIE_INDEX])*4;
- length=utrie_unserialize(&trie2, (const uint8_t *)(p+p[UPROPS_ADDITIONAL_TRIE_INDEX]), length, &errorCode);
- if(U_FAILURE(errorCode)) {
- uprv_memset(&trie2, 0, sizeof(trie2));
- } else {
- trie2.getFoldingOffset=getFoldingPropsOffset;
- }
- }
-
- /* in the mutex block, set the data for this process */
- umtx_lock(NULL);
- if(propsData==NULL) {
- propsData=data;
- data=NULL;
- pData32=p;
- p=NULL;
- uprv_memcpy(&propsTrie, &trie, sizeof(trie));
- uprv_memcpy(&propsVectorsTrie, &trie2, sizeof(trie2));
- }
- umtx_unlock(NULL);
-
- /* initialize some variables */
- uprv_memcpy(indexes, pData32, sizeof(indexes));
- props32Table=pData32+indexes[UPROPS_PROPS32_INDEX];
- exceptionsTable=pData32+indexes[UPROPS_EXCEPTIONS_INDEX];
- ucharsTable=(const UChar *)(pData32+indexes[UPROPS_EXCEPTIONS_TOP_INDEX]);
-
- /* additional properties */
- if(indexes[UPROPS_ADDITIONAL_VECTORS_INDEX]!=0) {
- propsVectors=pData32+indexes[UPROPS_ADDITIONAL_VECTORS_INDEX];
- countPropsVectors=indexes[UPROPS_RESERVED_INDEX]-indexes[UPROPS_ADDITIONAL_VECTORS_INDEX];
- propsVectorsColumns=indexes[UPROPS_ADDITIONAL_VECTORS_COLUMNS_INDEX];
- }
-
- havePropsData=1;
-
- /* if a different thread set it first, then close the extra data */
- if(data!=NULL) {
- udata_close(data); /* NULL if it was set correctly */
- }
- }
-
- return havePropsData;
-}
+/* uchar_props_data.h is machine-generated by genprops --csource */
+#define INCLUDED_FROM_UCHAR_C
+#include "uchar_props_data.h"
-/* constants and macros for access to the data */
+/* constants and macros for access to the data ------------------------------ */
/* getting a uint32_t properties word from the data */
-#define HAVE_DATA (havePropsData>0 || (havePropsData==0 && loadPropsData()>0))
-#define VALIDATE(c) (((uint32_t)(c))<=0x10ffff && HAVE_DATA)
-#define GET_PROPS_UNSAFE(c, result) \
- UTRIE_GET16(&propsTrie, c, result); \
- (result)=props32Table[(result)]
-#define GET_PROPS(c, result) \
- if(HAVE_DATA) { \
- GET_PROPS_UNSAFE(c, result); \
- } else { \
- (result)=0; \
- }
-
-/* finding an exception value */
-#define HAVE_EXCEPTION_VALUE(flags, index) ((flags)&(1UL<<(index)))
-
-/* number of bits in an 8-bit integer value */
-#define EXC_GROUP 8
-static const uint8_t flagsOffset[256]={
- 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
- 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
- 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
- 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
- 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
- 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
- 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
- 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
-};
-
-#define ADD_EXCEPTION_OFFSET(flags, index, offset) { \
- if((index)>=EXC_GROUP) { \
- (offset)+=flagsOffset[(flags)&((1<<EXC_GROUP)-1)]; \
- (flags)>>=EXC_GROUP; \
- (index)-=EXC_GROUP; \
- } \
- (offset)+=flagsOffset[(flags)&((1<<(index))-1)]; \
-}
+#define GET_PROPS(c, result) ((result)=UTRIE2_GET16(&propsTrie, c));
U_CFUNC UBool
uprv_haveProperties(UErrorCode *pErrorCode) {
- if(HAVE_DATA) {
- return TRUE;
- } else {
- *pErrorCode=dataErrorCode;
+ if(U_FAILURE(*pErrorCode)) {
return FALSE;
}
+ return TRUE;
}
/* API functions ------------------------------------------------------------ */
static uint32_t U_CALLCONV
_enumTypeValue(const void *context, uint32_t value) {
- /* access the general category from the 32-bit properties, and those from the 16-bit trie value */
- return GET_CATEGORY(props32Table[value]);
+ return GET_CATEGORY(value);
}
static UBool U_CALLCONV
-_enumTypeRange(const void *context, UChar32 start, UChar32 limit, uint32_t value) {
+_enumTypeRange(const void *context, UChar32 start, UChar32 end, uint32_t value) {
/* just cast the value to UCharCategory */
return ((struct _EnumTypeCallback *)context)->
enumRange(((struct _EnumTypeCallback *)context)->context,
- start, limit, (UCharCategory)value);
+ start, end+1, (UCharCategory)value);
}
U_CAPI void U_EXPORT2
u_enumCharTypes(UCharEnumTypeRange *enumRange, const void *context) {
struct _EnumTypeCallback callback;
- if(enumRange==NULL || !HAVE_DATA) {
+ if(enumRange==NULL) {
return;
}
callback.enumRange=enumRange;
callback.context=context;
- utrie_enum(&propsTrie, _enumTypeValue, _enumTypeRange, &callback);
+ utrie2_enum(&propsTrie, _enumTypeValue, _enumTypeRange, &callback);
}
/* Checks if ch is a lower case letter.*/
return (UBool)((CAT_MASK(props)&U_GC_L_MASK)!=0);
}
-/* Checks if ch is a letter or a decimal digit */
+U_CAPI UBool U_EXPORT2
+u_isUAlphabetic(UChar32 c) {
+ return (u_getUnicodeProperties(c, 1)&U_MASK(UPROPS_ALPHABETIC))!=0;
+}
+
+/* Checks if c is a letter or a decimal digit */
U_CAPI UBool U_EXPORT2
u_isalnum(UChar32 c) {
uint32_t props;
return (UBool)((CAT_MASK(props)&(U_GC_L_MASK|U_GC_ND_MASK))!=0);
}
+/**
+ * Checks if c is alphabetic, or a decimal digit; implements UCHAR_POSIX_ALNUM.
+ * @internal
+ */
+U_CFUNC UBool
+u_isalnumPOSIX(UChar32 c) {
+ return (UBool)(u_isUAlphabetic(c) || u_isdigit(c));
+}
+
/* Checks if ch is a unicode character with assigned character type.*/
U_CAPI UBool U_EXPORT2
u_isdefined(UChar32 c) {
#define IS_THAT_CONTROL_SPACE(c) \
(c<=0x9f && ((c>=TAB && c<=CR) || (c>=0x1c && c <=0x1f) || c==NL))
+/* Java has decided that U+0085 New Line is not whitespace any more. */
+#define IS_THAT_ASCII_CONTROL_SPACE(c) \
+ (c<=0x1f && c>=TAB && (c<=CR || c>=0x1c))
+
/* Checks if the Unicode character is a space character.*/
U_CAPI UBool U_EXPORT2
u_isspace(UChar32 c) {
return (UBool)(
((CAT_MASK(props)&U_GC_Z_MASK)!=0 &&
c!=NBSP && c!=FIGURESP && c!=NNBSP) || /* exclude no-break spaces */
- IS_THAT_CONTROL_SPACE(c)
+ IS_THAT_ASCII_CONTROL_SPACE(c)
);
}
if((uint32_t)c<=0x9f) {
return c==9 || c==0x20; /* TAB or SPACE */
} else {
- /* White_Space but not LS (Zl) or PS (Zp) */
- return u_isUWhiteSpace(c) && ((c&0xfffffffe)!=0x2028);
+ /* Zs */
+ uint32_t props;
+ GET_PROPS(c, props);
+ return (UBool)(GET_CATEGORY(props)==U_SPACE_SEPARATOR);
}
}
+U_CAPI UBool U_EXPORT2
+u_isUWhiteSpace(UChar32 c) {
+ return (u_getUnicodeProperties(c, 1)&U_MASK(UPROPS_WHITE_SPACE))!=0;
+}
+
/* Checks if the Unicode character is printable.*/
U_CAPI UBool U_EXPORT2
u_isprint(UChar32 c) {
return (UBool)((CAT_MASK(props)&U_GC_C_MASK)==0);
}
+/**
+ * Checks if c is in \p{graph}\p{blank} - \p{cntrl}.
+ * Implements UCHAR_POSIX_PRINT.
+ * @internal
+ */
+U_CFUNC UBool
+u_isprintPOSIX(UChar32 c) {
+ uint32_t props;
+ GET_PROPS(c, props);
+ /*
+ * The only cntrl character in graph+blank is TAB (in blank).
+ * Here we implement (blank-TAB)=Zs instead of calling u_isblank().
+ */
+ return (UBool)((GET_CATEGORY(props)==U_SPACE_SEPARATOR) || u_isgraphPOSIX(c));
+}
+
U_CAPI UBool U_EXPORT2
u_isgraph(UChar32 c) {
uint32_t props;
==0);
}
+/**
+ * Checks if c is in
+ * [^\p{space}\p{gc=Control}\p{gc=Surrogate}\p{gc=Unassigned}]
+ * with space=\p{Whitespace} and Control=Cc.
+ * Implements UCHAR_POSIX_GRAPH.
+ * @internal
+ */
+U_CFUNC UBool
+u_isgraphPOSIX(UChar32 c) {
+ uint32_t props;
+ GET_PROPS(c, props);
+ /* \p{space}\p{gc=Control} == \p{gc=Z}\p{Control} */
+ /* comparing ==0 returns FALSE for the categories mentioned */
+ return (UBool)((CAT_MASK(props)&
+ (U_GC_CC_MASK|U_GC_CS_MASK|U_GC_CN_MASK|U_GC_Z_MASK))
+ ==0);
+}
+
U_CAPI UBool U_EXPORT2
u_ispunct(UChar32 c) {
uint32_t props;
U_CAPI UBool U_EXPORT2
u_isIDIgnorable(UChar32 c) {
if(c<=0x9f) {
- return u_isISOControl(c) && !IS_THAT_CONTROL_SPACE(c);
+ return u_isISOControl(c) && !IS_THAT_ASCII_CONTROL_SPACE(c);
} else {
uint32_t props;
GET_PROPS(c, props);
u_isIDIgnorable(c));
}
-/* Transforms the Unicode character to its lower case equivalent.*/
-U_CAPI UChar32 U_EXPORT2
-u_tolower(UChar32 c) {
- uint32_t props;
- GET_PROPS(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(CAT_MASK(props)&(U_GC_LU_MASK|U_GC_LT_MASK)) {
- return c+GET_SIGNED_VALUE(props);
- }
- } else {
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_LOWERCASE)) {
- int i=EXC_LOWERCASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- return (UChar32)*pe;
- }
- }
- return c; /* no mapping - return c itself */
-}
-
-/* Transforms the Unicode character to its upper case equivalent.*/
-U_CAPI UChar32 U_EXPORT2
-u_toupper(UChar32 c) {
- uint32_t props;
- GET_PROPS(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(GET_CATEGORY(props)==U_LOWERCASE_LETTER) {
- return c-GET_SIGNED_VALUE(props);
- }
- } else {
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_UPPERCASE)) {
- int i=EXC_UPPERCASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- return (UChar32)*pe;
- }
- }
- return c; /* no mapping - return c itself */
-}
-
-/* Transforms the Unicode character to its title case equivalent.*/
-U_CAPI UChar32 U_EXPORT2
-u_totitle(UChar32 c) {
- uint32_t props;
- GET_PROPS(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(GET_CATEGORY(props)==U_LOWERCASE_LETTER) {
- /* here, titlecase is same as uppercase */
- return c-GET_SIGNED_VALUE(props);
- }
- } else {
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_TITLECASE)) {
- int i=EXC_TITLECASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- return (UChar32)*pe;
- } else if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_UPPERCASE)) {
- /* here, titlecase is same as uppercase */
- int i=EXC_UPPERCASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- return (UChar32)*pe;
- }
- }
- return c; /* no mapping - return c itself */
-}
-
U_CAPI int32_t U_EXPORT2
u_charDigitValue(UChar32 c) {
- uint32_t props, numericType;
+ uint32_t props;
+ int32_t value;
GET_PROPS(c, props);
- numericType=GET_NUMERIC_TYPE(props);
-
- if(numericType==1) {
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- return GET_SIGNED_VALUE(props);
- } else {
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_NUMERIC_VALUE)) {
- int i=EXC_NUMERIC_VALUE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- return (int32_t)*pe;
- }
- }
+ value=(int32_t)GET_NUMERIC_TYPE_VALUE(props)-UPROPS_NTV_DECIMAL_START;
+ if(value<=9) {
+ return value;
+ } else {
+ return -1;
}
-
- return -1;
}
U_CAPI double U_EXPORT2
u_getNumericValue(UChar32 c) {
- uint32_t props, numericType;
+ uint32_t props;
+ int32_t ntv;
GET_PROPS(c, props);
- numericType=GET_NUMERIC_TYPE(props);
+ ntv=(int32_t)GET_NUMERIC_TYPE_VALUE(props);
- if(numericType==0 || numericType>=(int32_t)U_NT_COUNT) {
+ if(ntv==UPROPS_NTV_NONE) {
return U_NO_NUMERIC_VALUE;
- } else {
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- return GET_SIGNED_VALUE(props);
- } else {
- const uint32_t *pe;
- uint32_t firstExceptionValue;
-
- double numValue;
- uint32_t denominator;
-
- pe=GET_EXCEPTIONS(props);
- firstExceptionValue=*pe++;
-
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_NUMERIC_VALUE)) {
- uint32_t flags=firstExceptionValue;
- int i=EXC_NUMERIC_VALUE;
- const uint32_t *p=pe;
- int32_t numerator;
-
- ADD_EXCEPTION_OFFSET(flags, i, p);
- numerator=(int32_t)*p;
-
- /*
- * There are special values for huge numbers that are powers of ten.
- * genprops/store.c documents:
- * if numericValue=0x7fffff00+x then numericValue=10^x
- */
- if(numerator<0x7fffff00) {
- numValue=(double)numerator;
- } else {
- numerator&=0xff;
-
- /* 10^x without math.h */
- numValue=1.;
- while(numerator>=4) {
- numValue*=10000.;
- numerator-=4;
- }
- switch(numerator) {
- case 3:
- numValue*=1000.;
- break;
- case 2:
- numValue*=100.;
- break;
- case 1:
- numValue*=10.;
- break;
- case 0:
- default:
- break;
- }
- }
- } else {
- numValue=0.;
- }
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_DENOMINATOR_VALUE)) {
- uint32_t flags=firstExceptionValue;
- int i=EXC_DENOMINATOR_VALUE;
- const uint32_t *p=pe;
- ADD_EXCEPTION_OFFSET(flags, i, p);
- denominator=*p;
- } else {
- denominator=0;
- }
-
- switch(firstExceptionValue&((1UL<<EXC_NUMERIC_VALUE)|(1UL<<EXC_DENOMINATOR_VALUE))) {
- case 1UL<<EXC_NUMERIC_VALUE:
- return numValue;
- case 1UL<<EXC_DENOMINATOR_VALUE:
- return (double)1./(double)denominator;
- case (1UL<<EXC_NUMERIC_VALUE)|(1UL<<EXC_DENOMINATOR_VALUE):
- return numValue/(double)denominator;
- case 0: /* none (should not occur with numericType>0) */
- default:
- return U_NO_NUMERIC_VALUE;
- }
+ } else if(ntv<UPROPS_NTV_DIGIT_START) {
+ /* decimal digit */
+ return ntv-UPROPS_NTV_DECIMAL_START;
+ } else if(ntv<UPROPS_NTV_NUMERIC_START) {
+ /* other digit */
+ return ntv-UPROPS_NTV_DIGIT_START;
+ } else if(ntv<UPROPS_NTV_FRACTION_START) {
+ /* small integer */
+ return ntv-UPROPS_NTV_NUMERIC_START;
+ } else if(ntv<UPROPS_NTV_LARGE_START) {
+ /* fraction */
+ int32_t numerator=(ntv>>4)-12;
+ int32_t denominator=(ntv&0xf)+1;
+ return (double)numerator/denominator;
+ } else if(ntv<UPROPS_NTV_BASE60_START) {
+ /* large, single-significant-digit integer */
+ double numValue;
+ int32_t mant=(ntv>>5)-14;
+ int32_t exp=(ntv&0x1f)+2;
+ numValue=mant;
+
+ /* multiply by 10^exp without math.h */
+ while(exp>=4) {
+ numValue*=10000.;
+ exp-=4;
+ }
+ switch(exp) {
+ case 3:
+ numValue*=1000.;
+ break;
+ case 2:
+ numValue*=100.;
+ break;
+ case 1:
+ numValue*=10.;
+ break;
+ case 0:
+ default:
+ break;
}
- }
-}
-/* Gets the character's linguistic directionality.*/
-U_CAPI UCharDirection U_EXPORT2
-u_charDirection(UChar32 c) {
- uint32_t props;
- GET_PROPS(c, props);
- return (UCharDirection)GET_BIDI_CLASS(props);
-}
+ return numValue;
+ } else if(ntv<UPROPS_NTV_RESERVED_START) {
+ /* sexagesimal (base 60) integer */
+ int32_t numValue=(ntv>>2)-0xbf;
+ int32_t exp=(ntv&3)+1;
-U_CAPI UBool U_EXPORT2
-u_isMirrored(UChar32 c) {
- uint32_t props;
- GET_PROPS(c, props);
- return (UBool)(props&(1UL<<UPROPS_MIRROR_SHIFT) ? TRUE : FALSE);
-}
+ switch(exp) {
+ case 4:
+ numValue*=60*60*60*60;
+ break;
+ case 3:
+ numValue*=60*60*60;
+ break;
+ case 2:
+ numValue*=60*60;
+ break;
+ case 1:
+ numValue*=60;
+ break;
+ case 0:
+ default:
+ break;
+ }
-U_CAPI UChar32 U_EXPORT2
-u_charMirror(UChar32 c) {
- uint32_t props;
- GET_PROPS(c, props);
- if((props&(1UL<<UPROPS_MIRROR_SHIFT))==0) {
- /* not mirrored - the value is not a mirror offset */
- return c;
- } else if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- return c+GET_SIGNED_VALUE(props);
+ return numValue;
} else {
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_MIRROR_MAPPING)) {
- int i=EXC_MIRROR_MAPPING;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- return (UChar32)*pe;
- } else {
- return c;
- }
+ /* reserved */
+ return U_NO_NUMERIC_VALUE;
}
}
-/* ICU 2.1: u_getCombiningClass() moved to unorm.cpp */
-
U_CAPI int32_t U_EXPORT2
u_digit(UChar32 ch, int8_t radix) {
int8_t value;
}
}
-/* miscellaneous, and support for uprops.c ---------------------------------- */
+/* miscellaneous, and support for uprops.cpp -------------------------------- */
U_CAPI void U_EXPORT2
u_getUnicodeVersion(UVersionInfo versionArray) {
if(versionArray!=NULL) {
- if(HAVE_DATA) {
- uprv_memcpy(versionArray, dataVersion, U_MAX_VERSION_LENGTH);
- } else {
- uprv_memset(versionArray, 0, U_MAX_VERSION_LENGTH);
- }
+ uprv_memcpy(versionArray, dataVersion, U_MAX_VERSION_LENGTH);
}
}
U_CFUNC uint32_t
-u_getUnicodeProperties(UChar32 c, int32_t column) {
- uint16_t vecIndex;
+u_getMainProperties(UChar32 c) {
+ uint32_t props;
+ GET_PROPS(c, props);
+ return props;
+}
- if(column==-1) {
- uint32_t props;
- GET_PROPS(c, props);
- return props;
- } else if( !HAVE_DATA || countPropsVectors==0 ||
- (uint32_t)c>0x10ffff ||
- column<0 || column>=propsVectorsColumns
- ) {
+U_CFUNC uint32_t
+u_getUnicodeProperties(UChar32 c, int32_t column) {
+ U_ASSERT(column>=0);
+ if(column>=propsVectorsColumns) {
return 0;
} else {
- UTRIE_GET16(&propsVectorsTrie, c, vecIndex);
+ uint16_t vecIndex=UTRIE2_GET16(&propsVectorsTrie, c);
return propsVectors[vecIndex+column];
}
}
U_CFUNC int32_t
uprv_getMaxValues(int32_t column) {
- if(HAVE_DATA) {
- switch(column) {
- case 0:
- return indexes[UPROPS_MAX_VALUES_INDEX];
- case 2:
- return indexes[UPROPS_MAX_VALUES_2_INDEX];
- default:
- return 0;
- }
- } else {
+ switch(column) {
+ case 0:
+ return indexes[UPROPS_MAX_VALUES_INDEX];
+ case 2:
+ return indexes[UPROPS_MAX_VALUES_2_INDEX];
+ default:
return 0;
}
}
-static UBool U_CALLCONV
-_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 limit, uint32_t value) {
- /* add the start code point to the USet */
- uset_add((USet *)context, start);
- return TRUE;
-}
-
-#define USET_ADD_CP_AND_NEXT(set, cp) uset_add(set, cp); uset_add(set, cp+1)
-
U_CAPI void U_EXPORT2
-uchar_addPropertyStarts(USet *set, UErrorCode *pErrorCode) {
- UChar32 c;
- int32_t value, value2;
-
- if(!HAVE_DATA) {
- *pErrorCode=dataErrorCode;
- return;
- }
-
- /* add the start code point of each same-value range of each trie */
- utrie_enum(&propsTrie, NULL, _enumPropertyStartsRange, set);
- utrie_enum(&propsVectorsTrie, NULL, _enumPropertyStartsRange, set);
-
- /* add code points with hardcoded properties, plus the ones following them */
-
- /* add for IS_THAT_CONTROL_SPACE() */
- uset_add(set, TAB); /* range TAB..CR */
- uset_add(set, CR+1);
- uset_add(set, 0x1c);
- uset_add(set, 0x1f+1);
- USET_ADD_CP_AND_NEXT(set, NL);
-
- /* add for u_isIDIgnorable() what was not added above */
- uset_add(set, DEL); /* range DEL..NBSP-1, NBSP added below */
- uset_add(set, HAIRSP);
- uset_add(set, RLM+1);
- uset_add(set, INHSWAP);
- uset_add(set, NOMDIG+1);
- USET_ADD_CP_AND_NEXT(set, ZWNBSP);
-
- /* add no-break spaces for u_isWhitespace() what was not added above */
- USET_ADD_CP_AND_NEXT(set, NBSP);
- USET_ADD_CP_AND_NEXT(set, FIGURESP);
- USET_ADD_CP_AND_NEXT(set, NNBSP);
-
- /* add for u_charDigitValue() */
- USET_ADD_CP_AND_NEXT(set, 0x3007);
- USET_ADD_CP_AND_NEXT(set, 0x4e00);
- USET_ADD_CP_AND_NEXT(set, 0x4e8c);
- USET_ADD_CP_AND_NEXT(set, 0x4e09);
- USET_ADD_CP_AND_NEXT(set, 0x56db);
- USET_ADD_CP_AND_NEXT(set, 0x4e94);
- USET_ADD_CP_AND_NEXT(set, 0x516d);
- USET_ADD_CP_AND_NEXT(set, 0x4e03);
- USET_ADD_CP_AND_NEXT(set, 0x516b);
- USET_ADD_CP_AND_NEXT(set, 0x4e5d);
-
- /* add for u_digit() */
- uset_add(set, U_a);
- uset_add(set, U_z+1);
- uset_add(set, U_A);
- uset_add(set, U_Z+1);
-
- /* add for UCHAR_DEFAULT_IGNORABLE_CODE_POINT what was not added above */
- uset_add(set, WJ); /* range WJ..NOMDIG */
- uset_add(set, 0xfff0);
- uset_add(set, 0xfffb+1);
- uset_add(set, 0xe0000);
- uset_add(set, 0xe0fff+1);
-
- /* add for UCHAR_GRAPHEME_BASE and others */
- USET_ADD_CP_AND_NEXT(set, CGJ);
-
- /* add for UCHAR_JOINING_TYPE */
- uset_add(set, ZWNJ); /* range ZWNJ..ZWJ */
- uset_add(set, ZWJ+1);
-
- /*
- * Add Jamo type boundaries for UCHAR_HANGUL_SYLLABLE_TYPE.
- * First, we add fixed boundaries for the blocks of Jamos.
- * Then we check in loops to see where the current Unicode version
- * actually stops assigning such Jamos. We start each loop
- * at the end of the per-Jamo-block assignments in Unicode 4 or earlier.
- * (These have not changed since Unicode 2.)
- */
- uset_add(set, 0x1100);
- value=U_HST_LEADING_JAMO;
- for(c=0x115a; c<=0x115f; ++c) {
- value2=u_getIntPropertyValue(c, UCHAR_HANGUL_SYLLABLE_TYPE);
- if(value!=value2) {
- value=value2;
- uset_add(set, c);
- }
- }
-
- uset_add(set, 0x1160);
- value=U_HST_VOWEL_JAMO;
- for(c=0x11a3; c<=0x11a7; ++c) {
- value2=u_getIntPropertyValue(c, UCHAR_HANGUL_SYLLABLE_TYPE);
- if(value!=value2) {
- value=value2;
- uset_add(set, c);
- }
- }
-
- uset_add(set, 0x11a8);
- value=U_HST_TRAILING_JAMO;
- for(c=0x11fa; c<=0x11ff; ++c) {
- value2=u_getIntPropertyValue(c, UCHAR_HANGUL_SYLLABLE_TYPE);
- if(value!=value2) {
- value=value2;
- uset_add(set, c);
- }
- }
-
-
- /*
- * Omit code points with hardcoded specialcasing properties
- * because we do not build property UnicodeSets for them right now.
- */
-}
-
-/* string casing ------------------------------------------------------------ */
-
-/*
- * These internal string case mapping functions are here instead of ustring.c
- * because we need efficient access to the character properties.
- *
- * This section contains helper functions that check for conditions
- * in the input text surrounding the current code point
- * according to SpecialCasing.txt.
- *
- * Starting with ICU 2.1, the "surrounding text" is passed in as an instance of
- * UCharIterator to allow the core case mapping functions to be used
- * inside transliterators (using Replaceable instead of UnicodeString/UChar *)
- * etc.
- *
- * Each helper function gets the index
- * - after the current code point if it looks at following text
- * - before the current code point if it looks at preceding text
- *
- * Unicode 3.2 UAX 21 "Case Mappings" defines the conditions as follows:
- *
- * Final_Sigma
- * C is preceded by a sequence consisting of
- * a cased letter and a case-ignorable sequence,
- * and C is not followed by a sequence consisting of
- * an ignorable sequence and then a cased letter.
- *
- * More_Above
- * C is followed by one or more characters of combining class 230 (ABOVE)
- * in the combining character sequence.
- *
- * After_Soft_Dotted
- * The last preceding character with combining class of zero before C
- * was Soft_Dotted,
- * and there is no intervening combining character class 230 (ABOVE).
- *
- * Before_Dot
- * C is followed by combining dot above (U+0307).
- * Any sequence of characters with a combining class that is neither 0 nor 230
- * may intervene between the current character and the combining dot above.
- *
- * The erratum from 2002-10-31 adds the condition
- *
- * After_I
- * The last preceding base character was an uppercase I, and there is no
- * intervening combining character class 230 (ABOVE).
- *
- * (See Jitterbug 2344 and the comments on After_I below.)
- *
- * Helper definitions in Unicode 3.2 UAX 21:
- *
- * D1. A character C is defined to be cased
- * if it meets any of the following criteria:
- *
- * - The general category of C is Titlecase Letter (Lt)
- * - In [CoreProps], C has one of the properties Uppercase, or Lowercase
- * - Given D = NFD(C), then it is not the case that:
- * D = UCD_lower(D) = UCD_upper(D) = UCD_title(D)
- * (This third criterium does not add any characters to the list
- * for Unicode 3.2. Ignored.)
- *
- * D2. A character C is defined to be case-ignorable
- * if it meets either of the following criteria:
- *
- * - The general category of C is
- * Nonspacing Mark (Mn), or Enclosing Mark (Me), or Format Control (Cf), or
- * Letter Modifier (Lm), or Symbol Modifier (Sk)
- * - C is one of the following characters
- * U+0027 APOSTROPHE
- * U+00AD SOFT HYPHEN (SHY)
- * U+2019 RIGHT SINGLE QUOTATION MARK
- * (the preferred character for apostrophe)
- *
- * D3. A case-ignorable sequence is a sequence of
- * zero or more case-ignorable characters.
- */
-
-#if UCONFIG_NO_NORMALIZATION
-/* no normalization - no combining classes */
-static U_INLINE uint8_t
-u_getCombiningClass(UChar32 c) {
- return 0;
-}
-#endif
-
-enum {
- LOC_ROOT,
- LOC_TURKISH,
- LOC_LITHUANIAN
-};
-
-static int32_t
-getCaseLocale(const char *locale) {
- char lang[32];
- UErrorCode errorCode;
- int32_t length;
-
- errorCode=U_ZERO_ERROR;
- length=uloc_getLanguage(locale, lang, sizeof(lang), &errorCode);
- if(U_FAILURE(errorCode) || length!=2) {
- return LOC_ROOT;
- }
-
- if( (lang[0]=='t' && lang[1]=='r') ||
- (lang[0]=='a' && lang[1]=='z')
- ) {
- return LOC_TURKISH;
- } else if(lang[0]=='l' && lang[1]=='t') {
- return LOC_LITHUANIAN;
+u_charAge(UChar32 c, UVersionInfo versionArray) {
+ if(versionArray!=NULL) {
+ uint32_t version=u_getUnicodeProperties(c, 0)>>UPROPS_AGE_SHIFT;
+ versionArray[0]=(uint8_t)(version>>4);
+ versionArray[1]=(uint8_t)(version&0xf);
+ versionArray[2]=versionArray[3]=0;
+ }
+}
+
+U_CAPI UScriptCode U_EXPORT2
+uscript_getScript(UChar32 c, UErrorCode *pErrorCode) {
+ uint32_t scriptX;
+ if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+ return USCRIPT_INVALID_CODE;
+ }
+ if((uint32_t)c>0x10ffff) {
+ *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
+ return USCRIPT_INVALID_CODE;
+ }
+ scriptX=u_getUnicodeProperties(c, 0)&UPROPS_SCRIPT_X_MASK;
+ if(scriptX<UPROPS_SCRIPT_X_WITH_COMMON) {
+ return (UScriptCode)scriptX;
+ } else if(scriptX<UPROPS_SCRIPT_X_WITH_INHERITED) {
+ return USCRIPT_COMMON;
+ } else if(scriptX<UPROPS_SCRIPT_X_WITH_OTHER) {
+ return USCRIPT_INHERITED;
} else {
- return LOC_ROOT;
+ return (UScriptCode)scriptExtensions[scriptX&UPROPS_SCRIPT_MASK];
}
}
-/* Is case-ignorable? */
-static U_INLINE UBool
-isCaseIgnorable(UChar32 c, uint32_t category) {
- return (FLAG(category)&(_Mn|_Me|_Cf|_Lm|_Sk))!=0 ||
- c==0x27 || c==0xad || c==0x2019;
-}
-
-/* Is this a "cased" character? */
-static U_INLINE UBool
-isCased(UChar32 c, uint32_t category) {
- /* Lt+Uppercase+Lowercase = Lt+Lu+Ll+Other_Uppercase+Other_Lowercase */
- return (FLAG(category)&(_Lt|_Lu|_Ll))!=0 ||
- (u_getUnicodeProperties(c, 1)&(FLAG(UPROPS_UPPERCASE)|FLAG(UPROPS_LOWERCASE)))!=0;
-}
-
-/* Is Soft_Dotted? */
-static U_INLINE UBool
-isSoftDotted(UChar32 c) {
- return (u_getUnicodeProperties(c, 1)&FLAG(UPROPS_SOFT_DOTTED))!=0;
-}
-
-/* Is followed by {case-ignorable}* cased ? */
-static UBool
-isFollowedByCasedLetter(UCharIterator *iter, int32_t index) {
- /* This is volatile because AIX 5.1 Visual Age 5.0 in 32-bit mode can't
- optimize this correctly. It couldn't optimize (1UL<<category)&0xE
- */
- volatile uint32_t category;
- uint32_t props;
- int32_t c;
-
- if(iter==NULL) {
- return FALSE;
- }
-
- iter->move(iter, index, UITER_ZERO);
- for(;;) {
- c=uiter_next32(iter);
- if(c<0) {
- break;
- }
- GET_PROPS_UNSAFE(c, props);
- category=GET_CATEGORY(props);
- if(isCased(c, category)) {
- return TRUE; /* followed by cased letter */
- }
- if(!isCaseIgnorable(c, category)) {
- return FALSE; /* not ignorable */
- }
- }
-
- return FALSE; /* not followed by cased letter */
-}
-
-/* Is preceded by cased {case-ignorable}* ? */
-static UBool
-isPrecededByCasedLetter(UCharIterator *iter, int32_t index) {
- /* This is volatile because AIX 5.1 Visual Age 5.0 in 32-bit mode can't
- optimize this correctly. It couldn't optimize (1UL<<category)&0xE
- */
- volatile uint32_t category;
- uint32_t props;
- int32_t c;
-
- if(iter==NULL) {
- return FALSE;
- }
-
- iter->move(iter, index, UITER_ZERO);
- for(;;) {
- c=uiter_previous32(iter);
- if(c<0) {
- break;
- }
- GET_PROPS_UNSAFE(c, props);
- category=GET_CATEGORY(props);
- if(isCased(c, category)) {
- return TRUE; /* preceded by cased letter */
- }
- if(!isCaseIgnorable(c, category)) {
- return FALSE; /* not ignorable */
- }
- }
-
- return FALSE; /* not followed by cased letter */
-}
-
-/* Is preceded by Soft_Dotted character with no intervening cc=230 ? */
-static UBool
-isPrecededBySoftDotted(UCharIterator *iter, int32_t index) {
- int32_t c;
- uint8_t cc;
-
- if(iter==NULL) {
- return FALSE;
- }
-
- iter->move(iter, index, UITER_ZERO);
- for(;;) {
- c=uiter_previous32(iter);
- if(c<0) {
- break;
- }
- if(isSoftDotted(c)) {
- return TRUE; /* preceded by TYPE_i */
- }
-
- cc=u_getCombiningClass(c);
- if(cc==0 || cc==230) {
- return FALSE; /* preceded by different base character (not TYPE_i), or intervening cc==230 */
- }
- }
-
- return FALSE; /* not preceded by TYPE_i */
-}
-
-/*
- * See Jitterbug 2344:
- * The condition After_I for Turkic-lowercasing of U+0307 combining dot above
- * is checked in ICU 2.0, 2.1, 2.6 but was not in 2.2 & 2.4 because
- * we made those releases compatible with Unicode 3.2 which had not fixed
- * a related but in SpecialCasing.txt.
- *
- * From the Jitterbug 2344 text:
- * ... this bug is listed as a Unicode erratum
- * from 2002-10-31 at http://www.unicode.org/uni2errata/UnicodeErrata.html
- * <quote>
- * There are two errors in SpecialCasing.txt.
- * 1. Missing semicolons on two lines. ... [irrelevant for ICU]
- * 2. An incorrect context definition. Correct as follows:
- * < 0307; ; 0307; 0307; tr After_Soft_Dotted; # COMBINING DOT ABOVE
- * < 0307; ; 0307; 0307; az After_Soft_Dotted; # COMBINING DOT ABOVE
- * ---
- * > 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
- * > 0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
- * where the context After_I is defined as:
- * The last preceding base character was an uppercase I, and there is no
- * intervening combining character class 230 (ABOVE).
- * </quote>
- *
- * Note that SpecialCasing.txt even in Unicode 3.2 described the condition as:
- *
- * # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
- * # This matches the behavior of the canonically equivalent I-dot_above
- *
- * See also the description in this place in older versions of uchar.c (revision 1.100).
- *
- * Markus W. Scherer 2003-feb-15
- */
-
-/* Is preceded by base character 'I' with no intervening cc=230 ? */
-static UBool
-isPrecededBy_I(UCharIterator *iter, int32_t index) {
- int32_t c;
- uint8_t cc;
-
- if(iter==NULL) {
- return FALSE;
- }
-
- iter->move(iter, index, UITER_ZERO);
- for(;;) {
- c=uiter_previous32(iter);
- if(c<0) {
- break;
- }
- if(c==0x49) {
- return TRUE; /* preceded by I */
- }
-
- cc=u_getCombiningClass(c);
- if(cc==0 || cc==230) {
- return FALSE; /* preceded by different base character (not I), or intervening cc==230 */
- }
- }
-
- return FALSE; /* not preceded by I */
-}
-
-/* Is followed by one or more cc==230 ? */
-static UBool
-isFollowedByMoreAbove(UCharIterator *iter, int32_t index) {
- int32_t c;
- uint8_t cc;
-
- if(iter==NULL) {
- return FALSE;
+U_CAPI UBool U_EXPORT2
+uscript_hasScript(UChar32 c, UScriptCode sc) {
+ const uint16_t *scx;
+ uint32_t scriptX=u_getUnicodeProperties(c, 0)&UPROPS_SCRIPT_X_MASK;
+ if(scriptX<UPROPS_SCRIPT_X_WITH_COMMON) {
+ return sc==(UScriptCode)scriptX;
}
- iter->move(iter, index, UITER_ZERO);
- for(;;) {
- c=uiter_next32(iter);
- if(c<0) {
- break;
- }
- cc=u_getCombiningClass(c);
- if(cc==230) {
- return TRUE; /* at least one cc==230 following */
- }
- if(cc==0) {
- return FALSE; /* next base character, no more cc==230 following */
- }
+ scx=scriptExtensions+(scriptX&UPROPS_SCRIPT_MASK);
+ if(scriptX>=UPROPS_SCRIPT_X_WITH_OTHER) {
+ scx=scriptExtensions+scx[1];
}
-
- return FALSE; /* no more cc==230 following */
-}
-
-/* Is followed by a dot above (without cc==230 in between) ? */
-static UBool
-isFollowedByDotAbove(UCharIterator *iter, int32_t index) {
- int32_t c;
- uint8_t cc;
-
- if(iter==NULL) {
+ if(sc>=USCRIPT_CODE_LIMIT) {
+ /* Guard against bogus input that would make us go past the Script_Extensions terminator. */
return FALSE;
}
-
- iter->move(iter, index, UITER_ZERO);
- for(;;) {
- c=uiter_next32(iter);
- if(c<0) {
- break;
- }
- if(c==0x307) {
- return TRUE;
- }
- cc=u_getCombiningClass(c);
- if(cc==0 || cc==230) {
- return FALSE; /* next base character or cc==230 in between */
- }
+ while(sc>*scx) {
+ ++scx;
}
-
- return FALSE; /* no dot above following */
+ return sc==(*scx&0x7fff);
}
-/* lowercasing -------------------------------------------------------------- */
-
-/* internal, see ustr_imp.h */
U_CAPI int32_t U_EXPORT2
-u_internalToLower(UChar32 c, UCharIterator *iter,
- UChar *dest, int32_t destCapacity,
- const char *locale) {
- UChar buffer[8];
- uint32_t props;
- UChar32 result;
- int32_t i, length;
-
- result=c;
- GET_PROPS(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(CAT_MASK(props)&(U_GC_LU_MASK|U_GC_LT_MASK)) {
- result=c+GET_SIGNED_VALUE(props);
- }
- } else {
- const UChar *u;
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe, specialCasing;
- int32_t minLength;
-
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_SPECIAL_CASING)) {
- i=EXC_SPECIAL_CASING;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- specialCasing=*pe;
- /* fill u and length with the case mapping result string */
- if(specialCasing&0x80000000) {
- /* use hardcoded conditions and mappings */
- int32_t loc=getCaseLocale(locale),
- srcIndex= iter!=NULL ? iter->getIndex(iter, UITER_CURRENT) : 0;
-
- /*
- * Test for conditional mappings first
- * (otherwise the unconditional default mappings are always taken),
- * then test for characters that have unconditional mappings in SpecialCasing.txt,
- * then get the UnicodeData.txt mappings.
- */
- if( loc==LOC_LITHUANIAN &&
- /* base characters, find accents above */
- (((c==0x49 || c==0x4a || c==0x12e) &&
- isFollowedByMoreAbove(iter, srcIndex)) ||
- /* precomposed with accent above, no need to find one */
- (c==0xcc || c==0xcd || c==0x128))
- ) {
- /*
- # Lithuanian
-
- # Lithuanian retains the dot in a lowercase i when followed by accents.
-
- # Introduce an explicit dot above when lowercasing capital I's and J's
- # whenever there are more accents above.
- # (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
-
- 0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
- 004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
- 012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
- 00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
- 00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
- 0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
- */
- u=buffer;
- buffer[1]=0x307;
- switch(c) {
- case 0x49: /* LATIN CAPITAL LETTER I */
- buffer[0]=0x69;
- length=2;
- break;
- case 0x4a: /* LATIN CAPITAL LETTER J */
- buffer[0]=0x6a;
- length=2;
- break;
- case 0x12e: /* LATIN CAPITAL LETTER I WITH OGONEK */
- buffer[0]=0x12f;
- length=2;
- break;
- case 0xcc: /* LATIN CAPITAL LETTER I WITH GRAVE */
- buffer[0]=0x69;
- buffer[2]=0x300;
- length=3;
- break;
- case 0xcd: /* LATIN CAPITAL LETTER I WITH ACUTE */
- buffer[0]=0x69;
- buffer[2]=0x301;
- length=3;
- break;
- case 0x128: /* LATIN CAPITAL LETTER I WITH TILDE */
- buffer[0]=0x69;
- buffer[2]=0x303;
- length=3;
- break;
- default:
- return 0; /* will not occur */
- }
- /* # Turkish and Azeri */
- } else if(loc==LOC_TURKISH && c==0x130) {
- /*
- # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
- # The following rules handle those cases.
-
- 0130; 0069; 0130; 0130; tr # LATIN CAPITAL LETTER I WITH DOT ABOVE
- 0130; 0069; 0130; 0130; az # LATIN CAPITAL LETTER I WITH DOT ABOVE
- */
- result=0x69;
- goto single;
- } else if(loc==LOC_TURKISH && c==0x307 && isPrecededBy_I(iter, srcIndex-1)) {
- /*
- # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
- # This matches the behavior of the canonically equivalent I-dot_above
-
- 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
- 0307; ; 0307; 0307; az After_I; # COMBINING DOT ABOVE
- */
- return 0; /* remove the dot (continue without output) */
- } else if(loc==LOC_TURKISH && c==0x49 && !isFollowedByDotAbove(iter, srcIndex)) {
- /*
- # When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
-
- 0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
- 0049; 0131; 0049; 0049; az Not_Before_Dot; # LATIN CAPITAL LETTER I
- */
- result=0x131;
- goto single;
- } else if(c==0x130) {
- /*
- # Preserve canonical equivalence for I with dot. Turkic is handled below.
-
- 0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE
- */
- static const UChar iWithDot[2]={ 0x69, 0x307 };
- u=iWithDot;
- length=2;
- } else if( c==0x3a3 &&
- !isFollowedByCasedLetter(iter, srcIndex) &&
- isPrecededByCasedLetter(iter, srcIndex-1)
- ) {
- /* greek capital sigma maps depending on surrounding cased letters (see SpecialCasing.txt) */
- /*
- # Special case for final form of sigma
-
- 03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
- */
- result=0x3c2; /* greek small final sigma */
- goto single;
- } else {
- /* no known conditional special case mapping, use a normal mapping */
- pe=GET_EXCEPTIONS(props); /* restore the initial exception pointer */
- firstExceptionValue=*pe;
- goto notSpecial;
- }
- } else {
- /* get the special case mapping string from the data file */
- u=ucharsTable+(specialCasing&0xffff);
- length=(int32_t)((*u++)&0x1f);
- }
-
- /* copy the result string */
- minLength = (length < destCapacity) ? length : destCapacity;
- i=0;
- while(i<minLength) {
- dest[i++]=*u++;
- }
- return length;
- }
-
-notSpecial:
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_LOWERCASE)) {
- i=EXC_LOWERCASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- result=(UChar32)*pe;
- }
- }
-
-single:
- length=UTF_CHAR_LENGTH(result);
- if(length<=destCapacity) {
- /* write result to dest */
- i=0;
- UTF_APPEND_CHAR_UNSAFE(dest, i, result);
+uscript_getScriptExtensions(UChar32 c,
+ UScriptCode *scripts, int32_t capacity,
+ UErrorCode *pErrorCode) {
+ uint32_t scriptX;
+ int32_t length;
+ const uint16_t *scx;
+ uint16_t sx;
+ if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
+ return 0;
}
- return (result==c) ? -length : length;
-}
-
-/*
- * Lowercases [srcStart..srcLimit[ but takes
- * context [0..srcLength[ into account.
- */
-U_CFUNC int32_t
-u_internalStrToLower(UChar *dest, int32_t destCapacity,
- const UChar *src, int32_t srcLength,
- int32_t srcStart, int32_t srcLimit,
- const char *locale,
- UErrorCode *pErrorCode) {
- UCharIterator iter;
- uint32_t props;
- int32_t srcIndex, destIndex;
- UChar32 c;
-
- /* test early, once, if there is a data file */
- if(!HAVE_DATA) {
- *pErrorCode=U_FILE_ACCESS_ERROR;
+ if(capacity<0 || (capacity>0 && scripts==NULL)) {
+ *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
-
- /* set up local variables */
- uiter_setString(&iter, src, srcLength);
-
- /* case mapping loop */
- srcIndex=srcStart;
- destIndex=0;
- while(srcIndex<srcLimit) {
- UTF_NEXT_CHAR(src, srcIndex, srcLimit, c);
- GET_PROPS_UNSAFE(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(CAT_MASK(props)&(U_GC_LU_MASK|U_GC_LT_MASK)) {
- c+=GET_SIGNED_VALUE(props);
- }
-
- /* handle 1:1 code point mappings from UnicodeData.txt */
- if(c<=0xffff) {
- if(destIndex<destCapacity) {
- dest[destIndex++]=(UChar)c;
- } else {
- /* buffer overflow */
- /* keep incrementing the destIndex for preflighting */
- ++destIndex;
- }
- } else {
- if((destIndex+2)<=destCapacity) {
- dest[destIndex++]=UTF16_LEAD(c);
- dest[destIndex++]=UTF16_TRAIL(c);
- } else {
- /* buffer overflow */
- /* write the first surrogate if possible */
- if(destIndex<destCapacity) {
- dest[destIndex]=UTF16_LEAD(c);
- }
- /* keep incrementing the destIndex for preflighting */
- destIndex+=2;
- }
- }
+ scriptX=u_getUnicodeProperties(c, 0)&UPROPS_SCRIPT_X_MASK;
+ if(scriptX<UPROPS_SCRIPT_X_WITH_COMMON) {
+ if(capacity==0) {
+ *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
} else {
- /* handle all exceptions in u_internalToLower() */
- int32_t length;
-
- iter.move(&iter, srcIndex, UITER_ZERO);
- if(destIndex<destCapacity) {
- length=u_internalToLower(c, &iter, dest+destIndex, destCapacity-destIndex, locale);
- } else {
- length=u_internalToLower(c, &iter, NULL, 0, locale);
- }
- if(length<0) {
- length=-length;
- }
- destIndex+=length;
+ scripts[0]=(UScriptCode)scriptX;
}
+ return 1;
}
- if(destIndex>destCapacity) {
- *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
+ scx=scriptExtensions+(scriptX&UPROPS_SCRIPT_MASK);
+ if(scriptX>=UPROPS_SCRIPT_X_WITH_OTHER) {
+ scx=scriptExtensions+scx[1];
}
- return destIndex;
-}
-
-/* uppercasing -------------------------------------------------------------- */
-
-/* internal */
-static int32_t
-u_internalToUpperOrTitle(UChar32 c, UCharIterator *iter,
- UChar *dest, int32_t destCapacity,
- const char *locale,
- UBool upperNotTitle) {
- uint32_t props;
- UChar32 result;
- int32_t i, length;
-
- result=c;
- GET_PROPS(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(GET_CATEGORY(props)==U_LOWERCASE_LETTER) {
- result=c-GET_SIGNED_VALUE(props);
- }
- } else {
- const UChar *u;
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe, specialCasing;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_SPECIAL_CASING)) {
- i=EXC_SPECIAL_CASING;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- specialCasing=*pe;
- /* fill u and length with the case mapping result string */
- if(specialCasing&0x80000000) {
- /* use hardcoded conditions and mappings */
- int32_t loc=getCaseLocale(locale),
- srcIndex= iter!=NULL ? iter->getIndex(iter, UITER_CURRENT) : 0;
-
- if(loc==LOC_TURKISH && c==0x69) {
- /*
- # Turkish and Azeri
-
- # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
- # The following rules handle those cases.
-
- # When uppercasing, i turns into a dotted capital I
-
- 0069; 0069; 0130; 0130; tr; # LATIN SMALL LETTER I
- 0069; 0069; 0130; 0130; az; # LATIN SMALL LETTER I
- */
- result=0x130;
- goto single;
- } else if(loc==LOC_LITHUANIAN && c==0x307 && isPrecededBySoftDotted(iter, srcIndex-1)) {
- /*
- # Lithuanian
-
- # Lithuanian retains the dot in a lowercase i when followed by accents.
-
- # Remove DOT ABOVE after "i" with upper or titlecase
-
- 0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
- */
- return 0; /* remove the dot (continue without output) */
- } else {
- /* no known conditional special case mapping, use a normal mapping */
- pe=GET_EXCEPTIONS(props); /* restore the initial exception pointer */
- firstExceptionValue=*pe;
- goto notSpecial;
- }
- } else {
- /* get the special case mapping string from the data file */
- u=ucharsTable+(specialCasing&0xffff);
- length=(int32_t)*u++;
-
- /* skip the lowercase result string */
- u+=length&0x1f;
- if(upperNotTitle) {
- length=(length>>5)&0x1f;
- } else {
- /* skip the uppercase result strings too */
- u+=(length>>5)&0x1f;
- length=(length>>10)&0x1f;
- }
- }
-
- /* copy the result string */
- i=0;
- while(i<length && i<destCapacity) {
- dest[i++]=*u++;
- }
- return length;
+ length=0;
+ do {
+ sx=*scx++;
+ if(length<capacity) {
+ scripts[length]=(UScriptCode)(sx&0x7fff);
}
-
-notSpecial:
- if(!upperNotTitle && HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_TITLECASE)) {
- i=EXC_TITLECASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- result=(UChar32)*pe;
- } else if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_UPPERCASE)) {
- /* here, titlecase is same as uppercase */
- i=EXC_UPPERCASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- result=(UChar32)*pe;
- }
- }
-
-single:
- length=UTF_CHAR_LENGTH(result);
- if(length<=destCapacity) {
- /* write result to dest */
- i=0;
- UTF_APPEND_CHAR_UNSAFE(dest, i, result);
+ ++length;
+ } while(sx<0x8000);
+ if(length>capacity) {
+ *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
}
- return (result==c) ? -length : length;
+ return length;
}
-/* internal, see ustr_imp.h */
-U_CAPI int32_t U_EXPORT2
-u_internalToUpper(UChar32 c, UCharIterator *iter,
- UChar *dest, int32_t destCapacity,
- const char *locale) {
- return u_internalToUpperOrTitle(c, iter, dest, destCapacity, locale, TRUE);
+U_CAPI UBlockCode U_EXPORT2
+ublock_getCode(UChar32 c) {
+ return (UBlockCode)((u_getUnicodeProperties(c, 0)&UPROPS_BLOCK_MASK)>>UPROPS_BLOCK_SHIFT);
}
-U_CFUNC int32_t
-u_internalStrToUpper(UChar *dest, int32_t destCapacity,
- const UChar *src, int32_t srcLength,
- const char *locale,
- UErrorCode *pErrorCode) {
- UCharIterator iter;
- uint32_t props;
- int32_t srcIndex, destIndex;
- UChar32 c;
+/* property starts for UnicodeSet ------------------------------------------- */
- /* test early, once, if there is a data file */
- if(!HAVE_DATA) {
- *pErrorCode=U_FILE_ACCESS_ERROR;
- return 0;
- }
+static UBool U_CALLCONV
+_enumPropertyStartsRange(const void *context, UChar32 start, UChar32 end, uint32_t value) {
+ /* add the start code point to the USet */
+ const USetAdder *sa=(const USetAdder *)context;
+ sa->add(sa->set, start);
+ return TRUE;
+}
- /* set up local variables */
- uiter_setString(&iter, src, srcLength);
-
- /* case mapping loop */
- srcIndex=destIndex=0;
- while(srcIndex<srcLength) {
- UTF_NEXT_CHAR(src, srcIndex, srcLength, c);
- GET_PROPS_UNSAFE(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(GET_CATEGORY(props)==U_LOWERCASE_LETTER) {
- c-=GET_SIGNED_VALUE(props);
- }
+#define USET_ADD_CP_AND_NEXT(sa, cp) sa->add(sa->set, cp); sa->add(sa->set, cp+1)
- /* handle 1:1 code point mappings from UnicodeData.txt */
- if(c<=0xffff) {
- if(destIndex<destCapacity) {
- dest[destIndex++]=(UChar)c;
- } else {
- /* buffer overflow */
- /* keep incrementing the destIndex for preflighting */
- ++destIndex;
- }
- } else {
- if((destIndex+2)<=destCapacity) {
- dest[destIndex++]=UTF16_LEAD(c);
- dest[destIndex++]=UTF16_TRAIL(c);
- } else {
- /* buffer overflow */
- /* write the first surrogate if possible */
- if(destIndex<destCapacity) {
- dest[destIndex]=UTF16_LEAD(c);
- }
- /* keep incrementing the destIndex for preflighting */
- destIndex+=2;
- }
- }
- } else {
- /* handle all exceptions in u_internalToUpper() */
- int32_t length;
-
- iter.move(&iter, srcIndex, UITER_ZERO);
- if(destIndex<destCapacity) {
- length=u_internalToUpperOrTitle(c, &iter, dest+destIndex, destCapacity-destIndex, locale, TRUE);
- } else {
- length=u_internalToUpperOrTitle(c, &iter, NULL, 0, locale, TRUE);
- }
- if(length<0) {
- length=-length;
- }
- destIndex+=length;
- }
+U_CFUNC void U_EXPORT2
+uchar_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) {
+ if(U_FAILURE(*pErrorCode)) {
+ return;
}
- if(destIndex>destCapacity) {
- *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
- }
- return destIndex;
-}
+ /* add the start code point of each same-value range of the main trie */
+ utrie2_enum(&propsTrie, NULL, _enumPropertyStartsRange, sa);
-/* titlecasing -------------------------------------------------------------- */
+ /* add code points with hardcoded properties, plus the ones following them */
-/* internal, see ustr_imp.h */
-U_CAPI int32_t U_EXPORT2
-u_internalToTitle(UChar32 c, UCharIterator *iter,
- UChar *dest, int32_t destCapacity,
- const char *locale) {
- return u_internalToUpperOrTitle(c, iter, dest, destCapacity, locale, FALSE);
-}
+ /* add for u_isblank() */
+ USET_ADD_CP_AND_NEXT(sa, TAB);
-/* case folding ------------------------------------------------------------- */
+ /* add for IS_THAT_CONTROL_SPACE() */
+ sa->add(sa->set, CR+1); /* range TAB..CR */
+ sa->add(sa->set, 0x1c);
+ sa->add(sa->set, 0x1f+1);
+ USET_ADD_CP_AND_NEXT(sa, NL);
-/*
- * Case folding is similar to lowercasing.
- * The result may be a simple mapping, i.e., a single code point, or
- * a full mapping, i.e., a string.
- * If the case folding for a code point is the same as its simple (1:1) lowercase mapping,
- * then only the lowercase mapping is stored.
- *
- * Some special cases are hardcoded because their conditions cannot be
- * parsed and processed from CaseFolding.txt.
- *
- * Unicode 3.2 CaseFolding.txt specifies for its status field:
-
-# C: common case folding, common mappings shared by both simple and full mappings.
-# F: full case folding, mappings that cause strings to grow in length. Multiple characters are separated by spaces.
-# S: simple case folding, mappings to single characters where different from F.
-# T: special case for uppercase I and dotted uppercase I
-# - For non-Turkic languages, this mapping is normally not used.
-# - For Turkic languages (tr, az), this mapping can be used instead of the normal mapping for these characters.
-#
-# Usage:
-# A. To do a simple case folding, use the mappings with status C + S.
-# B. To do a full case folding, use the mappings with status C + F.
-#
-# The mappings with status T can be used or omitted depending on the desired case-folding
-# behavior. (The default option is to exclude them.)
-
- * Unicode 3.2 has 'T' mappings as follows:
-
-0049; T; 0131; # LATIN CAPITAL LETTER I
-0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE
-
- * while the default mappings for these code points are:
-
-0049; C; 0069; # LATIN CAPITAL LETTER I
-0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE
-
- * U+0130 is otherwise lowercased to U+0069 (UnicodeData.txt).
- *
- * In case this code is used with CaseFolding.txt from an older version of Unicode
- * where CaseFolding.txt contains mappings with a status of 'I' that
- * have the opposite polarity ('I' mappings are included by default but excluded for Turkic),
- * we must also hardcode the Unicode 3.2 mappings for the code points
- * with 'I' mappings.
- * Unicode 3.1.1 has 'I' mappings for U+0130 and U+0131.
- * Unicode 3.2 has a 'T' mapping for U+0130, and lowercases U+0131 to itself (see UnicodeData.txt).
- */
+ /* add for u_isIDIgnorable() what was not added above */
+ sa->add(sa->set, DEL); /* range DEL..NBSP-1, NBSP added below */
+ sa->add(sa->set, HAIRSP);
+ sa->add(sa->set, RLM+1);
+ sa->add(sa->set, INHSWAP);
+ sa->add(sa->set, NOMDIG+1);
+ USET_ADD_CP_AND_NEXT(sa, ZWNBSP);
-/* return the simple case folding mapping for c */
-U_CAPI UChar32 U_EXPORT2
-u_foldCase(UChar32 c, uint32_t options) {
- uint32_t props;
- GET_PROPS(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(CAT_MASK(props)&(U_GC_LU_MASK|U_GC_LT_MASK)) {
- return c+GET_SIGNED_VALUE(props);
- }
- } else {
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_CASE_FOLDING)) {
- const uint32_t *oldPE=pe;
- int i=EXC_CASE_FOLDING;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- props=*pe;
- if(props!=0) {
- /* return the simple mapping, if there is one */
- const UChar *uchars=ucharsTable+(props&0xffff);
- UChar32 simple;
- i=0;
- UTF_NEXT_CHAR_UNSAFE(uchars, i, simple);
- if(simple!=0) {
- return simple;
- }
- /* fall through to use the lowercase exception value if there is no simple mapping */
- pe=oldPE;
- } else {
- /* special case folding mappings, hardcoded */
- if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) {
- /* default mappings */
- if(c==0x49) {
- /* 0049; C; 0069; # LATIN CAPITAL LETTER I */
- return 0x69;
- } else if(c==0x130) {
- /* no simple default mapping for U+0130, use UnicodeData.txt */
- return 0x69;
- }
- } else {
- /* Turkic mappings */
- if(c==0x49) {
- /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
- return 0x131;
- } else if(c==0x130) {
- /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
- return 0x69;
- }
- }
- /* return c itself because there is no special mapping for it */
- return c;
- }
- }
- /* not else! - allow to fall through from above */
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_LOWERCASE)) {
- int i=EXC_LOWERCASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- return (UChar32)*pe;
- }
- }
- return c; /* no mapping - return c itself */
-}
+ /* add no-break spaces for u_isWhitespace() what was not added above */
+ USET_ADD_CP_AND_NEXT(sa, NBSP);
+ USET_ADD_CP_AND_NEXT(sa, FIGURESP);
+ USET_ADD_CP_AND_NEXT(sa, NNBSP);
-/*
- * Issue for canonical caseless match (UAX #21):
- * Turkic casefolding (using "T" mappings in CaseFolding.txt) does not preserve
- * canonical equivalence, unlike default-option casefolding.
- * For example, I-grave and I + grave fold to strings that are not canonically
- * equivalent.
- * For more details, see the comment in unorm_compare() in unorm.cpp
- * and the intermediate prototype changes for Jitterbug 2021.
- * (For example, revision 1.104 of uchar.c and 1.4 of CaseFolding.txt.)
- *
- * This did not get fixed because it appears that it is not possible to fix
- * it for uppercase and lowercase characters (I-grave vs. i-grave)
- * together in a way that they still fold to common result strings.
- */
+ /* add for u_digit() */
+ sa->add(sa->set, U_a);
+ sa->add(sa->set, U_z+1);
+ sa->add(sa->set, U_A);
+ sa->add(sa->set, U_Z+1);
+ sa->add(sa->set, U_FW_a);
+ sa->add(sa->set, U_FW_z+1);
+ sa->add(sa->set, U_FW_A);
+ sa->add(sa->set, U_FW_Z+1);
+
+ /* add for u_isxdigit() */
+ sa->add(sa->set, U_f+1);
+ sa->add(sa->set, U_F+1);
+ sa->add(sa->set, U_FW_f+1);
+ sa->add(sa->set, U_FW_F+1);
-/* internal, see ustr_imp.h */
-U_CAPI int32_t U_EXPORT2
-u_internalFoldCase(UChar32 c,
- UChar *dest, int32_t destCapacity,
- uint32_t options) {
- uint32_t props;
- UChar32 result;
- int32_t i, length;
-
- result=c;
- GET_PROPS_UNSAFE(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(CAT_MASK(props)&(U_GC_LU_MASK|U_GC_LT_MASK)) {
- /* same as lowercase */
- result=c+GET_SIGNED_VALUE(props);
- }
- } else {
- const uint32_t *pe=GET_EXCEPTIONS(props);
- uint32_t firstExceptionValue=*pe;
- if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_CASE_FOLDING)) {
- i=EXC_CASE_FOLDING;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- props=*pe;
- if(props!=0) {
- /* return the full mapping */
- const UChar *uchars=ucharsTable+(props&0xffff)+2;
- int32_t minLength;
-
- length=props>>24;
- minLength = (length < destCapacity) ? length : destCapacity;
-
- /* copy the result string */
- i=0;
- while(i<minLength) {
- dest[i++]=*(uchars++);
- }
- return length;
- } else {
- /* special case folding mappings, hardcoded */
- if((options&_FOLD_CASE_OPTIONS_MASK)==U_FOLD_CASE_DEFAULT) {
- /* default mappings */
- if(c==0x49) {
- /* 0049; C; 0069; # LATIN CAPITAL LETTER I */
- result=0x69;
- } else if(c==0x130) {
- /* 0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
- if(0<destCapacity) {
- dest[0]=0x69;
- }
- if(1<destCapacity) {
- dest[1]=0x307;
- }
- return 2;
- }
- } else {
- /* Turkic mappings */
- if(c==0x49) {
- /* 0049; T; 0131; # LATIN CAPITAL LETTER I */
- result=0x131;
- } else if(c==0x130) {
- /* 0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE */
- result=0x69;
- }
- }
- /* return c itself because there is no special mapping for it */
- /* goto single; */
- }
- } else if(HAVE_EXCEPTION_VALUE(firstExceptionValue, EXC_LOWERCASE)) {
- i=EXC_LOWERCASE;
- ++pe;
- ADD_EXCEPTION_OFFSET(firstExceptionValue, i, pe);
- result=(UChar32)*pe;
- }
- }
+ /* add for UCHAR_DEFAULT_IGNORABLE_CODE_POINT what was not added above */
+ sa->add(sa->set, WJ); /* range WJ..NOMDIG */
+ sa->add(sa->set, 0xfff0);
+ sa->add(sa->set, 0xfffb+1);
+ sa->add(sa->set, 0xe0000);
+ sa->add(sa->set, 0xe0fff+1);
-/* single: */
- length=UTF_CHAR_LENGTH(result);
- if(length<=destCapacity) {
- /* write result to dest */
- i=0;
- UTF_APPEND_CHAR_UNSAFE(dest, i, result);
- }
- return (result==c) ? -length : length;
+ /* add for UCHAR_GRAPHEME_BASE and others */
+ USET_ADD_CP_AND_NEXT(sa, CGJ);
}
-/* case-fold the source string using the full mappings */
-U_CFUNC int32_t
-u_internalStrFoldCase(UChar *dest, int32_t destCapacity,
- const UChar *src, int32_t srcLength,
- uint32_t options,
- UErrorCode *pErrorCode) {
- uint32_t props;
- int32_t srcIndex, destIndex;
- UChar32 c;
-
- /* test early, once, if there is a data file */
- if(!HAVE_DATA) {
- *pErrorCode=U_FILE_ACCESS_ERROR;
- return 0;
- }
-
- /* case mapping loop */
- srcIndex=destIndex=0;
- while(srcIndex<srcLength) {
- UTF_NEXT_CHAR(src, srcIndex, srcLength, c);
- GET_PROPS_UNSAFE(c, props);
- if(!PROPS_VALUE_IS_EXCEPTION(props)) {
- if(CAT_MASK(props)&(U_GC_LU_MASK|U_GC_LT_MASK)) {
- c+=GET_SIGNED_VALUE(props);
- }
-
- /* handle 1:1 code point mappings from UnicodeData.txt */
- if(c<=0xffff) {
- if(destIndex<destCapacity) {
- dest[destIndex++]=(UChar)c;
- } else {
- /* buffer overflow */
- /* keep incrementing the destIndex for preflighting */
- ++destIndex;
- }
- } else {
- if((destIndex+2)<=destCapacity) {
- dest[destIndex++]=UTF16_LEAD(c);
- dest[destIndex++]=UTF16_TRAIL(c);
- } else {
- /* buffer overflow */
- /* write the first surrogate if possible */
- if(destIndex<destCapacity) {
- dest[destIndex]=UTF16_LEAD(c);
- }
- /* keep incrementing the destIndex for preflighting */
- destIndex+=2;
- }
- }
- } else {
- /* handle all exceptions in u_internalFoldCase() */
- int32_t length;
-
- if(destIndex<destCapacity) {
- length=u_internalFoldCase(c, dest+destIndex, destCapacity-destIndex, options);
- } else {
- length=u_internalFoldCase(c, NULL, 0, options);
- }
- if(length<0) {
- length=-length;
- }
- destIndex+=length;
- }
+U_CFUNC void U_EXPORT2
+upropsvec_addPropertyStarts(const USetAdder *sa, UErrorCode *pErrorCode) {
+ if(U_FAILURE(*pErrorCode)) {
+ return;
}
- if(destIndex>destCapacity) {
- *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
+ /* add the start code point of each same-value range of the properties vectors trie */
+ if(propsVectorsColumns>0) {
+ /* if propsVectorsColumns==0 then the properties vectors trie may not be there at all */
+ utrie2_enum(&propsVectorsTrie, NULL, _enumPropertyStartsRange, sa);
}
- return destIndex;
}
projects / apple / icu.git / blobdiff