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