Revert changes to ALWAYS_INLINEness of a couple of functions in UString.
[WebKit-https.git] / JavaScriptCore / runtime / UString.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
4  *  Copyright (C) 2009 Google Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Library General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Library General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Library General Public License
17  *  along with this library; see the file COPYING.LIB.  If not, write to
18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  *  Boston, MA 02110-1301, USA.
20  *
21  */
22
23 #ifndef UString_h
24 #define UString_h
25
26 #include "Collector.h"
27 #include <stdint.h>
28 #include <string.h>
29 #include <wtf/Assertions.h>
30 #include <wtf/CrossThreadRefCounted.h>
31 #include <wtf/OwnFastMallocPtr.h>
32 #include <wtf/PassRefPtr.h>
33 #include <wtf/RefPtr.h>
34 #include <wtf/Vector.h>
35 #include <wtf/text/CString.h>
36 #include <wtf/text/StringImpl.h>
37 #include <wtf/unicode/Unicode.h>
38
39 namespace JSC {
40
41 using WTF::PlacementNewAdoptType;
42 using WTF::PlacementNewAdopt;
43
44 class UString {
45 public:
46     UString() {}
47     UString(const char*); // Constructor for null-terminated string.
48     UString(const char*, unsigned length);
49     UString(const UChar*, unsigned length);
50     UString(const Vector<UChar>& buffer);
51
52     UString(const UString& s)
53         : m_impl(s.m_impl)
54     {
55     }
56
57     // Special constructor for cases where we overwrite an object in place.
58     UString(PlacementNewAdoptType)
59         : m_impl(PlacementNewAdopt)
60     {
61     }
62
63     template<size_t inlineCapacity>
64     static PassRefPtr<StringImpl> adopt(Vector<UChar, inlineCapacity>& vector)
65     {
66         return StringImpl::adopt(vector);
67     }
68
69     static UString number(int);
70     static UString number(long long);
71     static UString number(unsigned);
72     static UString number(long);
73     static UString number(double);
74
75     // NOTE: This method should only be used for *debugging* purposes as it
76     // is neither Unicode safe nor free from side effects nor thread-safe.
77     char* ascii() const;
78
79     /**
80      * Convert the string to UTF-8, assuming it is UTF-16 encoded.
81      * In non-strict mode, this function is tolerant of badly formed UTF-16, it
82      * can create UTF-8 strings that are invalid because they have characters in
83      * the range U+D800-U+DDFF, U+FFFE, or U+FFFF, but the UTF-8 string is
84      * guaranteed to be otherwise valid.
85      * In strict mode, error is returned as null CString.
86      */
87     CString UTF8String(bool strict = false) const;
88
89     unsigned length() const
90     {
91         if (!m_impl)
92             return 0;
93         return m_impl->length();
94     }
95
96     const UChar* characters() const
97     {
98         if (!m_impl)
99             return 0;
100         return m_impl->characters();
101     }
102
103     UChar operator[](unsigned pos) const;
104
105     double toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const;
106     double toDouble(bool tolerateTrailingJunk) const;
107     double toDouble() const;
108
109     uint32_t toUInt32(bool* ok = 0) const;
110     uint32_t toUInt32(bool* ok, bool tolerateEmptyString) const;
111     uint32_t toStrictUInt32(bool* ok = 0) const;
112
113     unsigned toArrayIndex(bool* ok = 0) const;
114
115     static const unsigned NotFound = 0xFFFFFFFFu;
116     unsigned find(const UString& f, unsigned pos = 0) const;
117     unsigned find(UChar, unsigned pos = 0) const;
118     unsigned rfind(const UString& f, unsigned pos) const;
119     unsigned rfind(UChar, unsigned pos) const;
120
121     UString substr(unsigned pos = 0, unsigned len = 0xFFFFFFFF) const;
122
123     bool isNull() const { return !m_impl; }
124     bool isEmpty() const { return !m_impl || !m_impl->length(); }
125
126     StringImpl* impl() const { return m_impl.get(); }
127
128     UString(PassRefPtr<StringImpl> r)
129         : m_impl(r)
130     {
131     }
132
133     size_t cost() const
134     {
135         if (!m_impl)
136             return 0;
137         return m_impl->cost();
138     }
139
140     ALWAYS_INLINE ~UString() { }
141 private:
142     RefPtr<StringImpl> m_impl;
143 };
144
145 ALWAYS_INLINE bool operator==(const UString& s1, const UString& s2)
146 {
147     StringImpl* rep1 = s1.impl();
148     StringImpl* rep2 = s2.impl();
149     unsigned size1 = 0;
150     unsigned size2 = 0;
151
152     if (rep1 == rep2) // If they're the same rep, they're equal.
153         return true;
154     
155     if (rep1)
156         size1 = rep1->length();
157         
158     if (rep2)
159         size2 = rep2->length();
160         
161     if (size1 != size2) // If the lengths are not the same, we're done.
162         return false;
163     
164     if (!size1)
165         return true;
166     
167     // At this point we know 
168     //   (a) that the strings are the same length and
169     //   (b) that they are greater than zero length.
170     const UChar* d1 = rep1->characters();
171     const UChar* d2 = rep2->characters();
172     
173     if (d1 == d2) // Check to see if the data pointers are the same.
174         return true;
175     
176     // Do quick checks for sizes 1 and 2.
177     switch (size1) {
178     case 1:
179         return d1[0] == d2[0];
180     case 2:
181         return (d1[0] == d2[0]) & (d1[1] == d2[1]);
182     default:
183         return memcmp(d1, d2, size1 * sizeof(UChar)) == 0;
184     }
185 }
186
187
188 inline bool operator!=(const UString& s1, const UString& s2)
189 {
190     return !JSC::operator==(s1, s2);
191 }
192
193 bool operator<(const UString& s1, const UString& s2);
194 bool operator>(const UString& s1, const UString& s2);
195
196 bool operator==(const UString& s1, const char* s2);
197
198 inline bool operator!=(const UString& s1, const char* s2)
199 {
200     return !JSC::operator==(s1, s2);
201 }
202
203 inline bool operator==(const char *s1, const UString& s2)
204 {
205     return operator==(s2, s1);
206 }
207
208 inline bool operator!=(const char *s1, const UString& s2)
209 {
210     return !JSC::operator==(s1, s2);
211 }
212
213 inline int codePointCompare(const UString& s1, const UString& s2)
214 {
215     return codePointCompare(s1.impl(), s2.impl());
216 }
217
218 // Rule from ECMA 15.2 about what an array index is.
219 // Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
220 inline unsigned UString::toArrayIndex(bool* ok) const
221 {
222     unsigned i = toStrictUInt32(ok);
223     if (ok && i >= 0xFFFFFFFFU)
224         *ok = false;
225     return i;
226 }
227
228 // We'd rather not do shared substring append for small strings, since
229 // this runs too much risk of a tiny initial string holding down a
230 // huge buffer.
231 static const unsigned minShareSize = Heap::minExtraCost / sizeof(UChar);
232
233 struct IdentifierRepHash : PtrHash<RefPtr<StringImpl> > {
234     static unsigned hash(const RefPtr<StringImpl>& key) { return key->existingHash(); }
235     static unsigned hash(StringImpl* key) { return key->existingHash(); }
236 };
237
238 } // namespace JSC
239
240 namespace WTF {
241
242 template<typename T> struct DefaultHash;
243 template<typename T> struct StrHash;
244
245 template<> struct StrHash<StringImpl*> {
246     static unsigned hash(const StringImpl* key) { return key->hash(); }
247     static bool equal(const StringImpl* a, const StringImpl* b) { return ::equal(a, b); }
248     static const bool safeToCompareToEmptyOrDeleted = false;
249 };
250
251 template<> struct StrHash<RefPtr<StringImpl> > : public StrHash<StringImpl*> {
252     using StrHash<StringImpl*>::hash;
253     static unsigned hash(const RefPtr<StringImpl>& key) { return key->hash(); }
254     using StrHash<StringImpl*>::equal;
255     static bool equal(const RefPtr<StringImpl>& a, const RefPtr<StringImpl>& b) { return ::equal(a.get(), b.get()); }
256     static bool equal(const StringImpl* a, const RefPtr<StringImpl>& b) { return ::equal(a, b.get()); }
257     static bool equal(const RefPtr<StringImpl>& a, const StringImpl* b) { return ::equal(a.get(), b); }
258
259     static const bool safeToCompareToEmptyOrDeleted = false;
260 };
261
262 template <> struct VectorTraits<JSC::UString> : SimpleClassVectorTraits
263 {
264     static const bool canInitializeWithMemset = true;
265 };
266     
267 } // namespace WTF
268
269 #endif
270
271 #include "StringConcatenate.h"