string.cc revision 590fee9e8972f872301c2d16a575d579ee564bee
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 17#include "string.h" 18 19#include "array.h" 20#include "class-inl.h" 21#include "gc/accounting/card_table-inl.h" 22#include "intern_table.h" 23#include "object-inl.h" 24#include "runtime.h" 25#include "sirt_ref.h" 26#include "thread.h" 27#include "utf-inl.h" 28 29namespace art { 30namespace mirror { 31 32const CharArray* String::GetCharArray() const { 33 return GetFieldObject<const CharArray*>(ValueOffset(), false); 34} 35 36CharArray* String::GetCharArray() { 37 return GetFieldObject<CharArray*>(ValueOffset(), false); 38} 39 40void String::ComputeHashCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 41 SetHashCode(ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength())); 42} 43 44int32_t String::GetUtfLength() const { 45 return CountUtf8Bytes(GetCharArray()->GetData() + GetOffset(), GetLength()); 46} 47 48int32_t String::FastIndexOf(int32_t ch, int32_t start) const { 49 int32_t count = GetLength(); 50 if (start < 0) { 51 start = 0; 52 } else if (start > count) { 53 start = count; 54 } 55 const uint16_t* chars = GetCharArray()->GetData() + GetOffset(); 56 const uint16_t* p = chars + start; 57 const uint16_t* end = chars + count; 58 while (p < end) { 59 if (*p++ == ch) { 60 return (p - 1) - chars; 61 } 62 } 63 return -1; 64} 65 66void String::SetArray(CharArray* new_array) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 67 DCHECK(new_array != NULL); 68 SetFieldObject(OFFSET_OF_OBJECT_MEMBER(String, array_), new_array, false); 69} 70 71// TODO: get global references for these 72Class* String::java_lang_String_ = NULL; 73 74void String::SetClass(Class* java_lang_String) { 75 CHECK(java_lang_String_ == NULL); 76 CHECK(java_lang_String != NULL); 77 java_lang_String_ = java_lang_String; 78} 79 80void String::ResetClass() { 81 CHECK(java_lang_String_ != NULL); 82 java_lang_String_ = NULL; 83} 84 85String* String::Intern() { 86 return Runtime::Current()->GetInternTable()->InternWeak(this); 87} 88 89int32_t String::GetHashCode() { 90 int32_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false); 91 if (result == 0) { 92 ComputeHashCode(); 93 } 94 result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false); 95 DCHECK(result != 0 || ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength()) == 0) 96 << ToModifiedUtf8() << " " << result; 97 return result; 98} 99 100int32_t String::GetLength() const { 101 int32_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, count_), false); 102 DCHECK(result >= 0 && result <= GetCharArray()->GetLength()); 103 return result; 104} 105 106uint16_t String::CharAt(int32_t index) const { 107 // TODO: do we need this? Equals is the only caller, and could 108 // bounds check itself. 109 DCHECK_GE(count_, 0); // ensures the unsigned comparison is safe. 110 if (UNLIKELY(static_cast<uint32_t>(index) >= static_cast<uint32_t>(count_))) { 111 Thread* self = Thread::Current(); 112 ThrowLocation throw_location = self->GetCurrentLocationForThrow(); 113 self->ThrowNewExceptionF(throw_location, "Ljava/lang/StringIndexOutOfBoundsException;", 114 "length=%i; index=%i", count_, index); 115 return 0; 116 } 117 return GetCharArray()->Get(index + GetOffset()); 118} 119 120String* String::AllocFromUtf16(Thread* self, 121 int32_t utf16_length, 122 const uint16_t* utf16_data_in, 123 int32_t hash_code) { 124 CHECK(utf16_data_in != NULL || utf16_length == 0); 125 String* string = Alloc(self, GetJavaLangString(), utf16_length); 126 if (UNLIKELY(string == nullptr)) { 127 return nullptr; 128 } 129 // TODO: use 16-bit wide memset variant 130 CharArray* array = const_cast<CharArray*>(string->GetCharArray()); 131 if (array == NULL) { 132 return NULL; 133 } 134 for (int i = 0; i < utf16_length; i++) { 135 array->Set(i, utf16_data_in[i]); 136 } 137 if (hash_code != 0) { 138 string->SetHashCode(hash_code); 139 } else { 140 string->ComputeHashCode(); 141 } 142 return string; 143} 144 145String* String::AllocFromModifiedUtf8(Thread* self, const char* utf) { 146 if (UNLIKELY(utf == nullptr)) { 147 return nullptr; 148 } 149 size_t char_count = CountModifiedUtf8Chars(utf); 150 return AllocFromModifiedUtf8(self, char_count, utf); 151} 152 153String* String::AllocFromModifiedUtf8(Thread* self, int32_t utf16_length, 154 const char* utf8_data_in) { 155 String* string = Alloc(self, GetJavaLangString(), utf16_length); 156 if (UNLIKELY(string == nullptr)) { 157 return nullptr; 158 } 159 uint16_t* utf16_data_out = 160 const_cast<uint16_t*>(string->GetCharArray()->GetData()); 161 ConvertModifiedUtf8ToUtf16(utf16_data_out, utf8_data_in); 162 string->ComputeHashCode(); 163 return string; 164} 165 166String* String::Alloc(Thread* self, Class* java_lang_String, int32_t utf16_length) { 167 CharArray* array = CharArray::Alloc(self, utf16_length); 168 if (UNLIKELY(array == nullptr)) { 169 return nullptr; 170 } 171 return Alloc(self, java_lang_String, array); 172} 173 174String* String::Alloc(Thread* self, Class* java_lang_String, CharArray* array) { 175 // Hold reference in case AllocObject causes GC. 176 SirtRef<CharArray> array_ref(self, array); 177 String* string = down_cast<String*>(java_lang_String->AllocObject(self)); 178 if (LIKELY(string != nullptr)) { 179 string->SetArray(array_ref.get()); 180 string->SetCount(array_ref->GetLength()); 181 } 182 return string; 183} 184 185bool String::Equals(const String* that) const { 186 if (this == that) { 187 // Quick reference equality test 188 return true; 189 } else if (that == NULL) { 190 // Null isn't an instanceof anything 191 return false; 192 } else if (this->GetLength() != that->GetLength()) { 193 // Quick length inequality test 194 return false; 195 } else { 196 // Note: don't short circuit on hash code as we're presumably here as the 197 // hash code was already equal 198 for (int32_t i = 0; i < that->GetLength(); ++i) { 199 if (this->CharAt(i) != that->CharAt(i)) { 200 return false; 201 } 202 } 203 return true; 204 } 205} 206 207bool String::Equals(const uint16_t* that_chars, int32_t that_offset, int32_t that_length) const { 208 if (this->GetLength() != that_length) { 209 return false; 210 } else { 211 for (int32_t i = 0; i < that_length; ++i) { 212 if (this->CharAt(i) != that_chars[that_offset + i]) { 213 return false; 214 } 215 } 216 return true; 217 } 218} 219 220bool String::Equals(const char* modified_utf8) const { 221 for (int32_t i = 0; i < GetLength(); ++i) { 222 uint16_t ch = GetUtf16FromUtf8(&modified_utf8); 223 if (ch == '\0' || ch != CharAt(i)) { 224 return false; 225 } 226 } 227 return *modified_utf8 == '\0'; 228} 229 230bool String::Equals(const StringPiece& modified_utf8) const { 231 const char* p = modified_utf8.data(); 232 for (int32_t i = 0; i < GetLength(); ++i) { 233 uint16_t ch = GetUtf16FromUtf8(&p); 234 if (ch != CharAt(i)) { 235 return false; 236 } 237 } 238 return true; 239} 240 241// Create a modified UTF-8 encoded std::string from a java/lang/String object. 242std::string String::ToModifiedUtf8() const { 243 const uint16_t* chars = GetCharArray()->GetData() + GetOffset(); 244 size_t byte_count = GetUtfLength(); 245 std::string result(byte_count, static_cast<char>(0)); 246 ConvertUtf16ToModifiedUtf8(&result[0], chars, GetLength()); 247 return result; 248} 249 250#ifdef HAVE__MEMCMP16 251// "count" is in 16-bit units. 252extern "C" uint32_t __memcmp16(const uint16_t* s0, const uint16_t* s1, size_t count); 253#define MemCmp16 __memcmp16 254#else 255static uint32_t MemCmp16(const uint16_t* s0, const uint16_t* s1, size_t count) { 256 for (size_t i = 0; i < count; i++) { 257 if (s0[i] != s1[i]) { 258 return static_cast<int32_t>(s0[i]) - static_cast<int32_t>(s1[i]); 259 } 260 } 261 return 0; 262} 263#endif 264 265int32_t String::CompareTo(String* rhs) const { 266 // Quick test for comparison of a string with itself. 267 const String* lhs = this; 268 if (lhs == rhs) { 269 return 0; 270 } 271 // TODO: is this still true? 272 // The annoying part here is that 0x00e9 - 0xffff != 0x00ea, 273 // because the interpreter converts the characters to 32-bit integers 274 // *without* sign extension before it subtracts them (which makes some 275 // sense since "char" is unsigned). So what we get is the result of 276 // 0x000000e9 - 0x0000ffff, which is 0xffff00ea. 277 int lhsCount = lhs->GetLength(); 278 int rhsCount = rhs->GetLength(); 279 int countDiff = lhsCount - rhsCount; 280 int minCount = (countDiff < 0) ? lhsCount : rhsCount; 281 const uint16_t* lhsChars = lhs->GetCharArray()->GetData() + lhs->GetOffset(); 282 const uint16_t* rhsChars = rhs->GetCharArray()->GetData() + rhs->GetOffset(); 283 int otherRes = MemCmp16(lhsChars, rhsChars, minCount); 284 if (otherRes != 0) { 285 return otherRes; 286 } 287 return countDiff; 288} 289 290} // namespace mirror 291} // namespace art 292