JavaScriptCore/kjs/ustring.h

   1 // -*- c-basic-offset: 2 -*-
   2 /*
   3  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   4  *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple 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 _KJS_USTRING_H_
  24 #define _KJS_USTRING_H_
  25
  26 #include "JSLock.h"
  27 #include "collector.h"
  28 #include <stdint.h>
  29 #include <wtf/Assertions.h>
  30 #include <wtf/FastMalloc.h>
  31 #include <wtf/PassRefPtr.h>
  32 #include <wtf/RefPtr.h>
  33 #include <wtf/unicode/Unicode.h>
  34 #include <wtf/Vector.h>
  35
  36 /**
  37  * @internal
  38  */
  39 namespace DOM {
  40   class DOMString;
  41   class AtomicString;
  42 }
  43 class KJScript;
  44
  45 namespace KJS {
  46
  47   using WTF::PlacementNewAdoptType;
  48   using WTF::PlacementNewAdopt;
  49
  50   class IdentifierTable;
  51   class UString;
  52
  53   /**
  54    * @short 8 bit char based string class
  55    */
  56   class CString {
  57   public:
  58     CString() : data(0), length(0) { }
  59     CString(const char *c);
  60     CString(const char *c, size_t len);
  61     CString(const CString &);
  62
  63     ~CString();
  64
  65     static CString adopt(char* c, size_t len); // c should be allocated with new[].
  66
  67     CString &append(const CString &);
  68     CString &operator=(const char *c);
  69     CString &operator=(const CString &);
  70     CString &operator+=(const CString &c) { return append(c); }
  71
  72     size_t size() const { return length; }
  73     const char *c_str() const { return data; }
  74   private:
  75     char *data;
  76     size_t length;
  77   };
  78
  79   typedef Vector<char, 32> CStringBuffer;
  80
  81   /**
  82    * @short Unicode string class
  83    */
  84   class UString {
  85     friend bool operator==(const UString&, const UString&);
  86
  87   public:
  88     /**
  89      * @internal
  90      */
  91     struct Rep {
  92
  93       static PassRefPtr<Rep> create(UChar *d, int l);
  94       static PassRefPtr<Rep> createCopying(const UChar *d, int l);
  95       static PassRefPtr<Rep> create(PassRefPtr<Rep> base, int offset, int length);
  96
  97       // Constructs a string from a UTF-8 string, using strict conversion (see comments in UTF8.h).
  98       // Returns UString::Rep::null for null input or conversion failure.
  99       static PassRefPtr<Rep> createFromUTF8(const char*);
 100
 101       void destroy();
 102
 103       bool baseIsSelf() const { return baseString == this; }
 104       UChar* data() const { return baseString->buf + baseString->preCapacity + offset; }
 105       int size() const { return len; }
 106
 107       unsigned hash() const { if (_hash == 0) _hash = computeHash(data(), len); return _hash; }
 108       unsigned computedHash() const { ASSERT(_hash); return _hash; } // fast path for Identifiers
 109
 110       static unsigned computeHash(const UChar *, int length);
 111       static unsigned computeHash(const char *);
 112
 113       Rep* ref() { ++rc; return this; }
 114       ALWAYS_INLINE void deref() { if (--rc == 0) destroy(); }
 115
 116       // unshared data
 117       int offset;
 118       int len;
 119       int rc; // For null and empty static strings, this field does not reflect a correct count, because ref/deref are not thread-safe. A special case in destroy() guarantees that these do not get deleted.
 120       mutable unsigned _hash;
 121       IdentifierTable* identifierTable; // 0 if not an identifier. Since garbage collection can happen on a different thread, there is no other way to get to the table during destruction.
 122       UString::Rep* baseString;
 123       bool isStatic : 1;
 124       size_t reportedCost : 31;
 125
 126       // potentially shared data
 127       UChar *buf;
 128       int usedCapacity;
 129       int capacity;
 130       int usedPreCapacity;
 131       int preCapacity;
 132
 133       static Rep null;
 134       static Rep empty;
 135     };
 136
 137   public:
 138
 139     /**
 140      * Constructs a null string.
 141      */
 142     UString();
 143     /**
 144      * Constructs a string from a classical zero-terminated char string.
 145      */
 146     UString(const char *c);
 147     /**
 148      * Constructs a string from an array of Unicode characters of the specified
 149      * length.
 150      */
 151     UString(const UChar *c, int length);
 152     /**
 153      * If copy is false the string data will be adopted.
 154      * That means that the data will NOT be copied and the pointer will
 155      * be deleted when the UString object is modified or destroyed.
 156      * Behaviour defaults to a deep copy if copy is true.
 157      */
 158     UString(UChar *c, int length, bool copy);
 159     /**
 160      * Copy constructor. Makes a shallow copy only.
 161      */
 162     UString(const UString &s) : m_rep(s.m_rep) {}
 163
 164     UString(const Vector<UChar>& buffer);
 165
 166     /**
 167      * Convenience declaration only ! You'll be on your own to write the
 168      * implementation for a construction from DOM::DOMString.
 169      *
 170      * Note: feel free to contact me if you want to see a dummy header for
 171      * your favorite FooString class here !
 172      */
 173     UString(const DOM::DOMString&);
 174     /**
 175      * Convenience declaration only ! See UString(const DOM::DOMString&).
 176      */
 177     UString(const DOM::AtomicString&);
 178
 179     /**
 180      * Concatenation constructor. Makes operator+ more efficient.
 181      */
 182     UString(const UString &, const UString &);
 183     /**
 184      * Destructor.
 185      */
 186     ~UString() {}
 187
 188     // Special constructor for cases where we overwrite an object in place.
 189     UString(PlacementNewAdoptType) : m_rep(PlacementNewAdopt) { }
 190
 191     /**
 192      * Constructs a string from an int.
 193      */
 194     static UString from(int i);
 195     /**
 196      * Constructs a string from an unsigned int.
 197      */
 198     static UString from(unsigned int u);
 199     /**
 200      * Constructs a string from a long int.
 201      */
 202     static UString from(long u);
 203     /**
 204      * Constructs a string from a double.
 205      */
 206     static UString from(double d);
 207
 208     struct Range {
 209     public:
 210       Range(int pos, int len) : position(pos), length(len) {}
 211       Range() {}
 212       int position;
 213       int length;
 214     };
 215
 216     UString spliceSubstringsWithSeparators(const Range* substringRanges, int rangeCount, const UString* separators, int separatorCount) const;
 217
 218     /**
 219      * Append another string.
 220      */
 221     UString& append(const UString&);
 222     UString& append(const char*);
 223     UString& append(UChar);
 224     UString& append(char c) { return append(static_cast<UChar>(static_cast<unsigned char>(c))); }
 225
 226     /**
 227      * @return The string converted to the 8-bit string type CString().
 228      * Returns false if any character is non-ASCII.
 229      */
 230     bool getCString(CStringBuffer&) const;
 231
 232     /**
 233      * Convert the Unicode string to plain ASCII chars chopping off any higher
 234      * bytes. This method should only be used for *debugging* purposes as it
 235      * is neither Unicode safe nor free from side effects nor thread-safe.
 236      * In order not to waste any memory the char buffer is static and *shared*
 237      * by all UString instances.
 238      */
 239     char* ascii() const;
 240
 241     /**
 242      * Convert the string to UTF-8, assuming it is UTF-16 encoded.
 243      * In non-strict mode, this function is tolerant of badly formed UTF-16, it
 244      * can create UTF-8 strings that are invalid because they have characters in
 245      * the range U+D800-U+DDFF, U+FFFE, or U+FFFF, but the UTF-8 string is
 246      * guaranteed to be otherwise valid.
 247      * In strict mode, error is returned as null CString.
 248      */
 249     CString UTF8String(bool strict = false) const;
 250
 251     /**
 252      * @see UString(const DOM::DOMString&).
 253      */
 254     DOM::DOMString domString() const;
 255
 256     /**
 257      * Assignment operator.
 258      */
 259     UString &operator=(const char *c);
 260     /**
 261      * Appends the specified string.
 262      */
 263     UString &operator+=(const UString &s) { return append(s); }
 264     UString &operator+=(const char *s) { return append(s); }
 265
 266     /**
 267      * @return A pointer to the internal Unicode data.
 268      */
 269     const UChar* data() const { return m_rep->data(); }
 270     /**
 271      * @return True if null.
 272      */
 273     bool isNull() const { return (m_rep == &Rep::null); }
 274     /**
 275      * @return True if null or zero length.
 276      */
 277     bool isEmpty() const { return (!m_rep->len); }
 278     /**
 279      * Use this if you want to make sure that this string is a plain ASCII
 280      * string. For example, if you don't want to lose any information when
 281      * using cstring() or ascii().
 282      *
 283      * @return True if the string doesn't contain any non-ASCII characters.
 284      */
 285     bool is8Bit() const;
 286     /**
 287      * @return The length of the string.
 288      */
 289     int size() const { return m_rep->size(); }
 290     /**
 291      * Const character at specified position.
 292      */
 293     UChar operator[](int pos) const;
 294
 295     /**
 296      * Attempts an conversion to a number. Apart from floating point numbers,
 297      * the algorithm will recognize hexadecimal representations (as
 298      * indicated by a 0x or 0X prefix) and +/- Infinity.
 299      * Returns NaN if the conversion failed.
 300      * @param tolerateTrailingJunk if true, toDouble can tolerate garbage after the number.
 301      * @param tolerateEmptyString if false, toDouble will turn an empty string into NaN rather than 0.
 302      */
 303     double toDouble(bool tolerateTrailingJunk, bool tolerateEmptyString) const;
 304     double toDouble(bool tolerateTrailingJunk) const;
 305     double toDouble() const;
 306
 307     /**
 308      * Attempts an conversion to a 32-bit integer. ok will be set
 309      * according to the success.
 310      * @param tolerateEmptyString if false, toUInt32 will return false for *ok for an empty string.
 311      */
 312     uint32_t toUInt32(bool *ok = 0) const;
 313     uint32_t toUInt32(bool *ok, bool tolerateEmptyString) const;
 314     uint32_t toStrictUInt32(bool *ok = 0) const;
 315
 316     /**
 317      * Attempts an conversion to an array index. The "ok" boolean will be set
 318      * to true if it is a valid array index according to the rule from
 319      * ECMA 15.2 about what an array index is. It must exactly match the string
 320      * form of an unsigned integer, and be less than 2^32 - 1.
 321      */
 322     unsigned toArrayIndex(bool *ok = 0) const;
 323
 324     /**
 325      * @return Position of first occurrence of f starting at position pos.
 326      * -1 if the search was not successful.
 327      */
 328     int find(const UString &f, int pos = 0) const;
 329     int find(UChar, int pos = 0) const;
 330     /**
 331      * @return Position of first occurrence of f searching backwards from
 332      * position pos.
 333      * -1 if the search was not successful.
 334      */
 335     int rfind(const UString &f, int pos) const;
 336     int rfind(UChar, int pos) const;
 337     /**
 338      * @return The sub string starting at position pos and length len.
 339      */
 340     UString substr(int pos = 0, int len = -1) const;
 341     /**
 342      * Static instance of a null string.
 343      */
 344     static const UString &null();
 345
 346     Rep* rep() const { return m_rep.get(); }
 347     UString(PassRefPtr<Rep> r) : m_rep(r) { ASSERT(m_rep); }
 348
 349     size_t cost() const;
 350
 351   private:
 352     size_t expandedSize(size_t size, size_t otherSize) const;
 353     int usedCapacity() const;
 354     int usedPreCapacity() const;
 355     void expandCapacity(int requiredLength);
 356     void expandPreCapacity(int requiredPreCap);
 357
 358     RefPtr<Rep> m_rep;
 359   };
 360
 361   bool operator==(const UString& s1, const UString& s2);
 362   inline bool operator!=(const UString& s1, const UString& s2) {
 363     return !KJS::operator==(s1, s2);
 364   }
 365   bool operator<(const UString& s1, const UString& s2);
 366   bool operator==(const UString& s1, const char *s2);
 367   inline bool operator!=(const UString& s1, const char *s2) {
 368     return !KJS::operator==(s1, s2);
 369   }
 370   inline bool operator==(const char *s1, const UString& s2) {
 371     return operator==(s2, s1);
 372   }
 373   inline bool operator!=(const char *s1, const UString& s2) {
 374     return !KJS::operator==(s1, s2);
 375   }
 376   bool operator==(const CString& s1, const CString& s2);
 377   inline UString operator+(const UString& s1, const UString& s2) {
 378     return UString(s1, s2);
 379   }
 380
 381   int compare(const UString &, const UString &);
 382
 383 inline UString::UString()
 384   : m_rep(&Rep::null)
 385 {
 386 }
 387
 388 // Rule from ECMA 15.2 about what an array index is.
 389 // Must exactly match string form of an unsigned integer, and be less than 2^32 - 1.
 390 inline unsigned UString::toArrayIndex(bool *ok) const
 391 {
 392     unsigned i = toStrictUInt32(ok);
 393     if (ok && i >= 0xFFFFFFFFU)
 394         *ok = false;
 395     return i;
 396 }
 397
 398 // We'd rather not do shared substring append for small strings, since
 399 // this runs too much risk of a tiny initial string holding down a
 400 // huge buffer.
 401 // FIXME: this should be size_t but that would cause warnings until we
 402 // fix UString sizes to be size_t instead of int
 403 static const int minShareSize = Collector::minExtraCostSize / sizeof(UChar);
 404
 405 inline size_t UString::cost() const
 406 {
 407    size_t capacity = (m_rep->baseString->capacity + m_rep->baseString->preCapacity) * sizeof(UChar);
 408    size_t reportedCost = m_rep->baseString->reportedCost;
 409    ASSERT(capacity >= reportedCost);
 410
 411    size_t capacityDelta = capacity - reportedCost;
 412
 413    if (capacityDelta < static_cast<size_t>(minShareSize))
 414        return 0;
 415
 416 #if COMPILER(MSVC)
 417 // MSVC complains about this assignment, since reportedCost is a 31-bit size_t.
 418 #pragma warning(push)
 419 #pragma warning(disable: 4267)
 420 #endif
 421
 422    m_rep->baseString->reportedCost = capacity;
 423
 424 #if COMPILER(MSVC)
 425 #pragma warning(pop)
 426 #endif
 427
 428    return capacityDelta;
 429 }
 430
 431 } // namespace
 432
 433 #endif