Chiebot-Mirror
/
harfbuzz
mirror of https://github.com/harfbuzz/harfbuzz.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

[buffer] Templatize UTF-* functions

Browse Source
pull/46/head
Behdad Esfahbod 10 years ago
parent e634fed428
commit 625dbf141a
2 changed files with 166 additions and 151 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      src/hb-buffer.cc
  2. 307
      src/hb-utf-private.hh

10
src/hb-buffer.cc
Unescape View File

@ -1298,6 +1298,8 @@ hb_buffer_add_utf (hb_buffer_t *buffer,
unsigned int item_offset, unsigned int item_offset,
int item_length) int item_length)
{ {
typedef hb_utf_t<T> utf_t;
assert (buffer->content_type == HB_BUFFER_CONTENT_TYPE_UNICODE || assert (buffer->content_type == HB_BUFFER_CONTENT_TYPE_UNICODE ||
(!buffer->len && buffer->content_type == HB_BUFFER_CONTENT_TYPE_INVALID)); (!buffer->len && buffer->content_type == HB_BUFFER_CONTENT_TYPE_INVALID));
@ -1305,7 +1307,7 @@ hb_buffer_add_utf (hb_buffer_t *buffer,
return; return;
if (text_length == -1) if (text_length == -1)
text_length = hb_utf_strlen (text); text_length = utf_t::strlen (text);
if (item_length == -1) if (item_length == -1)
item_length = text_length - item_offset; item_length = text_length - item_offset;
@ -1328,7 +1330,7 @@ hb_buffer_add_utf (hb_buffer_t *buffer,
while (start < prev && buffer->context_len[0] < buffer->CONTEXT_LENGTH) while (start < prev && buffer->context_len[0] < buffer->CONTEXT_LENGTH)
{ {
hb_codepoint_t u; hb_codepoint_t u;
prev = hb_utf_prev (prev, start, &u); prev = utf_t::prev (prev, start, &u);
buffer->context[0][buffer->context_len[0]++] = u; buffer->context[0][buffer->context_len[0]++] = u;
} }
} }
@ -1339,7 +1341,7 @@ hb_buffer_add_utf (hb_buffer_t *buffer,
{ {
hb_codepoint_t u; hb_codepoint_t u;
const T *old_next = next; const T *old_next = next;
next = hb_utf_next (next, end, &u); next = utf_t::next (next, end, &u);
buffer->add (u, old_next - (const T *) text); buffer->add (u, old_next - (const T *) text);
} }
@ -1349,7 +1351,7 @@ hb_buffer_add_utf (hb_buffer_t *buffer,
while (next < end && buffer->context_len[1] < buffer->CONTEXT_LENGTH) while (next < end && buffer->context_len[1] < buffer->CONTEXT_LENGTH)
{ {
hb_codepoint_t u; hb_codepoint_t u;
next = hb_utf_next (next, end, &u); next = utf_t::next (next, end, &u);
buffer->context[1][buffer->context_len[1]++] = u; buffer->context[1][buffer->context_len[1]++] = u;
} }

307
src/hb-utf-private.hh
Unescape View File

@ -29,202 +29,215 @@
#include "hb-private.hh" #include "hb-private.hh"
template <typename T, bool validate=true> struct hb_utf_t;
/* UTF-8 */ /* UTF-8 */
static inline const uint8_t * template <>
hb_utf_next (const uint8_t *text, struct hb_utf_t<uint8_t, true>
const uint8_t *end,
hb_codepoint_t *unicode)
{ {
/* Written to only accept well-formed sequences. static inline const uint8_t *
* Based on ideas from ICU's U8_NEXT. next (const uint8_t *text,
* Generates a -1 for each ill-formed byte. */ const uint8_t *end,
hb_codepoint_t *unicode)
{
/* Written to only accept well-formed sequences.
* Based on ideas from ICU's U8_NEXT.
* Generates a -1 for each ill-formed byte. */
hb_codepoint_t c = *text++; hb_codepoint_t c = *text++;
if (c > 0x7Fu) if (c > 0x7Fu)
{
if (hb_in_range (c, 0xC2u, 0xDFu)) /* Two-byte */
{ {
unsigned int t1; if (hb_in_range (c, 0xC2u, 0xDFu)) /* Two-byte */
if (likely (text < end &&
(t1 = text[0] - 0x80u) <= 0x3Fu))
{ {
c = ((c&0x1Fu)<<6) | t1; unsigned int t1;
text++; if (likely (text < end &&
(t1 = text[0] - 0x80u) <= 0x3Fu))
{
c = ((c&0x1Fu)<<6) | t1;
text++;
}
else
goto error;
} }
else else if (hb_in_range (c, 0xE0u, 0xEFu)) /* Three-byte */
goto error;
}
else if (hb_in_range (c, 0xE0u, 0xEFu)) /* Three-byte */
{
unsigned int t1, t2;
if (likely (1 < end - text &&
(t1 = text[0] - 0x80u) <= 0x3Fu &&
(t2 = text[1] - 0x80u) <= 0x3Fu))
{ {
c = ((c&0xFu)<<12) | (t1<<6) | t2; unsigned int t1, t2;
if (unlikely (c < 0x0800u || hb_in_range (c, 0xD800u, 0xDFFFu))) if (likely (1 < end - text &&
(t1 = text[0] - 0x80u) <= 0x3Fu &&
(t2 = text[1] - 0x80u) <= 0x3Fu))
{
c = ((c&0xFu)<<12) | (t1<<6) | t2;
if (unlikely (c < 0x0800u || hb_in_range (c, 0xD800u, 0xDFFFu)))
goto error;
text += 2;
}
else
goto error; goto error;
text += 2;
} }
else else if (hb_in_range (c, 0xF0u, 0xF4u)) /* Four-byte */
goto error;
}
else if (hb_in_range (c, 0xF0u, 0xF4u)) /* Four-byte */
{
unsigned int t1, t2, t3;
if (likely (2 < end - text &&
(t1 = text[0] - 0x80u) <= 0x3Fu &&
(t2 = text[1] - 0x80u) <= 0x3Fu &&
(t3 = text[2] - 0x80u) <= 0x3Fu))
{ {
c = ((c&0x7u)<<18) | (t1<<12) | (t2<<6) | t3; unsigned int t1, t2, t3;
if (unlikely (!hb_in_range (c, 0x10000u, 0x10FFFFu))) if (likely (2 < end - text &&
(t1 = text[0] - 0x80u) <= 0x3Fu &&
(t2 = text[1] - 0x80u) <= 0x3Fu &&
(t3 = text[2] - 0x80u) <= 0x3Fu))
{
c = ((c&0x7u)<<18) | (t1<<12) | (t2<<6) | t3;
if (unlikely (!hb_in_range (c, 0x10000u, 0x10FFFFu)))
goto error;
text += 3;
}
else
goto error; goto error;
text += 3;
} }
else else
goto error; goto error;
} }
else
goto error;
}
*unicode = c;
return text;
error:
*unicode = -1;
return text;
}
static inline const uint8_t * *unicode = c;
hb_utf_prev (const uint8_t *text, return text;
const uint8_t *start,
hb_codepoint_t *unicode)
{
const uint8_t *end = text--;
while (start < text && (*text & 0xc0) == 0x80 && end - text < 4)
text--;
if (likely (hb_utf_next (text, end, unicode) == end)) error:
*unicode = -1;
return text; return text;
}
*unicode = -1; static inline const uint8_t *
return end - 1; prev (const uint8_t *text,
} const uint8_t *start,
hb_codepoint_t *unicode)
{
const uint8_t *end = text--;
while (start < text && (*text & 0xc0) == 0x80 && end - text < 4)
text--;
if (likely (next (text, end, unicode) == end))
return text;
static inline unsigned int *unicode = -1;
hb_utf_strlen (const uint8_t *text) return end - 1;
{ }
return strlen ((const char *) text);
} static inline unsigned int
strlen (const uint8_t *text)
{
return ::strlen ((const char *) text);
}
};
/* UTF-16 */ /* UTF-16 */
static inline const uint16_t * template <>
hb_utf_next (const uint16_t *text, struct hb_utf_t<uint16_t, true>
const uint16_t *end,
hb_codepoint_t *unicode)
{ {
hb_codepoint_t c = *text++; static inline const uint16_t *
next (const uint16_t *text,
if (likely (!hb_in_range (c, 0xD800u, 0xDFFFu))) const uint16_t *end,
hb_codepoint_t *unicode)
{ {
*unicode = c; hb_codepoint_t c = *text++;
if (likely (!hb_in_range (c, 0xD800u, 0xDFFFu)))
{
*unicode = c;
return text;
}
if (likely (hb_in_range (c, 0xD800u, 0xDBFFu)))
{
/* High-surrogate in c */
hb_codepoint_t l;
if (text < end && ((l = *text), likely (hb_in_range (l, 0xDC00u, 0xDFFFu))))
{
/* Low-surrogate in l */
*unicode = (c << 10) + l - ((0xD800u << 10) - 0x10000u + 0xDC00u);
text++;
return text;
}
}
/* Lonely / out-of-order surrogate. */
*unicode = -1;
return text; return text;
} }
if (likely (hb_in_range (c, 0xD800u, 0xDBFFu))) static inline const uint16_t *
prev (const uint16_t *text,
const uint16_t *start,
hb_codepoint_t *unicode)
{ {
/* High-surrogate in c */ const uint16_t *end = text--;
hb_codepoint_t l; hb_codepoint_t c = *text;
if (text < end && ((l = *text), likely (hb_in_range (l, 0xDC00u, 0xDFFFu))))
if (likely (!hb_in_range (c, 0xD800u, 0xDFFFu)))
{ {
/* Low-surrogate in l */ *unicode = c;
*unicode = (c << 10) + l - ((0xD800u << 10) - 0x10000u + 0xDC00u); return text;
text++;
return text;
} }
}
/* Lonely / out-of-order surrogate. */ if (likely (start < text && hb_in_range (c, 0xDC00u, 0xDFFFu)))
*unicode = -1; text--;
return text;
}
static inline const uint16_t * if (likely (next (text, end, unicode) == end))
hb_utf_prev (const uint16_t *text, return text;
const uint16_t *start,
hb_codepoint_t *unicode)
{
const uint16_t *end = text--;
hb_codepoint_t c = *text;
if (likely (!hb_in_range (c, 0xD800u, 0xDFFFu))) *unicode = -1;
{ return end - 1;
*unicode = c;
return text;
} }
if (likely (start < text && hb_in_range (c, 0xDC00u, 0xDFFFu)))
text--;
if (likely (hb_utf_next (text, end, unicode) == end)) static inline unsigned int
return text; strlen (const uint16_t *text)
{
unsigned int l = 0;
while (*text++) l++;
return l;
}
};
*unicode = -1;
return end - 1;
}
/* UTF-32 */
static inline unsigned int template <bool validate>
hb_utf_strlen (const uint16_t *text) struct hb_utf_t<uint32_t, validate>
{ {
unsigned int l = 0; static inline const uint32_t *
while (*text++) l++; next (const uint32_t *text,
return l; const uint32_t *end HB_UNUSED,
} hb_codepoint_t *unicode)
{
hb_codepoint_t c = *text++;
if (validate && unlikely (c > 0x10FFFFu || hb_in_range (c, 0xD800u, 0xDFFFu)))
goto error;
*unicode = c;
return text;
/* UTF-32 */ error:
*unicode = -1;
return text;
}
static inline const uint32_t * static inline const uint32_t *
hb_utf_next (const uint32_t *text, prev (const uint32_t *text,
const uint32_t *end HB_UNUSED, const uint32_t *start HB_UNUSED,
hb_codepoint_t *unicode) hb_codepoint_t *unicode)
{ {
hb_codepoint_t c = *text++; next (text - 1, text, unicode);
if (unlikely (c > 0x10FFFFu || hb_in_range (c, 0xD800u, 0xDFFFu))) return text - 1;
goto error; }
*unicode = c;
return text;
error:
*unicode = -1;
return text;
}
static inline const uint32_t *
hb_utf_prev (const uint32_t *text,
const uint32_t *start HB_UNUSED,
hb_codepoint_t *unicode)
{
hb_utf_next (text - 1, text, unicode);
return text - 1;
}
static inline unsigned int static inline unsigned int
hb_utf_strlen (const uint32_t *text) strlen (const uint32_t *text)
{ {
unsigned int l = 0; unsigned int l = 0;
while (*text++) l++; while (*text++) l++;
return l; return l;
} }
};
#endif /* HB_UTF_PRIVATE_HH */ #endif /* HB_UTF_PRIVATE_HH */

Write Preview
Loading…
Cancel
Save