Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 1 | /* |
| 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 | */ |
| 16 | |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 17 | #include "string-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 18 | |
Andreas Gampe | 4d0589c | 2014-06-10 16:10:56 -0700 | [diff] [blame] | 19 | #include "arch/memcmp16.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 20 | #include "array.h" |
Hiroshi Yamauchi | 967a0ad | 2013-09-10 16:24:21 -0700 | [diff] [blame] | 21 | #include "class-inl.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 22 | #include "gc/accounting/card_table-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 23 | #include "intern_table.h" |
| 24 | #include "object-inl.h" |
| 25 | #include "runtime.h" |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 26 | #include "handle_scope-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 27 | #include "thread.h" |
Ian Rogers | a672490 | 2013-09-23 09:23:37 -0700 | [diff] [blame] | 28 | #include "utf-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 29 | |
| 30 | namespace art { |
| 31 | namespace mirror { |
| 32 | |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 33 | // TODO: get global references for these |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 34 | GcRoot<Class> String::java_lang_String_; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 35 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 36 | int32_t String::FastIndexOf(int32_t ch, int32_t start) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 37 | int32_t count = GetLength(); |
| 38 | if (start < 0) { |
| 39 | start = 0; |
| 40 | } else if (start > count) { |
| 41 | start = count; |
| 42 | } |
| 43 | const uint16_t* chars = GetCharArray()->GetData() + GetOffset(); |
| 44 | const uint16_t* p = chars + start; |
| 45 | const uint16_t* end = chars + count; |
| 46 | while (p < end) { |
| 47 | if (*p++ == ch) { |
| 48 | return (p - 1) - chars; |
| 49 | } |
| 50 | } |
| 51 | return -1; |
| 52 | } |
| 53 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 54 | void String::SetClass(Class* java_lang_String) { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 55 | CHECK(java_lang_String_.IsNull()); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 56 | CHECK(java_lang_String != NULL); |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 57 | java_lang_String_ = GcRoot<Class>(java_lang_String); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | void String::ResetClass() { |
Hiroshi Yamauchi | 94f7b49 | 2014-07-22 18:08:23 -0700 | [diff] [blame] | 61 | CHECK(!java_lang_String_.IsNull()); |
| 62 | java_lang_String_ = GcRoot<Class>(nullptr); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 63 | } |
| 64 | |
Mathieu Chartier | cdfd39f | 2014-08-29 18:16:58 -0700 | [diff] [blame] | 65 | int32_t String::ComputeHashCode() { |
| 66 | const int32_t hash_code = ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength()); |
| 67 | SetHashCode(hash_code); |
| 68 | return hash_code; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 69 | } |
| 70 | |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 71 | int32_t String::GetUtfLength() { |
| 72 | return CountUtf8Bytes(GetCharArray()->GetData() + GetOffset(), GetLength()); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 73 | } |
| 74 | |
| 75 | String* String::AllocFromUtf16(Thread* self, |
| 76 | int32_t utf16_length, |
| 77 | const uint16_t* utf16_data_in, |
| 78 | int32_t hash_code) { |
Ian Rogers | 4069d33 | 2014-01-03 10:28:27 -0800 | [diff] [blame] | 79 | CHECK(utf16_data_in != nullptr || utf16_length == 0); |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 80 | String* string = Alloc(self, utf16_length); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 81 | if (UNLIKELY(string == nullptr)) { |
| 82 | return nullptr; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 83 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 84 | CharArray* array = const_cast<CharArray*>(string->GetCharArray()); |
Ian Rogers | 4069d33 | 2014-01-03 10:28:27 -0800 | [diff] [blame] | 85 | if (UNLIKELY(array == nullptr)) { |
| 86 | return nullptr; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 87 | } |
Ian Rogers | 4069d33 | 2014-01-03 10:28:27 -0800 | [diff] [blame] | 88 | memcpy(array->GetData(), utf16_data_in, utf16_length * sizeof(uint16_t)); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 89 | if (hash_code != 0) { |
Ian Rogers | 4069d33 | 2014-01-03 10:28:27 -0800 | [diff] [blame] | 90 | DCHECK_EQ(hash_code, ComputeUtf16Hash(utf16_data_in, utf16_length)); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 91 | string->SetHashCode(hash_code); |
| 92 | } else { |
| 93 | string->ComputeHashCode(); |
| 94 | } |
| 95 | return string; |
| 96 | } |
| 97 | |
Ian Rogers | a436fde | 2013-08-27 23:34:06 -0700 | [diff] [blame] | 98 | String* String::AllocFromModifiedUtf8(Thread* self, const char* utf) { |
Mathieu Chartier | ed0fc1d | 2014-03-21 14:09:35 -0700 | [diff] [blame] | 99 | DCHECK(utf != nullptr); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 100 | size_t char_count = CountModifiedUtf8Chars(utf); |
| 101 | return AllocFromModifiedUtf8(self, char_count, utf); |
| 102 | } |
| 103 | |
| 104 | String* String::AllocFromModifiedUtf8(Thread* self, int32_t utf16_length, |
| 105 | const char* utf8_data_in) { |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 106 | String* string = Alloc(self, utf16_length); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 107 | if (UNLIKELY(string == nullptr)) { |
| 108 | return nullptr; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 109 | } |
| 110 | uint16_t* utf16_data_out = |
| 111 | const_cast<uint16_t*>(string->GetCharArray()->GetData()); |
| 112 | ConvertModifiedUtf8ToUtf16(utf16_data_out, utf8_data_in); |
| 113 | string->ComputeHashCode(); |
| 114 | return string; |
| 115 | } |
| 116 | |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 117 | String* String::Alloc(Thread* self, int32_t utf16_length) { |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 118 | StackHandleScope<1> hs(self); |
| 119 | Handle<CharArray> array(hs.NewHandle(CharArray::Alloc(self, utf16_length))); |
| 120 | if (UNLIKELY(array.Get() == nullptr)) { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 121 | return nullptr; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 122 | } |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 123 | return Alloc(self, array); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 124 | } |
| 125 | |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 126 | String* String::Alloc(Thread* self, Handle<CharArray> array) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 127 | // Hold reference in case AllocObject causes GC. |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 128 | String* string = down_cast<String*>(GetJavaLangString()->AllocObject(self)); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 129 | if (LIKELY(string != nullptr)) { |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 130 | string->SetArray(array.Get()); |
Sebastien Hertz | ee1d79a | 2014-02-21 15:46:30 +0100 | [diff] [blame] | 131 | string->SetCount(array->GetLength()); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 132 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 133 | return string; |
| 134 | } |
| 135 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 136 | bool String::Equals(String* that) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 137 | if (this == that) { |
| 138 | // Quick reference equality test |
| 139 | return true; |
| 140 | } else if (that == NULL) { |
| 141 | // Null isn't an instanceof anything |
| 142 | return false; |
| 143 | } else if (this->GetLength() != that->GetLength()) { |
| 144 | // Quick length inequality test |
| 145 | return false; |
| 146 | } else { |
| 147 | // Note: don't short circuit on hash code as we're presumably here as the |
| 148 | // hash code was already equal |
| 149 | for (int32_t i = 0; i < that->GetLength(); ++i) { |
Narayan Kamath | a5afcfc | 2015-01-29 20:06:46 +0000 | [diff] [blame] | 150 | if (this->UncheckedCharAt(i) != that->UncheckedCharAt(i)) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 151 | return false; |
| 152 | } |
| 153 | } |
| 154 | return true; |
| 155 | } |
| 156 | } |
| 157 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 158 | bool String::Equals(const uint16_t* that_chars, int32_t that_offset, int32_t that_length) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 159 | if (this->GetLength() != that_length) { |
| 160 | return false; |
| 161 | } else { |
| 162 | for (int32_t i = 0; i < that_length; ++i) { |
Narayan Kamath | a5afcfc | 2015-01-29 20:06:46 +0000 | [diff] [blame] | 163 | if (this->UncheckedCharAt(i) != that_chars[that_offset + i]) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 164 | return false; |
| 165 | } |
| 166 | } |
| 167 | return true; |
| 168 | } |
| 169 | } |
| 170 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 171 | bool String::Equals(const char* modified_utf8) { |
Narayan Kamath | a5afcfc | 2015-01-29 20:06:46 +0000 | [diff] [blame] | 172 | const int32_t length = GetLength(); |
| 173 | int32_t i = 0; |
| 174 | while (i < length) { |
| 175 | const uint32_t ch = GetUtf16FromUtf8(&modified_utf8); |
| 176 | if (ch == '\0') { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 177 | return false; |
| 178 | } |
Narayan Kamath | a5afcfc | 2015-01-29 20:06:46 +0000 | [diff] [blame] | 179 | |
| 180 | if (GetLeadingUtf16Char(ch) != UncheckedCharAt(i++)) { |
| 181 | return false; |
| 182 | } |
| 183 | |
| 184 | const uint16_t trailing = GetTrailingUtf16Char(ch); |
| 185 | if (trailing != 0) { |
| 186 | if (i == length) { |
| 187 | return false; |
| 188 | } |
| 189 | |
| 190 | if (UncheckedCharAt(i++) != trailing) { |
| 191 | return false; |
| 192 | } |
| 193 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 194 | } |
| 195 | return *modified_utf8 == '\0'; |
| 196 | } |
| 197 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 198 | bool String::Equals(const StringPiece& modified_utf8) { |
Narayan Kamath | a5afcfc | 2015-01-29 20:06:46 +0000 | [diff] [blame] | 199 | const int32_t length = GetLength(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 200 | const char* p = modified_utf8.data(); |
Narayan Kamath | a5afcfc | 2015-01-29 20:06:46 +0000 | [diff] [blame] | 201 | for (int32_t i = 0; i < length; ++i) { |
| 202 | uint32_t ch = GetUtf16FromUtf8(&p); |
| 203 | |
| 204 | if (GetLeadingUtf16Char(ch) != UncheckedCharAt(i)) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 205 | return false; |
| 206 | } |
Narayan Kamath | a5afcfc | 2015-01-29 20:06:46 +0000 | [diff] [blame] | 207 | |
| 208 | const uint16_t trailing = GetTrailingUtf16Char(ch); |
| 209 | if (trailing != 0) { |
| 210 | if (i == (length - 1)) { |
| 211 | return false; |
| 212 | } |
| 213 | |
| 214 | if (UncheckedCharAt(++i) != trailing) { |
| 215 | return false; |
| 216 | } |
| 217 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 218 | } |
| 219 | return true; |
| 220 | } |
| 221 | |
| 222 | // Create a modified UTF-8 encoded std::string from a java/lang/String object. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 223 | std::string String::ToModifiedUtf8() { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 224 | const uint16_t* chars = GetCharArray()->GetData() + GetOffset(); |
| 225 | size_t byte_count = GetUtfLength(); |
| 226 | std::string result(byte_count, static_cast<char>(0)); |
| 227 | ConvertUtf16ToModifiedUtf8(&result[0], chars, GetLength()); |
| 228 | return result; |
| 229 | } |
| 230 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 231 | int32_t String::CompareTo(String* rhs) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 232 | // Quick test for comparison of a string with itself. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 233 | String* lhs = this; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 234 | if (lhs == rhs) { |
| 235 | return 0; |
| 236 | } |
| 237 | // TODO: is this still true? |
| 238 | // The annoying part here is that 0x00e9 - 0xffff != 0x00ea, |
| 239 | // because the interpreter converts the characters to 32-bit integers |
| 240 | // *without* sign extension before it subtracts them (which makes some |
| 241 | // sense since "char" is unsigned). So what we get is the result of |
| 242 | // 0x000000e9 - 0x0000ffff, which is 0xffff00ea. |
Andreas Gampe | 4d0589c | 2014-06-10 16:10:56 -0700 | [diff] [blame] | 243 | int32_t lhsCount = lhs->GetLength(); |
| 244 | int32_t rhsCount = rhs->GetLength(); |
| 245 | int32_t countDiff = lhsCount - rhsCount; |
| 246 | int32_t minCount = (countDiff < 0) ? lhsCount : rhsCount; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 247 | const uint16_t* lhsChars = lhs->GetCharArray()->GetData() + lhs->GetOffset(); |
| 248 | const uint16_t* rhsChars = rhs->GetCharArray()->GetData() + rhs->GetOffset(); |
Andreas Gampe | 4d0589c | 2014-06-10 16:10:56 -0700 | [diff] [blame] | 249 | int32_t otherRes = MemCmp16(lhsChars, rhsChars, minCount); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 250 | if (otherRes != 0) { |
| 251 | return otherRes; |
| 252 | } |
| 253 | return countDiff; |
| 254 | } |
| 255 | |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 256 | void String::VisitRoots(RootCallback* callback, void* arg) { |
Mathieu Chartier | e34fa1d | 2015-01-14 14:55:47 -0800 | [diff] [blame] | 257 | java_lang_String_.VisitRootIfNonNull(callback, arg, RootInfo(kRootStickyClass)); |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 258 | } |
| 259 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 260 | } // namespace mirror |
| 261 | } // namespace art |