7d7b7bd5ff75a0ca9e08aa48f4db0c34fbf29f11
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSCJSValue.cpp
1 /*
2  *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
4  *  Copyright (C) 2003, 2007, 2008, 2012 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 #include "config.h"
24 #include "JSCJSValue.h"
25
26 #include "BooleanConstructor.h"
27 #include "BooleanPrototype.h"
28 #include "CustomGetterSetter.h"
29 #include "Error.h"
30 #include "ExceptionHelpers.h"
31 #include "GetterSetter.h"
32 #include "JSCJSValueInlines.h"
33 #include "JSFunction.h"
34 #include "JSGlobalObject.h"
35 #include "JSNotAnObject.h"
36 #include "NumberObject.h"
37 #include <wtf/MathExtras.h>
38 #include <wtf/StringExtras.h>
39
40 namespace JSC {
41
42 // ECMA 9.4
43 double JSValue::toInteger(ExecState* exec) const
44 {
45     if (isInt32())
46         return asInt32();
47     double d = toNumber(exec);
48     return std::isnan(d) ? 0.0 : trunc(d);
49 }
50
51 double JSValue::toIntegerPreserveNaN(ExecState* exec) const
52 {
53     if (isInt32())
54         return asInt32();
55     return trunc(toNumber(exec));
56 }
57
58 double JSValue::toNumberSlowCase(ExecState* exec) const
59 {
60     ASSERT(!isInt32() && !isDouble());
61     if (isCell())
62         return asCell()->toNumber(exec);
63     if (isTrue())
64         return 1.0;
65     return isUndefined() ? PNaN : 0; // null and false both convert to 0.
66 }
67
68 JSObject* JSValue::toObjectSlowCase(ExecState* exec, JSGlobalObject* globalObject) const
69 {
70     ASSERT(!isCell());
71
72     if (isInt32() || isDouble())
73         return constructNumber(exec, globalObject, asValue());
74     if (isTrue() || isFalse())
75         return constructBooleanFromImmediateBoolean(exec, globalObject, asValue());
76
77     ASSERT(isUndefinedOrNull());
78     VM& vm = exec->vm();
79     vm.throwException(exec, createNotAnObjectError(exec, *this));
80     return JSNotAnObject::create(vm);
81 }
82
83 JSValue JSValue::toThisSlowCase(ExecState* exec, ECMAMode ecmaMode) const
84 {
85     ASSERT(!isCell());
86
87     if (ecmaMode == StrictMode)
88         return *this;
89
90     if (isInt32() || isDouble())
91         return constructNumber(exec, exec->lexicalGlobalObject(), asValue());
92     if (isTrue() || isFalse())
93         return constructBooleanFromImmediateBoolean(exec, exec->lexicalGlobalObject(), asValue());
94     ASSERT(isUndefinedOrNull());
95     return exec->globalThisValue();
96 }
97
98 JSObject* JSValue::synthesizePrototype(ExecState* exec) const
99 {
100     if (isCell()) {
101         ASSERT(isString());
102         return exec->lexicalGlobalObject()->stringPrototype();
103     }
104
105     if (isNumber())
106         return exec->lexicalGlobalObject()->numberPrototype();
107     if (isBoolean())
108         return exec->lexicalGlobalObject()->booleanPrototype();
109
110     ASSERT(isUndefinedOrNull());
111     VM& vm = exec->vm();
112     vm.throwException(exec, createNotAnObjectError(exec, *this));
113     return JSNotAnObject::create(vm);
114 }
115
116 // ECMA 8.7.2
117 void JSValue::putToPrimitive(ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
118 {
119     VM& vm = exec->vm();
120
121     unsigned index = propertyName.asIndex();
122     if (index != PropertyName::NotAnIndex) {
123         putToPrimitiveByIndex(exec, index, value, slot.isStrictMode());
124         return;
125     }
126
127     // Check if there are any setters or getters in the prototype chain
128     JSObject* obj = synthesizePrototype(exec);
129     JSValue prototype;
130     if (propertyName != exec->propertyNames().underscoreProto) {
131         for (; !obj->structure()->hasReadOnlyOrGetterSetterPropertiesExcludingProto(); obj = asObject(prototype)) {
132             prototype = obj->prototype();
133             if (prototype.isNull()) {
134                 if (slot.isStrictMode())
135                     throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
136                 return;
137             }
138         }
139     }
140
141     for (; ; obj = asObject(prototype)) {
142         unsigned attributes;
143         JSCell* specificValue;
144         PropertyOffset offset = obj->structure()->get(vm, propertyName, attributes, specificValue);
145         if (offset != invalidOffset) {
146             if (attributes & ReadOnly) {
147                 if (slot.isStrictMode())
148                     exec->vm().throwException(exec, createTypeError(exec, StrictModeReadonlyPropertyWriteError));
149                 return;
150             }
151
152             JSValue gs = obj->getDirect(offset);
153             if (gs.isGetterSetter()) {
154                 callSetter(exec, *this, gs, value, slot.isStrictMode() ? StrictMode : NotStrictMode);
155                 return;
156             }
157
158             if (gs.isCustomGetterSetter()) {
159                 callCustomSetter(exec, gs, obj, slot.thisValue(), value);
160                 return;
161             }
162
163             // If there's an existing property on the object or one of its 
164             // prototypes it should be replaced, so break here.
165             break;
166         }
167
168         prototype = obj->prototype();
169         if (prototype.isNull())
170             break;
171     }
172     
173     if (slot.isStrictMode())
174         throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
175     return;
176 }
177
178 void JSValue::putToPrimitiveByIndex(ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow)
179 {
180     if (propertyName > MAX_ARRAY_INDEX) {
181         PutPropertySlot slot(*this, shouldThrow);
182         putToPrimitive(exec, Identifier::from(exec, propertyName), value, slot);
183         return;
184     }
185     
186     if (synthesizePrototype(exec)->attemptToInterceptPutByIndexOnHoleForPrototype(exec, *this, propertyName, value, shouldThrow))
187         return;
188     
189     if (shouldThrow)
190         throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
191 }
192
193 void JSValue::dump(PrintStream& out) const
194 {
195     dumpInContext(out, 0);
196 }
197
198 void JSValue::dumpInContext(PrintStream& out, DumpContext* context) const
199 {
200     if (!*this)
201         out.print("<JSValue()>");
202     else if (isInt32())
203         out.printf("Int32: %d", asInt32());
204     else if (isDouble()) {
205 #if USE(JSVALUE64)
206         out.printf("Double: %lld, %lf", (long long)reinterpretDoubleToInt64(asDouble()), asDouble());
207 #else
208         union {
209             double asDouble;
210             uint32_t asTwoInt32s[2];
211         } u;
212         u.asDouble = asDouble();
213         out.printf("Double: %08x:%08x, %lf", u.asTwoInt32s[1], u.asTwoInt32s[0], asDouble());
214 #endif
215     } else if (isCell()) {
216         if (asCell()->inherits(JSString::info())) {
217             JSString* string = jsCast<JSString*>(asCell());
218             out.print("String");
219             if (string->isRope())
220                 out.print(" (rope)");
221             const StringImpl* impl = string->tryGetValueImpl();
222             if (impl) {
223                 if (impl->isAtomic())
224                     out.print(" (atomic)");
225                 if (impl->isAtomic())
226                     out.print(" (identifier)");
227                 if (impl->isEmptyUnique())
228                     out.print(" (unique)");
229             } else
230                 out.print(" (unresolved)");
231             out.print(": ", impl);
232         } else if (asCell()->inherits(Structure::info()))
233             out.print("Structure: ", inContext(*jsCast<Structure*>(asCell()), context));
234         else {
235             out.print("Cell: ", RawPointer(asCell()));
236             out.print(" (", inContext(*asCell()->structure(), context), ")");
237         }
238 #if USE(JSVALUE64)
239         out.print(", ID: ", asCell()->structureID());
240 #endif
241     } else if (isTrue())
242         out.print("True");
243     else if (isFalse())
244         out.print("False");
245     else if (isNull())
246         out.print("Null");
247     else if (isUndefined())
248         out.print("Undefined");
249     else
250         out.print("INVALID");
251 }
252
253 // This in the ToInt32 operation is defined in section 9.5 of the ECMA-262 spec.
254 // Note that this operation is identical to ToUInt32 other than to interpretation
255 // of the resulting bit-pattern (as such this metod is also called to implement
256 // ToUInt32).
257 //
258 // The operation can be descibed as round towards zero, then select the 32 least
259 // bits of the resulting value in 2s-complement representation.
260 int32_t toInt32(double number)
261 {
262     int64_t bits = WTF::bitwise_cast<int64_t>(number);
263     int32_t exp = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;
264
265     // If exponent < 0 there will be no bits to the left of the decimal point
266     // after rounding; if the exponent is > 83 then no bits of precision can be
267     // left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
268     // of fractional precision).
269     // Note this case handles 0, -0, and all infinte, NaN, & denormal value. 
270     if (exp < 0 || exp > 83)
271         return 0;
272
273     // Select the appropriate 32-bits from the floating point mantissa.  If the
274     // exponent is 52 then the bits we need to select are already aligned to the
275     // lowest bits of the 64-bit integer representation of tghe number, no need
276     // to shift.  If the exponent is greater than 52 we need to shift the value
277     // left by (exp - 52), if the value is less than 52 we need to shift right
278     // accordingly.
279     int32_t result = (exp > 52)
280         ? static_cast<int32_t>(bits << (exp - 52))
281         : static_cast<int32_t>(bits >> (52 - exp));
282
283     // IEEE-754 double precision values are stored omitting an implicit 1 before
284     // the decimal point; we need to reinsert this now.  We may also the shifted
285     // invalid bits into the result that are not a part of the mantissa (the sign
286     // and exponent bits from the floatingpoint representation); mask these out.
287     if (exp < 32) {
288         int32_t missingOne = 1 << exp;
289         result &= missingOne - 1;
290         result += missingOne;
291     }
292
293     // If the input value was negative (we could test either 'number' or 'bits',
294     // but testing 'bits' is likely faster) invert the result appropriately.
295     return bits < 0 ? -result : result;
296 }
297
298 bool JSValue::isValidCallee()
299 {
300     return asObject(asCell())->globalObject();
301 }
302
303 JSString* JSValue::toStringSlowCase(ExecState* exec) const
304 {
305     VM& vm = exec->vm();
306     ASSERT(!isString());
307     if (isInt32())
308         return jsString(&vm, vm.numericStrings.add(asInt32()));
309     if (isDouble())
310         return jsString(&vm, vm.numericStrings.add(asDouble()));
311     if (isTrue())
312         return vm.smallStrings.trueString();
313     if (isFalse())
314         return vm.smallStrings.falseString();
315     if (isNull())
316         return vm.smallStrings.nullString();
317     if (isUndefined())
318         return vm.smallStrings.undefinedString();
319
320     ASSERT(isCell());
321     JSValue value = asCell()->toPrimitive(exec, PreferString);
322     if (exec->hadException())
323         return jsEmptyString(exec);
324     ASSERT(!value.isObject());
325     return value.toString(exec);
326 }
327
328 String JSValue::toWTFStringSlowCase(ExecState* exec) const
329 {
330     return inlineJSValueNotStringtoString(*this, exec);
331 }
332
333 } // namespace JSC