1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_LIBDEXFILE_DEX_UTF_INL_H_
#define ART_LIBDEXFILE_DEX_UTF_INL_H_
#include "utf.h"
namespace art {
inline uint16_t GetTrailingUtf16Char(uint32_t maybe_pair) {
return static_cast<uint16_t>(maybe_pair >> 16);
}
inline uint16_t GetLeadingUtf16Char(uint32_t maybe_pair) {
return static_cast<uint16_t>(maybe_pair & 0x0000FFFF);
}
inline uint32_t GetUtf16FromUtf8(const char** utf8_data_in) {
const uint8_t one = *(*utf8_data_in)++;
if ((one & 0x80) == 0) {
// one-byte encoding
return one;
}
const uint8_t two = *(*utf8_data_in)++;
if ((one & 0x20) == 0) {
// two-byte encoding
return ((one & 0x1f) << 6) | (two & 0x3f);
}
const uint8_t three = *(*utf8_data_in)++;
if ((one & 0x10) == 0) {
return ((one & 0x0f) << 12) | ((two & 0x3f) << 6) | (three & 0x3f);
}
// Four byte encodings need special handling. We'll have
// to convert them into a surrogate pair.
const uint8_t four = *(*utf8_data_in)++;
// Since this is a 4 byte UTF-8 sequence, it will lie between
// U+10000 and U+1FFFFF.
//
// TODO: What do we do about values in (U+10FFFF, U+1FFFFF) ? The
// spec says they're invalid but nobody appears to check for them.
const uint32_t code_point = ((one & 0x0f) << 18) | ((two & 0x3f) << 12)
| ((three & 0x3f) << 6) | (four & 0x3f);
uint32_t surrogate_pair = 0;
// Step two: Write out the high (leading) surrogate to the bottom 16 bits
// of the of the 32 bit type.
surrogate_pair |= ((code_point >> 10) + 0xd7c0) & 0xffff;
// Step three : Write out the low (trailing) surrogate to the top 16 bits.
surrogate_pair |= ((code_point & 0x03ff) + 0xdc00) << 16;
return surrogate_pair;
}
inline int CompareModifiedUtf8ToModifiedUtf8AsUtf16CodePointValues(const char* utf8_1,
const char* utf8_2) {
uint32_t c1, c2;
do {
c1 = *utf8_1;
c2 = *utf8_2;
// Did we reach a terminating character?
if (c1 == 0) {
return (c2 == 0) ? 0 : -1;
} else if (c2 == 0) {
return 1;
}
c1 = GetUtf16FromUtf8(&utf8_1);
c2 = GetUtf16FromUtf8(&utf8_2);
} while (c1 == c2);
const uint32_t leading_surrogate_diff = GetLeadingUtf16Char(c1) - GetLeadingUtf16Char(c2);
if (leading_surrogate_diff != 0) {
return static_cast<int>(leading_surrogate_diff);
}
return GetTrailingUtf16Char(c1) - GetTrailingUtf16Char(c2);
}
template <bool kUseShortZero, bool kUse4ByteSequence, bool kReplaceBadSurrogates, typename Append>
inline void ConvertUtf16ToUtf8(const uint16_t* utf16, size_t char_count, Append&& append) {
static_assert(kUse4ByteSequence || !kReplaceBadSurrogates);
// Use local helpers instead of macros from `libicu` to avoid the dependency on `libicu`.
auto is_lead = [](uint16_t ch) ALWAYS_INLINE { return (ch & 0xfc00u) == 0xd800u; };
auto is_trail = [](uint16_t ch) ALWAYS_INLINE { return (ch & 0xfc00u) == 0xdc00u; };
auto is_surrogate = [](uint16_t ch) ALWAYS_INLINE { return (ch & 0xf800u) == 0xd800u; };
auto is_surrogate_lead = [](uint16_t ch) ALWAYS_INLINE { return (ch & 0x0400u) == 0u; };
auto get_supplementary = [](uint16_t lead, uint16_t trail) ALWAYS_INLINE {
constexpr uint32_t offset = (0xd800u << 10) + 0xdc00u - 0x10000u;
return (static_cast<uint32_t>(lead) << 10) + static_cast<uint32_t>(trail) - offset;
};
for (size_t i = 0u; i < char_count; ++i) {
auto has_trail = [&]() { return i + 1u != char_count && is_trail(utf16[i + 1u]); };
uint16_t ch = utf16[i];
if (ch < 0x80u && (kUseShortZero || ch != 0u)) {
// One byte.
append(ch);
} else if (ch < 0x800u) {
// Two bytes.
append((ch >> 6) | 0xc0);
append((ch & 0x3f) | 0x80);
} else if (kReplaceBadSurrogates
? is_surrogate(ch)
: kUse4ByteSequence && is_lead(ch) && has_trail()) {
if (kReplaceBadSurrogates && (!is_surrogate_lead(ch) || !has_trail())) {
append('?');
} else {
// We have a *valid* surrogate pair.
uint32_t code_point = get_supplementary(ch, utf16[i + 1u]);
++i; // Consume the leading surrogate.
// Four bytes.
append((code_point >> 18) | 0xf0);
append(((code_point >> 12) & 0x3f) | 0x80);
append(((code_point >> 6) & 0x3f) | 0x80);
append((code_point & 0x3f) | 0x80);
}
} else {
// Three bytes.
append((ch >> 12) | 0xe0);
append(((ch >> 6) & 0x3f) | 0x80);
append((ch & 0x3f) | 0x80);
}
}
}
} // namespace art
#endif // ART_LIBDEXFILE_DEX_UTF_INL_H_
|
