blob: 3d13c3e492eafed173612b3add7812e1f0559c11 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Elliott Hughes814e4032011-08-23 12:07:56 -070016
17#include "utf.h"
18
Elliott Hughes07ed66b2012-12-12 18:34:25 -080019#include "base/logging.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080020#include "mirror/array.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070021#include "mirror/object-inl.h"
Ian Rogersa6724902013-09-23 09:23:37 -070022#include "utf-inl.h"
Elliott Hughesb465ab02011-08-24 11:21:21 -070023
Elliott Hughes814e4032011-08-23 12:07:56 -070024namespace art {
25
26size_t CountModifiedUtf8Chars(const char* utf8) {
27 size_t len = 0;
28 int ic;
29 while ((ic = *utf8++) != '\0') {
30 len++;
31 if ((ic & 0x80) == 0) {
32 // one-byte encoding
33 continue;
34 }
35 // two- or three-byte encoding
36 utf8++;
37 if ((ic & 0x20) == 0) {
38 // two-byte encoding
39 continue;
40 }
Elliott Hughes814e4032011-08-23 12:07:56 -070041 utf8++;
Narayan Kamatha5afcfc2015-01-29 20:06:46 +000042 if ((ic & 0x10) == 0) {
43 // three-byte encoding
44 continue;
45 }
46
47 // four-byte encoding: needs to be converted into a surrogate
48 // pair.
49 utf8++;
50 len++;
Elliott Hughes814e4032011-08-23 12:07:56 -070051 }
52 return len;
53}
54
55void ConvertModifiedUtf8ToUtf16(uint16_t* utf16_data_out, const char* utf8_data_in) {
56 while (*utf8_data_in != '\0') {
Narayan Kamatha5afcfc2015-01-29 20:06:46 +000057 const uint32_t ch = GetUtf16FromUtf8(&utf8_data_in);
58 const uint16_t leading = GetLeadingUtf16Char(ch);
59 const uint16_t trailing = GetTrailingUtf16Char(ch);
60
61 *utf16_data_out++ = leading;
62 if (trailing != 0) {
63 *utf16_data_out++ = trailing;
64 }
Elliott Hughes814e4032011-08-23 12:07:56 -070065 }
66}
67
Elliott Hughesb465ab02011-08-24 11:21:21 -070068void ConvertUtf16ToModifiedUtf8(char* utf8_out, const uint16_t* utf16_in, size_t char_count) {
69 while (char_count--) {
Narayan Kamathe16dad12015-02-13 11:49:22 +000070 const uint16_t ch = *utf16_in++;
Elliott Hughesb465ab02011-08-24 11:21:21 -070071 if (ch > 0 && ch <= 0x7f) {
72 *utf8_out++ = ch;
73 } else {
Narayan Kamathe16dad12015-02-13 11:49:22 +000074 // char_count == 0 here implies we've encountered an unpaired
75 // surrogate and we have no choice but to encode it as 3-byte UTF
76 // sequence. Note that unpaired surrogates can occur as a part of
77 // "normal" operation.
78 if ((ch >= 0xd800 && ch <= 0xdbff) && (char_count > 0)) {
79 const uint16_t ch2 = *utf16_in;
80
81 // Check if the other half of the pair is within the expected
82 // range. If it isn't, we will have to emit both "halves" as
83 // separate 3 byte sequences.
84 if (ch2 >= 0xdc00 && ch2 <= 0xdfff) {
85 utf16_in++;
86 char_count--;
87 const uint32_t code_point = (ch << 10) + ch2 - 0x035fdc00;
88 *utf8_out++ = (code_point >> 18) | 0xf0;
89 *utf8_out++ = ((code_point >> 12) & 0x3f) | 0x80;
90 *utf8_out++ = ((code_point >> 6) & 0x3f) | 0x80;
91 *utf8_out++ = (code_point & 0x3f) | 0x80;
92 continue;
93 }
94 }
95
Elliott Hughesb465ab02011-08-24 11:21:21 -070096 if (ch > 0x07ff) {
Narayan Kamathe16dad12015-02-13 11:49:22 +000097 // Three byte encoding.
Elliott Hughesb465ab02011-08-24 11:21:21 -070098 *utf8_out++ = (ch >> 12) | 0xe0;
99 *utf8_out++ = ((ch >> 6) & 0x3f) | 0x80;
100 *utf8_out++ = (ch & 0x3f) | 0x80;
101 } else /*(ch > 0x7f || ch == 0)*/ {
Narayan Kamathe16dad12015-02-13 11:49:22 +0000102 // Two byte encoding.
Elliott Hughesb465ab02011-08-24 11:21:21 -0700103 *utf8_out++ = (ch >> 6) | 0xc0;
104 *utf8_out++ = (ch & 0x3f) | 0x80;
105 }
106 }
107 }
108}
109
Ian Rogersef7d42f2014-01-06 12:55:46 -0800110int32_t ComputeUtf16Hash(mirror::CharArray* chars, int32_t offset,
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700111 size_t char_count) {
Ian Rogers8f41dc32014-10-30 15:16:16 -0700112 uint32_t hash = 0;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700113 for (size_t i = 0; i < char_count; i++) {
114 hash = hash * 31 + chars->Get(offset + i);
115 }
Ian Rogers8f41dc32014-10-30 15:16:16 -0700116 return static_cast<int32_t>(hash);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700117}
118
Elliott Hughes814e4032011-08-23 12:07:56 -0700119int32_t ComputeUtf16Hash(const uint16_t* chars, size_t char_count) {
Ian Rogers8f41dc32014-10-30 15:16:16 -0700120 uint32_t hash = 0;
Elliott Hughes814e4032011-08-23 12:07:56 -0700121 while (char_count--) {
122 hash = hash * 31 + *chars++;
123 }
Ian Rogers8f41dc32014-10-30 15:16:16 -0700124 return static_cast<int32_t>(hash);
Elliott Hughes814e4032011-08-23 12:07:56 -0700125}
126
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -0800127size_t ComputeModifiedUtf8Hash(const char* chars) {
128 size_t hash = 0;
Ian Rogers68b56852014-08-29 20:19:11 -0700129 while (*chars != '\0') {
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -0800130 hash = hash * 31 + *chars++;
Ian Rogers68b56852014-08-29 20:19:11 -0700131 }
Ian Rogers8f41dc32014-10-30 15:16:16 -0700132 return static_cast<int32_t>(hash);
Ian Rogers68b56852014-08-29 20:19:11 -0700133}
134
Vladimir Markoa48aef42014-12-03 17:53:53 +0000135int CompareModifiedUtf8ToUtf16AsCodePointValues(const char* utf8, const uint16_t* utf16,
136 size_t utf16_length) {
Ian Rogers637c65b2013-05-31 11:46:00 -0700137 for (;;) {
Vladimir Markoa48aef42014-12-03 17:53:53 +0000138 if (*utf8 == '\0') {
139 return (utf16_length == 0) ? 0 : -1;
140 } else if (utf16_length == 0) {
Ian Rogers637c65b2013-05-31 11:46:00 -0700141 return 1;
142 }
143
Narayan Kamatha5afcfc2015-01-29 20:06:46 +0000144 const uint32_t pair = GetUtf16FromUtf8(&utf8);
Ian Rogers637c65b2013-05-31 11:46:00 -0700145
Narayan Kamatha5afcfc2015-01-29 20:06:46 +0000146 // First compare the leading utf16 char.
147 const uint16_t lhs = GetLeadingUtf16Char(pair);
148 const uint16_t rhs = *utf16++;
149 --utf16_length;
150 if (lhs != rhs) {
151 return lhs > rhs ? 1 : -1;
152 }
153
154 // Then compare the trailing utf16 char. First check if there
155 // are any characters left to consume.
156 const uint16_t lhs2 = GetTrailingUtf16Char(pair);
157 if (lhs2 != 0) {
158 if (utf16_length == 0) {
159 return 1;
160 }
161
162 const uint16_t rhs2 = *utf16++;
163 --utf16_length;
164 if (lhs2 != rhs2) {
165 return lhs2 > rhs2 ? 1 : -1;
166 }
Ian Rogers637c65b2013-05-31 11:46:00 -0700167 }
168 }
169}
170
Elliott Hughes814e4032011-08-23 12:07:56 -0700171size_t CountUtf8Bytes(const uint16_t* chars, size_t char_count) {
172 size_t result = 0;
173 while (char_count--) {
Narayan Kamathe16dad12015-02-13 11:49:22 +0000174 const uint16_t ch = *chars++;
Elliott Hughes814e4032011-08-23 12:07:56 -0700175 if (ch > 0 && ch <= 0x7f) {
176 ++result;
Narayan Kamathe16dad12015-02-13 11:49:22 +0000177 } else if (ch >= 0xd800 && ch <= 0xdbff) {
178 if (char_count > 0) {
179 const uint16_t ch2 = *chars;
180 // If we find a properly paired surrogate, we emit it as a 4 byte
181 // UTF sequence. If we find an unpaired leading or trailing surrogate,
182 // we emit it as a 3 byte sequence like would have done earlier.
183 if (ch2 >= 0xdc00 && ch2 <= 0xdfff) {
184 chars++;
185 char_count--;
186
187 result += 4;
188 } else {
189 result += 3;
190 }
Elliott Hughes814e4032011-08-23 12:07:56 -0700191 } else {
Narayan Kamathe16dad12015-02-13 11:49:22 +0000192 // This implies we found an unpaired trailing surrogate at the end
193 // of a string.
194 result += 3;
Elliott Hughes814e4032011-08-23 12:07:56 -0700195 }
Narayan Kamathe16dad12015-02-13 11:49:22 +0000196 } else if (ch > 0x7ff) {
197 result += 3;
198 } else {
199 result += 2;
Elliott Hughes814e4032011-08-23 12:07:56 -0700200 }
201 }
202 return result;
203}
204
205} // namespace art