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