#ifndef _UCW_UNICODE_H
#define _UCW_UNICODE_H
-#include "ucw/unaligned.h"
+#include <ucw/unaligned.h>
+
+#ifdef CONFIG_UCW_CLEAN_ABI
+#define utf8_strlen ucw_utf8_strlen
+#define utf8_strnlen ucw_utf8_strnlen
+#endif
/* Macros for handling UTF-8 */
-#define UNI_REPLACEMENT 0xfffc
+#define UNI_REPLACEMENT 0xfffc /** Unicode value used as a default replacement of invalid characters. **/
-/* Encode a character from the basic multilingual plane [0, 0xFFFF]
- * (subset of Unicode 4.0); up to 3 bytes needed (RFC2279) */
-static inline byte *
-utf8_put(byte *p, uns u)
+/**
+ * Encode a value from the range `[0, 0xFFFF]`
+ * (basic multilingual plane); up to 3 bytes needed (RFC2279).
+ **/
+static inline byte *utf8_put(byte *p, uint u)
{
if (u < 0x80)
*p++ = u;
return p;
}
-/* Encode a value from the range [0, 0x7FFFFFFF];
- * (superset of Unicode 4.0) up to 6 bytes needed (RFC2279) */
-static inline byte *
-utf8_32_put(byte *p, uns u)
+/**
+ * Encode a value from the range `[0, 0x7FFFFFFF]`;
+ * (superset of Unicode 4.0) up to 6 bytes needed (RFC2279).
+ **/
+static inline byte *utf8_32_put(byte *p, uint u)
{
if (u < 0x80)
*p++ = u;
}
#define UTF8_GET_NEXT if (unlikely((*p & 0xc0) != 0x80)) goto bad; u = (u << 6) | (*p++ & 0x3f)
+#define UTF8_CHECK_RANGE(r) if (unlikely(u < r)) goto bad
-/* Decode a character from the basic multilingual plane [0, 0xFFFF]
- * or return 'repl' if the encoding has been corrupted */
-static inline byte *
-utf8_get_repl(const byte *p, uns *uu, uns repl)
+/**
+ * Decode a value from the range `[0, 0xFFFF]` (basic multilingual plane)
+ * or return @repl if the encoding has been corrupted.
+ **/
+static inline byte *utf8_get_repl(const byte *p, uint *uu, uint repl)
{
- uns u = *p++;
+ uint u = *p++;
if (u < 0x80)
;
else if (unlikely(u < 0xc0))
{
u &= 0x1f;
UTF8_GET_NEXT;
+ UTF8_CHECK_RANGE(0x80);
}
else if (likely(u < 0xf0))
{
u &= 0x0f;
UTF8_GET_NEXT;
UTF8_GET_NEXT;
+ UTF8_CHECK_RANGE(0x800);
}
else
goto bad;
return (byte *)p;
}
-/* Decode a value from the range [0, 0x7FFFFFFF]
- * or return 'repl' if the encoding has been corrupted */
-static inline byte *
-utf8_32_get_repl(const byte *p, uns *uu, uns repl)
+/**
+ * Decode a value from the range `[0, 0x7FFFFFFF]`
+ * or return @repl if the encoding has been corrupted.
+ **/
+static inline byte *utf8_32_get_repl(const byte *p, uint *uu, uint repl)
{
- uns u = *p++;
+ uint u = *p++;
+ uint limit;
if (u < 0x80)
;
else if (unlikely(u < 0xc0))
- {
- /* Incorrect byte sequence */
- bad:
- u = repl;
- }
+ goto bad;
else if (u < 0xe0)
{
u &= 0x1f;
+ limit = 0x80;
goto get1;
}
else if (u < 0xf0)
{
u &= 0x0f;
+ limit = 0x800;
goto get2;
}
else if (u < 0xf8)
{
u &= 0x07;
+ limit = 1 << 16;
goto get3;
}
else if (u < 0xfc)
{
u &= 0x03;
+ limit = 1 << 21;
goto get4;
}
else if (u < 0xfe)
{
u &= 0x01;
+ limit = 1 << 26;
UTF8_GET_NEXT;
get4: UTF8_GET_NEXT;
get3: UTF8_GET_NEXT;
get2: UTF8_GET_NEXT;
get1: UTF8_GET_NEXT;
+ if (unlikely(u < limit))
+ goto bad;
}
else
goto bad;
*uu = u;
return (byte *)p;
+
+bad:
+ /* Incorrect byte sequence */
+ *uu = repl;
+ return (byte *)p;
}
-/* Decode a character from the basic multilingual plane [0, 0xFFFF]
- * or return UNI_REPLACEMENT if the encoding has been corrupted */
-static inline byte *
-utf8_get(const byte *p, uns *uu)
+/**
+ * Decode a value from the range `[0, 0xFFFF]` (basic multilingual plane)
+ * or return `UNI_REPLACEMENT` if the encoding has been corrupted.
+ **/
+static inline byte *utf8_get(const byte *p, uint *uu)
{
return utf8_get_repl(p, uu, UNI_REPLACEMENT);
}
-/* Decode a value from the range [0, 0x7FFFFFFF]
- * or return UNI_REPLACEMENT if the encoding has been corrupted */
-static inline byte *
-utf8_32_get(const byte *p, uns *uu)
+/**
+ * Decode a value from the range `[0, 0x7FFFFFFF]`
+ * or return `UNI_REPLACEMENT` if the encoding has been corrupted.
+ **/
+static inline byte *utf8_32_get(const byte *p, uint *uu)
{
return utf8_32_get_repl(p, uu, UNI_REPLACEMENT);
}
#define UTF8_SKIP(p) do { \
- uns c = *p++; \
+ uint c = *p++; \
if (c >= 0xc0) \
while (c & 0x40 && *p >= 0x80 && *p < 0xc0) \
p++, c <<= 1; \
#define UTF8_SKIP_BWD(p) while ((*--(p) & 0xc0) == 0x80)
-static inline uns
-utf8_space(uns u)
+/**
+ * Return the number of bytes needed to encode a given value from the range `[0, 0x7FFFFFFF]` to UTF-8.
+ **/
+static inline uint utf8_space(uint u)
{
if (u < 0x80)
return 1;
return 6;
}
-static inline uns
-utf8_encoding_len(uns c)
+/**
+ * Compute the length of a single UTF-8 character from its first byte. The encoding must be valid.
+ **/
+static inline uint utf8_encoding_len(uint c)
{
if (c < 0x80)
return 1;
return 6;
}
-/* Encode a character from the range [0, 0xD7FF] or [0xE000,0x11FFFF];
- * up to 4 bytes needed */
-static inline void *
-utf16_le_put(void *p, uns u)
+/** Maximum number of bytes an UTF-8 character can have. **/
+#define UTF8_MAX_LEN 6
+
+/**
+ * Encode an UTF-16LE character from the range `[0, 0xD7FF]` or `[0xE000,0x11FFFF]`;
+ * up to 4 bytes needed.
+ **/
+static inline void *utf16_le_put(void *p, uint u)
{
if (u < 0xd800 || (u < 0x10000 && u >= 0xe000))
{
ASSERT(0);
}
-static inline void *
-utf16_be_put(void *p, uns u)
+/**
+ * Encode a UTF-16BE character from the range `[0, 0xD7FF]` or `[0xE000,0x11FFFF]`;
+ * up to 4 bytes needed.
+ **/
+static inline void *utf16_be_put(void *p, uint u)
{
if (u < 0xd800 || (u < 0x10000 && u >= 0xe000))
{
ASSERT(0);
}
-/* Decode a character from the range [0, 0xD7FF] or [0xE000,11FFFF]
- * or return `repl' if the encoding has been corrupted */
-static inline void *
-utf16_le_get_repl(const void *p, uns *uu, uns repl)
+/**
+ * Decode a UTF-16LE character from the range `[0, 0xD7FF]` or `[0xE000,11FFFF]`
+ * or return @repl if the encoding has been corrupted.
+ **/
+static inline void *utf16_le_get_repl(const void *p, uint *uu, uint repl)
{
- uns u = get_u16_le(p), x, y;
+ uint u = get_u16_le(p), x, y;
x = u - 0xd800;
if (x < 0x800)
if (x < 0x400 && (y = get_u16_le(p + 2) - 0xdc00) < 0x400)
return (void *)(p + 2);
}
-static inline void *
-utf16_be_get_repl(const void *p, uns *uu, uns repl)
+/**
+ * Decode a UTF-16BE character from the range `[0, 0xD7FF]` or `[0xE000,11FFFF]`
+ * or return @repl if the encoding has been corrupted.
+ **/
+static inline void *utf16_be_get_repl(const void *p, uint *uu, uint repl)
{
- uns u = get_u16_be(p), x, y;
+ uint u = get_u16_be(p), x, y;
x = u - 0xd800;
if (x < 0x800)
if (x < 0x400 && (y = get_u16_be(p + 2) - 0xdc00) < 0x400)
return (void *)(p + 2);
}
-/* Decode a character from the range [0, 0xD7FF] or [0xE000,11FFFF]
- * or return UNI_REPLACEMENT if the encoding has been corrupted */
-static inline void *
-utf16_le_get(const void *p, uns *uu)
+/**
+ * Decode a UTF-16LE character from the range `[0, 0xD7FF]` or `[0xE000,11FFFF]`
+ * or return `UNI_REPLACEMENT` if the encoding has been corrupted.
+ **/
+static inline void *utf16_le_get(const void *p, uint *uu)
{
return utf16_le_get_repl(p, uu, UNI_REPLACEMENT);
}
-static inline void *
-utf16_be_get(const void *p, uns *uu)
+/**
+ * Decode a UTF-16BE character from the range `[0, 0xD7FF]` or `[0xE000,11FFFF]`
+ * or return `UNI_REPLACEMENT` if the encoding has been corrupted.
+ **/
+static inline void *utf16_be_get(const void *p, uint *uu)
{
return utf16_be_get_repl(p, uu, UNI_REPLACEMENT);
}
-static inline uns
-unicode_sanitize_char(uns u)
+/**
+ * Basic sanity check on Unicode characters. Return `UNI_REPLACEMENT` if the input
+ * character is a surrogate, ASCII or Latin-1 control character different from the tab,
+ * or if it lies outside the basic plane. In all other cases, it acts as an identity.
+ **/
+static inline uint unicode_sanitize_char(uint u)
{
if (u >= 0x10000 || // We don't accept anything outside the basic plane
- u >= 0xd800 && u < 0xf900 || // neither we do surrogates
+ u >= 0xd800 && u < 0xf900 || // neither we do surrogates and private use characters
u >= 0x80 && u < 0xa0 || // nor latin-1 control chars
u < 0x20 && u != '\t')
return UNI_REPLACEMENT;
/* unicode-utf8.c */
-uns utf8_strlen(const byte *str);
-uns utf8_strnlen(const byte *str, uns n);
+/**
+ * Count the number of Unicode characters in a zero-terminated UTF-8 string.
+ * Returned value for corrupted encoding is undefined, but is never greater than strlen().
+ **/
+size_t utf8_strlen(const byte *str);
+
+/**
+ * Same as @utf8_strlen(), but returns at most @n characters.
+ **/
+size_t utf8_strnlen(const byte *str, size_t n);
#endif