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