kjs/value.h

   1 /*
   2  *  This file is part of the KDE libraries
   3  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
   4  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
   5  *  Copyright (C) 2003, 2004, 2005, 2007 Apple Inc. All rights reserved.
   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_VALUE_H
  25 #define KJS_VALUE_H
  26
  27 #include "JSImmediate.h"
  28 #include "ustring.h"
  29 #include "collector.h"
  30 #include <wtf/Noncopyable.h>
  31 #include <stddef.h> // for size_t
  32
  33 #ifndef NDEBUG // protection against problems if committing with KJS_VERBOSE on
  34
  35 // Uncomment this to enable very verbose output from KJS
  36 //#define KJS_VERBOSE
  37 // Uncomment this to debug memory allocation and garbage collection
  38 //#define KJS_DEBUG_MEM
  39
  40 #endif
  41
  42 namespace KJS {
  43
  44 struct ClassInfo;
  45 class ExecState;
  46 class JSObject;
  47 class JSCell;
  48
  49 /**
  50  * JSValue is the base type for all primitives (Undefined, Null, Boolean,
  51  * String, Number) and objects in ECMAScript.
  52  *
  53  * Note: you should never inherit from JSValue as it is for primitive types
  54  * only (all of which are provided internally by KJS). Instead, inherit from
  55  * JSObject.
  56  */
  57 class KJS_EXPORT JSValue : Noncopyable {
  58     friend class JSCell; // so it can derive from this class
  59     friend class Collector; // so it can call asCell()
  60
  61 private:
  62     JSValue();
  63     virtual ~JSValue();
  64
  65 public:
  66     // Querying the type.
  67     JSType type() const;
  68     bool isUndefined() const;
  69     bool isNull() const;
  70     bool isUndefinedOrNull() const;
  71     bool isBoolean() const;
  72     bool isNumber() const;
  73     bool isString() const;
  74     bool isObject() const;
  75     bool isObject(const ClassInfo *) const;
  76
  77     // Extracting the value.
  78     bool getBoolean(bool&) const;
  79     bool getBoolean() const; // false if not a boolean
  80     bool getNumber(double&) const;
  81     double getNumber() const; // NaN if not a number
  82     bool getString(UString&) const;
  83     UString getString() const; // null string if not a string
  84     JSObject *getObject(); // NULL if not an object
  85     const JSObject *getObject() const; // NULL if not an object
  86
  87     // Extracting integer values.
  88     bool getUInt32(uint32_t&) const;
  89     bool getTruncatedInt32(int32_t&) const;
  90     bool getTruncatedUInt32(uint32_t&) const;
  91
  92     JSValue* getByIndex(ExecState* exec, unsigned propertyName) const;
  93
  94     // Basic conversions.
  95     JSValue* toPrimitive(ExecState* exec, JSType preferredType = UnspecifiedType) const;
  96     bool getPrimitiveNumber(ExecState* exec, double& number, JSValue*& value);
  97
  98     bool toBoolean(ExecState *exec) const;
  99     double toNumber(ExecState *exec) const;
 100     JSValue* toJSNumber(ExecState*) const; // Fast path for when you expect that the value is an immediate number.
 101     UString toString(ExecState *exec) const;
 102     JSObject *toObject(ExecState *exec) const;
 103
 104     // Integer conversions.
 105     double toInteger(ExecState*) const;
 106     double toIntegerPreserveNaN(ExecState*) const;
 107     int32_t toInt32(ExecState*) const;
 108     int32_t toInt32(ExecState*, bool& ok) const;
 109     uint32_t toUInt32(ExecState*) const;
 110     uint32_t toUInt32(ExecState*, bool& ok) const;
 111     uint16_t toUInt16(ExecState *exec) const;
 112
 113     // These are identical logic to above, and faster than jsNumber(number)->toInt32(exec)
 114     static int32_t toInt32(double);
 115     static int32_t toUInt32(double);
 116
 117     // Floating point conversions.
 118     float toFloat(ExecState*) const;
 119
 120     // Object-level properties...
 121
 122     /**
 123      * Whether or not the value implements the call() method. If it does, this also
 124      * implies this is an object, and hence it can be cast to a JSObject
 125      * and the call method can be invoked
 126      *
 127      * @return true if this is an object implementing the call() method, otherwise
 128      * false
 129      */
 130     bool implementsCall() const;
 131
 132     // Garbage collection.
 133     void mark();
 134     bool marked() const;
 135
 136     static int32_t toInt32SlowCase(double, bool& ok);
 137     static uint32_t toUInt32SlowCase(double, bool& ok);
 138
 139 private:
 140     int32_t toInt32SlowCase(ExecState*, bool& ok) const;
 141     uint32_t toUInt32SlowCase(ExecState*, bool& ok) const;
 142
 143     // Implementation details.
 144     JSCell *asCell();
 145     const JSCell *asCell() const;
 146
 147     // emulate Q_DISABLE_COPY to avoid msvc linker errors
 148 #if !defined(_MSC_VER) || !defined(MAKE_KJS_LIB)
 149     // Give a compile time error if we try to copy one of these.
 150     JSValue(const JSValue&);
 151     JSValue& operator=(const JSValue&);
 152 #endif
 153 };
 154
 155 class KJS_EXPORT JSCell : public JSValue {
 156     friend class Collector;
 157     friend class NumberImp;
 158     friend class StringImp;
 159     friend class JSObject;
 160     friend class GetterSetterImp;
 161 private:
 162     explicit JSCell();
 163     virtual ~JSCell();
 164 public:
 165     // Querying the type.
 166     virtual JSType type() const = 0;
 167     bool isNumber() const;
 168     bool isString() const;
 169     bool isObject() const;
 170     bool isObject(const ClassInfo *) const;
 171
 172     // Extracting the value.
 173     bool getNumber(double&) const;
 174     double getNumber() const; // NaN if not a number
 175     bool getString(UString&) const;
 176     UString getString() const; // null string if not a string
 177     JSObject *getObject(); // NULL if not an object
 178     const JSObject *getObject() const; // NULL if not an object
 179
 180     // Extracting integer values.
 181     virtual bool getUInt32(uint32_t&) const;
 182     virtual bool getTruncatedInt32(int32_t&) const;
 183     virtual bool getTruncatedUInt32(uint32_t&) const;
 184
 185     // Basic conversions.
 186     virtual JSValue *toPrimitive(ExecState *exec, JSType preferredType = UnspecifiedType) const = 0;
 187     virtual bool getPrimitiveNumber(ExecState* exec, double& number, JSValue*& value) = 0;
 188     virtual bool toBoolean(ExecState *exec) const = 0;
 189     virtual double toNumber(ExecState *exec) const = 0;
 190     virtual UString toString(ExecState *exec) const = 0;
 191     virtual JSObject *toObject(ExecState *exec) const = 0;
 192
 193     // Higher-level (object-like) properties:
 194     virtual bool implementsCall() const;
 195
 196     // Garbage collection.
 197     void *operator new(size_t);
 198     virtual void mark();
 199     bool marked() const;
 200 };
 201
 202 KJS_EXPORT JSValue *jsNumberCell(double);
 203
 204 KJS_EXPORT JSCell* jsString(); // returns empty string
 205 KJS_EXPORT JSCell* jsString(const UString&); // returns empty string if passed null string
 206 KJS_EXPORT JSCell* jsString(const char* = ""); // returns empty string if passed 0
 207 KJS_EXPORT JSCell* jsString(const char* s, int len);
 208
 209 // should be used for strings that are owned by an object that will
 210 // likely outlive the JSValue this makes, such as the parse tree or a
 211 // DOM object that contains a UString
 212 JSCell *jsOwnedString(const UString&);
 213
 214 KJS_EXPORT extern const double NaN;
 215 KJS_EXPORT extern const double Inf;
 216
 217 inline JSValue* jsUndefined()
 218 {
 219     return JSImmediate::undefinedImmediate();
 220 }
 221
 222 inline JSValue* jsNull()
 223 {
 224     return JSImmediate::nullImmediate();
 225 }
 226
 227 inline JSValue* jsNaN()
 228 {
 229     static const union {
 230         uint64_t bits;
 231         double d;
 232     } nan = { 0x7ff80000ULL << 32 };
 233     return jsNumberCell(nan.d);
 234 }
 235
 236 inline JSValue* jsBoolean(bool b)
 237 {
 238     return b ? JSImmediate::trueImmediate() : JSImmediate::falseImmediate();
 239 }
 240
 241 ALWAYS_INLINE JSValue* jsNumber(double d)
 242 {
 243     JSValue* v = JSImmediate::from(d);
 244     return v ? v : jsNumberCell(d);
 245 }
 246
 247 ALWAYS_INLINE JSValue* jsNumber(int i)
 248 {
 249     JSValue* v = JSImmediate::from(i);
 250     return v ? v : jsNumberCell(i);
 251 }
 252
 253 ALWAYS_INLINE JSValue* jsNumber(unsigned i)
 254 {
 255     JSValue* v = JSImmediate::from(i);
 256     return v ? v : jsNumberCell(i);
 257 }
 258
 259 ALWAYS_INLINE JSValue* jsNumber(long i)
 260 {
 261     JSValue* v = JSImmediate::from(i);
 262     return v ? v : jsNumberCell(i);
 263 }
 264
 265 ALWAYS_INLINE JSValue* jsNumber(unsigned long i)
 266 {
 267     JSValue* v = JSImmediate::from(i);
 268     return v ? v : jsNumberCell(i);
 269 }
 270
 271 ALWAYS_INLINE JSValue* jsNumber(long long i)
 272 {
 273     JSValue* v = JSImmediate::from(i);
 274     return v ? v : jsNumberCell(static_cast<double>(i));
 275 }
 276
 277 ALWAYS_INLINE JSValue* jsNumber(unsigned long long i)
 278 {
 279     JSValue* v = JSImmediate::from(i);
 280     return v ? v : jsNumberCell(static_cast<double>(i));
 281 }
 282
 283 ALWAYS_INLINE JSValue* jsNumberFromAnd(ExecState *exec, JSValue* v1, JSValue* v2)
 284 {
 285     if (JSImmediate::areBothImmediateNumbers(v1, v2))
 286         return JSImmediate::andImmediateNumbers(v1, v2);
 287     return jsNumber(v1->toInt32(exec) & v2->toInt32(exec));
 288 }
 289
 290 inline JSValue::JSValue()
 291 {
 292 }
 293
 294 inline JSValue::~JSValue()
 295 {
 296 }
 297
 298 inline JSCell::JSCell()
 299 {
 300 }
 301
 302 inline JSCell::~JSCell()
 303 {
 304 }
 305
 306 inline bool JSCell::isNumber() const
 307 {
 308     return type() == NumberType;
 309 }
 310
 311 inline bool JSCell::isString() const
 312 {
 313     return type() == StringType;
 314 }
 315
 316 inline bool JSCell::isObject() const
 317 {
 318     return type() == ObjectType;
 319 }
 320
 321 inline bool JSCell::marked() const
 322 {
 323     return Collector::isCellMarked(this);
 324 }
 325
 326 inline void JSCell::mark()
 327 {
 328     return Collector::markCell(this);
 329 }
 330
 331 ALWAYS_INLINE JSCell* JSValue::asCell()
 332 {
 333     ASSERT(!JSImmediate::isImmediate(this));
 334     return static_cast<JSCell*>(this);
 335 }
 336
 337 ALWAYS_INLINE const JSCell* JSValue::asCell() const
 338 {
 339     ASSERT(!JSImmediate::isImmediate(this));
 340     return static_cast<const JSCell*>(this);
 341 }
 342
 343 inline bool JSValue::isUndefined() const
 344 {
 345     return this == jsUndefined();
 346 }
 347
 348 inline bool JSValue::isNull() const
 349 {
 350     return this == jsNull();
 351 }
 352
 353 inline bool JSValue::isUndefinedOrNull() const
 354 {
 355     return JSImmediate::isUndefinedOrNull(this);
 356 }
 357
 358 inline bool JSValue::isBoolean() const
 359 {
 360     return JSImmediate::isBoolean(this);
 361 }
 362
 363 inline bool JSValue::isNumber() const
 364 {
 365     return JSImmediate::isNumber(this) ||
 366            (!JSImmediate::isImmediate(this) && asCell()->isNumber());
 367 }
 368
 369 inline bool JSValue::isString() const
 370 {
 371     return !JSImmediate::isImmediate(this) && asCell()->isString();
 372 }
 373
 374 inline bool JSValue::isObject() const
 375 {
 376     return !JSImmediate::isImmediate(this) && asCell()->isObject();
 377 }
 378
 379 inline bool JSValue::getBoolean(bool& v) const
 380 {
 381     if (JSImmediate::isBoolean(this)) {
 382         v = JSImmediate::toBoolean(this);
 383         return true;
 384     }
 385
 386     return false;
 387 }
 388
 389 inline bool JSValue::getBoolean() const
 390 {
 391     return JSImmediate::isBoolean(this) ? JSImmediate::toBoolean(this) : false;
 392 }
 393
 394 inline bool JSValue::getNumber(double& v) const
 395 {
 396     if (JSImmediate::isImmediate(this)) {
 397         return JSImmediate::getNumber(this, v);
 398     }
 399     return asCell()->getNumber(v);
 400 }
 401
 402 inline double JSValue::getNumber() const
 403 {
 404     return JSImmediate::isImmediate(this) ? JSImmediate::getNumber(this) : asCell()->getNumber();
 405 }
 406
 407 inline bool JSValue::getString(UString& s) const
 408 {
 409     return !JSImmediate::isImmediate(this) && asCell()->getString(s);
 410 }
 411
 412 inline UString JSValue::getString() const
 413 {
 414     return JSImmediate::isImmediate(this) ? UString() : asCell()->getString();
 415 }
 416
 417 inline JSObject *JSValue::getObject()
 418 {
 419     return JSImmediate::isImmediate(this) ? 0 : asCell()->getObject();
 420 }
 421
 422 inline const JSObject *JSValue::getObject() const
 423 {
 424     return JSImmediate::isImmediate(this) ? 0 : asCell()->getObject();
 425 }
 426
 427 ALWAYS_INLINE bool JSValue::getUInt32(uint32_t& v) const
 428 {
 429     return JSImmediate::isImmediate(this) ? JSImmediate::getUInt32(this, v) : asCell()->getUInt32(v);
 430 }
 431
 432 ALWAYS_INLINE bool JSValue::getTruncatedInt32(int32_t& v) const
 433 {
 434     return JSImmediate::isImmediate(this) ? JSImmediate::getTruncatedInt32(this, v) : asCell()->getTruncatedInt32(v);
 435 }
 436
 437 inline bool JSValue::getTruncatedUInt32(uint32_t& v) const
 438 {
 439     return JSImmediate::isImmediate(this) ? JSImmediate::getTruncatedUInt32(this, v) : asCell()->getTruncatedUInt32(v);
 440 }
 441
 442 inline void JSValue::mark()
 443 {
 444     ASSERT(!JSImmediate::isImmediate(this)); // callers should check !marked() before calling mark()
 445     asCell()->mark();
 446 }
 447
 448 inline bool JSValue::marked() const
 449 {
 450     return JSImmediate::isImmediate(this) || asCell()->marked();
 451 }
 452
 453 inline JSType JSValue::type() const
 454 {
 455     return JSImmediate::isImmediate(this) ? JSImmediate::type(this) : asCell()->type();
 456 }
 457
 458 inline JSValue* JSValue::toPrimitive(ExecState* exec, JSType preferredType) const
 459 {
 460     return JSImmediate::isImmediate(this) ? const_cast<JSValue*>(this) : asCell()->toPrimitive(exec, preferredType);
 461 }
 462
 463 inline bool JSValue::getPrimitiveNumber(ExecState* exec, double& number, JSValue*& value)
 464 {
 465     if (JSImmediate::isImmediate(this)) {
 466         number = JSImmediate::toDouble(this);
 467         value = this;
 468         return true;
 469     }
 470     return asCell()->getPrimitiveNumber(exec, number, value);
 471 }
 472
 473 inline bool JSValue::toBoolean(ExecState *exec) const
 474 {
 475     return JSImmediate::isImmediate(this) ? JSImmediate::toBoolean(this) : asCell()->toBoolean(exec);
 476 }
 477
 478 ALWAYS_INLINE double JSValue::toNumber(ExecState *exec) const
 479 {
 480     return JSImmediate::isImmediate(this) ? JSImmediate::toDouble(this) : asCell()->toNumber(exec);
 481 }
 482
 483 ALWAYS_INLINE JSValue* JSValue::toJSNumber(ExecState* exec) const
 484 {
 485     return JSImmediate::isNumber(this) ? const_cast<JSValue*>(this) : jsNumber(this->toNumber(exec));
 486 }
 487
 488 inline UString JSValue::toString(ExecState *exec) const
 489 {
 490     return JSImmediate::isImmediate(this) ? JSImmediate::toString(this) : asCell()->toString(exec);
 491 }
 492
 493 inline JSObject* JSValue::toObject(ExecState* exec) const
 494 {
 495     return JSImmediate::isImmediate(this) ? JSImmediate::toObject(this, exec) : asCell()->toObject(exec);
 496 }
 497
 498 ALWAYS_INLINE int32_t JSValue::toInt32(ExecState* exec) const
 499 {
 500     int32_t i;
 501     if (getTruncatedInt32(i))
 502         return i;
 503     bool ok;
 504     return toInt32SlowCase(exec, ok);
 505 }
 506
 507 inline uint32_t JSValue::toUInt32(ExecState* exec) const
 508 {
 509     uint32_t i;
 510     if (getTruncatedUInt32(i))
 511         return i;
 512     bool ok;
 513     return toUInt32SlowCase(exec, ok);
 514 }
 515
 516 inline int32_t JSValue::toInt32(double val)
 517 {
 518     if (!(val >= -2147483648.0 && val < 2147483648.0)) {
 519         bool ignored;
 520         return toInt32SlowCase(val, ignored);
 521     }
 522     return static_cast<int32_t>(val);
 523 }
 524
 525 inline int32_t JSValue::toUInt32(double val)
 526 {
 527     if (!(val >= 0.0 && val < 4294967296.0)) {
 528         bool ignored;
 529         return toUInt32SlowCase(val, ignored);
 530     }
 531     return static_cast<uint32_t>(val);
 532 }
 533
 534 inline int32_t JSValue::toInt32(ExecState* exec, bool& ok) const
 535 {
 536     int32_t i;
 537     if (getTruncatedInt32(i)) {
 538         ok = true;
 539         return i;
 540     }
 541     return toInt32SlowCase(exec, ok);
 542 }
 543
 544 inline uint32_t JSValue::toUInt32(ExecState* exec, bool& ok) const
 545 {
 546     uint32_t i;
 547     if (getTruncatedUInt32(i)) {
 548         ok = true;
 549         return i;
 550     }
 551     return toUInt32SlowCase(exec, ok);
 552 }
 553
 554 inline bool JSValue::implementsCall() const
 555 {
 556     if (JSImmediate::isImmediate(this))
 557        return false; // immediate values are never calleable.
 558     else
 559        return asCell()->implementsCall();
 560 }
 561
 562 } // namespace
 563
 564 #endif // KJS_VALUE_H