123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253 |
- // Copyright 2018 Google LLC.
- // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
- #include "src/utils/SkUTF.h"
- #include <climits>
- static constexpr inline int32_t left_shift(int32_t value, int32_t shift) {
- return (int32_t) ((uint32_t) value << shift);
- }
- template <typename T> static constexpr bool is_align2(T x) { return 0 == (x & 1); }
- template <typename T> static constexpr bool is_align4(T x) { return 0 == (x & 3); }
- static constexpr inline bool utf16_is_high_surrogate(uint16_t c) { return (c & 0xFC00) == 0xD800; }
- static constexpr inline bool utf16_is_low_surrogate(uint16_t c) { return (c & 0xFC00) == 0xDC00; }
- /** @returns -1 iff invalid UTF8 byte,
- 0 iff UTF8 continuation byte,
- 1 iff ASCII byte,
- 2 iff leading byte of 2-byte sequence,
- 3 iff leading byte of 3-byte sequence, and
- 4 iff leading byte of 4-byte sequence.
- I.e.: if return value > 0, then gives length of sequence.
- */
- static int utf8_byte_type(uint8_t c) {
- if (c < 0x80) {
- return 1;
- } else if (c < 0xC0) {
- return 0;
- } else if (c >= 0xF5 || (c & 0xFE) == 0xC0) { // "octet values c0, c1, f5 to ff never appear"
- return -1;
- } else {
- int value = (((0xe5 << 24) >> ((unsigned)c >> 4 << 1)) & 3) + 1;
- // assert(value >= 2 && value <=4);
- return value;
- }
- }
- static bool utf8_type_is_valid_leading_byte(int type) { return type > 0; }
- static bool utf8_byte_is_continuation(uint8_t c) { return utf8_byte_type(c) == 0; }
- ////////////////////////////////////////////////////////////////////////////////
- int SkUTF::CountUTF8(const char* utf8, size_t byteLength) {
- if (!utf8) {
- return -1;
- }
- int count = 0;
- const char* stop = utf8 + byteLength;
- while (utf8 < stop) {
- int type = utf8_byte_type(*(const uint8_t*)utf8);
- if (!utf8_type_is_valid_leading_byte(type) || utf8 + type > stop) {
- return -1; // Sequence extends beyond end.
- }
- while(type-- > 1) {
- ++utf8;
- if (!utf8_byte_is_continuation(*(const uint8_t*)utf8)) {
- return -1;
- }
- }
- ++utf8;
- ++count;
- }
- return count;
- }
- int SkUTF::CountUTF16(const uint16_t* utf16, size_t byteLength) {
- if (!utf16 || !is_align2(intptr_t(utf16)) || !is_align2(byteLength)) {
- return -1;
- }
- const uint16_t* src = (const uint16_t*)utf16;
- const uint16_t* stop = src + (byteLength >> 1);
- int count = 0;
- while (src < stop) {
- unsigned c = *src++;
- if (utf16_is_low_surrogate(c)) {
- return -1;
- }
- if (utf16_is_high_surrogate(c)) {
- if (src >= stop) {
- return -1;
- }
- c = *src++;
- if (!utf16_is_low_surrogate(c)) {
- return -1;
- }
- }
- count += 1;
- }
- return count;
- }
- int SkUTF::CountUTF32(const int32_t* utf32, size_t byteLength) {
- if (!is_align4(intptr_t(utf32)) || !is_align4(byteLength) || byteLength >> 2 > INT_MAX) {
- return -1;
- }
- const uint32_t kInvalidUnicharMask = 0xFF000000; // unichar fits in 24 bits
- const uint32_t* ptr = (const uint32_t*)utf32;
- const uint32_t* stop = ptr + (byteLength >> 2);
- while (ptr < stop) {
- if (*ptr & kInvalidUnicharMask) {
- return -1;
- }
- ptr += 1;
- }
- return (int)(byteLength >> 2);
- }
- template <typename T>
- static SkUnichar next_fail(const T** ptr, const T* end) {
- *ptr = end;
- return -1;
- }
- SkUnichar SkUTF::NextUTF8(const char** ptr, const char* end) {
- if (!ptr || !end ) {
- return -1;
- }
- const uint8_t* p = (const uint8_t*)*ptr;
- if (!p || p >= (const uint8_t*)end) {
- return next_fail(ptr, end);
- }
- int c = *p;
- int hic = c << 24;
- if (!utf8_type_is_valid_leading_byte(utf8_byte_type(c))) {
- return next_fail(ptr, end);
- }
- if (hic < 0) {
- uint32_t mask = (uint32_t)~0x3F;
- hic = left_shift(hic, 1);
- do {
- ++p;
- if (p >= (const uint8_t*)end) {
- return next_fail(ptr, end);
- }
- // check before reading off end of array.
- uint8_t nextByte = *p;
- if (!utf8_byte_is_continuation(nextByte)) {
- return next_fail(ptr, end);
- }
- c = (c << 6) | (nextByte & 0x3F);
- mask <<= 5;
- } while ((hic = left_shift(hic, 1)) < 0);
- c &= ~mask;
- }
- *ptr = (char*)p + 1;
- return c;
- }
- SkUnichar SkUTF::NextUTF16(const uint16_t** ptr, const uint16_t* end) {
- if (!ptr || !end ) {
- return -1;
- }
- const uint16_t* src = *ptr;
- if (!src || src + 1 > end || !is_align2(intptr_t(src))) {
- return next_fail(ptr, end);
- }
- uint16_t c = *src++;
- SkUnichar result = c;
- if (utf16_is_low_surrogate(c)) {
- return next_fail(ptr, end); // srcPtr should never point at low surrogate.
- }
- if (utf16_is_high_surrogate(c)) {
- if (src + 1 > end) {
- return next_fail(ptr, end); // Truncated string.
- }
- uint16_t low = *src++;
- if (!utf16_is_low_surrogate(low)) {
- return next_fail(ptr, end);
- }
- /*
- [paraphrased from wikipedia]
- Take the high surrogate and subtract 0xD800, then multiply by 0x400.
- Take the low surrogate and subtract 0xDC00. Add these two results
- together, and finally add 0x10000 to get the final decoded codepoint.
- unicode = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000
- unicode = (high * 0x400) - (0xD800 * 0x400) + low - 0xDC00 + 0x10000
- unicode = (high << 10) - (0xD800 << 10) + low - 0xDC00 + 0x10000
- unicode = (high << 10) + low - ((0xD800 << 10) + 0xDC00 - 0x10000)
- */
- result = (result << 10) + (SkUnichar)low - ((0xD800 << 10) + 0xDC00 - 0x10000);
- }
- *ptr = src;
- return result;
- }
- SkUnichar SkUTF::NextUTF32(const int32_t** ptr, const int32_t* end) {
- if (!ptr || !end ) {
- return -1;
- }
- const int32_t* s = *ptr;
- if (!s || s + 1 > end || !is_align4(intptr_t(s))) {
- return next_fail(ptr, end);
- }
- int32_t value = *s;
- const uint32_t kInvalidUnicharMask = 0xFF000000; // unichar fits in 24 bits
- if (value & kInvalidUnicharMask) {
- return next_fail(ptr, end);
- }
- *ptr = s + 1;
- return value;
- }
- size_t SkUTF::ToUTF8(SkUnichar uni, char utf8[SkUTF::kMaxBytesInUTF8Sequence]) {
- if ((uint32_t)uni > 0x10FFFF) {
- return 0;
- }
- if (uni <= 127) {
- if (utf8) {
- *utf8 = (char)uni;
- }
- return 1;
- }
- char tmp[4];
- char* p = tmp;
- size_t count = 1;
- while (uni > 0x7F >> count) {
- *p++ = (char)(0x80 | (uni & 0x3F));
- uni >>= 6;
- count += 1;
- }
- if (utf8) {
- p = tmp;
- utf8 += count;
- while (p < tmp + count - 1) {
- *--utf8 = *p++;
- }
- *--utf8 = (char)(~(0xFF >> count) | uni);
- }
- return count;
- }
- size_t SkUTF::ToUTF16(SkUnichar uni, uint16_t utf16[2]) {
- if ((uint32_t)uni > 0x10FFFF) {
- return 0;
- }
- int extra = (uni > 0xFFFF);
- if (utf16) {
- if (extra) {
- utf16[0] = (uint16_t)((0xD800 - 64) + (uni >> 10));
- utf16[1] = (uint16_t)(0xDC00 | (uni & 0x3FF));
- } else {
- utf16[0] = (uint16_t)uni;
- }
- }
- return 1 + extra;
- }
|