X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fshared%2Futf8.c;h=800884ffee99c77b36c6c16f35015a70442409fa;hp=0b6c38ebbff2f90405d86704c86a459c7b0eeb78;hb=ebbac6d948b9d323b3d57bfd7c3513776e591dc1;hpb=fec8457652002fd5bff923042a7407b3810f5a7f diff --git a/src/shared/utf8.c b/src/shared/utf8.c index 0b6c38ebb..800884ffe 100644 --- a/src/shared/utf8.c +++ b/src/shared/utf8.c @@ -52,7 +52,7 @@ #include "utf8.h" #include "util.h" -static inline bool is_unicode_valid(uint32_t ch) { +bool unichar_is_valid(uint32_t ch) { if (ch >= 0x110000) /* End of unicode space */ return false; @@ -66,7 +66,7 @@ static inline bool is_unicode_valid(uint32_t ch) { return true; } -static bool is_unicode_control(uint32_t ch) { +static bool unichar_is_control(uint32_t ch) { /* 0 to ' '-1 is the C0 range. @@ -142,21 +142,21 @@ int utf8_encoded_to_unichar(const char *str) { } bool utf8_is_printable_newline(const char* str, size_t length, bool newline) { - const uint8_t *p; + const char *p; assert(str); - for (p = (const uint8_t*) str; length;) { + for (p = str; length;) { int encoded_len, val; - encoded_len = utf8_encoded_valid_unichar((const char *) p); + encoded_len = utf8_encoded_valid_unichar(p); if (encoded_len < 0 || (size_t) encoded_len > length) return false; - val = utf8_encoded_to_unichar((const char*) p); + val = utf8_encoded_to_unichar(p); if (val < 0 || - is_unicode_control(val) || + unichar_is_control(val) || (!newline && val == '\n')) return false; @@ -202,7 +202,7 @@ char *utf8_escape_invalid(const char *str) { s = mempcpy(s, str, len); str += len; } else { - s = mempcpy(s, UTF8_REPLACEMENT_CHARACTER, strlen(UTF8_REPLACEMENT_CHARACTER)); + s = stpcpy(s, UTF8_REPLACEMENT_CHARACTER); str += 1; } } @@ -230,18 +230,18 @@ char *utf8_escape_non_printable(const char *str) { s = mempcpy(s, str, len); str += len; } else { - if ((*str < ' ') || (*str >= 127)) { + while (len > 0) { *(s++) = '\\'; *(s++) = 'x'; *(s++) = hexchar((int) *str >> 4); *(s++) = hexchar((int) *str); - } else - *(s++) = *str; - str += 1; + str += 1; + len --; + } } } else { - s = mempcpy(s, UTF8_REPLACEMENT_CHARACTER, strlen(UTF8_REPLACEMENT_CHARACTER)); + s = stpcpy(s, UTF8_REPLACEMENT_CHARACTER); str += 1; } } @@ -263,39 +263,92 @@ char *ascii_is_valid(const char *str) { return (char*) str; } +/** + * utf8_encode_unichar() - Encode single UCS-4 character as UTF-8 + * @out_utf8: output buffer of at least 4 bytes or NULL + * @g: UCS-4 character to encode + * + * This encodes a single UCS-4 character as UTF-8 and writes it into @out_utf8. + * The length of the character is returned. It is not zero-terminated! If the + * output buffer is NULL, only the length is returned. + * + * Returns: The length in bytes that the UTF-8 representation does or would + * occupy. + */ +size_t utf8_encode_unichar(char *out_utf8, uint32_t g) { + + if (g < (1 << 7)) { + if (out_utf8) + out_utf8[0] = g & 0x7f; + return 1; + } else if (g < (1 << 11)) { + if (out_utf8) { + out_utf8[0] = 0xc0 | ((g >> 6) & 0x1f); + out_utf8[1] = 0x80 | (g & 0x3f); + } + return 2; + } else if (g < (1 << 16)) { + if (out_utf8) { + out_utf8[0] = 0xe0 | ((g >> 12) & 0x0f); + out_utf8[1] = 0x80 | ((g >> 6) & 0x3f); + out_utf8[2] = 0x80 | (g & 0x3f); + } + return 3; + } else if (g < (1 << 21)) { + if (out_utf8) { + out_utf8[0] = 0xf0 | ((g >> 18) & 0x07); + out_utf8[1] = 0x80 | ((g >> 12) & 0x3f); + out_utf8[2] = 0x80 | ((g >> 6) & 0x3f); + out_utf8[3] = 0x80 | (g & 0x3f); + } + return 4; + } + + return 0; +} + char *utf16_to_utf8(const void *s, size_t length) { - char *r; const uint8_t *f; - uint8_t *t; + char *r, *t; - r = new(char, (length*3+1)/2 + 1); + r = new(char, (length * 4 + 1) / 2 + 1); if (!r) return NULL; - t = (uint8_t*) r; + f = s; + t = r; - for (f = s; f < (const uint8_t*) s + length; f += 2) { - uint16_t c; + while (f < (const uint8_t*) s + length) { + uint16_t w1, w2; - c = (f[1] << 8) | f[0]; + /* see RFC 2781 section 2.2 */ - if (c == 0) { - *t = 0; - return r; - } else if (c < 0x80) { - *(t++) = (uint8_t) c; - } else if (c < 0x800) { - *(t++) = (uint8_t) (0xc0 | (c >> 6)); - *(t++) = (uint8_t) (0x80 | (c & 0x3f)); - } else { - *(t++) = (uint8_t) (0xe0 | (c >> 12)); - *(t++) = (uint8_t) (0x80 | ((c >> 6) & 0x3f)); - *(t++) = (uint8_t) (0x80 | (c & 0x3f)); + w1 = f[1] << 8 | f[0]; + f += 2; + + if (!utf16_is_surrogate(w1)) { + t += utf8_encode_unichar(t, w1); + + continue; } + + if (utf16_is_trailing_surrogate(w1)) + continue; + else if (f >= (const uint8_t*) s + length) + break; + + w2 = f[1] << 8 | f[0]; + f += 2; + + if (!utf16_is_trailing_surrogate(w2)) { + f -= 2; + continue; + } + + t += utf8_encode_unichar(t, utf16_surrogate_pair_to_unichar(w1, w2)); } *t = 0; - return r; } @@ -342,7 +395,7 @@ int utf8_encoded_valid_unichar(const char *str) { return -EINVAL; /* check if value has valid range */ - if (!is_unicode_valid(unichar)) + if (!unichar_is_valid(unichar)) return -EINVAL; return len;