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 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 JSNumberCell_h

    24 #define JSNumberCell_h

    25 

    26 #include "CallFrame.h"

    27 #include "JSCell.h"

    28 #include "JSImmediate.h"

    29 #include "Collector.h"

    30 #include "UString.h"

    31 #include <stddef.h> // for size_t

    32 

    33 namespace JSC {

    34 

    35     extern const double NaN;

    36     extern const double Inf;

    37 

    38 #if USE(JSVALUE32)

    39     JSValue jsNumberCell(ExecState*, double);

    40 

    41     class Identifier;

    42     class JSCell;

    43     class JSObject;

    44     class JSString;

    45     class PropertySlot;

    46 

    47     struct ClassInfo;

    48     struct Instruction;

    49 

    50     class JSNumberCell : public JSCell {

    51         friend class JIT;

    52         friend JSValue jsNumberCell(JSGlobalData*, double);

    53         friend JSValue jsNumberCell(ExecState*, double);

    54 

    55     public:

    56         double value() const { return m_value; }

    57 

    58         virtual JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;

    59         virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue& value);

    60         virtual bool toBoolean(ExecState*) const;

    61         virtual double toNumber(ExecState*) const;

    62         virtual UString toString(ExecState*) const;

    63         virtual JSObject* toObject(ExecState*) const;

    64 

    65         virtual JSObject* toThisObject(ExecState*) const;

    66         virtual JSValue getJSNumber();

    67 

    68         void* operator new(size_t size, ExecState* exec)

    69         {

    70             return exec->heap()->allocateNumber(size);

    71         }

    72 

    73         void* operator new(size_t size, JSGlobalData* globalData)

    74         {

    75             return globalData->heap.allocateNumber(size);

    76         }

    77 

    78         static PassRefPtr<Structure> createStructure(JSValue proto) { return Structure::create(proto, TypeInfo(NumberType, OverridesGetOwnPropertySlot | NeedsThisConversion), AnonymousSlotCount); }

    79 

    80     private:

    81         JSNumberCell(JSGlobalData* globalData, double value)

    82             : JSCell(globalData->numberStructure.get())

    83             , m_value(value)

    84         {

    85         }

    86 

    87         JSNumberCell(ExecState* exec, double value)

    88             : JSCell(exec->globalData().numberStructure.get())

    89             , m_value(value)

    90         {

    91         }

    92 

    93         virtual bool getUInt32(uint32_t&) const;

    94 

    95         double m_value;

    96     };

    97 

    98     JSValue jsNumberCell(JSGlobalData*, double);

    99 

   100     inline bool isNumberCell(JSValue v)

   101     {

   102         return v.isCell() && v.asCell()->isNumber();

   103     }

   104 

   105     inline JSNumberCell* asNumberCell(JSValue v)

   106     {

   107         ASSERT(isNumberCell(v));

   108         return static_cast<JSNumberCell*>(v.asCell());

   109     }

   110 

   111     ALWAYS_INLINE JSValue::JSValue(EncodeAsDoubleTag, ExecState* exec, double d)

   112     {

   113         *this = jsNumberCell(exec, d);

   114     }

   115 

   116     inline JSValue::JSValue(ExecState* exec, double d)

   117     {

   118         JSValue v = JSImmediate::from(d);

   119         *this = v ? v : jsNumberCell(exec, d);

   120     }

   121 

   122     inline JSValue::JSValue(ExecState* exec, int i)

   123     {

   124         JSValue v = JSImmediate::from(i);

   125         *this = v ? v : jsNumberCell(exec, i);

   126     }

   127 

   128     inline JSValue::JSValue(ExecState* exec, unsigned i)

   129     {

   130         JSValue v = JSImmediate::from(i);

   131         *this = v ? v : jsNumberCell(exec, i);

   132     }

   133 

   134     inline JSValue::JSValue(ExecState* exec, long i)

   135     {

   136         JSValue v = JSImmediate::from(i);

   137         *this = v ? v : jsNumberCell(exec, i);

   138     }

   139 

   140     inline JSValue::JSValue(ExecState* exec, unsigned long i)

   141     {

   142         JSValue v = JSImmediate::from(i);

   143         *this = v ? v : jsNumberCell(exec, i);

   144     }

   145 

   146     inline JSValue::JSValue(ExecState* exec, long long i)

   147     {

   148         JSValue v = JSImmediate::from(i);

   149         *this = v ? v : jsNumberCell(exec, static_cast<double>(i));

   150     }

   151 

   152     inline JSValue::JSValue(ExecState* exec, unsigned long long i)

   153     {

   154         JSValue v = JSImmediate::from(i);

   155         *this = v ? v : jsNumberCell(exec, static_cast<double>(i));

   156     }

   157 

   158     inline JSValue::JSValue(JSGlobalData* globalData, double d)

   159     {

   160         JSValue v = JSImmediate::from(d);

   161         *this = v ? v : jsNumberCell(globalData, d);

   162     }

   163 

   164     inline JSValue::JSValue(JSGlobalData* globalData, int i)

   165     {

   166         JSValue v = JSImmediate::from(i);

   167         *this = v ? v : jsNumberCell(globalData, i);

   168     }

   169 

   170     inline JSValue::JSValue(JSGlobalData* globalData, unsigned i)

   171     {

   172         JSValue v = JSImmediate::from(i);

   173         *this = v ? v : jsNumberCell(globalData, i);

   174     }

   175 

   176     inline bool JSValue::isDouble() const

   177     {

   178         return isNumberCell(asValue());

   179     }

   180 

   181     inline double JSValue::asDouble() const

   182     {

   183         return asNumberCell(asValue())->value();

   184     }

   185 

   186     inline bool JSValue::isNumber() const

   187     {

   188         return JSImmediate::isNumber(asValue()) || isDouble();

   189     }

   190 

   191     inline double JSValue::uncheckedGetNumber() const

   192     {

   193         ASSERT(isNumber());

   194         return JSImmediate::isImmediate(asValue()) ? JSImmediate::toDouble(asValue()) : asDouble();

   195     }

   196 

   197 #endif // USE(JSVALUE32)

   198 

   199 #if USE(JSVALUE64)

   200     ALWAYS_INLINE JSValue::JSValue(EncodeAsDoubleTag, ExecState*, double d)

   201     {

   202         *this = JSImmediate::fromNumberOutsideIntegerRange(d);

   203     }

   204 

   205     inline JSValue::JSValue(ExecState*, double d)

   206     {

   207         JSValue v = JSImmediate::from(d);

   208         ASSERT(v);

   209         *this = v;

   210     }

   211 

   212     inline JSValue::JSValue(ExecState*, int i)

   213     {

   214         JSValue v = JSImmediate::from(i);

   215         ASSERT(v);

   216         *this = v;

   217     }

   218 

   219     inline JSValue::JSValue(ExecState*, unsigned i)

   220     {

   221         JSValue v = JSImmediate::from(i);

   222         ASSERT(v);

   223         *this = v;

   224     }

   225 

   226     inline JSValue::JSValue(ExecState*, long i)

   227     {

   228         JSValue v = JSImmediate::from(i);

   229         ASSERT(v);

   230         *this = v;

   231     }

   232 

   233     inline JSValue::JSValue(ExecState*, unsigned long i)

   234     {

   235         JSValue v = JSImmediate::from(i);

   236         ASSERT(v);

   237         *this = v;

   238     }

   239 

   240     inline JSValue::JSValue(ExecState*, long long i)

   241     {

   242         JSValue v = JSImmediate::from(static_cast<double>(i));

   243         ASSERT(v);

   244         *this = v;

   245     }

   246 

   247     inline JSValue::JSValue(ExecState*, unsigned long long i)

   248     {

   249         JSValue v = JSImmediate::from(static_cast<double>(i));

   250         ASSERT(v);

   251         *this = v;

   252     }

   253 

   254     inline JSValue::JSValue(JSGlobalData*, double d)

   255     {

   256         JSValue v = JSImmediate::from(d);

   257         ASSERT(v);

   258         *this = v;

   259     }

   260 

   261     inline JSValue::JSValue(JSGlobalData*, int i)

   262     {

   263         JSValue v = JSImmediate::from(i);

   264         ASSERT(v);

   265         *this = v;

   266     }

   267 

   268     inline JSValue::JSValue(JSGlobalData*, unsigned i)

   269     {

   270         JSValue v = JSImmediate::from(i);

   271         ASSERT(v);

   272         *this = v;

   273     }

   274 

   275     inline bool JSValue::isDouble() const

   276     {

   277         return JSImmediate::isDouble(asValue());

   278     }

   279 

   280     inline double JSValue::asDouble() const

   281     {

   282         return JSImmediate::doubleValue(asValue());

   283     }

   284 

   285     inline bool JSValue::isNumber() const

   286     {

   287         return JSImmediate::isNumber(asValue());

   288     }

   289 

   290     inline double JSValue::uncheckedGetNumber() const

   291     {

   292         ASSERT(isNumber());

   293         return JSImmediate::toDouble(asValue());

   294     }

   295 

   296 #endif // USE(JSVALUE64)

   297 

   298 #if USE(JSVALUE32) || USE(JSVALUE64)

   299 

   300     inline JSValue::JSValue(ExecState*, char i)

   301     {

   302         ASSERT(JSImmediate::from(i));

   303         *this = JSImmediate::from(i);

   304     }

   305 

   306     inline JSValue::JSValue(ExecState*, unsigned char i)

   307     {

   308         ASSERT(JSImmediate::from(i));

   309         *this = JSImmediate::from(i);

   310     }

   311 

   312     inline JSValue::JSValue(ExecState*, short i)

   313     {

   314         ASSERT(JSImmediate::from(i));

   315         *this = JSImmediate::from(i);

   316     }

   317 

   318     inline JSValue::JSValue(ExecState*, unsigned short i)

   319     {

   320         ASSERT(JSImmediate::from(i));

   321         *this = JSImmediate::from(i);

   322     }

   323 

   324     inline JSValue jsNaN(ExecState* exec)

   325     {

   326         return jsNumber(exec, NaN);

   327     }

   328 

   329     inline JSValue jsNaN(JSGlobalData* globalData)

   330     {

   331         return jsNumber(globalData, NaN);

   332     }

   333 

   334     // --- JSValue inlines ----------------------------

   335 

   336     ALWAYS_INLINE JSValue JSValue::toJSNumber(ExecState* exec) const

   337     {

   338         return isNumber() ? asValue() : jsNumber(exec, this->toNumber(exec));

   339     }

   340 

   341     inline bool JSValue::getNumber(double &result) const

   342     {

   343         if (isInt32())

   344             result = asInt32();

   345         else if (LIKELY(isDouble()))

   346             result = asDouble();

   347         else {

   348             ASSERT(!isNumber());

   349             return false;

   350         }

   351         return true;

   352     }

   353 

   354 #endif // USE(JSVALUE32) || USE(JSVALUE64)

   355 

   356 } // namespace JSC

   357 

   358 #endif // JSNumberCell_h