JavaScriptCore/runtime/JSValue.h

   1 /*
   2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
   4  *  Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009 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 JSValue_h
  24 #define JSValue_h
  25
  26 #include "CallData.h"
  27 #include "ConstructData.h"
  28 #include <math.h>
  29 #include <stddef.h> // for size_t
  30 #include <stdint.h>
  31 #include <wtf/AlwaysInline.h>
  32 #include <wtf/Assertions.h>
  33 #include <wtf/HashTraits.h>
  34 #include <wtf/MathExtras.h>
  35
  36 namespace JSC {
  37
  38     class Identifier;
  39     class JSCell;
  40     class JSGlobalData;
  41     class JSImmediate;
  42     class JSObject;
  43     class JSString;
  44     class PropertySlot;
  45     class PutPropertySlot;
  46     class UString;
  47
  48     struct ClassInfo;
  49     struct Instruction;
  50
  51     enum PreferredPrimitiveType { NoPreference, PreferNumber, PreferString };
  52
  53 #if USE(JSVALUE32_64)
  54     typedef int64_t EncodedJSValue;
  55 #else
  56     typedef void* EncodedJSValue;
  57 #endif
  58
  59     double nonInlineNaN();
  60     int32_t toInt32SlowCase(double, bool& ok);
  61     uint32_t toUInt32SlowCase(double, bool& ok);
  62
  63     class JSValue {
  64         friend class JSImmediate;
  65         friend struct EncodedJSValueHashTraits;
  66         friend class JIT;
  67         friend class JITStubs;
  68         friend class JITStubCall;
  69
  70     public:
  71         static EncodedJSValue encode(JSValue value);
  72         static JSValue decode(EncodedJSValue ptr);
  73 #if !USE(JSVALUE32_64)
  74     private:
  75         static JSValue makeImmediate(intptr_t value);
  76         intptr_t immediateValue();
  77     public:
  78 #endif
  79         enum JSNullTag { JSNull };
  80         enum JSUndefinedTag { JSUndefined };
  81         enum JSTrueTag { JSTrue };
  82         enum JSFalseTag { JSFalse };
  83         enum EncodeAsDoubleTag { EncodeAsDouble };
  84
  85         JSValue();
  86         JSValue(JSNullTag);
  87         JSValue(JSUndefinedTag);
  88         JSValue(JSTrueTag);
  89         JSValue(JSFalseTag);
  90         JSValue(JSCell* ptr);
  91         JSValue(const JSCell* ptr);
  92
  93         // Numbers
  94         JSValue(EncodeAsDoubleTag, ExecState*, double);
  95         JSValue(ExecState*, double);
  96         JSValue(ExecState*, char);
  97         JSValue(ExecState*, unsigned char);
  98         JSValue(ExecState*, short);
  99         JSValue(ExecState*, unsigned short);
 100         JSValue(ExecState*, int);
 101         JSValue(ExecState*, unsigned);
 102         JSValue(ExecState*, long);
 103         JSValue(ExecState*, unsigned long);
 104         JSValue(ExecState*, long long);
 105         JSValue(ExecState*, unsigned long long);
 106         JSValue(JSGlobalData*, double);
 107         JSValue(JSGlobalData*, int);
 108         JSValue(JSGlobalData*, unsigned);
 109
 110         operator bool() const;
 111         bool operator==(const JSValue& other) const;
 112         bool operator!=(const JSValue& other) const;
 113
 114         bool isInt32() const;
 115         bool isUInt32() const;
 116         bool isDouble() const;
 117         bool isTrue() const;
 118         bool isFalse() const;
 119
 120         int32_t asInt32() const;
 121         uint32_t asUInt32() const;
 122         double asDouble() const;
 123
 124         // Querying the type.
 125         bool isUndefined() const;
 126         bool isNull() const;
 127         bool isUndefinedOrNull() const;
 128         bool isBoolean() const;
 129         bool isNumber() const;
 130         bool isString() const;
 131         bool isGetterSetter() const;
 132         bool isObject() const;
 133         bool inherits(const ClassInfo*) const;
 134
 135         // Extracting the value.
 136         bool getBoolean(bool&) const;
 137         bool getBoolean() const; // false if not a boolean
 138         bool getNumber(double&) const;
 139         double uncheckedGetNumber() const;
 140         bool getString(ExecState* exec, UString&) const;
 141         UString getString(ExecState* exec) const; // null string if not a string
 142         JSObject* getObject() const; // 0 if not an object
 143
 144         CallType getCallData(CallData&);
 145         ConstructType getConstructData(ConstructData&);
 146
 147         // Extracting integer values.
 148         bool getUInt32(uint32_t&) const;
 149
 150         // Basic conversions.
 151         JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
 152         bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
 153
 154         bool toBoolean(ExecState*) const;
 155
 156         // toNumber conversion is expected to be side effect free if an exception has
 157         // been set in the ExecState already.
 158         double toNumber(ExecState*) const;
 159         JSValue toJSNumber(ExecState*) const; // Fast path for when you expect that the value is an immediate number.
 160         UString toString(ExecState*) const;
 161         UString toPrimitiveString(ExecState*) const;
 162         JSObject* toObject(ExecState*) const;
 163
 164         // Integer conversions.
 165         double toInteger(ExecState*) const;
 166         double toIntegerPreserveNaN(ExecState*) const;
 167         int32_t toInt32(ExecState*) const;
 168         int32_t toInt32(ExecState*, bool& ok) const;
 169         uint32_t toUInt32(ExecState*) const;
 170         uint32_t toUInt32(ExecState*, bool& ok) const;
 171
 172 #if ENABLE(JSC_ZOMBIES)
 173         bool isZombie() const;
 174 #endif
 175
 176         // Floating point conversions (this is a convenience method for webcore;
 177         // signle precision float is not a representation used in JS or JSC).
 178         float toFloat(ExecState* exec) const { return static_cast<float>(toNumber(exec)); }
 179
 180         // Object operations, with the toObject operation included.
 181         JSValue get(ExecState*, const Identifier& propertyName) const;
 182         JSValue get(ExecState*, const Identifier& propertyName, PropertySlot&) const;
 183         JSValue get(ExecState*, unsigned propertyName) const;
 184         JSValue get(ExecState*, unsigned propertyName, PropertySlot&) const;
 185         void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
 186         void put(ExecState*, unsigned propertyName, JSValue);
 187
 188         bool needsThisConversion() const;
 189         JSObject* toThisObject(ExecState*) const;
 190         UString toThisString(ExecState*) const;
 191         JSString* toThisJSString(ExecState*);
 192
 193         static bool equal(ExecState* exec, JSValue v1, JSValue v2);
 194         static bool equalSlowCase(ExecState* exec, JSValue v1, JSValue v2);
 195         static bool equalSlowCaseInline(ExecState* exec, JSValue v1, JSValue v2);
 196         static bool strictEqual(ExecState* exec, JSValue v1, JSValue v2);
 197         static bool strictEqualSlowCase(ExecState* exec, JSValue v1, JSValue v2);
 198         static bool strictEqualSlowCaseInline(ExecState* exec, JSValue v1, JSValue v2);
 199
 200         JSValue getJSNumber(); // JSValue() if this is not a JSNumber or number object
 201
 202         bool isCell() const;
 203         JSCell* asCell() const;
 204
 205 #ifndef NDEBUG
 206         char* description();
 207 #endif
 208
 209     private:
 210         enum HashTableDeletedValueTag { HashTableDeletedValue };
 211         JSValue(HashTableDeletedValueTag);
 212
 213         inline const JSValue asValue() const { return *this; }
 214         JSObject* toObjectSlowCase(ExecState*) const;
 215         JSObject* toThisObjectSlowCase(ExecState*) const;
 216
 217         enum { Int32Tag =        0xffffffff };
 218         enum { CellTag =         0xfffffffe };
 219         enum { TrueTag =         0xfffffffd };
 220         enum { FalseTag =        0xfffffffc };
 221         enum { NullTag =         0xfffffffb };
 222         enum { UndefinedTag =    0xfffffffa };
 223         enum { EmptyValueTag =   0xfffffff9 };
 224         enum { DeletedValueTag = 0xfffffff8 };
 225
 226         enum { LowestTag =  DeletedValueTag };
 227
 228         uint32_t tag() const;
 229         int32_t payload() const;
 230
 231         JSObject* synthesizePrototype(ExecState*) const;
 232         JSObject* synthesizeObject(ExecState*) const;
 233
 234 #if USE(JSVALUE32_64)
 235         union {
 236             EncodedJSValue asEncodedJSValue;
 237             double asDouble;
 238 #if PLATFORM(BIG_ENDIAN)
 239             struct {
 240                 int32_t tag;
 241                 int32_t payload;
 242             } asBits;
 243 #else
 244             struct {
 245                 int32_t payload;
 246                 int32_t tag;
 247             } asBits;
 248 #endif
 249         } u;
 250 #else // USE(JSVALUE32_64)
 251         JSCell* m_ptr;
 252 #endif // USE(JSVALUE32_64)
 253     };
 254
 255 #if USE(JSVALUE32_64)
 256     typedef IntHash<EncodedJSValue> EncodedJSValueHash;
 257
 258     struct EncodedJSValueHashTraits : HashTraits<EncodedJSValue> {
 259         static const bool emptyValueIsZero = false;
 260         static EncodedJSValue emptyValue() { return JSValue::encode(JSValue()); }
 261         static void constructDeletedValue(EncodedJSValue& slot) { slot = JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 262         static bool isDeletedValue(EncodedJSValue value) { return value == JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 263     };
 264 #else
 265     typedef PtrHash<EncodedJSValue> EncodedJSValueHash;
 266
 267     struct EncodedJSValueHashTraits : HashTraits<EncodedJSValue> {
 268         static void constructDeletedValue(EncodedJSValue& slot) { slot = JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 269         static bool isDeletedValue(EncodedJSValue value) { return value == JSValue::encode(JSValue(JSValue::HashTableDeletedValue)); }
 270     };
 271 #endif
 272
 273     // Stand-alone helper functions.
 274     inline JSValue jsNull()
 275     {
 276         return JSValue(JSValue::JSNull);
 277     }
 278
 279     inline JSValue jsUndefined()
 280     {
 281         return JSValue(JSValue::JSUndefined);
 282     }
 283
 284     inline JSValue jsBoolean(bool b)
 285     {
 286         return b ? JSValue(JSValue::JSTrue) : JSValue(JSValue::JSFalse);
 287     }
 288
 289     ALWAYS_INLINE JSValue jsDoubleNumber(ExecState* exec, double d)
 290     {
 291         return JSValue(JSValue::EncodeAsDouble, exec, d);
 292     }
 293
 294     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, double d)
 295     {
 296         return JSValue(exec, d);
 297     }
 298
 299     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, char i)
 300     {
 301         return JSValue(exec, i);
 302     }
 303
 304     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, unsigned char i)
 305     {
 306         return JSValue(exec, i);
 307     }
 308
 309     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, short i)
 310     {
 311         return JSValue(exec, i);
 312     }
 313
 314     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, unsigned short i)
 315     {
 316         return JSValue(exec, i);
 317     }
 318
 319     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, int i)
 320     {
 321         return JSValue(exec, i);
 322     }
 323
 324     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, unsigned i)
 325     {
 326         return JSValue(exec, i);
 327     }
 328
 329     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, long i)
 330     {
 331         return JSValue(exec, i);
 332     }
 333
 334     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, unsigned long i)
 335     {
 336         return JSValue(exec, i);
 337     }
 338
 339     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, long long i)
 340     {
 341         return JSValue(exec, i);
 342     }
 343
 344     ALWAYS_INLINE JSValue jsNumber(ExecState* exec, unsigned long long i)
 345     {
 346         return JSValue(exec, i);
 347     }
 348
 349     ALWAYS_INLINE JSValue jsNumber(JSGlobalData* globalData, double d)
 350     {
 351         return JSValue(globalData, d);
 352     }
 353
 354     ALWAYS_INLINE JSValue jsNumber(JSGlobalData* globalData, int i)
 355     {
 356         return JSValue(globalData, i);
 357     }
 358
 359     ALWAYS_INLINE JSValue jsNumber(JSGlobalData* globalData, unsigned i)
 360     {
 361         return JSValue(globalData, i);
 362     }
 363
 364     inline bool operator==(const JSValue a, const JSCell* b) { return a == JSValue(b); }
 365     inline bool operator==(const JSCell* a, const JSValue b) { return JSValue(a) == b; }
 366
 367     inline bool operator!=(const JSValue a, const JSCell* b) { return a != JSValue(b); }
 368     inline bool operator!=(const JSCell* a, const JSValue b) { return JSValue(a) != b; }
 369
 370     inline int32_t toInt32(double val)
 371     {
 372         if (!(val >= -2147483648.0 && val < 2147483648.0)) {
 373             bool ignored;
 374             return toInt32SlowCase(val, ignored);
 375         }
 376         return static_cast<int32_t>(val);
 377     }
 378
 379     inline uint32_t toUInt32(double val)
 380     {
 381         if (!(val >= 0.0 && val < 4294967296.0)) {
 382             bool ignored;
 383             return toUInt32SlowCase(val, ignored);
 384         }
 385         return static_cast<uint32_t>(val);
 386     }
 387
 388     // FIXME: We should deprecate this and just use JSValue::asCell() instead.
 389     JSCell* asCell(JSValue);
 390
 391     inline JSCell* asCell(JSValue value)
 392     {
 393         return value.asCell();
 394     }
 395
 396     ALWAYS_INLINE int32_t JSValue::toInt32(ExecState* exec) const
 397     {
 398         if (isInt32())
 399             return asInt32();
 400         bool ignored;
 401         return toInt32SlowCase(toNumber(exec), ignored);
 402     }
 403
 404     inline uint32_t JSValue::toUInt32(ExecState* exec) const
 405     {
 406         if (isUInt32())
 407             return asInt32();
 408         bool ignored;
 409         return toUInt32SlowCase(toNumber(exec), ignored);
 410     }
 411
 412     inline int32_t JSValue::toInt32(ExecState* exec, bool& ok) const
 413     {
 414         if (isInt32()) {
 415             ok = true;
 416             return asInt32();
 417         }
 418         return toInt32SlowCase(toNumber(exec), ok);
 419     }
 420
 421     inline uint32_t JSValue::toUInt32(ExecState* exec, bool& ok) const
 422     {
 423         if (isUInt32()) {
 424             ok = true;
 425             return asInt32();
 426         }
 427         return toUInt32SlowCase(toNumber(exec), ok);
 428     }
 429
 430 #if USE(JSVALUE32_64)
 431     inline JSValue jsNaN(ExecState* exec)
 432     {
 433         return JSValue(exec, nonInlineNaN());
 434     }
 435
 436     // JSValue member functions.
 437     inline EncodedJSValue JSValue::encode(JSValue value)
 438     {
 439         return value.u.asEncodedJSValue;
 440     }
 441
 442     inline JSValue JSValue::decode(EncodedJSValue encodedJSValue)
 443     {
 444         JSValue v;
 445         v.u.asEncodedJSValue = encodedJSValue;
 446 #if ENABLE(JSC_ZOMBIES)
 447         ASSERT(!v.isZombie());
 448 #endif
 449         return v;
 450     }
 451
 452     inline JSValue::JSValue()
 453     {
 454         u.asBits.tag = EmptyValueTag;
 455         u.asBits.payload = 0;
 456     }
 457
 458     inline JSValue::JSValue(JSNullTag)
 459     {
 460         u.asBits.tag = NullTag;
 461         u.asBits.payload = 0;
 462     }
 463
 464     inline JSValue::JSValue(JSUndefinedTag)
 465     {
 466         u.asBits.tag = UndefinedTag;
 467         u.asBits.payload = 0;
 468     }
 469
 470     inline JSValue::JSValue(JSTrueTag)
 471     {
 472         u.asBits.tag = TrueTag;
 473         u.asBits.payload = 0;
 474     }
 475
 476     inline JSValue::JSValue(JSFalseTag)
 477     {
 478         u.asBits.tag = FalseTag;
 479         u.asBits.payload = 0;
 480     }
 481
 482     inline JSValue::JSValue(HashTableDeletedValueTag)
 483     {
 484         u.asBits.tag = DeletedValueTag;
 485         u.asBits.payload = 0;
 486     }
 487
 488     inline JSValue::JSValue(JSCell* ptr)
 489     {
 490         if (ptr)
 491             u.asBits.tag = CellTag;
 492         else
 493             u.asBits.tag = EmptyValueTag;
 494         u.asBits.payload = reinterpret_cast<int32_t>(ptr);
 495 #if ENABLE(JSC_ZOMBIES)
 496         ASSERT(!isZombie());
 497 #endif
 498     }
 499
 500     inline JSValue::JSValue(const JSCell* ptr)
 501     {
 502         if (ptr)
 503             u.asBits.tag = CellTag;
 504         else
 505             u.asBits.tag = EmptyValueTag;
 506         u.asBits.payload = reinterpret_cast<int32_t>(const_cast<JSCell*>(ptr));
 507 #if ENABLE(JSC_ZOMBIES)
 508         ASSERT(!isZombie());
 509 #endif
 510     }
 511
 512     inline JSValue::operator bool() const
 513     {
 514         ASSERT(tag() != DeletedValueTag);
 515         return tag() != EmptyValueTag;
 516     }
 517
 518     inline bool JSValue::operator==(const JSValue& other) const
 519     {
 520         return u.asEncodedJSValue == other.u.asEncodedJSValue;
 521     }
 522
 523     inline bool JSValue::operator!=(const JSValue& other) const
 524     {
 525         return u.asEncodedJSValue != other.u.asEncodedJSValue;
 526     }
 527
 528     inline bool JSValue::isUndefined() const
 529     {
 530         return tag() == UndefinedTag;
 531     }
 532
 533     inline bool JSValue::isNull() const
 534     {
 535         return tag() == NullTag;
 536     }
 537
 538     inline bool JSValue::isUndefinedOrNull() const
 539     {
 540         return isUndefined() || isNull();
 541     }
 542
 543     inline bool JSValue::isCell() const
 544     {
 545         return tag() == CellTag;
 546     }
 547
 548     inline bool JSValue::isInt32() const
 549     {
 550         return tag() == Int32Tag;
 551     }
 552
 553     inline bool JSValue::isUInt32() const
 554     {
 555         return tag() == Int32Tag && asInt32() > -1;
 556     }
 557
 558     inline bool JSValue::isDouble() const
 559     {
 560         return tag() < LowestTag;
 561     }
 562
 563     inline bool JSValue::isTrue() const
 564     {
 565         return tag() == TrueTag;
 566     }
 567
 568     inline bool JSValue::isFalse() const
 569     {
 570         return tag() == FalseTag;
 571     }
 572
 573     inline uint32_t JSValue::tag() const
 574     {
 575         return u.asBits.tag;
 576     }
 577
 578     inline int32_t JSValue::payload() const
 579     {
 580         return u.asBits.payload;
 581     }
 582
 583     inline int32_t JSValue::asInt32() const
 584     {
 585         ASSERT(isInt32());
 586         return u.asBits.payload;
 587     }
 588
 589     inline uint32_t JSValue::asUInt32() const
 590     {
 591         ASSERT(isUInt32());
 592         return u.asBits.payload;
 593     }
 594
 595     inline double JSValue::asDouble() const
 596     {
 597         ASSERT(isDouble());
 598         return u.asDouble;
 599     }
 600
 601     ALWAYS_INLINE JSCell* JSValue::asCell() const
 602     {
 603         ASSERT(isCell());
 604         return reinterpret_cast<JSCell*>(u.asBits.payload);
 605     }
 606
 607     ALWAYS_INLINE JSValue::JSValue(EncodeAsDoubleTag, ExecState*, double d)
 608     {
 609         u.asDouble = d;
 610     }
 611
 612     inline JSValue::JSValue(ExecState* exec, double d)
 613     {
 614         const int32_t asInt32 = static_cast<int32_t>(d);
 615         if (asInt32 != d || (!asInt32 && signbit(d))) { // true for -0.0
 616             u.asDouble = d;
 617             return;
 618         }
 619         *this = JSValue(exec, static_cast<int32_t>(d));
 620     }
 621
 622     inline JSValue::JSValue(ExecState* exec, char i)
 623     {
 624         *this = JSValue(exec, static_cast<int32_t>(i));
 625     }
 626
 627     inline JSValue::JSValue(ExecState* exec, unsigned char i)
 628     {
 629         *this = JSValue(exec, static_cast<int32_t>(i));
 630     }
 631
 632     inline JSValue::JSValue(ExecState* exec, short i)
 633     {
 634         *this = JSValue(exec, static_cast<int32_t>(i));
 635     }
 636
 637     inline JSValue::JSValue(ExecState* exec, unsigned short i)
 638     {
 639         *this = JSValue(exec, static_cast<int32_t>(i));
 640     }
 641
 642     inline JSValue::JSValue(ExecState*, int i)
 643     {
 644         u.asBits.tag = Int32Tag;
 645         u.asBits.payload = i;
 646     }
 647
 648     inline JSValue::JSValue(ExecState* exec, unsigned i)
 649     {
 650         if (static_cast<int32_t>(i) < 0) {
 651             *this = JSValue(exec, static_cast<double>(i));
 652             return;
 653         }
 654         *this = JSValue(exec, static_cast<int32_t>(i));
 655     }
 656
 657     inline JSValue::JSValue(ExecState* exec, long i)
 658     {
 659         if (static_cast<int32_t>(i) != i) {
 660             *this = JSValue(exec, static_cast<double>(i));
 661             return;
 662         }
 663         *this = JSValue(exec, static_cast<int32_t>(i));
 664     }
 665
 666     inline JSValue::JSValue(ExecState* exec, unsigned long i)
 667     {
 668         if (static_cast<uint32_t>(i) != i) {
 669             *this = JSValue(exec, static_cast<double>(i));
 670             return;
 671         }
 672         *this = JSValue(exec, static_cast<uint32_t>(i));
 673     }
 674
 675     inline JSValue::JSValue(ExecState* exec, long long i)
 676     {
 677         if (static_cast<int32_t>(i) != i) {
 678             *this = JSValue(exec, static_cast<double>(i));
 679             return;
 680         }
 681         *this = JSValue(exec, static_cast<int32_t>(i));
 682     }
 683
 684     inline JSValue::JSValue(ExecState* exec, unsigned long long i)
 685     {
 686         if (static_cast<uint32_t>(i) != i) {
 687             *this = JSValue(exec, static_cast<double>(i));
 688             return;
 689         }
 690         *this = JSValue(exec, static_cast<uint32_t>(i));
 691     }
 692
 693     inline JSValue::JSValue(JSGlobalData* globalData, double d)
 694     {
 695         const int32_t asInt32 = static_cast<int32_t>(d);
 696         if (asInt32 != d || (!asInt32 && signbit(d))) { // true for -0.0
 697             u.asDouble = d;
 698             return;
 699         }
 700         *this = JSValue(globalData, static_cast<int32_t>(d));
 701     }
 702
 703     inline JSValue::JSValue(JSGlobalData*, int i)
 704     {
 705         u.asBits.tag = Int32Tag;
 706         u.asBits.payload = i;
 707     }
 708
 709     inline JSValue::JSValue(JSGlobalData* globalData, unsigned i)
 710     {
 711         if (static_cast<int32_t>(i) < 0) {
 712             *this = JSValue(globalData, static_cast<double>(i));
 713             return;
 714         }
 715         *this = JSValue(globalData, static_cast<int32_t>(i));
 716     }
 717
 718     inline bool JSValue::isNumber() const
 719     {
 720         return isInt32() || isDouble();
 721     }
 722
 723     inline bool JSValue::isBoolean() const
 724     {
 725         return isTrue() || isFalse();
 726     }
 727
 728     inline bool JSValue::getBoolean(bool& v) const
 729     {
 730         if (isTrue()) {
 731             v = true;
 732             return true;
 733         }
 734         if (isFalse()) {
 735             v = false;
 736             return true;
 737         }
 738
 739         return false;
 740     }
 741
 742     inline bool JSValue::getBoolean() const
 743     {
 744         ASSERT(isBoolean());
 745         return tag() == TrueTag;
 746     }
 747
 748     inline double JSValue::uncheckedGetNumber() const
 749     {
 750         ASSERT(isNumber());
 751         return isInt32() ? asInt32() : asDouble();
 752     }
 753
 754     ALWAYS_INLINE JSValue JSValue::toJSNumber(ExecState* exec) const
 755     {
 756         return isNumber() ? asValue() : jsNumber(exec, this->toNumber(exec));
 757     }
 758
 759     inline bool JSValue::getNumber(double& result) const
 760     {
 761         if (isInt32()) {
 762             result = asInt32();
 763             return true;
 764         }
 765         if (isDouble()) {
 766             result = asDouble();
 767             return true;
 768         }
 769         return false;
 770     }
 771
 772 #else // USE(JSVALUE32_64)
 773
 774     // JSValue member functions.
 775     inline EncodedJSValue JSValue::encode(JSValue value)
 776     {
 777         return reinterpret_cast<EncodedJSValue>(value.m_ptr);
 778     }
 779
 780     inline JSValue JSValue::decode(EncodedJSValue ptr)
 781     {
 782         return JSValue(reinterpret_cast<JSCell*>(ptr));
 783     }
 784
 785     inline JSValue JSValue::makeImmediate(intptr_t value)
 786     {
 787         return JSValue(reinterpret_cast<JSCell*>(value));
 788     }
 789
 790     inline intptr_t JSValue::immediateValue()
 791     {
 792         return reinterpret_cast<intptr_t>(m_ptr);
 793     }
 794
 795     // 0x0 can never occur naturally because it has a tag of 00, indicating a pointer value, but a payload of 0x0, which is in the (invalid) zero page.
 796     inline JSValue::JSValue()
 797         : m_ptr(0)
 798     {
 799     }
 800
 801     // 0x4 can never occur naturally because it has a tag of 00, indicating a pointer value, but a payload of 0x4, which is in the (invalid) zero page.
 802     inline JSValue::JSValue(HashTableDeletedValueTag)
 803         : m_ptr(reinterpret_cast<JSCell*>(0x4))
 804     {
 805     }
 806
 807     inline JSValue::JSValue(JSCell* ptr)
 808         : m_ptr(ptr)
 809     {
 810 #if ENABLE(JSC_ZOMBIES)
 811         ASSERT(!isZombie());
 812 #endif
 813     }
 814
 815     inline JSValue::JSValue(const JSCell* ptr)
 816         : m_ptr(const_cast<JSCell*>(ptr))
 817     {
 818 #if ENABLE(JSC_ZOMBIES)
 819         ASSERT(!isZombie());
 820 #endif
 821     }
 822
 823     inline JSValue::operator bool() const
 824     {
 825         return m_ptr;
 826     }
 827
 828     inline bool JSValue::operator==(const JSValue& other) const
 829     {
 830         return m_ptr == other.m_ptr;
 831     }
 832
 833     inline bool JSValue::operator!=(const JSValue& other) const
 834     {
 835         return m_ptr != other.m_ptr;
 836     }
 837
 838     inline bool JSValue::isUndefined() const
 839     {
 840         return asValue() == jsUndefined();
 841     }
 842
 843     inline bool JSValue::isNull() const
 844     {
 845         return asValue() == jsNull();
 846     }
 847 #endif // USE(JSVALUE32_64)
 848
 849 } // namespace JSC
 850
 851 #endif // JSValue_h