walkero
/
harfbuzz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[icu] Remove support of ICU versions before 42 

ICU 42 is released in 2012, see also 44a3136ae6 (commitcomment-41016353)
This commit is contained in:
Ebrahim Byagowi 2020-07-30 00:53:40 +04:30
parent 4ba8e3c6fd
commit c9e5da8ded
1 changed files with 24 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
src/hb-icu.cc
View File

@ -194,43 +194,11 @@ hb_icu_unicode_compose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
hb_codepoint_t *ab, hb_codepoint_t *ab,
void *user_data HB_UNUSED) void *user_data HB_UNUSED)
{ {
#if U_ICU_VERSION_MAJOR_NUM >= 49
{
const UNormalizer2 *normalizer = (const UNormalizer2 *) user_data; const UNormalizer2 *normalizer = (const UNormalizer2 *) user_data;
UChar32 ret = unorm2_composePair (normalizer, a, b); UChar32 ret = unorm2_composePair (normalizer, a, b);
if (ret < 0) return false; if (ret < 0) return false;
*ab = ret; *ab = ret;
return true; return true;
}
#endif
/* We don't ifdef-out the fallback code such that compiler always
* sees it and makes sure it's compilable. */
UChar utf16[4], normalized[5];
unsigned int len;
hb_bool_t ret, err;
UErrorCode icu_err;
len = 0;
err = false;
U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), a, err);
if (err) return false;
U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), b, err);
if (err) return false;
icu_err = U_ZERO_ERROR;
len = unorm2_normalize (unorm2_getNFCInstance (&icu_err), utf16, len, normalized, ARRAY_LENGTH (normalized), &icu_err);
if (U_FAILURE (icu_err))
return false;
if (u_countChar32 (normalized, len) == 1) {
U16_GET_UNSAFE (normalized, 0, *ab);
ret = true;
} else {
ret = false;
}
return ret;
} }
static hb_bool_t static hb_bool_t
@ -240,8 +208,6 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
hb_codepoint_t *b, hb_codepoint_t *b,
void *user_data HB_UNUSED) void *user_data HB_UNUSED)
{ {
#if U_ICU_VERSION_MAJOR_NUM >= 49
{
const UNormalizer2 *normalizer = (const UNormalizer2 *) user_data; const UNormalizer2 *normalizer = (const UNormalizer2 *) user_data;
UChar decomposed[4]; UChar decomposed[4];
int len; int len;
@ -251,84 +217,19 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
if (U_FAILURE (icu_err) || len < 0) return false; if (U_FAILURE (icu_err) || len < 0) return false;
len = u_countChar32 (decomposed, len); len = u_countChar32 (decomposed, len);
if (len == 1) { if (len == 1)
{
U16_GET_UNSAFE (decomposed, 0, *a); U16_GET_UNSAFE (decomposed, 0, *a);
*b = 0; *b = 0;
return *a != ab; return *a != ab;
} else if (len == 2) { }
else if (len == 2)
{
len = 0; len = 0;
U16_NEXT_UNSAFE (decomposed, len, *a); U16_NEXT_UNSAFE (decomposed, len, *a);
U16_NEXT_UNSAFE (decomposed, len, *b); U16_NEXT_UNSAFE (decomposed, len, *b);
} }
return true; return true;
}
#endif
/* We don't ifdef-out the fallback code such that compiler always
* sees it and makes sure it's compilable. */
UChar utf16[2], normalized[2 * 19/*HB_UNICODE_MAX_DECOMPOSITION_LEN*/ + 1];
unsigned int len;
hb_bool_t ret, err;
UErrorCode icu_err;
/* This function is a monster! Maybe it wasn't a good idea adding a
* pairwise decompose API... */
/* Watchout for the dragons. Err, watchout for macros changing len. */
len = 0;
err = false;
U16_APPEND (utf16, len, ARRAY_LENGTH (utf16), ab, err);
if (err) return false;
icu_err = U_ZERO_ERROR;
len = unorm2_normalize (unorm2_getNFDInstance (&icu_err), utf16, len, normalized, ARRAY_LENGTH (normalized), &icu_err);
if (U_FAILURE (icu_err))
return false;
len = u_countChar32 (normalized, len);
if (len == 1) {
U16_GET_UNSAFE (normalized, 0, *a);
*b = 0;
ret = *a != ab;
} else if (len == 2) {
len = 0;
U16_NEXT_UNSAFE (normalized, len, *a);
U16_NEXT_UNSAFE (normalized, len, *b);
/* Here's the ugly part: if ab decomposes to a single character and
* that character decomposes again, we have to detect that and undo
* the second part :-(. */
UChar recomposed[20];
icu_err = U_ZERO_ERROR;
unorm2_normalize (unorm2_getNFCInstance (&icu_err), normalized, len, recomposed, ARRAY_LENGTH (recomposed), &icu_err);
if (U_FAILURE (icu_err))
return false;
hb_codepoint_t c;
U16_GET_UNSAFE (recomposed, 0, c);
if (c != *a && c != ab) {
*a = c;
*b = 0;
}
ret = true;
} else {
/* If decomposed to more than two characters, take the last one,
* and recompose the rest to get the first component. */
U16_PREV_UNSAFE (normalized, len, *b); /* Changes len in-place. */
UChar recomposed[18 * 2];
icu_err = U_ZERO_ERROR;
len = unorm2_normalize (unorm2_getNFCInstance (&icu_err), normalized, len, recomposed, ARRAY_LENGTH (recomposed), &icu_err);
if (U_FAILURE (icu_err))
return false;
/* We expect that recomposed has exactly one character now. */
if (unlikely (u_countChar32 (recomposed, len) != 1))
return false;
U16_GET_UNSAFE (recomposed, 0, *a);
ret = true;
}
return ret;
} }