7f42d68a7450d7fb01f6934a4fc0cee5f3bbc4d9
[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 UCharReference;
55   class UString;
56
57   /**
58    * @short Unicode character.
59    *
60    * UChar represents a 16 bit Unicode character. It's internal data
61    * representation is compatible to XChar2b and QChar. It's therefore
62    * possible to exchange data with X and Qt with shallow copies.
63    */
64   struct UChar {
65     /**
66      * Construct a character with uninitialized value.    
67      */
68     UChar();
69     /**
70      * Construct a character with the value denoted by the arguments.
71      * @param h higher byte
72      * @param l lower byte
73      */
74     UChar(unsigned char h , unsigned char l);
75     /**
76      * Construct a character with the given value.
77      * @param u 16 bit Unicode value
78      */
79     UChar(char u);
80     UChar(unsigned char u);
81     UChar(unsigned short u);
82     UChar(const UCharReference &c);
83     /**
84      * @return The higher byte of the character.
85      */
86     unsigned char high() const { return static_cast<unsigned char>(uc >> 8); }
87     /**
88      * @return The lower byte of the character.
89      */
90     unsigned char low() const { return static_cast<unsigned char>(uc); }
91     /**
92      * @return the 16 bit Unicode value of the character
93      */
94     unsigned short unicode() const { return uc; }
95
96     unsigned short uc;
97   } PACK_STRUCT;
98
99   inline UChar::UChar() { }
100   inline UChar::UChar(unsigned char h , unsigned char l) : uc(h << 8 | l) { }
101   inline UChar::UChar(char u) : uc((unsigned char)u) { }
102   inline UChar::UChar(unsigned char u) : uc(u) { }
103   inline UChar::UChar(unsigned short u) : uc(u) { }
104
105   /**
106    * @short Dynamic reference to a string character.
107    *
108    * UCharReference is the dynamic counterpart of UChar. It's used when
109    * characters retrieved via index from a UString are used in an
110    * assignment expression (and therefore can't be treated as being const):
111    * \code
112    * UString s("hello world");
113    * s[0] = 'H';
114    * \endcode
115    *
116    * If that sounds confusing your best bet is to simply forget about the
117    * existence of this class and treat is as being identical to UChar.
118    */
119   class UCharReference {
120     friend class UString;
121     UCharReference(UString *s, unsigned int off) : str(s), offset(off) { }
122   public:
123     /**
124      * Set the referenced character to c.
125      */
126     UCharReference& operator=(UChar c);
127     /**
128      * Same operator as above except the argument that it takes.
129      */
130     UCharReference& operator=(char c) { return operator=(UChar(c)); }
131     /**
132      * @return Unicode value.
133      */
134     unsigned short unicode() const { return ref().uc; }
135     /**
136      * @return Lower byte.
137      */
138     unsigned char low() const { return static_cast<unsigned char>(ref().uc); }
139     /**
140      * @return Higher byte.
141      */
142     unsigned char high() const { return static_cast<unsigned char>(ref().uc >> 8); }
143
144   private:
145     // not implemented, can only be constructed from UString
146     UCharReference();
147
148     UChar& ref() const;
149     UString *str;
150     int offset;
151   };
152
153   inline UChar::UChar(const UCharReference &c) : uc(c.unicode()) { }
154
155   /**
156    * @short 8 bit char based string class
157    */
158   class CString {
159   public:
160     CString() : data(0), length(0) { }
161     CString(const char *c);
162     CString(const char *c, size_t len);
163     CString(const CString &);
164
165     ~CString();
166
167     CString &append(const CString &);
168     CString &operator=(const char *c);
169     CString &operator=(const CString &);
170     CString &operator+=(const CString &c) { return append(c); }
171
172     size_t size() const { return length; }
173     const char *c_str() const { return data; }
174   private:
175     char *data;
176     size_t length;
177   };
178
179   /**
180    * @short Unicode string class
181    */
182   class UString {
183     friend bool operator==(const UString&, const UString&);
184
185   public:
186     /**
187      * @internal
188      */
189     struct Rep {
190
191       static PassRefPtr<Rep> create(UChar *d, int l);
192       static PassRefPtr<Rep> createCopying(const UChar *d, int l);
193       static PassRefPtr<Rep> create(PassRefPtr<Rep> base, int offset, int length);
194
195       void destroy();
196       
197       bool baseIsSelf() const { return baseString == this; }
198       UChar* data() const { return baseString->buf + baseString->preCapacity + offset; }
199       int size() const { return len; }
200       
201       unsigned hash() const { if (_hash == 0) _hash = computeHash(data(), len); return _hash; }
202       static unsigned computeHash(const UChar *, int length);
203       static unsigned computeHash(const char *);
204
205       Rep* ref() { ASSERT(JSLock::lockCount() > 0); ++rc; return this; }
206       void deref() { ASSERT(JSLock::lockCount() > 0); if (--rc == 0) destroy(); }
207
208       // unshared data
209       int offset;
210       int len;
211       int rc;
212       mutable unsigned _hash;
213       bool isIdentifier;
214       UString::Rep* baseString;
215
216       // potentially shared data
217       UChar *buf;
218       int usedCapacity;
219       int capacity;
220       int usedPreCapacity;
221       int preCapacity;
222       
223       static Rep null;
224       static Rep empty;
225     };
226
227   public:
228
229     /**
230      * Constructs a null string.
231      */
232     UString();
233     /**
234      * Constructs a string from a classical zero-terminated char string.
235      */
236     UString(const char *c);
237     /**
238      * Constructs a string from an array of Unicode characters of the specified
239      * length.
240      */
241     UString(const UChar *c, int length);
242     /**
243      * If copy is false the string data will be adopted.
244      * That means that the data will NOT be copied and the pointer will
245      * be deleted when the UString object is modified or destroyed.
246      * Behaviour defaults to a deep copy if copy is true.
247      */
248     UString(UChar *c, int length, bool copy);
249     /**
250      * Copy constructor. Makes a shallow copy only.
251      */
252     UString(const UString &s) : m_rep(s.m_rep) {}
253     /**
254      * Convenience declaration only ! You'll be on your own to write the
255      * implementation for a construction from DOM::DOMString.
256      *
257      * Note: feel free to contact me if you want to see a dummy header for
258      * your favorite FooString class here !
259      */
260     UString(const DOM::DOMString&);
261     /**
262      * Convenience declaration only ! See UString(const DOM::DOMString&).
263      */
264     UString(const DOM::AtomicString&);
265
266     /**
267      * Concatenation constructor. Makes operator+ more efficient.
268      */
269     UString(const UString &, const UString &);
270     /**
271      * Destructor.
272      */
273     ~UString() {}
274
275     /**
276      * Constructs a string from an int.
277      */
278     static UString from(int i);
279     /**
280      * Constructs a string from an unsigned int.
281      */
282     static UString from(unsigned int u);
283     /**
284      * Constructs a string from a long int.
285      */
286     static UString from(long u);
287     /**
288      * Constructs a string from a double.
289      */
290     static UString from(double d);
291
292     struct Range {
293     public:
294       Range(int pos, int len) : position(pos), length(len) {}
295       Range() {}
296       int position;
297       int length;
298     };
299
300     UString spliceSubstringsWithSeparators(const Range *substringRanges, int rangeCount, const UString *separators, int separatorCount) const;
301
302     /**
303      * Append another string.
304      */
305     UString &append(const UString &);
306     UString &append(const char *);
307     UString &append(unsigned short);
308     UString &append(char c) { return append(static_cast<unsigned short>(static_cast<unsigned char>(c))); }
309     UString &append(UChar c) { return append(c.uc); }
310
311     /**
312      * @return The string converted to the 8-bit string type CString().
313      */
314     CString cstring() const;
315     /**
316      * Convert the Unicode string to plain ASCII chars chopping of any higher
317      * bytes. This method should only be used for *debugging* purposes as it
318      * is neither Unicode safe nor free from side effects. In order not to
319      * waste any memory the char buffer is static and *shared* by all UString
320      * instances.
321      */
322     char *ascii() const;
323
324     /**
325      * Convert the string to UTF-8, assuming it is UTF-16 encoded.
326      * Since this function is tolerant of badly formed UTF-16, it can create UTF-8
327      * strings that are invalid because they have characters in the range
328      * U+D800-U+DDFF, U+FFFE, or U+FFFF, but the UTF-8 string is guaranteed to
329      * be otherwise valid.
330      */
331     CString UTF8String() const;
332
333     /**
334      * @see UString(const DOM::DOMString&).
335      */
336     DOM::DOMString domString() const;
337
338     /**
339      * Assignment operator.
340      */
341     UString &operator=(const char *c);
342     /**
343      * Appends the specified string.
344      */
345     UString &operator+=(const UString &s) { return append(s); }
346     UString &operator+=(const char *s) { return append(s); }
347
348     /**
349      * @return A pointer to the internal Unicode data.
350      */
351     const UChar* data() const { return m_rep->data(); }
352     /**
353      * @return True if null.
354      */
355     bool isNull() const { return (m_rep == &Rep::null); }
356     /**
357      * @return True if null or zero length.
358      */
359     bool isEmpty() const { return (!m_rep->len); }
360     /**
361      * Use this if you want to make sure that this string is a plain ASCII
362      * string. For example, if you don't want to lose any information when
363      * using cstring() or ascii().
364      *
365      * @return True if the string doesn't contain any non-ASCII characters.
366      */
367     bool is8Bit() const;
368     /**
369      * @return The length of the string.
370      */
371     int size() const { return m_rep->size(); }
372     /**
373      * Const character at specified position.
374      */
375     UChar operator[](int pos) const;
376     /**
377      * Writable reference to character at specified position.
378      */
379     UCharReference operator[](int pos);
380
381     /**
382      * Attempts an conversion to a number. Apart from floating point numbers,
383      * the algorithm will recognize hexadecimal representations (as
384      * indicated by a 0x or 0X prefix) and +/- Infinity.
385      * Returns NaN if the conversion failed.
386      * @param tolerateTrailingJunk if true, toDouble can tolerate garbage after the number.
387      * @param tolerateEmptyString if false, toDouble will turn an empty string into NaN rather than 0.
388      */
389     double toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const;
390     double toDouble(bool tolerateTrailingJunk) const;
391     double toDouble() const;
392
393     /**
394      * Attempts an conversion to a 32-bit integer. ok will be set
395      * according to the success.
396      * @param tolerateEmptyString if false, toUInt32 will return false for *ok for an empty string.
397      */
398     uint32_t toUInt32(bool *ok = 0) const;
399     uint32_t toUInt32(bool *ok, bool tolerateEmptyString) const;
400     uint32_t toStrictUInt32(bool *ok = 0) const;
401
402     /**
403      * Attempts an conversion to an array index. The "ok" boolean will be set
404      * to true if it is a valid array index according to the rule from
405      * ECMA 15.2 about what an array index is. It must exactly match the string
406      * form of an unsigned integer, and be less than 2^32 - 1.
407      */
408     unsigned toArrayIndex(bool *ok = 0) const;
409
410     /**
411      * @return Position of first occurrence of f starting at position pos.
412      * -1 if the search was not successful.
413      */
414     int find(const UString &f, int pos = 0) const;
415     int find(UChar, int pos = 0) const;
416     /**
417      * @return Position of first occurrence of f searching backwards from
418      * position pos.
419      * -1 if the search was not successful.
420      */
421     int rfind(const UString &f, int pos) const;
422     int rfind(UChar, int pos) const;
423     /**
424      * @return The sub string starting at position pos and length len.
425      */
426     UString substr(int pos = 0, int len = -1) const;
427     /**
428      * Static instance of a null string.
429      */
430     static const UString &null();
431 #ifdef KJS_DEBUG_MEM
432     /**
433      * Clear statically allocated resources.
434      */
435     static void globalClear();
436 #endif
437
438     Rep *rep() const { return m_rep.get(); }
439     UString(PassRefPtr<Rep> r) : m_rep(r) { }
440
441     void copyForWriting();
442
443     size_t cost() const;
444
445   private:
446     int expandedSize(int size, int otherSize) const;
447     int usedCapacity() const;
448     int usedPreCapacity() const;
449     void expandCapacity(int requiredLength);
450     void expandPreCapacity(int requiredPreCap);
451
452     RefPtr<Rep> m_rep;
453   };
454
455   inline bool operator==(const UChar &c1, const UChar &c2) {
456     return (c1.uc == c2.uc);
457   }
458   bool operator==(const UString& s1, const UString& s2);
459   inline bool operator!=(const UString& s1, const UString& s2) {
460     return !KJS::operator==(s1, s2);
461   }
462   bool operator<(const UString& s1, const UString& s2);
463   bool operator==(const UString& s1, const char *s2);
464   inline bool operator!=(const UString& s1, const char *s2) {
465     return !KJS::operator==(s1, s2);
466   }
467   inline bool operator==(const char *s1, const UString& s2) {
468     return operator==(s2, s1);
469   }
470   inline bool operator!=(const char *s1, const UString& s2) {
471     return !KJS::operator==(s1, s2);
472   }
473   bool operator==(const CString& s1, const CString& s2);
474   inline UString operator+(const UString& s1, const UString& s2) {
475     return UString(s1, s2);
476   }
477   
478   int compare(const UString &, const UString &);
479
480   // Given a first byte, gives the length of the UTF-8 sequence it begins.
481   // Returns 0 for bytes that are not legal starts of UTF-8 sequences.
482   // Only allows sequences of up to 4 bytes, since that works for all Unicode characters (U-00000000 to U-0010FFFF).
483   int UTF8SequenceLength(char);
484
485   // Takes a null-terminated C-style string with a UTF-8 sequence in it and converts it to a character.
486   // Only allows Unicode characters (U-00000000 to U-0010FFFF).
487   // Returns -1 if the sequence is not valid (including presence of extra bytes).
488   int decodeUTF8Sequence(const char *);
489
490 inline UString::UString()
491   : m_rep(&Rep::null)
492 {
493 }
494
495 // Rule from ECMA 15.2 about what an array index is.
496 // Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
497 inline unsigned UString::toArrayIndex(bool *ok) const
498 {
499     unsigned i = toStrictUInt32(ok);
500     if (ok && i >= 0xFFFFFFFFU)
501         *ok = false;
502     return i;
503 }
504
505 inline size_t UString::cost() const
506 {
507     // If this string is sharing with a base, then don't count any cost. We will never share
508     // with a base that wasn't already big enough to register extra cost, so a string holding that
509     // buffer has already paid extra cost at some point; and if we just
510     // enlarged it by a huge amount, it must have been by appending a string
511     // that itself paid extra cost, or a huge number of small strings. Either way, GC will come
512     // relatively soon.
513   
514     // If we didn't do this, the shared substring optimization would result
515     // in constantly garbage collecting when sharing with one big string.
516
517     if (!m_rep->baseIsSelf())
518         return 0;
519
520     return (m_rep->capacity + m_rep->preCapacity) * sizeof(UChar);
521 }
522
523 } // namespace
524
525 #endif