Reviewed by Adele.
[WebKit-https.git] / JavaScriptCore / kjs / ustring.h
1 // -*- c-basic-offset: 2 -*-
2 /*
3  *  This file is part of the KDE libraries
4  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
5  *  Copyright (C) 2004 Apple Computer, Inc.
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Library General Public
9  *  License as published by the Free Software Foundation; either
10  *  version 2 of the License, or (at your option) any later version.
11  *
12  *  This library is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  *  Library General Public License for more details.
16  *
17  *  You should have received a copy of the GNU Library General Public License
18  *  along with this library; see the file COPYING.LIB.  If not, write to
19  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  *  Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #ifndef _KJS_USTRING_H_
25 #define _KJS_USTRING_H_
26
27 #include "JSLock.h"
28 #include "collector.h"
29 #include <stdint.h>
30 #include <wtf/Assertions.h>
31 #include <wtf/FastMalloc.h>
32 #include <wtf/PassRefPtr.h>
33 #include <wtf/RefPtr.h>
34
35 /* On ARM some versions of GCC don't pack structures by default so sizeof(UChar)
36    will end up being != 2 which causes crashes since the code depends on that. */
37 #if COMPILER(GCC) && PLATFORM(ARM)
38 #define PACK_STRUCT __attribute__((packed))
39 #else
40 #define PACK_STRUCT
41 #endif
42
43 /**
44  * @internal
45  */
46 namespace DOM {
47   class DOMString;
48   class AtomicString;
49 }
50 class KJScript;
51
52 namespace KJS {
53
54   class UString;
55
56   /**
57    * @short Unicode character.
58    *
59    * UChar represents a 16 bit Unicode character. It's internal data
60    * representation is compatible to XChar2b and QChar. It's therefore
61    * possible to exchange data with X and Qt with shallow copies.
62    */
63   struct UChar {
64     /**
65      * Construct a character with uninitialized value.    
66      */
67     UChar();
68     /**
69      * Construct a character with the value denoted by the arguments.
70      * @param h higher byte
71      * @param l lower byte
72      */
73     UChar(unsigned char h , unsigned char l);
74     /**
75      * Construct a character with the given value.
76      * @param u 16 bit Unicode value
77      */
78     UChar(char u);
79     UChar(unsigned char u);
80     UChar(unsigned short u);
81     /**
82      * @return The higher byte of the character.
83      */
84     unsigned char high() const { return static_cast<unsigned char>(uc >> 8); }
85     /**
86      * @return The lower byte of the character.
87      */
88     unsigned char low() const { return static_cast<unsigned char>(uc); }
89     /**
90      * @return the 16 bit Unicode value of the character
91      */
92     unsigned short unicode() const { return uc; }
93
94     unsigned short uc;
95   } PACK_STRUCT;
96
97   inline UChar::UChar() { }
98   inline UChar::UChar(unsigned char h , unsigned char l) : uc(h << 8 | l) { }
99   inline UChar::UChar(char u) : uc((unsigned char)u) { }
100   inline UChar::UChar(unsigned char u) : uc(u) { }
101   inline UChar::UChar(unsigned short u) : uc(u) { }
102
103   /**
104    * @short 8 bit char based string class
105    */
106   class CString {
107   public:
108     CString() : data(0), length(0) { }
109     CString(const char *c);
110     CString(const char *c, size_t len);
111     CString(const CString &);
112
113     ~CString();
114
115     CString &append(const CString &);
116     CString &operator=(const char *c);
117     CString &operator=(const CString &);
118     CString &operator+=(const CString &c) { return append(c); }
119
120     size_t size() const { return length; }
121     const char *c_str() const { return data; }
122   private:
123     char *data;
124     size_t length;
125   };
126
127   /**
128    * @short Unicode string class
129    */
130   class UString {
131     friend bool operator==(const UString&, const UString&);
132
133   public:
134     /**
135      * @internal
136      */
137     struct Rep {
138
139       static PassRefPtr<Rep> create(UChar *d, int l);
140       static PassRefPtr<Rep> createCopying(const UChar *d, int l);
141       static PassRefPtr<Rep> create(PassRefPtr<Rep> base, int offset, int length);
142
143       void destroy();
144       
145       bool baseIsSelf() const { return baseString == this; }
146       UChar* data() const { return baseString->buf + baseString->preCapacity + offset; }
147       int size() const { return len; }
148       
149       unsigned hash() const { if (_hash == 0) _hash = computeHash(data(), len); return _hash; }
150       static unsigned computeHash(const UChar *, int length);
151       static unsigned computeHash(const char *);
152
153       Rep* ref() { ASSERT(JSLock::lockCount() > 0); ++rc; return this; }
154       void deref() { ASSERT(JSLock::lockCount() > 0); if (--rc == 0) destroy(); }
155
156       // unshared data
157       int offset;
158       int len;
159       int rc;
160       mutable unsigned _hash;
161       bool isIdentifier;
162       UString::Rep* baseString;
163
164       // potentially shared data
165       UChar *buf;
166       int usedCapacity;
167       int capacity;
168       int usedPreCapacity;
169       int preCapacity;
170       
171       static Rep null;
172       static Rep empty;
173     };
174
175   public:
176
177     /**
178      * Constructs a null string.
179      */
180     UString();
181     /**
182      * Constructs a string from a classical zero-terminated char string.
183      */
184     UString(const char *c);
185     /**
186      * Constructs a string from an array of Unicode characters of the specified
187      * length.
188      */
189     UString(const UChar *c, int length);
190     /**
191      * If copy is false the string data will be adopted.
192      * That means that the data will NOT be copied and the pointer will
193      * be deleted when the UString object is modified or destroyed.
194      * Behaviour defaults to a deep copy if copy is true.
195      */
196     UString(UChar *c, int length, bool copy);
197     /**
198      * Copy constructor. Makes a shallow copy only.
199      */
200     UString(const UString &s) : m_rep(s.m_rep) {}
201     /**
202      * Convenience declaration only ! You'll be on your own to write the
203      * implementation for a construction from DOM::DOMString.
204      *
205      * Note: feel free to contact me if you want to see a dummy header for
206      * your favorite FooString class here !
207      */
208     UString(const DOM::DOMString&);
209     /**
210      * Convenience declaration only ! See UString(const DOM::DOMString&).
211      */
212     UString(const DOM::AtomicString&);
213
214     /**
215      * Concatenation constructor. Makes operator+ more efficient.
216      */
217     UString(const UString &, const UString &);
218     /**
219      * Destructor.
220      */
221     ~UString() {}
222
223     /**
224      * Constructs a string from an int.
225      */
226     static UString from(int i);
227     /**
228      * Constructs a string from an unsigned int.
229      */
230     static UString from(unsigned int u);
231     /**
232      * Constructs a string from a long int.
233      */
234     static UString from(long u);
235     /**
236      * Constructs a string from a double.
237      */
238     static UString from(double d);
239
240     struct Range {
241     public:
242       Range(int pos, int len) : position(pos), length(len) {}
243       Range() {}
244       int position;
245       int length;
246     };
247
248     UString spliceSubstringsWithSeparators(const Range *substringRanges, int rangeCount, const UString *separators, int separatorCount) const;
249
250     /**
251      * Append another string.
252      */
253     UString &append(const UString &);
254     UString &append(const char *);
255     UString &append(unsigned short);
256     UString &append(char c) { return append(static_cast<unsigned short>(static_cast<unsigned char>(c))); }
257     UString &append(UChar c) { return append(c.uc); }
258
259     /**
260      * @return The string converted to the 8-bit string type CString().
261      */
262     CString cstring() const;
263     /**
264      * Convert the Unicode string to plain ASCII chars chopping of any higher
265      * bytes. This method should only be used for *debugging* purposes as it
266      * is neither Unicode safe nor free from side effects. In order not to
267      * waste any memory the char buffer is static and *shared* by all UString
268      * instances.
269      */
270     char *ascii() const;
271
272     /**
273      * Convert the string to UTF-8, assuming it is UTF-16 encoded.
274      * Since this function is tolerant of badly formed UTF-16, it can create UTF-8
275      * strings that are invalid because they have characters in the range
276      * U+D800-U+DDFF, U+FFFE, or U+FFFF, but the UTF-8 string is guaranteed to
277      * be otherwise valid.
278      */
279     CString UTF8String() const;
280
281     /**
282      * @see UString(const DOM::DOMString&).
283      */
284     DOM::DOMString domString() const;
285
286     /**
287      * Assignment operator.
288      */
289     UString &operator=(const char *c);
290     /**
291      * Appends the specified string.
292      */
293     UString &operator+=(const UString &s) { return append(s); }
294     UString &operator+=(const char *s) { return append(s); }
295
296     /**
297      * @return A pointer to the internal Unicode data.
298      */
299     const UChar* data() const { return m_rep->data(); }
300     /**
301      * @return True if null.
302      */
303     bool isNull() const { return (m_rep == &Rep::null); }
304     /**
305      * @return True if null or zero length.
306      */
307     bool isEmpty() const { return (!m_rep->len); }
308     /**
309      * Use this if you want to make sure that this string is a plain ASCII
310      * string. For example, if you don't want to lose any information when
311      * using cstring() or ascii().
312      *
313      * @return True if the string doesn't contain any non-ASCII characters.
314      */
315     bool is8Bit() const;
316     /**
317      * @return The length of the string.
318      */
319     int size() const { return m_rep->size(); }
320     /**
321      * Const character at specified position.
322      */
323     const UChar operator[](int pos) const;
324
325     /**
326      * Attempts an conversion to a number. Apart from floating point numbers,
327      * the algorithm will recognize hexadecimal representations (as
328      * indicated by a 0x or 0X prefix) and +/- Infinity.
329      * Returns NaN if the conversion failed.
330      * @param tolerateTrailingJunk if true, toDouble can tolerate garbage after the number.
331      * @param tolerateEmptyString if false, toDouble will turn an empty string into NaN rather than 0.
332      */
333     double toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const;
334     double toDouble(bool tolerateTrailingJunk) const;
335     double toDouble() const;
336
337     /**
338      * Attempts an conversion to a 32-bit integer. ok will be set
339      * according to the success.
340      * @param tolerateEmptyString if false, toUInt32 will return false for *ok for an empty string.
341      */
342     uint32_t toUInt32(bool *ok = 0) const;
343     uint32_t toUInt32(bool *ok, bool tolerateEmptyString) const;
344     uint32_t toStrictUInt32(bool *ok = 0) const;
345
346     /**
347      * Attempts an conversion to an array index. The "ok" boolean will be set
348      * to true if it is a valid array index according to the rule from
349      * ECMA 15.2 about what an array index is. It must exactly match the string
350      * form of an unsigned integer, and be less than 2^32 - 1.
351      */
352     unsigned toArrayIndex(bool *ok = 0) const;
353
354     /**
355      * @return Position of first occurrence of f starting at position pos.
356      * -1 if the search was not successful.
357      */
358     int find(const UString &f, int pos = 0) const;
359     int find(UChar, int pos = 0) const;
360     /**
361      * @return Position of first occurrence of f searching backwards from
362      * position pos.
363      * -1 if the search was not successful.
364      */
365     int rfind(const UString &f, int pos) const;
366     int rfind(UChar, int pos) const;
367     /**
368      * @return The sub string starting at position pos and length len.
369      */
370     UString substr(int pos = 0, int len = -1) const;
371     /**
372      * Static instance of a null string.
373      */
374     static const UString &null();
375 #ifdef KJS_DEBUG_MEM
376     /**
377      * Clear statically allocated resources.
378      */
379     static void globalClear();
380 #endif
381
382     Rep* rep() const { return m_rep.get(); }
383     UString(PassRefPtr<Rep> r) : m_rep(r) { ASSERT(m_rep); }
384
385     size_t cost() const;
386
387   private:
388     size_t expandedSize(size_t size, size_t otherSize) const;
389     int usedCapacity() const;
390     int usedPreCapacity() const;
391     void expandCapacity(int requiredLength);
392     void expandPreCapacity(int requiredPreCap);
393
394     RefPtr<Rep> m_rep;
395   };
396
397   inline bool operator==(const UChar &c1, const UChar &c2) {
398     return (c1.uc == c2.uc);
399   }
400   bool operator==(const UString& s1, const UString& s2);
401   inline bool operator!=(const UString& s1, const UString& s2) {
402     return !KJS::operator==(s1, s2);
403   }
404   bool operator<(const UString& s1, const UString& s2);
405   bool operator==(const UString& s1, const char *s2);
406   inline bool operator!=(const UString& s1, const char *s2) {
407     return !KJS::operator==(s1, s2);
408   }
409   inline bool operator==(const char *s1, const UString& s2) {
410     return operator==(s2, s1);
411   }
412   inline bool operator!=(const char *s1, const UString& s2) {
413     return !KJS::operator==(s1, s2);
414   }
415   bool operator==(const CString& s1, const CString& s2);
416   inline UString operator+(const UString& s1, const UString& s2) {
417     return UString(s1, s2);
418   }
419   
420   int compare(const UString &, const UString &);
421
422   // Given a first byte, gives the length of the UTF-8 sequence it begins.
423   // Returns 0 for bytes that are not legal starts of UTF-8 sequences.
424   // Only allows sequences of up to 4 bytes, since that works for all Unicode characters (U-00000000 to U-0010FFFF).
425   int UTF8SequenceLength(char);
426
427   // Takes a null-terminated C-style string with a UTF-8 sequence in it and converts it to a character.
428   // Only allows Unicode characters (U-00000000 to U-0010FFFF).
429   // Returns -1 if the sequence is not valid (including presence of extra bytes).
430   int decodeUTF8Sequence(const char *);
431
432 inline UString::UString()
433   : m_rep(&Rep::null)
434 {
435 }
436
437 // Rule from ECMA 15.2 about what an array index is.
438 // Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
439 inline unsigned UString::toArrayIndex(bool *ok) const
440 {
441     unsigned i = toStrictUInt32(ok);
442     if (ok && i >= 0xFFFFFFFFU)
443         *ok = false;
444     return i;
445 }
446
447 inline size_t UString::cost() const
448 {
449     // If this string is sharing with a base, then don't count any cost. We will never share
450     // with a base that wasn't already big enough to register extra cost, so a string holding that
451     // buffer has already paid extra cost at some point; and if we just
452     // enlarged it by a huge amount, it must have been by appending a string
453     // that itself paid extra cost, or a huge number of small strings. Either way, GC will come
454     // relatively soon.
455   
456     // If we didn't do this, the shared substring optimization would result
457     // in constantly garbage collecting when sharing with one big string.
458
459     if (!m_rep->baseIsSelf())
460         return 0;
461
462     return (m_rep->capacity + m_rep->preCapacity) * sizeof(UChar);
463 }
464
465 } // namespace
466
467 #endif