Unreviewed, rolling out r140703.
[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 static const double D32 = 4294967296.0;
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 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() ? QNaN : 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     throwError(exec, createNotAnObjectError(exec, *this));
80     return JSNotAnObject::create(exec);
81 }
82
83 JSObject* JSValue::toThisObjectSlowCase(ExecState* exec) const
84 {
85     ASSERT(!isCell());
86
87     if (isInt32() || isDouble())
88         return constructNumber(exec, exec->lexicalGlobalObject(), asValue());
89     if (isTrue() || isFalse())
90         return constructBooleanFromImmediateBoolean(exec, exec->lexicalGlobalObject(), asValue());
91     ASSERT(isUndefinedOrNull());
92     return exec->globalThisValue();
93 }
94
95 JSObject* JSValue::synthesizePrototype(ExecState* exec) const
96 {
97     if (isCell()) {
98         ASSERT(isString());
99         return exec->lexicalGlobalObject()->stringPrototype();
100     }
101
102     if (isNumber())
103         return exec->lexicalGlobalObject()->numberPrototype();
104     if (isBoolean())
105         return exec->lexicalGlobalObject()->booleanPrototype();
106
107     ASSERT(isUndefinedOrNull());
108     throwError(exec, createNotAnObjectError(exec, *this));
109     return JSNotAnObject::create(exec);
110 }
111
112 // ECMA 8.7.2
113 void JSValue::putToPrimitive(ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
114 {
115     JSGlobalData& globalData = exec->globalData();
116
117     unsigned index = propertyName.asIndex();
118     if (index != PropertyName::NotAnIndex) {
119         putToPrimitiveByIndex(exec, index, value, slot.isStrictMode());
120         return;
121     }
122
123     // Check if there are any setters or getters in the prototype chain
124     JSObject* obj = synthesizePrototype(exec);
125     JSValue prototype;
126     if (propertyName != exec->propertyNames().underscoreProto) {
127         for (; !obj->structure()->hasReadOnlyOrGetterSetterPropertiesExcludingProto(); obj = asObject(prototype)) {
128             prototype = obj->prototype();
129             if (prototype.isNull()) {
130                 if (slot.isStrictMode())
131                     throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
132                 return;
133             }
134         }
135     }
136
137     for (; ; obj = asObject(prototype)) {
138         unsigned attributes;
139         JSCell* specificValue;
140         PropertyOffset offset = obj->structure()->get(globalData, propertyName, attributes, specificValue);
141         if (offset != invalidOffset) {
142             if (attributes & ReadOnly) {
143                 if (slot.isStrictMode())
144                     throwError(exec, createTypeError(exec, StrictModeReadonlyPropertyWriteError));
145                 return;
146             }
147
148             JSValue gs = obj->getDirect(offset);
149             if (gs.isGetterSetter()) {
150                 JSObject* setterFunc = asGetterSetter(gs)->setter();        
151                 if (!setterFunc) {
152                     if (slot.isStrictMode())
153                         throwError(exec, createTypeError(exec, ASCIILiteral("setting a property that has only a getter")));
154                     return;
155                 }
156                 
157                 CallData callData;
158                 CallType callType = setterFunc->methodTable()->getCallData(setterFunc, callData);
159                 MarkedArgumentBuffer args;
160                 args.append(value);
161
162                 // If this is WebCore's global object then we need to substitute the shell.
163                 call(exec, setterFunc, callType, callData, *this, args);
164                 return;
165             }
166
167             // If there's an existing property on the object or one of its 
168             // prototypes it should be replaced, so break here.
169             break;
170         }
171
172         prototype = obj->prototype();
173         if (prototype.isNull())
174             break;
175     }
176     
177     if (slot.isStrictMode())
178         throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
179     return;
180 }
181
182 void JSValue::putToPrimitiveByIndex(ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow)
183 {
184     if (propertyName > MAX_ARRAY_INDEX) {
185         PutPropertySlot slot(shouldThrow);
186         putToPrimitive(exec, Identifier::from(exec, propertyName), value, slot);
187         return;
188     }
189     
190     if (synthesizePrototype(exec)->attemptToInterceptPutByIndexOnHoleForPrototype(exec, *this, propertyName, value, shouldThrow))
191         return;
192     
193     if (shouldThrow)
194         throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
195 }
196
197 void JSValue::dump(PrintStream& out) const
198 {
199     if (!*this)
200         out.print("<JSValue()>");
201     else if (isInt32())
202         out.printf("Int32: %d", asInt32());
203     else if (isDouble()) {
204 #if USE(JSVALUE64)
205         out.printf("Double: %lld, %lf", (long long)reinterpretDoubleToInt64(asDouble()), asDouble());
206 #else
207         union {
208             double asDouble;
209             uint32_t asTwoInt32s[2];
210         } u;
211         u.asDouble = asDouble();
212         out.printf("Double: %08x:%08x, %lf", u.asTwoInt32s[1], u.asTwoInt32s[0], asDouble());
213 #endif
214     } else if (isCell()) {
215         if (asCell()->inherits(&Structure::s_info)) {
216             Structure* structure = jsCast<Structure*>(asCell());
217             out.print(
218                 "Structure: ", RawPointer(structure), ": ", structure->classInfo()->className,
219                 ", ", IndexingTypeDump(structure->indexingTypeIncludingHistory()));
220         } else {
221             out.print("Cell: ", RawPointer(asCell()));
222             if (isObject() && asObject(*this)->butterfly())
223                 out.print("->", RawPointer(asObject(*this)->butterfly()));
224             out.print(
225                 " (", RawPointer(asCell()->structure()), ": ", asCell()->structure()->classInfo()->className,
226                 ", ", IndexingTypeDump(asCell()->structure()->indexingTypeIncludingHistory()), ")");
227         }
228     } else if (isTrue())
229         out.print("True");
230     else if (isFalse())
231         out.print("False");
232     else if (isNull())
233         out.print("Null");
234     else if (isUndefined())
235         out.print("Undefined");
236     else
237         out.print("INVALID");
238 }
239
240 // This in the ToInt32 operation is defined in section 9.5 of the ECMA-262 spec.
241 // Note that this operation is identical to ToUInt32 other than to interpretation
242 // of the resulting bit-pattern (as such this metod is also called to implement
243 // ToUInt32).
244 //
245 // The operation can be descibed as round towards zero, then select the 32 least
246 // bits of the resulting value in 2s-complement representation.
247 int32_t toInt32(double number)
248 {
249     int64_t bits = WTF::bitwise_cast<int64_t>(number);
250     int32_t exp = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;
251
252     // If exponent < 0 there will be no bits to the left of the decimal point
253     // after rounding; if the exponent is > 83 then no bits of precision can be
254     // left in the low 32-bit range of the result (IEEE-754 doubles have 52 bits
255     // of fractional precision).
256     // Note this case handles 0, -0, and all infinte, NaN, & denormal value. 
257     if (exp < 0 || exp > 83)
258         return 0;
259
260     // Select the appropriate 32-bits from the floating point mantissa.  If the
261     // exponent is 52 then the bits we need to select are already aligned to the
262     // lowest bits of the 64-bit integer representation of tghe number, no need
263     // to shift.  If the exponent is greater than 52 we need to shift the value
264     // left by (exp - 52), if the value is less than 52 we need to shift right
265     // accordingly.
266     int32_t result = (exp > 52)
267         ? static_cast<int32_t>(bits << (exp - 52))
268         : static_cast<int32_t>(bits >> (52 - exp));
269
270     // IEEE-754 double precision values are stored omitting an implicit 1 before
271     // the decimal point; we need to reinsert this now.  We may also the shifted
272     // invalid bits into the result that are not a part of the mantissa (the sign
273     // and exponent bits from the floatingpoint representation); mask these out.
274     if (exp < 32) {
275         int32_t missingOne = 1 << exp;
276         result &= missingOne - 1;
277         result += missingOne;
278     }
279
280     // If the input value was negative (we could test either 'number' or 'bits',
281     // but testing 'bits' is likely faster) invert the result appropriately.
282     return bits < 0 ? -result : result;
283 }
284
285 bool JSValue::isValidCallee()
286 {
287     return asObject(asCell())->globalObject();
288 }
289
290 JSString* JSValue::toStringSlowCase(ExecState* exec) const
291 {
292     JSGlobalData& globalData = exec->globalData();
293     ASSERT(!isString());
294     if (isInt32())
295         return jsString(&globalData, globalData.numericStrings.add(asInt32()));
296     if (isDouble())
297         return jsString(&globalData, globalData.numericStrings.add(asDouble()));
298     if (isTrue())
299         return globalData.smallStrings.trueString();
300     if (isFalse())
301         return globalData.smallStrings.falseString();
302     if (isNull())
303         return globalData.smallStrings.nullString();
304     if (isUndefined())
305         return globalData.smallStrings.undefinedString();
306
307     ASSERT(isCell());
308     JSValue value = asCell()->toPrimitive(exec, PreferString);
309     if (exec->hadException())
310         return jsEmptyString(exec);
311     ASSERT(!value.isObject());
312     return value.toString(exec);
313 }
314
315 String JSValue::toWTFStringSlowCase(ExecState* exec) const
316 {
317     return inlineJSValueNotStringtoString(*this, exec);
318 }
319
320 } // namespace JSC