diff options
Diffstat (limited to 'JavaScriptCore/kjs/array_object.cpp')
| -rw-r--r-- | JavaScriptCore/kjs/array_object.cpp | 760 |
1 files changed, 760 insertions, 0 deletions
diff --git a/JavaScriptCore/kjs/array_object.cpp b/JavaScriptCore/kjs/array_object.cpp new file mode 100644 index 0000000..48b0855 --- /dev/null +++ b/JavaScriptCore/kjs/array_object.cpp @@ -0,0 +1,760 @@ +/* + * Copyright (C) 1999-2000 Harri Porten (porten@kde.org) + * Copyright (C) 2003, 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2003 Peter Kelly (pmk@post.com) + * Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 + * USA + * + */ + +#include "config.h" +#include "array_object.h" +#include "array_object.lut.h" + +#include "error_object.h" +#include "lookup.h" +#include "operations.h" +#include <stdio.h> +#include <wtf/Assertions.h> +#include <wtf/HashSet.h> + +#include <algorithm> // for std::min + +namespace KJS { + +// ------------------------------ ArrayPrototype ---------------------------- + +const ClassInfo ArrayPrototype::info = {"Array", &ArrayInstance::info, &arrayTable}; + +/* Source for array_object.lut.h +@begin arrayTable 16 + toString arrayProtoFuncToString DontEnum|Function 0 + toLocaleString arrayProtoFuncToLocaleString DontEnum|Function 0 + concat arrayProtoFuncConcat DontEnum|Function 1 + join arrayProtoFuncJoin DontEnum|Function 1 + pop arrayProtoFuncPop DontEnum|Function 0 + push arrayProtoFuncPush DontEnum|Function 1 + reverse arrayProtoFuncReverse DontEnum|Function 0 + shift arrayProtoFuncShift DontEnum|Function 0 + slice arrayProtoFuncSlice DontEnum|Function 2 + sort arrayProtoFuncSort DontEnum|Function 1 + splice arrayProtoFuncSplice DontEnum|Function 2 + unshift arrayProtoFuncUnShift DontEnum|Function 1 + every arrayProtoFuncEvery DontEnum|Function 1 + forEach arrayProtoFuncForEach DontEnum|Function 1 + some arrayProtoFuncSome DontEnum|Function 1 + indexOf arrayProtoFuncIndexOf DontEnum|Function 1 + lastIndexOf arrayProtoFuncLastIndexOf DontEnum|Function 1 + filter arrayProtoFuncFilter DontEnum|Function 1 + map arrayProtoFuncMap DontEnum|Function 1 +@end +*/ + +// ECMA 15.4.4 +ArrayPrototype::ArrayPrototype(ExecState*, ObjectPrototype* objProto) + : ArrayInstance(objProto, 0) +{ +} + +bool ArrayPrototype::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot) +{ + return getStaticFunctionSlot<ArrayInstance>(exec, &arrayTable, this, propertyName, slot); +} + + +// ------------------------------ Array Functions ---------------------------- + +// Helper function +static JSValue* getProperty(ExecState* exec, JSObject* obj, unsigned index) +{ + PropertySlot slot; + if (!obj->getPropertySlot(exec, index, slot)) + return 0; + return slot.getValue(exec, obj, index); +} + +JSValue* arrayProtoFuncToString(ExecState* exec, JSObject* thisObj, const List&) +{ + if (!thisObj->inherits(&ArrayInstance::info)) + return throwError(exec, TypeError); + + static HashSet<JSObject*> visitedElems; + static const UString* empty = new UString(""); + static const UString* comma = new UString(","); + bool alreadyVisited = !visitedElems.add(thisObj).second; + if (alreadyVisited) + return jsString(*empty); + UString separator = *comma; + UString str = *empty; + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned k = 0; k < length; k++) { + if (k >= 1) + str += separator; + if (str.isNull()) { + JSObject* error = Error::create(exec, GeneralError, "Out of memory"); + exec->setException(error); + break; + } + + JSValue* element = thisObj->get(exec, k); + if (element->isUndefinedOrNull()) + continue; + + str += element->toString(exec); + + if (str.isNull()) { + JSObject* error = Error::create(exec, GeneralError, "Out of memory"); + exec->setException(error); + } + + if (exec->hadException()) + break; + } + visitedElems.remove(thisObj); + return jsString(str); +} + +JSValue* arrayProtoFuncToLocaleString(ExecState* exec, JSObject* thisObj, const List&) +{ + if (!thisObj->inherits(&ArrayInstance::info)) + return throwError(exec, TypeError); + + static HashSet<JSObject*> visitedElems; + static const UString* empty = new UString(""); + static const UString* comma = new UString(","); + bool alreadyVisited = !visitedElems.add(thisObj).second; + if (alreadyVisited) + return jsString(*empty); + UString separator = *comma; + UString str = *empty; + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned k = 0; k < length; k++) { + if (k >= 1) + str += separator; + if (str.isNull()) { + JSObject* error = Error::create(exec, GeneralError, "Out of memory"); + exec->setException(error); + break; + } + + JSValue* element = thisObj->get(exec, k); + if (element->isUndefinedOrNull()) + continue; + + JSObject* o = element->toObject(exec); + JSValue* conversionFunction = o->get(exec, exec->propertyNames().toLocaleString); + if (conversionFunction->isObject() && static_cast<JSObject*>(conversionFunction)->implementsCall()) + str += static_cast<JSObject*>(conversionFunction)->call(exec, o, exec->emptyList())->toString(exec); + else + str += element->toString(exec); + + if (str.isNull()) { + JSObject* error = Error::create(exec, GeneralError, "Out of memory"); + exec->setException(error); + } + + if (exec->hadException()) + break; + } + visitedElems.remove(thisObj); + return jsString(str); +} + +JSValue* arrayProtoFuncJoin(ExecState* exec, JSObject* thisObj, const List& args) +{ + static HashSet<JSObject*> visitedElems; + static const UString* empty = new UString(""); + static const UString* comma = new UString(","); + bool alreadyVisited = !visitedElems.add(thisObj).second; + if (alreadyVisited) + return jsString(*empty); + UString separator = *comma; + UString str = *empty; + + if (!args[0]->isUndefined()) + separator = args[0]->toString(exec); + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned k = 0; k < length; k++) { + if (k >= 1) + str += separator; + if (str.isNull()) { + JSObject* error = Error::create(exec, GeneralError, "Out of memory"); + exec->setException(error); + break; + } + + JSValue* element = thisObj->get(exec, k); + if (element->isUndefinedOrNull()) + continue; + + str += element->toString(exec); + + if (str.isNull()) { + JSObject* error = Error::create(exec, GeneralError, "Out of memory"); + exec->setException(error); + } + + if (exec->hadException()) + break; + } + visitedElems.remove(thisObj); + return jsString(str); +} + +JSValue* arrayProtoFuncConcat(ExecState* exec, JSObject* thisObj, const List& args) +{ + JSObject* arr = static_cast<JSObject*>(exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList())); + int n = 0; + JSValue* curArg = thisObj; + JSObject* curObj = static_cast<JSObject* >(thisObj); + List::const_iterator it = args.begin(); + List::const_iterator end = args.end(); + while (1) { + if (curArg->isObject() && curObj->inherits(&ArrayInstance::info)) { + unsigned k = 0; + // Older versions tried to optimize out getting the length of thisObj + // by checking for n != 0, but that doesn't work if thisObj is an empty array. + unsigned length = curObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + while (k < length) { + if (JSValue* v = getProperty(exec, curObj, k)) + arr->put(exec, n, v); + n++; + k++; + } + } else { + arr->put(exec, n, curArg); + n++; + } + if (it == end) + break; + curArg = *it; + curObj = static_cast<JSObject*>(curArg); // may be 0 + ++it; + } + arr->put(exec, exec->propertyNames().length, jsNumber(n)); + return arr; +} + +JSValue* arrayProtoFuncPop(ExecState* exec, JSObject* thisObj, const List&) +{ + JSValue* result = 0; + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + if (length == 0) { + thisObj->put(exec, exec->propertyNames().length, jsNumber(length)); + result = jsUndefined(); + } else { + result = thisObj->get(exec, length - 1); + thisObj->deleteProperty(exec, length - 1); + thisObj->put(exec, exec->propertyNames().length, jsNumber(length - 1)); + } + return result; +} + +JSValue* arrayProtoFuncPush(ExecState* exec, JSObject* thisObj, const List& args) +{ + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned n = 0; n < args.size(); n++) + thisObj->put(exec, length + n, args[n]); + length += args.size(); + thisObj->put(exec, exec->propertyNames().length, jsNumber(length)); + return jsNumber(length); +} + +JSValue* arrayProtoFuncReverse(ExecState* exec, JSObject* thisObj, const List&) +{ + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + unsigned middle = length / 2; + + for (unsigned k = 0; k < middle; k++) { + unsigned lk1 = length - k - 1; + JSValue* obj2 = getProperty(exec, thisObj, lk1); + JSValue* obj = getProperty(exec, thisObj, k); + + if (obj2) + thisObj->put(exec, k, obj2); + else + thisObj->deleteProperty(exec, k); + + if (obj) + thisObj->put(exec, lk1, obj); + else + thisObj->deleteProperty(exec, lk1); + } + return thisObj; +} + +JSValue* arrayProtoFuncShift(ExecState* exec, JSObject* thisObj, const List&) +{ + JSValue* result = 0; + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + if (length == 0) { + thisObj->put(exec, exec->propertyNames().length, jsNumber(length)); + result = jsUndefined(); + } else { + result = thisObj->get(exec, 0); + for (unsigned k = 1; k < length; k++) { + if (JSValue* obj = getProperty(exec, thisObj, k)) + thisObj->put(exec, k - 1, obj); + else + thisObj->deleteProperty(exec, k - 1); + } + thisObj->deleteProperty(exec, length - 1); + thisObj->put(exec, exec->propertyNames().length, jsNumber(length - 1)); + } + return result; +} + +JSValue* arrayProtoFuncSlice(ExecState* exec, JSObject* thisObj, const List& args) +{ + // http://developer.netscape.com/docs/manuals/js/client/jsref/array.htm#1193713 or 15.4.4.10 + + // We return a new array + JSObject* resObj = static_cast<JSObject* >(exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList())); + JSValue* result = resObj; + double begin = args[0]->toInteger(exec); + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + if (begin >= 0) { + if (begin > length) + begin = length; + } else { + begin += length; + if (begin < 0) + begin = 0; + } + double end; + if (args[1]->isUndefined()) + end = length; + else { + end = args[1]->toInteger(exec); + if (end < 0) { + end += length; + if (end < 0) + end = 0; + } else { + if (end > length) + end = length; + } + } + + int n = 0; + int b = static_cast<int>(begin); + int e = static_cast<int>(end); + for (int k = b; k < e; k++, n++) { + if (JSValue* v = getProperty(exec, thisObj, k)) + resObj->put(exec, n, v); + } + resObj->put(exec, exec->propertyNames().length, jsNumber(n)); + return result; +} + +JSValue* arrayProtoFuncSort(ExecState* exec, JSObject* thisObj, const List& args) +{ + JSObject* sortFunction = 0; + if (!args[0]->isUndefined()) { + sortFunction = args[0]->toObject(exec); + if (!sortFunction->implementsCall()) + sortFunction = 0; + } + + if (thisObj->classInfo() == &ArrayInstance::info) { + if (sortFunction) + static_cast<ArrayInstance*>(thisObj)->sort(exec, sortFunction); + else + static_cast<ArrayInstance*>(thisObj)->sort(exec); + return thisObj; + } + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + + if (!length) + return thisObj; + + // "Min" sort. Not the fastest, but definitely less code than heapsort + // or quicksort, and much less swapping than bubblesort/insertionsort. + for (unsigned i = 0; i < length - 1; ++i) { + JSValue* iObj = thisObj->get(exec, i); + unsigned themin = i; + JSValue* minObj = iObj; + for (unsigned j = i + 1; j < length; ++j) { + JSValue* jObj = thisObj->get(exec, j); + double compareResult; + if (jObj->isUndefined()) + compareResult = 1; // don't check minObj because there's no need to differentiate == (0) from > (1) + else if (minObj->isUndefined()) + compareResult = -1; + else if (sortFunction) { + List l; + l.append(jObj); + l.append(minObj); + compareResult = sortFunction->call(exec, exec->dynamicGlobalObject(), l)->toNumber(exec); + } else + compareResult = (jObj->toString(exec) < minObj->toString(exec)) ? -1 : 1; + + if (compareResult < 0) { + themin = j; + minObj = jObj; + } + } + // Swap themin and i + if (themin > i) { + thisObj->put(exec, i, minObj); + thisObj->put(exec, themin, iObj); + } + } + return thisObj; +} + +JSValue* arrayProtoFuncSplice(ExecState* exec, JSObject* thisObj, const List& args) +{ + // 15.4.4.12 + JSObject* resObj = static_cast<JSObject* >(exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList())); + JSValue* result = resObj; + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + if (!args.size()) + return jsUndefined(); + int begin = args[0]->toUInt32(exec); + if (begin < 0) + begin = std::max<int>(begin + length, 0); + else + begin = std::min<int>(begin, length); + + unsigned deleteCount; + if (args.size() > 1) + deleteCount = std::min<int>(std::max<int>(args[1]->toUInt32(exec), 0), length - begin); + else + deleteCount = length - begin; + + for (unsigned k = 0; k < deleteCount; k++) { + if (JSValue* v = getProperty(exec, thisObj, k + begin)) + resObj->put(exec, k, v); + } + resObj->put(exec, exec->propertyNames().length, jsNumber(deleteCount)); + + unsigned additionalArgs = std::max<int>(args.size() - 2, 0); + if (additionalArgs != deleteCount) { + if (additionalArgs < deleteCount) { + for (unsigned k = begin; k < length - deleteCount; ++k) { + if (JSValue* v = getProperty(exec, thisObj, k + deleteCount)) + thisObj->put(exec, k + additionalArgs, v); + else + thisObj->deleteProperty(exec, k + additionalArgs); + } + for (unsigned k = length; k > length - deleteCount + additionalArgs; --k) + thisObj->deleteProperty(exec, k - 1); + } else { + for (unsigned k = length - deleteCount; (int)k > begin; --k) { + if (JSValue* obj = getProperty(exec, thisObj, k + deleteCount - 1)) + thisObj->put(exec, k + additionalArgs - 1, obj); + else + thisObj->deleteProperty(exec, k + additionalArgs - 1); + } + } + } + for (unsigned k = 0; k < additionalArgs; ++k) + thisObj->put(exec, k + begin, args[k + 2]); + + thisObj->put(exec, exec->propertyNames().length, jsNumber(length - deleteCount + additionalArgs)); + return result; +} + +JSValue* arrayProtoFuncUnShift(ExecState* exec, JSObject* thisObj, const List& args) +{ + // 15.4.4.13 + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + unsigned nrArgs = args.size(); + if (nrArgs) { + for (unsigned k = length; k > 0; --k) { + if (JSValue* v = getProperty(exec, thisObj, k - 1)) + thisObj->put(exec, k + nrArgs - 1, v); + else + thisObj->deleteProperty(exec, k + nrArgs - 1); + } + } + for (unsigned k = 0; k < nrArgs; ++k) + thisObj->put(exec, k, args[k]); + JSValue* result = jsNumber(length + nrArgs); + thisObj->put(exec, exec->propertyNames().length, result); + return result; +} + +JSValue* arrayProtoFuncFilter(ExecState* exec, JSObject* thisObj, const List& args) +{ + JSObject* eachFunction = args[0]->toObject(exec); + + if (!eachFunction->implementsCall()) + return throwError(exec, TypeError); + + JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->dynamicGlobalObject() : args[1]->toObject(exec); + JSObject* resultArray = static_cast<JSObject*>(exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList())); + + unsigned filterIndex = 0; + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned k = 0; k < length && !exec->hadException(); ++k) { + PropertySlot slot; + + if (!thisObj->getPropertySlot(exec, k, slot)) + continue; + + JSValue* v = slot.getValue(exec, thisObj, k); + + List eachArguments; + + eachArguments.append(v); + eachArguments.append(jsNumber(k)); + eachArguments.append(thisObj); + + JSValue* result = eachFunction->call(exec, applyThis, eachArguments); + + if (result->toBoolean(exec)) + resultArray->put(exec, filterIndex++, v); + } + return resultArray; +} + +JSValue* arrayProtoFuncMap(ExecState* exec, JSObject* thisObj, const List& args) +{ + JSObject* eachFunction = args[0]->toObject(exec); + if (!eachFunction->implementsCall()) + return throwError(exec, TypeError); + + JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->dynamicGlobalObject() : args[1]->toObject(exec); + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + + List mapArgs; + mapArgs.append(jsNumber(length)); + JSObject* resultArray = static_cast<JSObject*>(exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, mapArgs)); + + for (unsigned k = 0; k < length && !exec->hadException(); ++k) { + PropertySlot slot; + if (!thisObj->getPropertySlot(exec, k, slot)) + continue; + + JSValue* v = slot.getValue(exec, thisObj, k); + + List eachArguments; + + eachArguments.append(v); + eachArguments.append(jsNumber(k)); + eachArguments.append(thisObj); + + JSValue* result = eachFunction->call(exec, applyThis, eachArguments); + resultArray->put(exec, k, result); + } + + return resultArray; +} + +// Documentation for these three is available at: +// http://developer-test.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:every +// http://developer-test.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:forEach +// http://developer-test.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:some + +JSValue* arrayProtoFuncEvery(ExecState* exec, JSObject* thisObj, const List& args) +{ + JSObject* eachFunction = args[0]->toObject(exec); + + if (!eachFunction->implementsCall()) + return throwError(exec, TypeError); + + JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->dynamicGlobalObject() : args[1]->toObject(exec); + + JSValue* result = jsBoolean(true); + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned k = 0; k < length && !exec->hadException(); ++k) { + PropertySlot slot; + + if (!thisObj->getPropertySlot(exec, k, slot)) + continue; + + List eachArguments; + + eachArguments.append(slot.getValue(exec, thisObj, k)); + eachArguments.append(jsNumber(k)); + eachArguments.append(thisObj); + + bool predicateResult = eachFunction->call(exec, applyThis, eachArguments)->toBoolean(exec); + + if (!predicateResult) { + result = jsBoolean(false); + break; + } + } + + return result; +} + +JSValue* arrayProtoFuncForEach(ExecState* exec, JSObject* thisObj, const List& args) +{ + JSObject* eachFunction = args[0]->toObject(exec); + + if (!eachFunction->implementsCall()) + return throwError(exec, TypeError); + + JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->dynamicGlobalObject() : args[1]->toObject(exec); + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned k = 0; k < length && !exec->hadException(); ++k) { + PropertySlot slot; + if (!thisObj->getPropertySlot(exec, k, slot)) + continue; + + List eachArguments; + eachArguments.append(slot.getValue(exec, thisObj, k)); + eachArguments.append(jsNumber(k)); + eachArguments.append(thisObj); + + eachFunction->call(exec, applyThis, eachArguments); + } + return jsUndefined(); +} + +JSValue* arrayProtoFuncSome(ExecState* exec, JSObject* thisObj, const List& args) +{ + JSObject* eachFunction = args[0]->toObject(exec); + + if (!eachFunction->implementsCall()) + return throwError(exec, TypeError); + + JSObject* applyThis = args[1]->isUndefinedOrNull() ? exec->dynamicGlobalObject() : args[1]->toObject(exec); + + JSValue* result = jsBoolean(false); + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + for (unsigned k = 0; k < length && !exec->hadException(); ++k) { + PropertySlot slot; + if (!thisObj->getPropertySlot(exec, k, slot)) + continue; + + List eachArguments; + eachArguments.append(slot.getValue(exec, thisObj, k)); + eachArguments.append(jsNumber(k)); + eachArguments.append(thisObj); + + bool predicateResult = eachFunction->call(exec, applyThis, eachArguments)->toBoolean(exec); + + if (predicateResult) { + result = jsBoolean(true); + break; + } + } + return result; +} + +JSValue* arrayProtoFuncIndexOf(ExecState* exec, JSObject* thisObj, const List& args) +{ + // JavaScript 1.5 Extension by Mozilla + // Documentation: http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf + + unsigned index = 0; + double d = args[1]->toInteger(exec); + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + if (d < 0) + d += length; + if (d > 0) { + if (d > length) + index = length; + else + index = static_cast<unsigned>(d); + } + + JSValue* searchElement = args[0]; + for (; index < length; ++index) { + JSValue* e = getProperty(exec, thisObj, index); + if (!e) + continue; + if (strictEqual(exec, searchElement, e)) + return jsNumber(index); + } + + return jsNumber(-1); +} + +JSValue* arrayProtoFuncLastIndexOf(ExecState* exec, JSObject* thisObj, const List& args) +{ + // JavaScript 1.6 Extension by Mozilla + // Documentation: http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:lastIndexOf + + unsigned length = thisObj->get(exec, exec->propertyNames().length)->toUInt32(exec); + int index = length - 1; + double d = args[1]->toIntegerPreserveNaN(exec); + + if (d < 0) { + d += length; + if (d < 0) + return jsNumber(-1); + } + if (d < length) + index = static_cast<int>(d); + + JSValue* searchElement = args[0]; + for (; index >= 0; --index) { + JSValue* e = getProperty(exec, thisObj, index); + if (!e) + continue; + if (strictEqual(exec, searchElement, e)) + return jsNumber(index); + } + + return jsNumber(-1); +} + +// ------------------------------ ArrayObjectImp ------------------------------- + +ArrayObjectImp::ArrayObjectImp(ExecState* exec, FunctionPrototype* funcProto, ArrayPrototype* arrayProto) + : InternalFunctionImp(funcProto, arrayProto->classInfo()->className) +{ + // ECMA 15.4.3.1 Array.prototype + putDirect(exec->propertyNames().prototype, arrayProto, DontEnum|DontDelete|ReadOnly); + + // no. of arguments for constructor + putDirect(exec->propertyNames().length, jsNumber(1), ReadOnly|DontDelete|DontEnum); +} + +bool ArrayObjectImp::implementsConstruct() const +{ + return true; +} + +// ECMA 15.4.2 +JSObject* ArrayObjectImp::construct(ExecState* exec, const List& args) +{ + // a single numeric argument denotes the array size (!) + if (args.size() == 1 && args[0]->isNumber()) { + uint32_t n = args[0]->toUInt32(exec); + if (n != args[0]->toNumber(exec)) + return throwError(exec, RangeError, "Array size is not a small enough positive integer."); + return new ArrayInstance(exec->lexicalGlobalObject()->arrayPrototype(), n); + } + + // otherwise the array is constructed with the arguments in it + return new ArrayInstance(exec->lexicalGlobalObject()->arrayPrototype(), args); +} + +// ECMA 15.6.1 +JSValue* ArrayObjectImp::callAsFunction(ExecState* exec, JSObject*, const List& args) +{ + // equivalent to 'new Array(....)' + return construct(exec,args); +} + +} |