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